From e46616571bcdc9bdf239d353edc12b049e105a50 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Mon, 8 May 2023 13:41:19 -0300 Subject: [PATCH 01/23] urlpattern: adds id_start and id_pard lookup table --- include/ada/urlpattern.h | 77 ++++++++++++++++++++++++++++++++++++++ src/unicode.cpp | 80 ++++++++++++++++++++++++++++++++++++++++ src/urlpattern.cpp | 17 +++++++++ 3 files changed, 174 insertions(+) create mode 100644 include/ada/urlpattern.h create mode 100644 src/urlpattern.cpp diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h new file mode 100644 index 000000000..307b4f647 --- /dev/null +++ b/include/ada/urlpattern.h @@ -0,0 +1,77 @@ +#ifndef ADA_URL_PATTERN_H +#define ADA_URL_PATTERN_H + +#include +#include +#include +#include + +namespace ada { + +struct urlpattern_options { + bool ignore_case = false; +}; + +struct component_result { + std::string_view input; + std::unordered_map> groups; +}; + +struct urlpattern_init { + std::string_view protocol; + std::string_view username; + std::string_view password; + std::string_view hostname; + std::string_view port; + std::string_view pathname; + std::string_view search; + std::string_view hash; + std::string_view base_url; +}; + +union input_union { + urlpattern_options urlpattern_init; + std::string_view str; +}; + +typedef input_union urlpattern_input; + +struct urlpattern_result { + component_result protocol; + component_result username; + component_result password; + component_result hostname; + component_result port; + component_result pathname; + component_result search; + component_result hash; + urlpattern_input input[]; +}; + +struct urlpattern { + urlpattern(urlpattern_input input, std::string_view base_url, + std::optional options); + + urlpattern(std::optional input, + std::optional); + + bool test(std::optional input, + std::optional base_url); + + std::optional exec( + std::optional input, + std::optional base_url); + + const std::string_view protocol; + const std::string_view username; + const std::string_view password; + const std::string_view hostname; + const std::string_view port; + const std::string_view pathname; + const std::string_view search; + const std::string_view hash; +}; + +} // namespace ada + +#endif \ No newline at end of file diff --git a/src/unicode.cpp b/src/unicode.cpp index a24d159f2..2a827056c 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -238,6 +238,86 @@ static_assert(unicode::is_alnum_plus('1')); static_assert(unicode::is_alnum_plus('a')); static_assert(unicode::is_alnum_plus('b')); +// https://tc39.es/ecma262/#prod-IdentifierStart +// up to the extented ascii, with the regex /[$_\p{ID_Start}]/u +constexpr static bool valid_identifier_start_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1}; + +static_assert(sizeof(valid_identifier_start_table) == 256); + +ada_really_inline constexpr bool is_valid_identifier_start( + const char32_t c) noexcept { + if (c < 256) { + // extended ascii fast path + return valid_identifier_start_table[c]; + } + // TODO: handle this + return false; +} + +static_assert(unicode::is_valid_identifier_start('$')); +static_assert(unicode::is_valid_identifier_start('_')); +static_assert(unicode::is_valid_identifier_start('a')); +static_assert(unicode::is_valid_identifier_start('z')); +static_assert(unicode::is_valid_identifier_start('A')); +static_assert(unicode::is_valid_identifier_start('Z')); +static_assert(!unicode::is_valid_identifier_start('0')); +static_assert(!unicode::is_valid_identifier_start('9')); +static_assert(!unicode::is_valid_identifier_start('\n')); +static_assert(!unicode::is_valid_identifier_start('\\')); +static_assert(!unicode::is_valid_identifier_start('\'')); +static_assert(!unicode::is_valid_identifier_start('*')); +static_assert(!unicode::is_valid_identifier_start('&')); + +constexpr static bool valid_identifier_part_table[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1}; + +static_assert(sizeof(valid_identifier_part_table) == 256); + +ada_really_inline constexpr bool is_valid_identifier_part( + const char32_t c) noexcept { + if (c < 256) { + // extended ascii fast path + return valid_identifier_part_table[c]; + } + // TODO: handle this + return false; +} + +static_assert(unicode::is_valid_identifier_part('$')); +static_assert(unicode::is_valid_identifier_part('_')); +static_assert(unicode::is_valid_identifier_part('a')); +static_assert(unicode::is_valid_identifier_part('z')); +static_assert(unicode::is_valid_identifier_part('A')); +static_assert(unicode::is_valid_identifier_part('Z')); +static_assert(unicode::is_valid_identifier_part('0')); +static_assert(unicode::is_valid_identifier_part('9')); +static_assert(!unicode::is_valid_identifier_part('\n')); +static_assert(!unicode::is_valid_identifier_part('\\')); +static_assert(!unicode::is_valid_identifier_part('\'')); +static_assert(!unicode::is_valid_identifier_part('*')); +static_assert(!unicode::is_valid_identifier_part('&')); + ada_really_inline constexpr bool is_ascii_hex_digit(const char c) noexcept { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp new file mode 100644 index 000000000..f01f0d620 --- /dev/null +++ b/src/urlpattern.cpp @@ -0,0 +1,17 @@ +#include "ada/urlpattern.h" +#include "common_defs.h" + +namespace ada { +ada_really_inline bool is_valid_name_code_point(const char32_t& c, + bool is_first) { + // To perform is a valid name code point given a Unicode code point and a + // boolean first: If first is true return the result of checking if code + + // is contained in the IdentifierStart set of code points. + if (is_first) { + return c <= 255 ? unicode::is_identifier_start(c) : false; + } + return c <= 255 ? unicode::is_identifier_part(c) : false; +} + +} // namespace ada \ No newline at end of file From 4aa5f5518768d1aa244d89ee587088934a833f9c Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 9 May 2023 17:13:23 -0300 Subject: [PATCH 02/23] urlpattern: adds id_start & id_part + tokenizer sketch --- include/ada.h | 1 + include/ada/unicode.h | 4 + include/ada/urlpattern.h | 9 +- src/ada.cpp | 3 +- src/unicode.cpp | 4670 +++++++++++++++++++++++++++++++++++++- src/urlpattern.cpp | 200 +- 6 files changed, 4837 insertions(+), 50 deletions(-) diff --git a/include/ada.h b/include/ada.h index da8723394..9ca33aa46 100644 --- a/include/ada.h +++ b/include/ada.h @@ -23,6 +23,7 @@ #include "ada/url_components.h" #include "ada/url_aggregator.h" #include "ada/url_aggregator-inl.h" +#include "ada/urlpattern.h" // Public API #include "ada/ada_version.h" diff --git a/include/ada/unicode.h b/include/ada/unicode.h index 3c0208a39..ecf4881fb 100644 --- a/include/ada/unicode.h +++ b/include/ada/unicode.h @@ -201,6 +201,10 @@ ada_really_inline size_t percent_encode_index(const std::string_view input, * Return true if the content was ASCII. */ constexpr bool to_lower_ascii(char* input, size_t length) noexcept; + +bool is_valid_identifier_part(const char32_t& c) noexcept; +bool is_valid_identifier_start(const char32_t& c) noexcept; + } // namespace ada::unicode #endif // ADA_UNICODE_H diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index 307b4f647..3c8755ebf 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -1,13 +1,18 @@ #ifndef ADA_URL_PATTERN_H #define ADA_URL_PATTERN_H -#include -#include +#include "ada/common_defs.h" + #include #include +#include +#include namespace ada { +ada_really_inline bool is_valid_name_code_point(const char32_t& c, + bool is_first) noexcept; + struct urlpattern_options { bool ignore_case = false; }; diff --git a/src/ada.cpp b/src/ada.cpp index c4959c2c8..3720d665d 100644 --- a/src/ada.cpp +++ b/src/ada.cpp @@ -9,4 +9,5 @@ #include "url-setters.cpp" #include "parser.cpp" #include "url_components.cpp" -#include "url_aggregator.cpp" \ No newline at end of file +#include "url_aggregator.cpp" +#include "urlpattern.cpp" diff --git a/src/unicode.cpp b/src/unicode.cpp index 2a827056c..04d8707ad 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -255,31 +255,4637 @@ constexpr static bool valid_identifier_start_table[] = { static_assert(sizeof(valid_identifier_start_table) == 256); -ada_really_inline constexpr bool is_valid_identifier_start( - const char32_t c) noexcept { +// Valid IdentifierStart unicods points 256+ +// ranges obtained with the regex /[$_\p{ID_Start}]/u +// https://tc39.es/ecma262/#prod-IdentifierStart +size_t valid_id_start_ranges_unicode[6451][2] = { + {255, 705}, {710, 721}, {736, 740}, + {748, 748}, {750, 750}, {880, 884}, + {886, 887}, {890, 893}, {895, 895}, + {902, 902}, {904, 906}, {908, 908}, + {910, 929}, {931, 1013}, {1015, 1153}, + {1162, 1327}, {1329, 1366}, {1369, 1369}, + {1376, 1416}, {1488, 1514}, {1519, 1522}, + {1568, 1610}, {1646, 1647}, {1649, 1747}, + {1749, 1749}, {1765, 1766}, {1774, 1775}, + {1786, 1788}, {1791, 1791}, {1808, 1808}, + {1810, 1839}, {1869, 1957}, {1969, 1969}, + {1994, 2026}, {2036, 2037}, {2042, 2042}, + {2048, 2069}, {2074, 2074}, {2084, 2084}, + {2088, 2088}, {2112, 2136}, {2144, 2154}, + {2160, 2183}, {2185, 2190}, {2208, 2249}, + {2308, 2361}, {2365, 2365}, {2384, 2384}, + {2392, 2401}, {2417, 2432}, {2437, 2444}, + {2447, 2448}, {2451, 2472}, {2474, 2480}, + {2482, 2482}, {2486, 2489}, {2493, 2493}, + {2510, 2510}, {2524, 2525}, {2527, 2529}, + {2544, 2545}, {2556, 2556}, {2565, 2570}, + {2575, 2576}, {2579, 2600}, {2602, 2608}, + {2610, 2611}, {2613, 2614}, {2616, 2617}, + {2649, 2652}, {2654, 2654}, {2674, 2676}, + {2693, 2701}, {2703, 2705}, {2707, 2728}, + {2730, 2736}, {2738, 2739}, {2741, 2745}, + {2749, 2749}, {2768, 2768}, {2784, 2785}, + {2809, 2809}, {2821, 2828}, {2831, 2832}, + {2835, 2856}, {2858, 2864}, {2866, 2867}, + {2869, 2873}, {2877, 2877}, {2908, 2909}, + {2911, 2913}, {2929, 2929}, {2947, 2947}, + {2949, 2954}, {2958, 2960}, {2962, 2965}, + {2969, 2970}, {2972, 2972}, {2974, 2975}, + {2979, 2980}, {2984, 2986}, {2990, 3001}, + {3024, 3024}, {3077, 3084}, {3086, 3088}, + {3090, 3112}, {3114, 3129}, {3133, 3133}, + {3160, 3162}, {3165, 3165}, {3168, 3169}, + {3200, 3200}, {3205, 3212}, {3214, 3216}, + {3218, 3240}, {3242, 3251}, {3253, 3257}, + {3261, 3261}, {3293, 3294}, {3296, 3297}, + {3313, 3314}, {3332, 3340}, {3342, 3344}, + {3346, 3386}, {3389, 3389}, {3406, 3406}, + {3412, 3414}, {3423, 3425}, {3450, 3455}, + {3461, 3478}, {3482, 3505}, {3507, 3515}, + {3517, 3517}, {3520, 3526}, {3585, 3632}, + {3634, 3635}, {3648, 3654}, {3713, 3714}, + {3716, 3716}, {3718, 3722}, {3724, 3747}, + {3749, 3749}, {3751, 3760}, {3762, 3763}, + {3773, 3773}, {3776, 3780}, {3782, 3782}, + {3804, 3807}, {3840, 3840}, {3904, 3911}, + {3913, 3948}, {3976, 3980}, {4096, 4138}, + {4159, 4159}, {4176, 4181}, {4186, 4189}, + {4193, 4193}, {4197, 4198}, {4206, 4208}, + {4213, 4225}, {4238, 4238}, {4256, 4293}, + {4295, 4295}, {4301, 4301}, {4304, 4346}, + {4348, 4680}, {4682, 4685}, {4688, 4694}, + {4696, 4696}, {4698, 4701}, {4704, 4744}, + {4746, 4749}, {4752, 4784}, {4786, 4789}, + {4792, 4798}, {4800, 4800}, {4802, 4805}, + {4808, 4822}, {4824, 4880}, {4882, 4885}, + {4888, 4954}, {4992, 5007}, {5024, 5109}, + {5112, 5117}, {5121, 5740}, {5743, 5759}, + {5761, 5786}, {5792, 5866}, {5870, 5880}, + {5888, 5905}, {5919, 5937}, {5952, 5969}, + {5984, 5996}, {5998, 6000}, {6016, 6067}, + {6103, 6103}, {6108, 6108}, {6176, 6264}, + {6272, 6312}, {6314, 6314}, {6320, 6389}, + {6400, 6430}, {6480, 6509}, {6512, 6516}, + {6528, 6571}, {6576, 6601}, {6656, 6678}, + {6688, 6740}, {6823, 6823}, {6917, 6963}, + {6981, 6988}, {7043, 7072}, {7086, 7087}, + {7098, 7141}, {7168, 7203}, {7245, 7247}, + {7258, 7293}, {7296, 7304}, {7312, 7354}, + {7357, 7359}, {7401, 7404}, {7406, 7411}, + {7413, 7414}, {7418, 7418}, {7424, 7615}, + {7680, 7957}, {7960, 7965}, {7968, 8005}, + {8008, 8013}, {8016, 8023}, {8025, 8025}, + {8027, 8027}, {8029, 8029}, {8031, 8061}, + {8064, 8116}, {8118, 8124}, {8126, 8126}, + {8130, 8132}, {8134, 8140}, {8144, 8147}, + {8150, 8155}, {8160, 8172}, {8178, 8180}, + {8182, 8188}, {8305, 8305}, {8319, 8319}, + {8336, 8348}, {8450, 8450}, {8455, 8455}, + {8458, 8467}, {8469, 8469}, {8472, 8477}, + {8484, 8484}, {8486, 8486}, {8488, 8488}, + {8490, 8505}, {8508, 8511}, {8517, 8521}, + {8526, 8526}, {8544, 8584}, {11264, 11492}, + {11499, 11502}, {11506, 11507}, {11520, 11557}, + {11559, 11559}, {11565, 11565}, {11568, 11623}, + {11631, 11631}, {11648, 11670}, {11680, 11686}, + {11688, 11694}, {11696, 11702}, {11704, 11710}, + {11712, 11718}, {11720, 11726}, {11728, 11734}, + {11736, 11742}, {12293, 12295}, {12321, 12329}, + {12337, 12341}, {12344, 12348}, {12353, 12438}, + {12443, 12447}, {12449, 12538}, {12540, 12543}, + {12549, 12591}, {12593, 12686}, {12704, 12735}, + {12784, 12799}, {13312, 19903}, {19968, 42124}, + {42192, 42237}, {42240, 42508}, {42512, 42527}, + {42538, 42539}, {42560, 42606}, {42623, 42653}, + {42656, 42735}, {42775, 42783}, {42786, 42888}, + {42891, 42954}, {42960, 42961}, {42963, 42963}, + {42965, 42969}, {42994, 43009}, {43011, 43013}, + {43015, 43018}, {43020, 43042}, {43072, 43123}, + {43138, 43187}, {43250, 43255}, {43259, 43259}, + {43261, 43262}, {43274, 43301}, {43312, 43334}, + {43360, 43388}, {43396, 43442}, {43471, 43471}, + {43488, 43492}, {43494, 43503}, {43514, 43518}, + {43520, 43560}, {43584, 43586}, {43588, 43595}, + {43616, 43638}, {43642, 43642}, {43646, 43695}, + {43697, 43697}, {43701, 43702}, {43705, 43709}, + {43712, 43712}, {43714, 43714}, {43739, 43741}, + {43744, 43754}, {43762, 43764}, {43777, 43782}, + {43785, 43790}, {43793, 43798}, {43808, 43814}, + {43816, 43822}, {43824, 43866}, {43868, 43881}, + {43888, 44002}, {44032, 55203}, {55216, 55238}, + {55243, 55291}, {63744, 64109}, {64112, 64217}, + {64256, 64262}, {64275, 64279}, {64285, 64285}, + {64287, 64296}, {64298, 64310}, {64312, 64316}, + {64318, 64318}, {64320, 64321}, {64323, 64324}, + {64326, 64433}, {64467, 64829}, {64848, 64911}, + {64914, 64967}, {65008, 65019}, {65136, 65140}, + {65142, 65276}, {65313, 65338}, {65345, 65370}, + {65382, 65470}, {65474, 65479}, {65482, 65487}, + {65490, 65495}, {65498, 65500}, {65572, 65572}, + {65601, 65626}, {65631, 65631}, {65633, 65658}, + {65706, 65706}, {65717, 65717}, {65722, 65722}, + {65728, 65750}, {65752, 65782}, {65784, 66241}, + {66246, 66257}, {66272, 66276}, {66284, 66284}, + {66286, 66286}, {66416, 66420}, {66422, 66423}, + {66426, 66429}, {66431, 66431}, {66438, 66438}, + {66440, 66442}, {66444, 66444}, {66446, 66465}, + {66467, 66549}, {66551, 66689}, {66698, 66863}, + {66865, 66902}, {66905, 66905}, {66912, 66952}, + {67024, 67050}, {67055, 67058}, {67104, 67146}, + {67182, 67183}, {67185, 67283}, {67285, 67285}, + {67301, 67302}, {67310, 67311}, {67322, 67324}, + {67327, 67327}, {67344, 67344}, {67346, 67375}, + {67405, 67493}, {67505, 67505}, {67530, 67562}, + {67572, 67573}, {67578, 67578}, {67584, 67605}, + {67610, 67610}, {67620, 67620}, {67624, 67624}, + {67648, 67672}, {67680, 67690}, {67696, 67719}, + {67721, 67726}, {67744, 67785}, {67844, 67897}, + {67901, 67901}, {67920, 67920}, {67928, 67937}, + {67953, 67968}, {67973, 67980}, {67983, 67984}, + {67987, 68008}, {68010, 68016}, {68018, 68018}, + {68022, 68025}, {68029, 68029}, {68046, 68046}, + {68060, 68061}, {68063, 68065}, {68080, 68081}, + {68092, 68092}, {68101, 68106}, {68111, 68112}, + {68115, 68136}, {68138, 68144}, {68146, 68147}, + {68149, 68150}, {68152, 68153}, {68185, 68188}, + {68190, 68190}, {68210, 68212}, {68229, 68237}, + {68239, 68241}, {68243, 68264}, {68266, 68272}, + {68274, 68275}, {68277, 68281}, {68285, 68285}, + {68304, 68304}, {68320, 68321}, {68345, 68345}, + {68357, 68364}, {68367, 68368}, {68371, 68392}, + {68394, 68400}, {68402, 68403}, {68405, 68409}, + {68413, 68413}, {68444, 68445}, {68447, 68449}, + {68465, 68465}, {68483, 68483}, {68485, 68490}, + {68494, 68496}, {68498, 68501}, {68505, 68506}, + {68508, 68508}, {68510, 68511}, {68515, 68516}, + {68520, 68522}, {68526, 68537}, {68560, 68560}, + {68613, 68620}, {68622, 68624}, {68626, 68648}, + {68650, 68665}, {68669, 68669}, {68696, 68698}, + {68701, 68701}, {68704, 68705}, {68736, 68736}, + {68741, 68748}, {68750, 68752}, {68754, 68776}, + {68778, 68787}, {68789, 68793}, {68797, 68797}, + {68829, 68830}, {68832, 68833}, {68849, 68850}, + {68868, 68876}, {68878, 68880}, {68882, 68922}, + {68925, 68925}, {68942, 68942}, {68948, 68950}, + {68959, 68961}, {68986, 68991}, {68997, 69014}, + {69018, 69041}, {69043, 69051}, {69053, 69053}, + {69056, 69062}, {69121, 69168}, {69170, 69171}, + {69184, 69190}, {69249, 69250}, {69252, 69252}, + {69254, 69258}, {69260, 69283}, {69285, 69285}, + {69287, 69296}, {69298, 69299}, {69309, 69309}, + {69312, 69316}, {69318, 69318}, {69340, 69343}, + {69376, 69376}, {69440, 69447}, {69449, 69484}, + {69512, 69516}, {69632, 69674}, {69695, 69695}, + {69712, 69717}, {69722, 69725}, {69729, 69729}, + {69733, 69734}, {69742, 69744}, {69749, 69761}, + {69774, 69774}, {69792, 69829}, {69831, 69831}, + {69837, 69837}, {69840, 69882}, {69884, 70216}, + {70218, 70221}, {70224, 70230}, {70232, 70232}, + {70234, 70237}, {70240, 70280}, {70282, 70285}, + {70288, 70320}, {70322, 70325}, {70328, 70334}, + {70336, 70336}, {70338, 70341}, {70344, 70358}, + {70360, 70416}, {70418, 70421}, {70424, 70490}, + {70528, 70543}, {70560, 70645}, {70648, 70653}, + {70657, 71276}, {71279, 71295}, {71297, 71322}, + {71328, 71402}, {71406, 71416}, {71424, 71441}, + {71455, 71473}, {71488, 71505}, {71520, 71532}, + {71534, 71536}, {71552, 71603}, {71639, 71639}, + {71644, 71644}, {71712, 71800}, {71808, 71848}, + {71850, 71850}, {71856, 71925}, {71936, 71966}, + {72016, 72045}, {72048, 72052}, {72064, 72107}, + {72112, 72137}, {72192, 72214}, {72224, 72276}, + {72359, 72359}, {72453, 72499}, {72517, 72524}, + {72579, 72608}, {72622, 72623}, {72634, 72677}, + {72704, 72739}, {72781, 72783}, {72794, 72829}, + {72832, 72840}, {72848, 72890}, {72893, 72895}, + {72937, 72940}, {72942, 72947}, {72949, 72950}, + {72954, 72954}, {72960, 73151}, {73216, 73493}, + {73496, 73501}, {73504, 73541}, {73544, 73549}, + {73552, 73559}, {73561, 73561}, {73563, 73563}, + {73565, 73565}, {73567, 73597}, {73600, 73652}, + {73654, 73660}, {73662, 73662}, {73666, 73668}, + {73670, 73676}, {73680, 73683}, {73686, 73691}, + {73696, 73708}, {73714, 73716}, {73718, 73724}, + {73841, 73841}, {73855, 73855}, {73872, 73884}, + {73986, 73986}, {73991, 73991}, {73994, 74003}, + {74005, 74005}, {74008, 74013}, {74020, 74020}, + {74022, 74022}, {74024, 74024}, {74026, 74041}, + {74044, 74047}, {74053, 74057}, {74062, 74062}, + {74080, 74120}, {76800, 77028}, {77035, 77038}, + {77042, 77043}, {77056, 77093}, {77095, 77095}, + {77101, 77101}, {77104, 77159}, {77167, 77167}, + {77184, 77206}, {77216, 77222}, {77224, 77230}, + {77232, 77238}, {77240, 77246}, {77248, 77254}, + {77256, 77262}, {77264, 77270}, {77272, 77278}, + {77829, 77831}, {77857, 77865}, {77873, 77877}, + {77880, 77884}, {77889, 77974}, {77979, 77983}, + {77985, 78074}, {78076, 78079}, {78085, 78127}, + {78129, 78222}, {78240, 78271}, {78320, 78335}, + {78848, 85439}, {85504, 107660}, {107728, 107773}, + {107776, 108044}, {108048, 108063}, {108074, 108075}, + {108096, 108142}, {108159, 108189}, {108192, 108271}, + {108311, 108319}, {108322, 108424}, {108427, 108490}, + {108496, 108497}, {108499, 108499}, {108501, 108505}, + {108530, 108545}, {108547, 108549}, {108551, 108554}, + {108556, 108578}, {108608, 108659}, {108674, 108723}, + {108786, 108791}, {108795, 108795}, {108797, 108798}, + {108810, 108837}, {108848, 108870}, {108896, 108924}, + {108932, 108978}, {109007, 109007}, {109024, 109028}, + {109030, 109039}, {109050, 109054}, {109056, 109096}, + {109120, 109122}, {109124, 109131}, {109152, 109174}, + {109178, 109178}, {109182, 109231}, {109233, 109233}, + {109237, 109238}, {109241, 109245}, {109248, 109248}, + {109250, 109250}, {109275, 109277}, {109280, 109290}, + {109298, 109300}, {109313, 109318}, {109321, 109326}, + {109329, 109334}, {109344, 109350}, {109352, 109358}, + {109360, 109402}, {109404, 109417}, {109424, 109538}, + {109568, 120739}, {120752, 120774}, {120779, 120827}, + {129280, 129645}, {129648, 129753}, {129792, 129798}, + {129811, 129815}, {129821, 129821}, {129823, 129832}, + {129834, 129846}, {129848, 129852}, {129854, 129854}, + {129856, 129857}, {129859, 129860}, {129862, 129969}, + {130003, 130365}, {130384, 130447}, {130450, 130503}, + {130544, 130555}, {130672, 130676}, {130678, 130812}, + {130849, 130874}, {130881, 130906}, {130918, 131006}, + {131010, 131015}, {131018, 131023}, {131026, 131031}, + {131034, 131036}, {131108, 131108}, {131137, 131162}, + {131167, 131167}, {131169, 131194}, {131242, 131242}, + {131253, 131253}, {131258, 131258}, {131264, 131286}, + {131288, 131318}, {131320, 131777}, {131782, 131793}, + {131808, 131812}, {131820, 131820}, {131822, 131822}, + {131952, 131956}, {131958, 131959}, {131962, 131965}, + {131967, 131967}, {131974, 131974}, {131976, 131978}, + {131980, 131980}, {131982, 132001}, {132003, 132085}, + {132087, 132225}, {132234, 132399}, {132401, 132438}, + {132441, 132441}, {132448, 132488}, {132560, 132586}, + {132591, 132594}, {132640, 132682}, {132718, 132719}, + {132721, 132819}, {132821, 132821}, {132837, 132838}, + {132846, 132847}, {132858, 132860}, {132863, 132863}, + {132880, 132880}, {132882, 132911}, {132941, 133029}, + {133041, 133041}, {133066, 133098}, {133108, 133109}, + {133114, 133114}, {133120, 133141}, {133146, 133146}, + {133156, 133156}, {133160, 133160}, {133184, 133208}, + {133216, 133226}, {133232, 133255}, {133257, 133262}, + {133280, 133321}, {133380, 133433}, {133437, 133437}, + {133456, 133456}, {133464, 133473}, {133489, 133504}, + {133509, 133516}, {133519, 133520}, {133523, 133544}, + {133546, 133552}, {133554, 133554}, {133558, 133561}, + {133565, 133565}, {133582, 133582}, {133596, 133597}, + {133599, 133601}, {133616, 133617}, {133628, 133628}, + {133637, 133642}, {133647, 133648}, {133651, 133672}, + {133674, 133680}, {133682, 133683}, {133685, 133686}, + {133688, 133689}, {133721, 133724}, {133726, 133726}, + {133746, 133748}, {133765, 133773}, {133775, 133777}, + {133779, 133800}, {133802, 133808}, {133810, 133811}, + {133813, 133817}, {133821, 133821}, {133840, 133840}, + {133856, 133857}, {133881, 133881}, {133893, 133900}, + {133903, 133904}, {133907, 133928}, {133930, 133936}, + {133938, 133939}, {133941, 133945}, {133949, 133949}, + {133980, 133981}, {133983, 133985}, {134001, 134001}, + {134019, 134019}, {134021, 134026}, {134030, 134032}, + {134034, 134037}, {134041, 134042}, {134044, 134044}, + {134046, 134047}, {134051, 134052}, {134056, 134058}, + {134062, 134073}, {134096, 134096}, {134149, 134156}, + {134158, 134160}, {134162, 134184}, {134186, 134201}, + {134205, 134205}, {134232, 134234}, {134237, 134237}, + {134240, 134241}, {134272, 134272}, {134277, 134284}, + {134286, 134288}, {134290, 134312}, {134314, 134323}, + {134325, 134329}, {134333, 134333}, {134365, 134366}, + {134368, 134369}, {134385, 134386}, {134404, 134412}, + {134414, 134416}, {134418, 134458}, {134461, 134461}, + {134478, 134478}, {134484, 134486}, {134495, 134497}, + {134522, 134527}, {134533, 134550}, {134554, 134577}, + {134579, 134587}, {134589, 134589}, {134592, 134598}, + {134657, 134704}, {134706, 134707}, {134720, 134726}, + {134785, 134786}, {134788, 134788}, {134790, 134794}, + {134796, 134819}, {134821, 134821}, {134823, 134832}, + {134834, 134835}, {134845, 134845}, {134848, 134852}, + {134854, 134854}, {134876, 134879}, {134912, 134912}, + {134976, 134983}, {134985, 135020}, {135048, 135052}, + {135168, 135210}, {135231, 135231}, {135248, 135253}, + {135258, 135261}, {135265, 135265}, {135269, 135270}, + {135278, 135280}, {135285, 135297}, {135310, 135310}, + {135328, 135365}, {135367, 135367}, {135373, 135373}, + {135376, 135418}, {135420, 135752}, {135754, 135757}, + {135760, 135766}, {135768, 135768}, {135770, 135773}, + {135776, 135816}, {135818, 135821}, {135824, 135856}, + {135858, 135861}, {135864, 135870}, {135872, 135872}, + {135874, 135877}, {135880, 135894}, {135896, 135952}, + {135954, 135957}, {135960, 136026}, {136064, 136079}, + {136096, 136181}, {136184, 136189}, {136193, 136812}, + {136815, 136831}, {136833, 136858}, {136864, 136938}, + {136942, 136952}, {136960, 136977}, {136991, 137009}, + {137024, 137041}, {137056, 137068}, {137070, 137072}, + {137088, 137139}, {137175, 137175}, {137180, 137180}, + {137248, 137336}, {137344, 137384}, {137386, 137386}, + {137392, 137461}, {137472, 137502}, {137552, 137581}, + {137584, 137588}, {137600, 137643}, {137648, 137673}, + {137728, 137750}, {137760, 137812}, {137895, 137895}, + {137989, 138035}, {138053, 138060}, {138115, 138144}, + {138158, 138159}, {138170, 138213}, {138240, 138275}, + {138317, 138319}, {138330, 138365}, {138368, 138376}, + {138384, 138426}, {138429, 138431}, {138473, 138476}, + {138478, 138483}, {138485, 138486}, {138490, 138490}, + {138496, 138687}, {138752, 139029}, {139032, 139037}, + {139040, 139077}, {139080, 139085}, {139088, 139095}, + {139097, 139097}, {139099, 139099}, {139101, 139101}, + {139103, 139133}, {139136, 139188}, {139190, 139196}, + {139198, 139198}, {139202, 139204}, {139206, 139212}, + {139216, 139219}, {139222, 139227}, {139232, 139244}, + {139250, 139252}, {139254, 139260}, {139377, 139377}, + {139391, 139391}, {139408, 139420}, {139522, 139522}, + {139527, 139527}, {139530, 139539}, {139541, 139541}, + {139544, 139549}, {139556, 139556}, {139558, 139558}, + {139560, 139560}, {139562, 139577}, {139580, 139583}, + {139589, 139593}, {139598, 139598}, {139616, 139656}, + {142336, 142564}, {142571, 142574}, {142578, 142579}, + {142592, 142629}, {142631, 142631}, {142637, 142637}, + {142640, 142695}, {142703, 142703}, {142720, 142742}, + {142752, 142758}, {142760, 142766}, {142768, 142774}, + {142776, 142782}, {142784, 142790}, {142792, 142798}, + {142800, 142806}, {142808, 142814}, {143365, 143367}, + {143393, 143401}, {143409, 143413}, {143416, 143420}, + {143425, 143510}, {143515, 143519}, {143521, 143610}, + {143612, 143615}, {143621, 143663}, {143665, 143758}, + {143776, 143807}, {143856, 143871}, {144384, 150975}, + {151040, 173196}, {173264, 173309}, {173312, 173580}, + {173584, 173599}, {173610, 173611}, {173632, 173678}, + {173695, 173725}, {173728, 173807}, {173847, 173855}, + {173858, 173960}, {173963, 174026}, {174032, 174033}, + {174035, 174035}, {174037, 174041}, {174066, 174081}, + {174083, 174085}, {174087, 174090}, {174092, 174114}, + {174144, 174195}, {174210, 174259}, {174322, 174327}, + {174331, 174331}, {174333, 174334}, {174346, 174373}, + {174384, 174406}, {174432, 174460}, {174468, 174514}, + {174543, 174543}, {174560, 174564}, {174566, 174575}, + {174586, 174590}, {174592, 174632}, {174656, 174658}, + {174660, 174667}, {174688, 174710}, {174714, 174714}, + {174718, 174767}, {174769, 174769}, {174773, 174774}, + {174777, 174781}, {174784, 174784}, {174786, 174786}, + {174811, 174813}, {174816, 174826}, {174834, 174836}, + {174849, 174854}, {174857, 174862}, {174865, 174870}, + {174880, 174886}, {174888, 174894}, {174896, 174938}, + {174940, 174953}, {174960, 175074}, {175104, 186275}, + {186288, 186310}, {186315, 186363}, {194816, 195181}, + {195184, 195289}, {195328, 195334}, {195347, 195351}, + {195357, 195357}, {195359, 195368}, {195370, 195382}, + {195384, 195388}, {195390, 195390}, {195392, 195393}, + {195395, 195396}, {195398, 195505}, {195539, 195901}, + {195920, 195983}, {195986, 196039}, {196080, 196091}, + {196208, 196212}, {196214, 196348}, {196385, 196410}, + {196417, 196442}, {196454, 196542}, {196546, 196551}, + {196554, 196559}, {196562, 196567}, {196570, 196572}, + {196644, 196644}, {196673, 196698}, {196703, 196703}, + {196705, 196730}, {196778, 196778}, {196789, 196789}, + {196794, 196794}, {196800, 196822}, {196824, 196854}, + {196856, 197313}, {197318, 197329}, {197344, 197348}, + {197356, 197356}, {197358, 197358}, {197488, 197492}, + {197494, 197495}, {197498, 197501}, {197503, 197503}, + {197510, 197510}, {197512, 197514}, {197516, 197516}, + {197518, 197537}, {197539, 197621}, {197623, 197761}, + {197770, 197935}, {197937, 197974}, {197977, 197977}, + {197984, 198024}, {198096, 198122}, {198127, 198130}, + {198176, 198218}, {198254, 198255}, {198257, 198355}, + {198357, 198357}, {198373, 198374}, {198382, 198383}, + {198394, 198396}, {198399, 198399}, {198416, 198416}, + {198418, 198447}, {198477, 198565}, {198577, 198577}, + {198602, 198634}, {198644, 198645}, {198650, 198650}, + {198656, 198677}, {198682, 198682}, {198692, 198692}, + {198696, 198696}, {198720, 198744}, {198752, 198762}, + {198768, 198791}, {198793, 198798}, {198816, 198857}, + {198916, 198969}, {198973, 198973}, {198992, 198992}, + {199000, 199009}, {199025, 199040}, {199045, 199052}, + {199055, 199056}, {199059, 199080}, {199082, 199088}, + {199090, 199090}, {199094, 199097}, {199101, 199101}, + {199118, 199118}, {199132, 199133}, {199135, 199137}, + {199152, 199153}, {199164, 199164}, {199173, 199178}, + {199183, 199184}, {199187, 199208}, {199210, 199216}, + {199218, 199219}, {199221, 199222}, {199224, 199225}, + {199257, 199260}, {199262, 199262}, {199282, 199284}, + {199301, 199309}, {199311, 199313}, {199315, 199336}, + {199338, 199344}, {199346, 199347}, {199349, 199353}, + {199357, 199357}, {199376, 199376}, {199392, 199393}, + {199417, 199417}, {199429, 199436}, {199439, 199440}, + {199443, 199464}, {199466, 199472}, {199474, 199475}, + {199477, 199481}, {199485, 199485}, {199516, 199517}, + {199519, 199521}, {199537, 199537}, {199555, 199555}, + {199557, 199562}, {199566, 199568}, {199570, 199573}, + {199577, 199578}, {199580, 199580}, {199582, 199583}, + {199587, 199588}, {199592, 199594}, {199598, 199609}, + {199632, 199632}, {199685, 199692}, {199694, 199696}, + {199698, 199720}, {199722, 199737}, {199741, 199741}, + {199768, 199770}, {199773, 199773}, {199776, 199777}, + {199808, 199808}, {199813, 199820}, {199822, 199824}, + {199826, 199848}, {199850, 199859}, {199861, 199865}, + {199869, 199869}, {199901, 199902}, {199904, 199905}, + {199921, 199922}, {199940, 199948}, {199950, 199952}, + {199954, 199994}, {199997, 199997}, {200014, 200014}, + {200020, 200022}, {200031, 200033}, {200058, 200063}, + {200069, 200086}, {200090, 200113}, {200115, 200123}, + {200125, 200125}, {200128, 200134}, {200193, 200240}, + {200242, 200243}, {200256, 200262}, {200321, 200322}, + {200324, 200324}, {200326, 200330}, {200332, 200355}, + {200357, 200357}, {200359, 200368}, {200370, 200371}, + {200381, 200381}, {200384, 200388}, {200390, 200390}, + {200412, 200415}, {200448, 200448}, {200512, 200519}, + {200521, 200556}, {200584, 200588}, {200704, 200746}, + {200767, 200767}, {200784, 200789}, {200794, 200797}, + {200801, 200801}, {200805, 200806}, {200814, 200816}, + {200821, 200833}, {200846, 200846}, {200864, 200901}, + {200903, 200903}, {200909, 200909}, {200912, 200954}, + {200956, 201288}, {201290, 201293}, {201296, 201302}, + {201304, 201304}, {201306, 201309}, {201312, 201352}, + {201354, 201357}, {201360, 201392}, {201394, 201397}, + {201400, 201406}, {201408, 201408}, {201410, 201413}, + {201416, 201430}, {201432, 201488}, {201490, 201493}, + {201496, 201562}, {201600, 201615}, {201632, 201717}, + {201720, 201725}, {201729, 202348}, {202351, 202367}, + {202369, 202394}, {202400, 202474}, {202478, 202488}, + {202496, 202513}, {202527, 202545}, {202560, 202577}, + {202592, 202604}, {202606, 202608}, {202624, 202675}, + {202711, 202711}, {202716, 202716}, {202784, 202872}, + {202880, 202920}, {202922, 202922}, {202928, 202997}, + {203008, 203038}, {203088, 203117}, {203120, 203124}, + {203136, 203179}, {203184, 203209}, {203264, 203286}, + {203296, 203348}, {203431, 203431}, {203525, 203571}, + {203589, 203596}, {203651, 203680}, {203694, 203695}, + {203706, 203749}, {203776, 203811}, {203853, 203855}, + {203866, 203901}, {203904, 203912}, {203920, 203962}, + {203965, 203967}, {204009, 204012}, {204014, 204019}, + {204021, 204022}, {204026, 204026}, {204032, 204223}, + {204288, 204565}, {204568, 204573}, {204576, 204613}, + {204616, 204621}, {204624, 204631}, {204633, 204633}, + {204635, 204635}, {204637, 204637}, {204639, 204669}, + {204672, 204724}, {204726, 204732}, {204734, 204734}, + {204738, 204740}, {204742, 204748}, {204752, 204755}, + {204758, 204763}, {204768, 204780}, {204786, 204788}, + {204790, 204796}, {204913, 204913}, {204927, 204927}, + {204944, 204956}, {205058, 205058}, {205063, 205063}, + {205066, 205075}, {205077, 205077}, {205080, 205085}, + {205092, 205092}, {205094, 205094}, {205096, 205096}, + {205098, 205113}, {205116, 205119}, {205125, 205129}, + {205134, 205134}, {205152, 205192}, {207872, 208100}, + {208107, 208110}, {208114, 208115}, {208128, 208165}, + {208167, 208167}, {208173, 208173}, {208176, 208231}, + {208239, 208239}, {208256, 208278}, {208288, 208294}, + {208296, 208302}, {208304, 208310}, {208312, 208318}, + {208320, 208326}, {208328, 208334}, {208336, 208342}, + {208344, 208350}, {208901, 208903}, {208929, 208937}, + {208945, 208949}, {208952, 208956}, {208961, 209046}, + {209051, 209055}, {209057, 209146}, {209148, 209151}, + {209157, 209199}, {209201, 209294}, {209312, 209343}, + {209392, 209407}, {209920, 216511}, {216576, 238732}, + {238800, 238845}, {238848, 239116}, {239120, 239135}, + {239146, 239147}, {239168, 239214}, {239231, 239261}, + {239264, 239343}, {239383, 239391}, {239394, 239496}, + {239499, 239562}, {239568, 239569}, {239571, 239571}, + {239573, 239577}, {239602, 239617}, {239619, 239621}, + {239623, 239626}, {239628, 239650}, {239680, 239731}, + {239746, 239795}, {239858, 239863}, {239867, 239867}, + {239869, 239870}, {239882, 239909}, {239920, 239942}, + {239968, 239996}, {240004, 240050}, {240079, 240079}, + {240096, 240100}, {240102, 240111}, {240122, 240126}, + {240128, 240168}, {240192, 240194}, {240196, 240203}, + {240224, 240246}, {240250, 240250}, {240254, 240303}, + {240305, 240305}, {240309, 240310}, {240313, 240317}, + {240320, 240320}, {240322, 240322}, {240347, 240349}, + {240352, 240362}, {240370, 240372}, {240385, 240390}, + {240393, 240398}, {240401, 240406}, {240416, 240422}, + {240424, 240430}, {240432, 240474}, {240476, 240489}, + {240496, 240610}, {240640, 251811}, {251824, 251846}, + {251851, 251899}, {260352, 260717}, {260720, 260825}, + {260864, 260870}, {260883, 260887}, {260893, 260893}, + {260895, 260904}, {260906, 260918}, {260920, 260924}, + {260926, 260926}, {260928, 260929}, {260931, 260932}, + {260934, 261041}, {261075, 261437}, {261456, 261519}, + {261522, 261575}, {261616, 261627}, {261744, 261748}, + {261750, 261884}, {261921, 261946}, {261953, 261978}, + {261990, 262078}, {262082, 262087}, {262090, 262095}, + {262098, 262103}, {262106, 262108}, {262180, 262180}, + {262209, 262234}, {262239, 262239}, {262241, 262266}, + {262314, 262314}, {262325, 262325}, {262330, 262330}, + {262336, 262358}, {262360, 262390}, {262392, 262849}, + {262854, 262865}, {262880, 262884}, {262892, 262892}, + {262894, 262894}, {263024, 263028}, {263030, 263031}, + {263034, 263037}, {263039, 263039}, {263046, 263046}, + {263048, 263050}, {263052, 263052}, {263054, 263073}, + {263075, 263157}, {263159, 263297}, {263306, 263471}, + {263473, 263510}, {263513, 263513}, {263520, 263560}, + {263632, 263658}, {263663, 263666}, {263712, 263754}, + {263790, 263791}, {263793, 263891}, {263893, 263893}, + {263909, 263910}, {263918, 263919}, {263930, 263932}, + {263935, 263935}, {263952, 263952}, {263954, 263983}, + {264013, 264101}, {264113, 264113}, {264138, 264170}, + {264180, 264181}, {264186, 264186}, {264192, 264213}, + {264218, 264218}, {264228, 264228}, {264232, 264232}, + {264256, 264280}, {264288, 264298}, {264304, 264327}, + {264329, 264334}, {264352, 264393}, {264452, 264505}, + {264509, 264509}, {264528, 264528}, {264536, 264545}, + {264561, 264576}, {264581, 264588}, {264591, 264592}, + {264595, 264616}, {264618, 264624}, {264626, 264626}, + {264630, 264633}, {264637, 264637}, {264654, 264654}, + {264668, 264669}, {264671, 264673}, {264688, 264689}, + {264700, 264700}, {264709, 264714}, {264719, 264720}, + {264723, 264744}, {264746, 264752}, {264754, 264755}, + {264757, 264758}, {264760, 264761}, {264793, 264796}, + {264798, 264798}, {264818, 264820}, {264837, 264845}, + {264847, 264849}, {264851, 264872}, {264874, 264880}, + {264882, 264883}, {264885, 264889}, {264893, 264893}, + {264912, 264912}, {264928, 264929}, {264953, 264953}, + {264965, 264972}, {264975, 264976}, {264979, 265000}, + {265002, 265008}, {265010, 265011}, {265013, 265017}, + {265021, 265021}, {265052, 265053}, {265055, 265057}, + {265073, 265073}, {265091, 265091}, {265093, 265098}, + {265102, 265104}, {265106, 265109}, {265113, 265114}, + {265116, 265116}, {265118, 265119}, {265123, 265124}, + {265128, 265130}, {265134, 265145}, {265168, 265168}, + {265221, 265228}, {265230, 265232}, {265234, 265256}, + {265258, 265273}, {265277, 265277}, {265304, 265306}, + {265309, 265309}, {265312, 265313}, {265344, 265344}, + {265349, 265356}, {265358, 265360}, {265362, 265384}, + {265386, 265395}, {265397, 265401}, {265405, 265405}, + {265437, 265438}, {265440, 265441}, {265457, 265458}, + {265476, 265484}, {265486, 265488}, {265490, 265530}, + {265533, 265533}, {265550, 265550}, {265556, 265558}, + {265567, 265569}, {265594, 265599}, {265605, 265622}, + {265626, 265649}, {265651, 265659}, {265661, 265661}, + {265664, 265670}, {265729, 265776}, {265778, 265779}, + {265792, 265798}, {265857, 265858}, {265860, 265860}, + {265862, 265866}, {265868, 265891}, {265893, 265893}, + {265895, 265904}, {265906, 265907}, {265917, 265917}, + {265920, 265924}, {265926, 265926}, {265948, 265951}, + {265984, 265984}, {266048, 266055}, {266057, 266092}, + {266120, 266124}, {266240, 266282}, {266303, 266303}, + {266320, 266325}, {266330, 266333}, {266337, 266337}, + {266341, 266342}, {266350, 266352}, {266357, 266369}, + {266382, 266382}, {266400, 266437}, {266439, 266439}, + {266445, 266445}, {266448, 266490}, {266492, 266824}, + {266826, 266829}, {266832, 266838}, {266840, 266840}, + {266842, 266845}, {266848, 266888}, {266890, 266893}, + {266896, 266928}, {266930, 266933}, {266936, 266942}, + {266944, 266944}, {266946, 266949}, {266952, 266966}, + {266968, 267024}, {267026, 267029}, {267032, 267098}, + {267136, 267151}, {267168, 267253}, {267256, 267261}, + {267265, 267884}, {267887, 267903}, {267905, 267930}, + {267936, 268010}, {268014, 268024}, {268032, 268049}, + {268063, 268081}, {268096, 268113}, {268128, 268140}, + {268142, 268144}, {268160, 268211}, {268247, 268247}, + {268252, 268252}, {268320, 268408}, {268416, 268456}, + {268458, 268458}, {268464, 268533}, {268544, 268574}, + {268624, 268653}, {268656, 268660}, {268672, 268715}, + {268720, 268745}, {268800, 268822}, {268832, 268884}, + {268967, 268967}, {269061, 269107}, {269125, 269132}, + {269187, 269216}, {269230, 269231}, {269242, 269285}, + {269312, 269347}, {269389, 269391}, {269402, 269437}, + {269440, 269448}, {269456, 269498}, {269501, 269503}, + {269545, 269548}, {269550, 269555}, {269557, 269558}, + {269562, 269562}, {269568, 269759}, {269824, 270101}, + {270104, 270109}, {270112, 270149}, {270152, 270157}, + {270160, 270167}, {270169, 270169}, {270171, 270171}, + {270173, 270173}, {270175, 270205}, {270208, 270260}, + {270262, 270268}, {270270, 270270}, {270274, 270276}, + {270278, 270284}, {270288, 270291}, {270294, 270299}, + {270304, 270316}, {270322, 270324}, {270326, 270332}, + {270449, 270449}, {270463, 270463}, {270480, 270492}, + {270594, 270594}, {270599, 270599}, {270602, 270611}, + {270613, 270613}, {270616, 270621}, {270628, 270628}, + {270630, 270630}, {270632, 270632}, {270634, 270649}, + {270652, 270655}, {270661, 270665}, {270670, 270670}, + {270688, 270728}, {273408, 273636}, {273643, 273646}, + {273650, 273651}, {273664, 273701}, {273703, 273703}, + {273709, 273709}, {273712, 273767}, {273775, 273775}, + {273792, 273814}, {273824, 273830}, {273832, 273838}, + {273840, 273846}, {273848, 273854}, {273856, 273862}, + {273864, 273870}, {273872, 273878}, {273880, 273886}, + {274437, 274439}, {274465, 274473}, {274481, 274485}, + {274488, 274492}, {274497, 274582}, {274587, 274591}, + {274593, 274682}, {274684, 274687}, {274693, 274735}, + {274737, 274830}, {274848, 274879}, {274928, 274943}, + {275456, 282047}, {282112, 304268}, {304336, 304381}, + {304384, 304652}, {304656, 304671}, {304682, 304683}, + {304704, 304750}, {304767, 304797}, {304800, 304879}, + {304919, 304927}, {304930, 305032}, {305035, 305098}, + {305104, 305105}, {305107, 305107}, {305109, 305113}, + {305138, 305153}, {305155, 305157}, {305159, 305162}, + {305164, 305186}, {305216, 305267}, {305282, 305331}, + {305394, 305399}, {305403, 305403}, {305405, 305406}, + {305418, 305445}, {305456, 305478}, {305504, 305532}, + {305540, 305586}, {305615, 305615}, {305632, 305636}, + {305638, 305647}, {305658, 305662}, {305664, 305704}, + {305728, 305730}, {305732, 305739}, {305760, 305782}, + {305786, 305786}, {305790, 305839}, {305841, 305841}, + {305845, 305846}, {305849, 305853}, {305856, 305856}, + {305858, 305858}, {305883, 305885}, {305888, 305898}, + {305906, 305908}, {305921, 305926}, {305929, 305934}, + {305937, 305942}, {305952, 305958}, {305960, 305966}, + {305968, 306010}, {306012, 306025}, {306032, 306146}, + {306176, 317347}, {317360, 317382}, {317387, 317435}, + {325888, 326253}, {326256, 326361}, {326400, 326406}, + {326419, 326423}, {326429, 326429}, {326431, 326440}, + {326442, 326454}, {326456, 326460}, {326462, 326462}, + {326464, 326465}, {326467, 326468}, {326470, 326577}, + {326611, 326973}, {326992, 327055}, {327058, 327111}, + {327152, 327163}, {327280, 327284}, {327286, 327420}, + {327457, 327482}, {327489, 327514}, {327526, 327614}, + {327618, 327623}, {327626, 327631}, {327634, 327639}, + {327642, 327644}, {327716, 327716}, {327745, 327770}, + {327775, 327775}, {327777, 327802}, {327850, 327850}, + {327861, 327861}, {327866, 327866}, {327872, 327894}, + {327896, 327926}, {327928, 328385}, {328390, 328401}, + {328416, 328420}, {328428, 328428}, {328430, 328430}, + {328560, 328564}, {328566, 328567}, {328570, 328573}, + {328575, 328575}, {328582, 328582}, {328584, 328586}, + {328588, 328588}, {328590, 328609}, {328611, 328693}, + {328695, 328833}, {328842, 329007}, {329009, 329046}, + {329049, 329049}, {329056, 329096}, {329168, 329194}, + {329199, 329202}, {329248, 329290}, {329326, 329327}, + {329329, 329427}, {329429, 329429}, {329445, 329446}, + {329454, 329455}, {329466, 329468}, {329471, 329471}, + {329488, 329488}, {329490, 329519}, {329549, 329637}, + {329649, 329649}, {329674, 329706}, {329716, 329717}, + {329722, 329722}, {329728, 329749}, {329754, 329754}, + {329764, 329764}, {329768, 329768}, {329792, 329816}, + {329824, 329834}, {329840, 329863}, {329865, 329870}, + {329888, 329929}, {329988, 330041}, {330045, 330045}, + {330064, 330064}, {330072, 330081}, {330097, 330112}, + {330117, 330124}, {330127, 330128}, {330131, 330152}, + {330154, 330160}, {330162, 330162}, {330166, 330169}, + {330173, 330173}, {330190, 330190}, {330204, 330205}, + {330207, 330209}, {330224, 330225}, {330236, 330236}, + {330245, 330250}, {330255, 330256}, {330259, 330280}, + {330282, 330288}, {330290, 330291}, {330293, 330294}, + {330296, 330297}, {330329, 330332}, {330334, 330334}, + {330354, 330356}, {330373, 330381}, {330383, 330385}, + {330387, 330408}, {330410, 330416}, {330418, 330419}, + {330421, 330425}, {330429, 330429}, {330448, 330448}, + {330464, 330465}, {330489, 330489}, {330501, 330508}, + {330511, 330512}, {330515, 330536}, {330538, 330544}, + {330546, 330547}, {330549, 330553}, {330557, 330557}, + {330588, 330589}, {330591, 330593}, {330609, 330609}, + {330627, 330627}, {330629, 330634}, {330638, 330640}, + {330642, 330645}, {330649, 330650}, {330652, 330652}, + {330654, 330655}, {330659, 330660}, {330664, 330666}, + {330670, 330681}, {330704, 330704}, {330757, 330764}, + {330766, 330768}, {330770, 330792}, {330794, 330809}, + {330813, 330813}, {330840, 330842}, {330845, 330845}, + {330848, 330849}, {330880, 330880}, {330885, 330892}, + {330894, 330896}, {330898, 330920}, {330922, 330931}, + {330933, 330937}, {330941, 330941}, {330973, 330974}, + {330976, 330977}, {330993, 330994}, {331012, 331020}, + {331022, 331024}, {331026, 331066}, {331069, 331069}, + {331086, 331086}, {331092, 331094}, {331103, 331105}, + {331130, 331135}, {331141, 331158}, {331162, 331185}, + {331187, 331195}, {331197, 331197}, {331200, 331206}, + {331265, 331312}, {331314, 331315}, {331328, 331334}, + {331393, 331394}, {331396, 331396}, {331398, 331402}, + {331404, 331427}, {331429, 331429}, {331431, 331440}, + {331442, 331443}, {331453, 331453}, {331456, 331460}, + {331462, 331462}, {331484, 331487}, {331520, 331520}, + {331584, 331591}, {331593, 331628}, {331656, 331660}, + {331776, 331818}, {331839, 331839}, {331856, 331861}, + {331866, 331869}, {331873, 331873}, {331877, 331878}, + {331886, 331888}, {331893, 331905}, {331918, 331918}, + {331936, 331973}, {331975, 331975}, {331981, 331981}, + {331984, 332026}, {332028, 332360}, {332362, 332365}, + {332368, 332374}, {332376, 332376}, {332378, 332381}, + {332384, 332424}, {332426, 332429}, {332432, 332464}, + {332466, 332469}, {332472, 332478}, {332480, 332480}, + {332482, 332485}, {332488, 332502}, {332504, 332560}, + {332562, 332565}, {332568, 332634}, {332672, 332687}, + {332704, 332789}, {332792, 332797}, {332801, 333420}, + {333423, 333439}, {333441, 333466}, {333472, 333546}, + {333550, 333560}, {333568, 333585}, {333599, 333617}, + {333632, 333649}, {333664, 333676}, {333678, 333680}, + {333696, 333747}, {333783, 333783}, {333788, 333788}, + {333856, 333944}, {333952, 333992}, {333994, 333994}, + {334000, 334069}, {334080, 334110}, {334160, 334189}, + {334192, 334196}, {334208, 334251}, {334256, 334281}, + {334336, 334358}, {334368, 334420}, {334503, 334503}, + {334597, 334643}, {334661, 334668}, {334723, 334752}, + {334766, 334767}, {334778, 334821}, {334848, 334883}, + {334925, 334927}, {334938, 334973}, {334976, 334984}, + {334992, 335034}, {335037, 335039}, {335081, 335084}, + {335086, 335091}, {335093, 335094}, {335098, 335098}, + {335104, 335295}, {335360, 335637}, {335640, 335645}, + {335648, 335685}, {335688, 335693}, {335696, 335703}, + {335705, 335705}, {335707, 335707}, {335709, 335709}, + {335711, 335741}, {335744, 335796}, {335798, 335804}, + {335806, 335806}, {335810, 335812}, {335814, 335820}, + {335824, 335827}, {335830, 335835}, {335840, 335852}, + {335858, 335860}, {335862, 335868}, {335985, 335985}, + {335999, 335999}, {336016, 336028}, {336130, 336130}, + {336135, 336135}, {336138, 336147}, {336149, 336149}, + {336152, 336157}, {336164, 336164}, {336166, 336166}, + {336168, 336168}, {336170, 336185}, {336188, 336191}, + {336197, 336201}, {336206, 336206}, {336224, 336264}, + {338944, 339172}, {339179, 339182}, {339186, 339187}, + {339200, 339237}, {339239, 339239}, {339245, 339245}, + {339248, 339303}, {339311, 339311}, {339328, 339350}, + {339360, 339366}, {339368, 339374}, {339376, 339382}, + {339384, 339390}, {339392, 339398}, {339400, 339406}, + {339408, 339414}, {339416, 339422}, {339973, 339975}, + {340001, 340009}, {340017, 340021}, {340024, 340028}, + {340033, 340118}, {340123, 340127}, {340129, 340218}, + {340220, 340223}, {340229, 340271}, {340273, 340366}, + {340384, 340415}, {340464, 340479}, {340992, 347583}, + {347648, 369804}, {369872, 369917}, {369920, 370188}, + {370192, 370207}, {370218, 370219}, {370240, 370286}, + {370303, 370333}, {370336, 370415}, {370455, 370463}, + {370466, 370568}, {370571, 370634}, {370640, 370641}, + {370643, 370643}, {370645, 370649}, {370674, 370689}, + {370691, 370693}, {370695, 370698}, {370700, 370722}, + {370752, 370803}, {370818, 370867}, {370930, 370935}, + {370939, 370939}, {370941, 370942}, {370954, 370981}, + {370992, 371014}, {371040, 371068}, {371076, 371122}, + {371151, 371151}, {371168, 371172}, {371174, 371183}, + {371194, 371198}, {371200, 371240}, {371264, 371266}, + {371268, 371275}, {371296, 371318}, {371322, 371322}, + {371326, 371375}, {371377, 371377}, {371381, 371382}, + {371385, 371389}, {371392, 371392}, {371394, 371394}, + {371419, 371421}, {371424, 371434}, {371442, 371444}, + {371457, 371462}, {371465, 371470}, {371473, 371478}, + {371488, 371494}, {371496, 371502}, {371504, 371546}, + {371548, 371561}, {371568, 371682}, {371712, 382883}, + {382896, 382918}, {382923, 382971}, {391424, 391789}, + {391792, 391897}, {391936, 391942}, {391955, 391959}, + {391965, 391965}, {391967, 391976}, {391978, 391990}, + {391992, 391996}, {391998, 391998}, {392000, 392001}, + {392003, 392004}, {392006, 392113}, {392147, 392509}, + {392528, 392591}, {392594, 392647}, {392688, 392699}, + {392816, 392820}, {392822, 392956}, {392993, 393018}, + {393025, 393050}, {393062, 393150}, {393154, 393159}, + {393162, 393167}, {393170, 393175}, {393178, 393180}, + {393252, 393252}, {393281, 393306}, {393311, 393311}, + {393313, 393338}, {393386, 393386}, {393397, 393397}, + {393402, 393402}, {393408, 393430}, {393432, 393462}, + {393464, 393921}, {393926, 393937}, {393952, 393956}, + {393964, 393964}, {393966, 393966}, {394096, 394100}, + {394102, 394103}, {394106, 394109}, {394111, 394111}, + {394118, 394118}, {394120, 394122}, {394124, 394124}, + {394126, 394145}, {394147, 394229}, {394231, 394369}, + {394378, 394543}, {394545, 394582}, {394585, 394585}, + {394592, 394632}, {394704, 394730}, {394735, 394738}, + {394784, 394826}, {394862, 394863}, {394865, 394963}, + {394965, 394965}, {394981, 394982}, {394990, 394991}, + {395002, 395004}, {395007, 395007}, {395024, 395024}, + {395026, 395055}, {395085, 395173}, {395185, 395185}, + {395210, 395242}, {395252, 395253}, {395258, 395258}, + {395264, 395285}, {395290, 395290}, {395300, 395300}, + {395304, 395304}, {395328, 395352}, {395360, 395370}, + {395376, 395399}, {395401, 395406}, {395424, 395465}, + {395524, 395577}, {395581, 395581}, {395600, 395600}, + {395608, 395617}, {395633, 395648}, {395653, 395660}, + {395663, 395664}, {395667, 395688}, {395690, 395696}, + {395698, 395698}, {395702, 395705}, {395709, 395709}, + {395726, 395726}, {395740, 395741}, {395743, 395745}, + {395760, 395761}, {395772, 395772}, {395781, 395786}, + {395791, 395792}, {395795, 395816}, {395818, 395824}, + {395826, 395827}, {395829, 395830}, {395832, 395833}, + {395865, 395868}, {395870, 395870}, {395890, 395892}, + {395909, 395917}, {395919, 395921}, {395923, 395944}, + {395946, 395952}, {395954, 395955}, {395957, 395961}, + {395965, 395965}, {395984, 395984}, {396000, 396001}, + {396025, 396025}, {396037, 396044}, {396047, 396048}, + {396051, 396072}, {396074, 396080}, {396082, 396083}, + {396085, 396089}, {396093, 396093}, {396124, 396125}, + {396127, 396129}, {396145, 396145}, {396163, 396163}, + {396165, 396170}, {396174, 396176}, {396178, 396181}, + {396185, 396186}, {396188, 396188}, {396190, 396191}, + {396195, 396196}, {396200, 396202}, {396206, 396217}, + {396240, 396240}, {396293, 396300}, {396302, 396304}, + {396306, 396328}, {396330, 396345}, {396349, 396349}, + {396376, 396378}, {396381, 396381}, {396384, 396385}, + {396416, 396416}, {396421, 396428}, {396430, 396432}, + {396434, 396456}, {396458, 396467}, {396469, 396473}, + {396477, 396477}, {396509, 396510}, {396512, 396513}, + {396529, 396530}, {396548, 396556}, {396558, 396560}, + {396562, 396602}, {396605, 396605}, {396622, 396622}, + {396628, 396630}, {396639, 396641}, {396666, 396671}, + {396677, 396694}, {396698, 396721}, {396723, 396731}, + {396733, 396733}, {396736, 396742}, {396801, 396848}, + {396850, 396851}, {396864, 396870}, {396929, 396930}, + {396932, 396932}, {396934, 396938}, {396940, 396963}, + {396965, 396965}, {396967, 396976}, {396978, 396979}, + {396989, 396989}, {396992, 396996}, {396998, 396998}, + {397020, 397023}, {397056, 397056}, {397120, 397127}, + {397129, 397164}, {397192, 397196}, {397312, 397354}, + {397375, 397375}, {397392, 397397}, {397402, 397405}, + {397409, 397409}, {397413, 397414}, {397422, 397424}, + {397429, 397441}, {397454, 397454}, {397472, 397509}, + {397511, 397511}, {397517, 397517}, {397520, 397562}, + {397564, 397896}, {397898, 397901}, {397904, 397910}, + {397912, 397912}, {397914, 397917}, {397920, 397960}, + {397962, 397965}, {397968, 398000}, {398002, 398005}, + {398008, 398014}, {398016, 398016}, {398018, 398021}, + {398024, 398038}, {398040, 398096}, {398098, 398101}, + {398104, 398170}, {398208, 398223}, {398240, 398325}, + {398328, 398333}, {398337, 398956}, {398959, 398975}, + {398977, 399002}, {399008, 399082}, {399086, 399096}, + {399104, 399121}, {399135, 399153}, {399168, 399185}, + {399200, 399212}, {399214, 399216}, {399232, 399283}, + {399319, 399319}, {399324, 399324}, {399392, 399480}, + {399488, 399528}, {399530, 399530}, {399536, 399605}, + {399616, 399646}, {399696, 399725}, {399728, 399732}, + {399744, 399787}, {399792, 399817}, {399872, 399894}, + {399904, 399956}, {400039, 400039}, {400133, 400179}, + {400197, 400204}, {400259, 400288}, {400302, 400303}, + {400314, 400357}, {400384, 400419}, {400461, 400463}, + {400474, 400509}, {400512, 400520}, {400528, 400570}, + {400573, 400575}, {400617, 400620}, {400622, 400627}, + {400629, 400630}, {400634, 400634}, {400640, 400831}, + {400896, 401173}, {401176, 401181}, {401184, 401221}, + {401224, 401229}, {401232, 401239}, {401241, 401241}, + {401243, 401243}, {401245, 401245}, {401247, 401277}, + {401280, 401332}, {401334, 401340}, {401342, 401342}, + {401346, 401348}, {401350, 401356}, {401360, 401363}, + {401366, 401371}, {401376, 401388}, {401394, 401396}, + {401398, 401404}, {401521, 401521}, {401535, 401535}, + {401552, 401564}, {401666, 401666}, {401671, 401671}, + {401674, 401683}, {401685, 401685}, {401688, 401693}, + {401700, 401700}, {401702, 401702}, {401704, 401704}, + {401706, 401721}, {401724, 401727}, {401733, 401737}, + {401742, 401742}, {401760, 401800}, {404480, 404708}, + {404715, 404718}, {404722, 404723}, {404736, 404773}, + {404775, 404775}, {404781, 404781}, {404784, 404839}, + {404847, 404847}, {404864, 404886}, {404896, 404902}, + {404904, 404910}, {404912, 404918}, {404920, 404926}, + {404928, 404934}, {404936, 404942}, {404944, 404950}, + {404952, 404958}, {405509, 405511}, {405537, 405545}, + {405553, 405557}, {405560, 405564}, {405569, 405654}, + {405659, 405663}, {405665, 405754}, {405756, 405759}, + {405765, 405807}, {405809, 405902}, {405920, 405951}, + {406000, 406015}, {406528, 413119}, {413184, 435340}, + {435408, 435453}, {435456, 435724}, {435728, 435743}, + {435754, 435755}, {435776, 435822}, {435839, 435869}, + {435872, 435951}, {435991, 435999}, {436002, 436104}, + {436107, 436170}, {436176, 436177}, {436179, 436179}, + {436181, 436185}, {436210, 436225}, {436227, 436229}, + {436231, 436234}, {436236, 436258}, {436288, 436339}, + {436354, 436403}, {436466, 436471}, {436475, 436475}, + {436477, 436478}, {436490, 436517}, {436528, 436550}, + {436576, 436604}, {436612, 436658}, {436687, 436687}, + {436704, 436708}, {436710, 436719}, {436730, 436734}, + {436736, 436776}, {436800, 436802}, {436804, 436811}, + {436832, 436854}, {436858, 436858}, {436862, 436911}, + {436913, 436913}, {436917, 436918}, {436921, 436925}, + {436928, 436928}, {436930, 436930}, {436955, 436957}, + {436960, 436970}, {436978, 436980}, {436993, 436998}, + {437001, 437006}, {437009, 437014}, {437024, 437030}, + {437032, 437038}, {437040, 437082}, {437084, 437097}, + {437104, 437218}, {437248, 448419}, {448432, 448454}, + {448459, 448507}, {456960, 457325}, {457328, 457433}, + {457472, 457478}, {457491, 457495}, {457501, 457501}, + {457503, 457512}, {457514, 457526}, {457528, 457532}, + {457534, 457534}, {457536, 457537}, {457539, 457540}, + {457542, 457649}, {457683, 458045}, {458064, 458127}, + {458130, 458183}, {458224, 458235}, {458352, 458356}, + {458358, 458492}, {458529, 458554}, {458561, 458586}, + {458598, 458686}, {458690, 458695}, {458698, 458703}, + {458706, 458711}, {458714, 458716}, {458788, 458788}, + {458817, 458842}, {458847, 458847}, {458849, 458874}, + {458922, 458922}, {458933, 458933}, {458938, 458938}, + {458944, 458966}, {458968, 458998}, {459000, 459457}, + {459462, 459473}, {459488, 459492}, {459500, 459500}, + {459502, 459502}, {459632, 459636}, {459638, 459639}, + {459642, 459645}, {459647, 459647}, {459654, 459654}, + {459656, 459658}, {459660, 459660}, {459662, 459681}, + {459683, 459765}, {459767, 459905}, {459914, 460079}, + {460081, 460118}, {460121, 460121}, {460128, 460168}, + {460240, 460266}, {460271, 460274}, {460320, 460362}, + {460398, 460399}, {460401, 460499}, {460501, 460501}, + {460517, 460518}, {460526, 460527}, {460538, 460540}, + {460543, 460543}, {460560, 460560}, {460562, 460591}, + {460621, 460709}, {460721, 460721}, {460746, 460778}, + {460788, 460789}, {460794, 460794}, {460800, 460821}, + {460826, 460826}, {460836, 460836}, {460840, 460840}, + {460864, 460888}, {460896, 460906}, {460912, 460935}, + {460937, 460942}, {460960, 461001}, {461060, 461113}, + {461117, 461117}, {461136, 461136}, {461144, 461153}, + {461169, 461184}, {461189, 461196}, {461199, 461200}, + {461203, 461224}, {461226, 461232}, {461234, 461234}, + {461238, 461241}, {461245, 461245}, {461262, 461262}, + {461276, 461277}, {461279, 461281}, {461296, 461297}, + {461308, 461308}, {461317, 461322}, {461327, 461328}, + {461331, 461352}, {461354, 461360}, {461362, 461363}, + {461365, 461366}, {461368, 461369}, {461401, 461404}, + {461406, 461406}, {461426, 461428}, {461445, 461453}, + {461455, 461457}, {461459, 461480}, {461482, 461488}, + {461490, 461491}, {461493, 461497}, {461501, 461501}, + {461520, 461520}, {461536, 461537}, {461561, 461561}, + {461573, 461580}, {461583, 461584}, {461587, 461608}, + {461610, 461616}, {461618, 461619}, {461621, 461625}, + {461629, 461629}, {461660, 461661}, {461663, 461665}, + {461681, 461681}, {461699, 461699}, {461701, 461706}, + {461710, 461712}, {461714, 461717}, {461721, 461722}, + {461724, 461724}, {461726, 461727}, {461731, 461732}, + {461736, 461738}, {461742, 461753}, {461776, 461776}, + {461829, 461836}, {461838, 461840}, {461842, 461864}, + {461866, 461881}, {461885, 461885}, {461912, 461914}, + {461917, 461917}, {461920, 461921}, {461952, 461952}, + {461957, 461964}, {461966, 461968}, {461970, 461992}, + {461994, 462003}, {462005, 462009}, {462013, 462013}, + {462045, 462046}, {462048, 462049}, {462065, 462066}, + {462084, 462092}, {462094, 462096}, {462098, 462138}, + {462141, 462141}, {462158, 462158}, {462164, 462166}, + {462175, 462177}, {462202, 462207}, {462213, 462230}, + {462234, 462257}, {462259, 462267}, {462269, 462269}, + {462272, 462278}, {462337, 462384}, {462386, 462387}, + {462400, 462406}, {462465, 462466}, {462468, 462468}, + {462470, 462474}, {462476, 462499}, {462501, 462501}, + {462503, 462512}, {462514, 462515}, {462525, 462525}, + {462528, 462532}, {462534, 462534}, {462556, 462559}, + {462592, 462592}, {462656, 462663}, {462665, 462700}, + {462728, 462732}, {462848, 462890}, {462911, 462911}, + {462928, 462933}, {462938, 462941}, {462945, 462945}, + {462949, 462950}, {462958, 462960}, {462965, 462977}, + {462990, 462990}, {463008, 463045}, {463047, 463047}, + {463053, 463053}, {463056, 463098}, {463100, 463432}, + {463434, 463437}, {463440, 463446}, {463448, 463448}, + {463450, 463453}, {463456, 463496}, {463498, 463501}, + {463504, 463536}, {463538, 463541}, {463544, 463550}, + {463552, 463552}, {463554, 463557}, {463560, 463574}, + {463576, 463632}, {463634, 463637}, {463640, 463706}, + {463744, 463759}, {463776, 463861}, {463864, 463869}, + {463873, 464492}, {464495, 464511}, {464513, 464538}, + {464544, 464618}, {464622, 464632}, {464640, 464657}, + {464671, 464689}, {464704, 464721}, {464736, 464748}, + {464750, 464752}, {464768, 464819}, {464855, 464855}, + {464860, 464860}, {464928, 465016}, {465024, 465064}, + {465066, 465066}, {465072, 465141}, {465152, 465182}, + {465232, 465261}, {465264, 465268}, {465280, 465323}, + {465328, 465353}, {465408, 465430}, {465440, 465492}, + {465575, 465575}, {465669, 465715}, {465733, 465740}, + {465795, 465824}, {465838, 465839}, {465850, 465893}, + {465920, 465955}, {465997, 465999}, {466010, 466045}, + {466048, 466056}, {466064, 466106}, {466109, 466111}, + {466153, 466156}, {466158, 466163}, {466165, 466166}, + {466170, 466170}, {466176, 466367}, {466432, 466709}, + {466712, 466717}, {466720, 466757}, {466760, 466765}, + {466768, 466775}, {466777, 466777}, {466779, 466779}, + {466781, 466781}, {466783, 466813}, {466816, 466868}, + {466870, 466876}, {466878, 466878}, {466882, 466884}, + {466886, 466892}, {466896, 466899}, {466902, 466907}, + {466912, 466924}, {466930, 466932}, {466934, 466940}, + {467057, 467057}, {467071, 467071}, {467088, 467100}, + {467202, 467202}, {467207, 467207}, {467210, 467219}, + {467221, 467221}, {467224, 467229}, {467236, 467236}, + {467238, 467238}, {467240, 467240}, {467242, 467257}, + {467260, 467263}, {467269, 467273}, {467278, 467278}, + {467296, 467336}, {470016, 470244}, {470251, 470254}, + {470258, 470259}, {470272, 470309}, {470311, 470311}, + {470317, 470317}, {470320, 470375}, {470383, 470383}, + {470400, 470422}, {470432, 470438}, {470440, 470446}, + {470448, 470454}, {470456, 470462}, {470464, 470470}, + {470472, 470478}, {470480, 470486}, {470488, 470494}, + {471045, 471047}, {471073, 471081}, {471089, 471093}, + {471096, 471100}, {471105, 471190}, {471195, 471199}, + {471201, 471290}, {471292, 471295}, {471301, 471343}, + {471345, 471438}, {471456, 471487}, {471536, 471551}, + {472064, 478655}, {478720, 500876}, {500944, 500989}, + {500992, 501260}, {501264, 501279}, {501290, 501291}, + {501312, 501358}, {501375, 501405}, {501408, 501487}, + {501527, 501535}, {501538, 501640}, {501643, 501706}, + {501712, 501713}, {501715, 501715}, {501717, 501721}, + {501746, 501761}, {501763, 501765}, {501767, 501770}, + {501772, 501794}, {501824, 501875}, {501890, 501939}, + {502002, 502007}, {502011, 502011}, {502013, 502014}, + {502026, 502053}, {502064, 502086}, {502112, 502140}, + {502148, 502194}, {502223, 502223}, {502240, 502244}, + {502246, 502255}, {502266, 502270}, {502272, 502312}, + {502336, 502338}, {502340, 502347}, {502368, 502390}, + {502394, 502394}, {502398, 502447}, {502449, 502449}, + {502453, 502454}, {502457, 502461}, {502464, 502464}, + {502466, 502466}, {502491, 502493}, {502496, 502506}, + {502514, 502516}, {502529, 502534}, {502537, 502542}, + {502545, 502550}, {502560, 502566}, {502568, 502574}, + {502576, 502618}, {502620, 502633}, {502640, 502754}, + {502784, 513955}, {513968, 513990}, {513995, 514043}, + {522496, 522861}, {522864, 522969}, {523008, 523014}, + {523027, 523031}, {523037, 523037}, {523039, 523048}, + {523050, 523062}, {523064, 523068}, {523070, 523070}, + {523072, 523073}, {523075, 523076}, {523078, 523185}, + {523219, 523581}, {523600, 523663}, {523666, 523719}, + {523760, 523771}, {523888, 523892}, {523894, 524028}, + {524065, 524090}, {524097, 524122}, {524134, 524222}, + {524226, 524231}, {524234, 524239}, {524242, 524247}, + {524250, 524252}, {524324, 524324}, {524353, 524378}, + {524383, 524383}, {524385, 524410}, {524458, 524458}, + {524469, 524469}, {524474, 524474}, {524480, 524502}, + {524504, 524534}, {524536, 524993}, {524998, 525009}, + {525024, 525028}, {525036, 525036}, {525038, 525038}, + {525168, 525172}, {525174, 525175}, {525178, 525181}, + {525183, 525183}, {525190, 525190}, {525192, 525194}, + {525196, 525196}, {525198, 525217}, {525219, 525301}, + {525303, 525441}, {525450, 525615}, {525617, 525654}, + {525657, 525657}, {525664, 525704}, {525776, 525802}, + {525807, 525810}, {525856, 525898}, {525934, 525935}, + {525937, 526035}, {526037, 526037}, {526053, 526054}, + {526062, 526063}, {526074, 526076}, {526079, 526079}, + {526096, 526096}, {526098, 526127}, {526157, 526245}, + {526257, 526257}, {526282, 526314}, {526324, 526325}, + {526330, 526330}, {526336, 526357}, {526362, 526362}, + {526372, 526372}, {526376, 526376}, {526400, 526424}, + {526432, 526442}, {526448, 526471}, {526473, 526478}, + {526496, 526537}, {526596, 526649}, {526653, 526653}, + {526672, 526672}, {526680, 526689}, {526705, 526720}, + {526725, 526732}, {526735, 526736}, {526739, 526760}, + {526762, 526768}, {526770, 526770}, {526774, 526777}, + {526781, 526781}, {526798, 526798}, {526812, 526813}, + {526815, 526817}, {526832, 526833}, {526844, 526844}, + {526853, 526858}, {526863, 526864}, {526867, 526888}, + {526890, 526896}, {526898, 526899}, {526901, 526902}, + {526904, 526905}, {526937, 526940}, {526942, 526942}, + {526962, 526964}, {526981, 526989}, {526991, 526993}, + {526995, 527016}, {527018, 527024}, {527026, 527027}, + {527029, 527033}, {527037, 527037}, {527056, 527056}, + {527072, 527073}, {527097, 527097}, {527109, 527116}, + {527119, 527120}, {527123, 527144}, {527146, 527152}, + {527154, 527155}, {527157, 527161}, {527165, 527165}, + {527196, 527197}, {527199, 527201}, {527217, 527217}, + {527235, 527235}, {527237, 527242}, {527246, 527248}, + {527250, 527253}, {527257, 527258}, {527260, 527260}, + {527262, 527263}, {527267, 527268}, {527272, 527274}, + {527278, 527289}, {527312, 527312}, {527365, 527372}, + {527374, 527376}, {527378, 527400}, {527402, 527417}, + {527421, 527421}, {527448, 527450}, {527453, 527453}, + {527456, 527457}, {527488, 527488}, {527493, 527500}, + {527502, 527504}, {527506, 527528}, {527530, 527539}, + {527541, 527545}, {527549, 527549}, {527581, 527582}, + {527584, 527585}, {527601, 527602}, {527620, 527628}, + {527630, 527632}, {527634, 527674}, {527677, 527677}, + {527694, 527694}, {527700, 527702}, {527711, 527713}, + {527738, 527743}, {527749, 527766}, {527770, 527793}, + {527795, 527803}, {527805, 527805}, {527808, 527814}, + {527873, 527920}, {527922, 527923}, {527936, 527942}, + {528001, 528002}, {528004, 528004}, {528006, 528010}, + {528012, 528035}, {528037, 528037}, {528039, 528048}, + {528050, 528051}, {528061, 528061}, {528064, 528068}, + {528070, 528070}, {528092, 528095}, {528128, 528128}, + {528192, 528199}, {528201, 528236}, {528264, 528268}, + {528384, 528426}, {528447, 528447}, {528464, 528469}, + {528474, 528477}, {528481, 528481}, {528485, 528486}, + {528494, 528496}, {528501, 528513}, {528526, 528526}, + {528544, 528581}, {528583, 528583}, {528589, 528589}, + {528592, 528634}, {528636, 528968}, {528970, 528973}, + {528976, 528982}, {528984, 528984}, {528986, 528989}, + {528992, 529032}, {529034, 529037}, {529040, 529072}, + {529074, 529077}, {529080, 529086}, {529088, 529088}, + {529090, 529093}, {529096, 529110}, {529112, 529168}, + {529170, 529173}, {529176, 529242}, {529280, 529295}, + {529312, 529397}, {529400, 529405}, {529409, 530028}, + {530031, 530047}, {530049, 530074}, {530080, 530154}, + {530158, 530168}, {530176, 530193}, {530207, 530225}, + {530240, 530257}, {530272, 530284}, {530286, 530288}, + {530304, 530355}, {530391, 530391}, {530396, 530396}, + {530464, 530552}, {530560, 530600}, {530602, 530602}, + {530608, 530677}, {530688, 530718}, {530768, 530797}, + {530800, 530804}, {530816, 530859}, {530864, 530889}, + {530944, 530966}, {530976, 531028}, {531111, 531111}, + {531205, 531251}, {531269, 531276}, {531331, 531360}, + {531374, 531375}, {531386, 531429}, {531456, 531491}, + {531533, 531535}, {531546, 531581}, {531584, 531592}, + {531600, 531642}, {531645, 531647}, {531689, 531692}, + {531694, 531699}, {531701, 531702}, {531706, 531706}, + {531712, 531903}, {531968, 532245}, {532248, 532253}, + {532256, 532293}, {532296, 532301}, {532304, 532311}, + {532313, 532313}, {532315, 532315}, {532317, 532317}, + {532319, 532349}, {532352, 532404}, {532406, 532412}, + {532414, 532414}, {532418, 532420}, {532422, 532428}, + {532432, 532435}, {532438, 532443}, {532448, 532460}, + {532466, 532468}, {532470, 532476}, {532593, 532593}, + {532607, 532607}, {532624, 532636}, {532738, 532738}, + {532743, 532743}, {532746, 532755}, {532757, 532757}, + {532760, 532765}, {532772, 532772}, {532774, 532774}, + {532776, 532776}, {532778, 532793}, {532796, 532799}, + {532805, 532809}, {532814, 532814}, {532832, 532872}, + {535552, 535780}, {535787, 535790}, {535794, 535795}, + {535808, 535845}, {535847, 535847}, {535853, 535853}, + {535856, 535911}, {535919, 535919}, {535936, 535958}, + {535968, 535974}, {535976, 535982}, {535984, 535990}, + {535992, 535998}, {536000, 536006}, {536008, 536014}, + {536016, 536022}, {536024, 536030}, {536581, 536583}, + {536609, 536617}, {536625, 536629}, {536632, 536636}, + {536641, 536726}, {536731, 536735}, {536737, 536826}, + {536828, 536831}, {536837, 536879}, {536881, 536974}, + {536992, 537023}, {537072, 537087}, {537600, 544191}, + {544256, 566412}, {566480, 566525}, {566528, 566796}, + {566800, 566815}, {566826, 566827}, {566848, 566894}, + {566911, 566941}, {566944, 567023}, {567063, 567071}, + {567074, 567176}, {567179, 567242}, {567248, 567249}, + {567251, 567251}, {567253, 567257}, {567282, 567297}, + {567299, 567301}, {567303, 567306}, {567308, 567330}, + {567360, 567411}, {567426, 567475}, {567538, 567543}, + {567547, 567547}, {567549, 567550}, {567562, 567589}, + {567600, 567622}, {567648, 567676}, {567684, 567730}, + {567759, 567759}, {567776, 567780}, {567782, 567791}, + {567802, 567806}, {567808, 567848}, {567872, 567874}, + {567876, 567883}, {567904, 567926}, {567930, 567930}, + {567934, 567983}, {567985, 567985}, {567989, 567990}, + {567993, 567997}, {568000, 568000}, {568002, 568002}, + {568027, 568029}, {568032, 568042}, {568050, 568052}, + {568065, 568070}, {568073, 568078}, {568081, 568086}, + {568096, 568102}, {568104, 568110}, {568112, 568154}, + {568156, 568169}, {568176, 568290}, {568320, 579491}, + {579504, 579526}, {579531, 579579}, {588032, 588397}, + {588400, 588505}, {588544, 588550}, {588563, 588567}, + {588573, 588573}, {588575, 588584}, {588586, 588598}, + {588600, 588604}, {588606, 588606}, {588608, 588609}, + {588611, 588612}, {588614, 588721}, {588755, 589117}, + {589136, 589199}, {589202, 589255}, {589296, 589307}, + {589424, 589428}, {589430, 589564}, {589601, 589626}, + {589633, 589658}, {589670, 589758}, {589762, 589767}, + {589770, 589775}, {589778, 589783}, {589786, 589788}, + {589860, 589860}, {589889, 589914}, {589919, 589919}, + {589921, 589946}, {589994, 589994}, {590005, 590005}, + {590010, 590010}, {590016, 590038}, {590040, 590070}, + {590072, 590529}, {590534, 590545}, {590560, 590564}, + {590572, 590572}, {590574, 590574}, {590704, 590708}, + {590710, 590711}, {590714, 590717}, {590719, 590719}, + {590726, 590726}, {590728, 590730}, {590732, 590732}, + {590734, 590753}, {590755, 590837}, {590839, 590977}, + {590986, 591151}, {591153, 591190}, {591193, 591193}, + {591200, 591240}, {591312, 591338}, {591343, 591346}, + {591392, 591434}, {591470, 591471}, {591473, 591571}, + {591573, 591573}, {591589, 591590}, {591598, 591599}, + {591610, 591612}, {591615, 591615}, {591632, 591632}, + {591634, 591663}, {591693, 591781}, {591793, 591793}, + {591818, 591850}, {591860, 591861}, {591866, 591866}, + {591872, 591893}, {591898, 591898}, {591908, 591908}, + {591912, 591912}, {591936, 591960}, {591968, 591978}, + {591984, 592007}, {592009, 592014}, {592032, 592073}, + {592132, 592185}, {592189, 592189}, {592208, 592208}, + {592216, 592225}, {592241, 592256}, {592261, 592268}, + {592271, 592272}, {592275, 592296}, {592298, 592304}, + {592306, 592306}, {592310, 592313}, {592317, 592317}, + {592334, 592334}, {592348, 592349}, {592351, 592353}, + {592368, 592369}, {592380, 592380}, {592389, 592394}, + {592399, 592400}, {592403, 592424}, {592426, 592432}, + {592434, 592435}, {592437, 592438}, {592440, 592441}, + {592473, 592476}, {592478, 592478}, {592498, 592500}, + {592517, 592525}, {592527, 592529}, {592531, 592552}, + {592554, 592560}, {592562, 592563}, {592565, 592569}, + {592573, 592573}, {592592, 592592}, {592608, 592609}, + {592633, 592633}, {592645, 592652}, {592655, 592656}, + {592659, 592680}, {592682, 592688}, {592690, 592691}, + {592693, 592697}, {592701, 592701}, {592732, 592733}, + {592735, 592737}, {592753, 592753}, {592771, 592771}, + {592773, 592778}, {592782, 592784}, {592786, 592789}, + {592793, 592794}, {592796, 592796}, {592798, 592799}, + {592803, 592804}, {592808, 592810}, {592814, 592825}, + {592848, 592848}, {592901, 592908}, {592910, 592912}, + {592914, 592936}, {592938, 592953}, {592957, 592957}, + {592984, 592986}, {592989, 592989}, {592992, 592993}, + {593024, 593024}, {593029, 593036}, {593038, 593040}, + {593042, 593064}, {593066, 593075}, {593077, 593081}, + {593085, 593085}, {593117, 593118}, {593120, 593121}, + {593137, 593138}, {593156, 593164}, {593166, 593168}, + {593170, 593210}, {593213, 593213}, {593230, 593230}, + {593236, 593238}, {593247, 593249}, {593274, 593279}, + {593285, 593302}, {593306, 593329}, {593331, 593339}, + {593341, 593341}, {593344, 593350}, {593409, 593456}, + {593458, 593459}, {593472, 593478}, {593537, 593538}, + {593540, 593540}, {593542, 593546}, {593548, 593571}, + {593573, 593573}, {593575, 593584}, {593586, 593587}, + {593597, 593597}, {593600, 593604}, {593606, 593606}, + {593628, 593631}, {593664, 593664}, {593728, 593735}, + {593737, 593772}, {593800, 593804}, {593920, 593962}, + {593983, 593983}, {594000, 594005}, {594010, 594013}, + {594017, 594017}, {594021, 594022}, {594030, 594032}, + {594037, 594049}, {594062, 594062}, {594080, 594117}, + {594119, 594119}, {594125, 594125}, {594128, 594170}, + {594172, 594504}, {594506, 594509}, {594512, 594518}, + {594520, 594520}, {594522, 594525}, {594528, 594568}, + {594570, 594573}, {594576, 594608}, {594610, 594613}, + {594616, 594622}, {594624, 594624}, {594626, 594629}, + {594632, 594646}, {594648, 594704}, {594706, 594709}, + {594712, 594778}, {594816, 594831}, {594848, 594933}, + {594936, 594941}, {594945, 595564}, {595567, 595583}, + {595585, 595610}, {595616, 595690}, {595694, 595704}, + {595712, 595729}, {595743, 595761}, {595776, 595793}, + {595808, 595820}, {595822, 595824}, {595840, 595891}, + {595927, 595927}, {595932, 595932}, {596000, 596088}, + {596096, 596136}, {596138, 596138}, {596144, 596213}, + {596224, 596254}, {596304, 596333}, {596336, 596340}, + {596352, 596395}, {596400, 596425}, {596480, 596502}, + {596512, 596564}, {596647, 596647}, {596741, 596787}, + {596805, 596812}, {596867, 596896}, {596910, 596911}, + {596922, 596965}, {596992, 597027}, {597069, 597071}, + {597082, 597117}, {597120, 597128}, {597136, 597178}, + {597181, 597183}, {597225, 597228}, {597230, 597235}, + {597237, 597238}, {597242, 597242}, {597248, 597439}, + {597504, 597781}, {597784, 597789}, {597792, 597829}, + {597832, 597837}, {597840, 597847}, {597849, 597849}, + {597851, 597851}, {597853, 597853}, {597855, 597885}, + {597888, 597940}, {597942, 597948}, {597950, 597950}, + {597954, 597956}, {597958, 597964}, {597968, 597971}, + {597974, 597979}, {597984, 597996}, {598002, 598004}, + {598006, 598012}, {598129, 598129}, {598143, 598143}, + {598160, 598172}, {598274, 598274}, {598279, 598279}, + {598282, 598291}, {598293, 598293}, {598296, 598301}, + {598308, 598308}, {598310, 598310}, {598312, 598312}, + {598314, 598329}, {598332, 598335}, {598341, 598345}, + {598350, 598350}, {598368, 598408}, {601088, 601316}, + {601323, 601326}, {601330, 601331}, {601344, 601381}, + {601383, 601383}, {601389, 601389}, {601392, 601447}, + {601455, 601455}, {601472, 601494}, {601504, 601510}, + {601512, 601518}, {601520, 601526}, {601528, 601534}, + {601536, 601542}, {601544, 601550}, {601552, 601558}, + {601560, 601566}, {602117, 602119}, {602145, 602153}, + {602161, 602165}, {602168, 602172}, {602177, 602262}, + {602267, 602271}, {602273, 602362}, {602364, 602367}, + {602373, 602415}, {602417, 602510}, {602528, 602559}, + {602608, 602623}, {603136, 609727}, {609792, 631948}, + {632016, 632061}, {632064, 632332}, {632336, 632351}, + {632362, 632363}, {632384, 632430}, {632447, 632477}, + {632480, 632559}, {632599, 632607}, {632610, 632712}, + {632715, 632778}, {632784, 632785}, {632787, 632787}, + {632789, 632793}, {632818, 632833}, {632835, 632837}, + {632839, 632842}, {632844, 632866}, {632896, 632947}, + {632962, 633011}, {633074, 633079}, {633083, 633083}, + {633085, 633086}, {633098, 633125}, {633136, 633158}, + {633184, 633212}, {633220, 633266}, {633295, 633295}, + {633312, 633316}, {633318, 633327}, {633338, 633342}, + {633344, 633384}, {633408, 633410}, {633412, 633419}, + {633440, 633462}, {633466, 633466}, {633470, 633519}, + {633521, 633521}, {633525, 633526}, {633529, 633533}, + {633536, 633536}, {633538, 633538}, {633563, 633565}, + {633568, 633578}, {633586, 633588}, {633601, 633606}, + {633609, 633614}, {633617, 633622}, {633632, 633638}, + {633640, 633646}, {633648, 633690}, {633692, 633705}, + {633712, 633826}, {633856, 645027}, {645040, 645062}, + {645067, 645115}, {653568, 653933}, {653936, 654041}, + {654080, 654086}, {654099, 654103}, {654109, 654109}, + {654111, 654120}, {654122, 654134}, {654136, 654140}, + {654142, 654142}, {654144, 654145}, {654147, 654148}, + {654150, 654257}, {654291, 654653}, {654672, 654735}, + {654738, 654791}, {654832, 654843}, {654960, 654964}, + {654966, 655100}, {655137, 655162}, {655169, 655194}, + {655206, 655294}, {655298, 655303}, {655306, 655311}, + {655314, 655319}, {655322, 655324}, {655396, 655396}, + {655425, 655450}, {655455, 655455}, {655457, 655482}, + {655530, 655530}, {655541, 655541}, {655546, 655546}, + {655552, 655574}, {655576, 655606}, {655608, 656065}, + {656070, 656081}, {656096, 656100}, {656108, 656108}, + {656110, 656110}, {656240, 656244}, {656246, 656247}, + {656250, 656253}, {656255, 656255}, {656262, 656262}, + {656264, 656266}, {656268, 656268}, {656270, 656289}, + {656291, 656373}, {656375, 656513}, {656522, 656687}, + {656689, 656726}, {656729, 656729}, {656736, 656776}, + {656848, 656874}, {656879, 656882}, {656928, 656970}, + {657006, 657007}, {657009, 657107}, {657109, 657109}, + {657125, 657126}, {657134, 657135}, {657146, 657148}, + {657151, 657151}, {657168, 657168}, {657170, 657199}, + {657229, 657317}, {657329, 657329}, {657354, 657386}, + {657396, 657397}, {657402, 657402}, {657408, 657429}, + {657434, 657434}, {657444, 657444}, {657448, 657448}, + {657472, 657496}, {657504, 657514}, {657520, 657543}, + {657545, 657550}, {657568, 657609}, {657668, 657721}, + {657725, 657725}, {657744, 657744}, {657752, 657761}, + {657777, 657792}, {657797, 657804}, {657807, 657808}, + {657811, 657832}, {657834, 657840}, {657842, 657842}, + {657846, 657849}, {657853, 657853}, {657870, 657870}, + {657884, 657885}, {657887, 657889}, {657904, 657905}, + {657916, 657916}, {657925, 657930}, {657935, 657936}, + {657939, 657960}, {657962, 657968}, {657970, 657971}, + {657973, 657974}, {657976, 657977}, {658009, 658012}, + {658014, 658014}, {658034, 658036}, {658053, 658061}, + {658063, 658065}, {658067, 658088}, {658090, 658096}, + {658098, 658099}, {658101, 658105}, {658109, 658109}, + {658128, 658128}, {658144, 658145}, {658169, 658169}, + {658181, 658188}, {658191, 658192}, {658195, 658216}, + {658218, 658224}, {658226, 658227}, {658229, 658233}, + {658237, 658237}, {658268, 658269}, {658271, 658273}, + {658289, 658289}, {658307, 658307}, {658309, 658314}, + {658318, 658320}, {658322, 658325}, {658329, 658330}, + {658332, 658332}, {658334, 658335}, {658339, 658340}, + {658344, 658346}, {658350, 658361}, {658384, 658384}, + {658437, 658444}, {658446, 658448}, {658450, 658472}, + {658474, 658489}, {658493, 658493}, {658520, 658522}, + {658525, 658525}, {658528, 658529}, {658560, 658560}, + {658565, 658572}, {658574, 658576}, {658578, 658600}, + {658602, 658611}, {658613, 658617}, {658621, 658621}, + {658653, 658654}, {658656, 658657}, {658673, 658674}, + {658692, 658700}, {658702, 658704}, {658706, 658746}, + {658749, 658749}, {658766, 658766}, {658772, 658774}, + {658783, 658785}, {658810, 658815}, {658821, 658838}, + {658842, 658865}, {658867, 658875}, {658877, 658877}, + {658880, 658886}, {658945, 658992}, {658994, 658995}, + {659008, 659014}, {659073, 659074}, {659076, 659076}, + {659078, 659082}, {659084, 659107}, {659109, 659109}, + {659111, 659120}, {659122, 659123}, {659133, 659133}, + {659136, 659140}, {659142, 659142}, {659164, 659167}, + {659200, 659200}, {659264, 659271}, {659273, 659308}, + {659336, 659340}, {659456, 659498}, {659519, 659519}, + {659536, 659541}, {659546, 659549}, {659553, 659553}, + {659557, 659558}, {659566, 659568}, {659573, 659585}, + {659598, 659598}, {659616, 659653}, {659655, 659655}, + {659661, 659661}, {659664, 659706}, {659708, 660040}, + {660042, 660045}, {660048, 660054}, {660056, 660056}, + {660058, 660061}, {660064, 660104}, {660106, 660109}, + {660112, 660144}, {660146, 660149}, {660152, 660158}, + {660160, 660160}, {660162, 660165}, {660168, 660182}, + {660184, 660240}, {660242, 660245}, {660248, 660314}, + {660352, 660367}, {660384, 660469}, {660472, 660477}, + {660481, 661100}, {661103, 661119}, {661121, 661146}, + {661152, 661226}, {661230, 661240}, {661248, 661265}, + {661279, 661297}, {661312, 661329}, {661344, 661356}, + {661358, 661360}, {661376, 661427}, {661463, 661463}, + {661468, 661468}, {661536, 661624}, {661632, 661672}, + {661674, 661674}, {661680, 661749}, {661760, 661790}, + {661840, 661869}, {661872, 661876}, {661888, 661931}, + {661936, 661961}, {662016, 662038}, {662048, 662100}, + {662183, 662183}, {662277, 662323}, {662341, 662348}, + {662403, 662432}, {662446, 662447}, {662458, 662501}, + {662528, 662563}, {662605, 662607}, {662618, 662653}, + {662656, 662664}, {662672, 662714}, {662717, 662719}, + {662761, 662764}, {662766, 662771}, {662773, 662774}, + {662778, 662778}, {662784, 662975}, {663040, 663317}, + {663320, 663325}, {663328, 663365}, {663368, 663373}, + {663376, 663383}, {663385, 663385}, {663387, 663387}, + {663389, 663389}, {663391, 663421}, {663424, 663476}, + {663478, 663484}, {663486, 663486}, {663490, 663492}, + {663494, 663500}, {663504, 663507}, {663510, 663515}, + {663520, 663532}, {663538, 663540}, {663542, 663548}, + {663665, 663665}, {663679, 663679}, {663696, 663708}, + {663810, 663810}, {663815, 663815}, {663818, 663827}, + {663829, 663829}, {663832, 663837}, {663844, 663844}, + {663846, 663846}, {663848, 663848}, {663850, 663865}, + {663868, 663871}, {663877, 663881}, {663886, 663886}, + {663904, 663944}, {666624, 666852}, {666859, 666862}, + {666866, 666867}, {666880, 666917}, {666919, 666919}, + {666925, 666925}, {666928, 666983}, {666991, 666991}, + {667008, 667030}, {667040, 667046}, {667048, 667054}, + {667056, 667062}, {667064, 667070}, {667072, 667078}, + {667080, 667086}, {667088, 667094}, {667096, 667102}, + {667653, 667655}, {667681, 667689}, {667697, 667701}, + {667704, 667708}, {667713, 667798}, {667803, 667807}, + {667809, 667898}, {667900, 667903}, {667909, 667951}, + {667953, 668046}, {668064, 668095}, {668144, 668159}, + {668672, 675263}, {675328, 697484}, {697552, 697597}, + {697600, 697868}, {697872, 697887}, {697898, 697899}, + {697920, 697966}, {697983, 698013}, {698016, 698095}, + {698135, 698143}, {698146, 698248}, {698251, 698314}, + {698320, 698321}, {698323, 698323}, {698325, 698329}, + {698354, 698369}, {698371, 698373}, {698375, 698378}, + {698380, 698402}, {698432, 698483}, {698498, 698547}, + {698610, 698615}, {698619, 698619}, {698621, 698622}, + {698634, 698661}, {698672, 698694}, {698720, 698748}, + {698756, 698802}, {698831, 698831}, {698848, 698852}, + {698854, 698863}, {698874, 698878}, {698880, 698920}, + {698944, 698946}, {698948, 698955}, {698976, 698998}, + {699002, 699002}, {699006, 699055}, {699057, 699057}, + {699061, 699062}, {699065, 699069}, {699072, 699072}, + {699074, 699074}, {699099, 699101}, {699104, 699114}, + {699122, 699124}, {699137, 699142}, {699145, 699150}, + {699153, 699158}, {699168, 699174}, {699176, 699182}, + {699184, 699226}, {699228, 699241}, {699248, 699362}, + {699392, 710563}, {710576, 710598}, {710603, 710651}, + {719104, 719469}, {719472, 719577}, {719616, 719622}, + {719635, 719639}, {719645, 719645}, {719647, 719656}, + {719658, 719670}, {719672, 719676}, {719678, 719678}, + {719680, 719681}, {719683, 719684}, {719686, 719793}, + {719827, 720189}, {720208, 720271}, {720274, 720327}, + {720368, 720379}, {720496, 720500}, {720502, 720636}, + {720673, 720698}, {720705, 720730}, {720742, 720830}, + {720834, 720839}, {720842, 720847}, {720850, 720855}, + {720858, 720860}, {720932, 720932}, {720961, 720986}, + {720991, 720991}, {720993, 721018}, {721066, 721066}, + {721077, 721077}, {721082, 721082}, {721088, 721110}, + {721112, 721142}, {721144, 721601}, {721606, 721617}, + {721632, 721636}, {721644, 721644}, {721646, 721646}, + {721776, 721780}, {721782, 721783}, {721786, 721789}, + {721791, 721791}, {721798, 721798}, {721800, 721802}, + {721804, 721804}, {721806, 721825}, {721827, 721909}, + {721911, 722049}, {722058, 722223}, {722225, 722262}, + {722265, 722265}, {722272, 722312}, {722384, 722410}, + {722415, 722418}, {722464, 722506}, {722542, 722543}, + {722545, 722643}, {722645, 722645}, {722661, 722662}, + {722670, 722671}, {722682, 722684}, {722687, 722687}, + {722704, 722704}, {722706, 722735}, {722765, 722853}, + {722865, 722865}, {722890, 722922}, {722932, 722933}, + {722938, 722938}, {722944, 722965}, {722970, 722970}, + {722980, 722980}, {722984, 722984}, {723008, 723032}, + {723040, 723050}, {723056, 723079}, {723081, 723086}, + {723104, 723145}, {723204, 723257}, {723261, 723261}, + {723280, 723280}, {723288, 723297}, {723313, 723328}, + {723333, 723340}, {723343, 723344}, {723347, 723368}, + {723370, 723376}, {723378, 723378}, {723382, 723385}, + {723389, 723389}, {723406, 723406}, {723420, 723421}, + {723423, 723425}, {723440, 723441}, {723452, 723452}, + {723461, 723466}, {723471, 723472}, {723475, 723496}, + {723498, 723504}, {723506, 723507}, {723509, 723510}, + {723512, 723513}, {723545, 723548}, {723550, 723550}, + {723570, 723572}, {723589, 723597}, {723599, 723601}, + {723603, 723624}, {723626, 723632}, {723634, 723635}, + {723637, 723641}, {723645, 723645}, {723664, 723664}, + {723680, 723681}, {723705, 723705}, {723717, 723724}, + {723727, 723728}, {723731, 723752}, {723754, 723760}, + {723762, 723763}, {723765, 723769}, {723773, 723773}, + {723804, 723805}, {723807, 723809}, {723825, 723825}, + {723843, 723843}, {723845, 723850}, {723854, 723856}, + {723858, 723861}, {723865, 723866}, {723868, 723868}, + {723870, 723871}, {723875, 723876}, {723880, 723882}, + {723886, 723897}, {723920, 723920}, {723973, 723980}, + {723982, 723984}, {723986, 724008}, {724010, 724025}, + {724029, 724029}, {724056, 724058}, {724061, 724061}, + {724064, 724065}, {724096, 724096}, {724101, 724108}, + {724110, 724112}, {724114, 724136}, {724138, 724147}, + {724149, 724153}, {724157, 724157}, {724189, 724190}, + {724192, 724193}, {724209, 724210}, {724228, 724236}, + {724238, 724240}, {724242, 724282}, {724285, 724285}, + {724302, 724302}, {724308, 724310}, {724319, 724321}, + {724346, 724351}, {724357, 724374}, {724378, 724401}, + {724403, 724411}, {724413, 724413}, {724416, 724422}, + {724481, 724528}, {724530, 724531}, {724544, 724550}, + {724609, 724610}, {724612, 724612}, {724614, 724618}, + {724620, 724643}, {724645, 724645}, {724647, 724656}, + {724658, 724659}, {724669, 724669}, {724672, 724676}, + {724678, 724678}, {724700, 724703}, {724736, 724736}, + {724800, 724807}, {724809, 724844}, {724872, 724876}, + {724992, 725034}, {725055, 725055}, {725072, 725077}, + {725082, 725085}, {725089, 725089}, {725093, 725094}, + {725102, 725104}, {725109, 725121}, {725134, 725134}, + {725152, 725189}, {725191, 725191}, {725197, 725197}, + {725200, 725242}, {725244, 725576}, {725578, 725581}, + {725584, 725590}, {725592, 725592}, {725594, 725597}, + {725600, 725640}, {725642, 725645}, {725648, 725680}, + {725682, 725685}, {725688, 725694}, {725696, 725696}, + {725698, 725701}, {725704, 725718}, {725720, 725776}, + {725778, 725781}, {725784, 725850}, {725888, 725903}, + {725920, 726005}, {726008, 726013}, {726017, 726636}, + {726639, 726655}, {726657, 726682}, {726688, 726762}, + {726766, 726776}, {726784, 726801}, {726815, 726833}, + {726848, 726865}, {726880, 726892}, {726894, 726896}, + {726912, 726963}, {726999, 726999}, {727004, 727004}, + {727072, 727160}, {727168, 727208}, {727210, 727210}, + {727216, 727285}, {727296, 727326}, {727376, 727405}, + {727408, 727412}, {727424, 727467}, {727472, 727497}, + {727552, 727574}, {727584, 727636}, {727719, 727719}, + {727813, 727859}, {727877, 727884}, {727939, 727968}, + {727982, 727983}, {727994, 728037}, {728064, 728099}, + {728141, 728143}, {728154, 728189}, {728192, 728200}, + {728208, 728250}, {728253, 728255}, {728297, 728300}, + {728302, 728307}, {728309, 728310}, {728314, 728314}, + {728320, 728511}, {728576, 728853}, {728856, 728861}, + {728864, 728901}, {728904, 728909}, {728912, 728919}, + {728921, 728921}, {728923, 728923}, {728925, 728925}, + {728927, 728957}, {728960, 729012}, {729014, 729020}, + {729022, 729022}, {729026, 729028}, {729030, 729036}, + {729040, 729043}, {729046, 729051}, {729056, 729068}, + {729074, 729076}, {729078, 729084}, {729201, 729201}, + {729215, 729215}, {729232, 729244}, {729346, 729346}, + {729351, 729351}, {729354, 729363}, {729365, 729365}, + {729368, 729373}, {729380, 729380}, {729382, 729382}, + {729384, 729384}, {729386, 729401}, {729404, 729407}, + {729413, 729417}, {729422, 729422}, {729440, 729480}, + {732160, 732388}, {732395, 732398}, {732402, 732403}, + {732416, 732453}, {732455, 732455}, {732461, 732461}, + {732464, 732519}, {732527, 732527}, {732544, 732566}, + {732576, 732582}, {732584, 732590}, {732592, 732598}, + {732600, 732606}, {732608, 732614}, {732616, 732622}, + {732624, 732630}, {732632, 732638}, {733189, 733191}, + {733217, 733225}, {733233, 733237}, {733240, 733244}, + {733249, 733334}, {733339, 733343}, {733345, 733434}, + {733436, 733439}, {733445, 733487}, {733489, 733582}, + {733600, 733631}, {733680, 733695}, {734208, 740799}, + {740864, 763020}, {763088, 763133}, {763136, 763404}, + {763408, 763423}, {763434, 763435}, {763456, 763502}, + {763519, 763549}, {763552, 763631}, {763671, 763679}, + {763682, 763784}, {763787, 763850}, {763856, 763857}, + {763859, 763859}, {763861, 763865}, {763890, 763905}, + {763907, 763909}, {763911, 763914}, {763916, 763938}, + {763968, 764019}, {764034, 764083}, {764146, 764151}, + {764155, 764155}, {764157, 764158}, {764170, 764197}, + {764208, 764230}, {764256, 764284}, {764292, 764338}, + {764367, 764367}, {764384, 764388}, {764390, 764399}, + {764410, 764414}, {764416, 764456}, {764480, 764482}, + {764484, 764491}, {764512, 764534}, {764538, 764538}, + {764542, 764591}, {764593, 764593}, {764597, 764598}, + {764601, 764605}, {764608, 764608}, {764610, 764610}, + {764635, 764637}, {764640, 764650}, {764658, 764660}, + {764673, 764678}, {764681, 764686}, {764689, 764694}, + {764704, 764710}, {764712, 764718}, {764720, 764762}, + {764764, 764777}, {764784, 764898}, {764928, 776099}, + {776112, 776134}, {776139, 776187}, {784640, 785005}, + {785008, 785113}, {785152, 785158}, {785171, 785175}, + {785181, 785181}, {785183, 785192}, {785194, 785206}, + {785208, 785212}, {785214, 785214}, {785216, 785217}, + {785219, 785220}, {785222, 785329}, {785363, 785725}, + {785744, 785807}, {785810, 785863}, {785904, 785915}, + {786032, 786036}, {786038, 786172}, {786209, 786234}, + {786241, 786266}, {786278, 786366}, {786370, 786375}, + {786378, 786383}, {786386, 786391}, {786394, 786396}, + {786468, 786468}, {786497, 786522}, {786527, 786527}, + {786529, 786554}, {786602, 786602}, {786613, 786613}, + {786618, 786618}, {786624, 786646}, {786648, 786678}, + {786680, 787137}, {787142, 787153}, {787168, 787172}, + {787180, 787180}, {787182, 787182}, {787312, 787316}, + {787318, 787319}, {787322, 787325}, {787327, 787327}, + {787334, 787334}, {787336, 787338}, {787340, 787340}, + {787342, 787361}, {787363, 787445}, {787447, 787585}, + {787594, 787759}, {787761, 787798}, {787801, 787801}, + {787808, 787848}, {787920, 787946}, {787951, 787954}, + {788000, 788042}, {788078, 788079}, {788081, 788179}, + {788181, 788181}, {788197, 788198}, {788206, 788207}, + {788218, 788220}, {788223, 788223}, {788240, 788240}, + {788242, 788271}, {788301, 788389}, {788401, 788401}, + {788426, 788458}, {788468, 788469}, {788474, 788474}, + {788480, 788501}, {788506, 788506}, {788516, 788516}, + {788520, 788520}, {788544, 788568}, {788576, 788586}, + {788592, 788615}, {788617, 788622}, {788640, 788681}, + {788740, 788793}, {788797, 788797}, {788816, 788816}, + {788824, 788833}, {788849, 788864}, {788869, 788876}, + {788879, 788880}, {788883, 788904}, {788906, 788912}, + {788914, 788914}, {788918, 788921}, {788925, 788925}, + {788942, 788942}, {788956, 788957}, {788959, 788961}, + {788976, 788977}, {788988, 788988}, {788997, 789002}, + {789007, 789008}, {789011, 789032}, {789034, 789040}, + {789042, 789043}, {789045, 789046}, {789048, 789049}, + {789081, 789084}, {789086, 789086}, {789106, 789108}, + {789125, 789133}, {789135, 789137}, {789139, 789160}, + {789162, 789168}, {789170, 789171}, {789173, 789177}, + {789181, 789181}, {789200, 789200}, {789216, 789217}, + {789241, 789241}, {789253, 789260}, {789263, 789264}, + {789267, 789288}, {789290, 789296}, {789298, 789299}, + {789301, 789305}, {789309, 789309}, {789340, 789341}, + {789343, 789345}, {789361, 789361}, {789379, 789379}, + {789381, 789386}, {789390, 789392}, {789394, 789397}, + {789401, 789402}, {789404, 789404}, {789406, 789407}, + {789411, 789412}, {789416, 789418}, {789422, 789433}, + {789456, 789456}, {789509, 789516}, {789518, 789520}, + {789522, 789544}, {789546, 789561}, {789565, 789565}, + {789592, 789594}, {789597, 789597}, {789600, 789601}, + {789632, 789632}, {789637, 789644}, {789646, 789648}, + {789650, 789672}, {789674, 789683}, {789685, 789689}, + {789693, 789693}, {789725, 789726}, {789728, 789729}, + {789745, 789746}, {789764, 789772}, {789774, 789776}, + {789778, 789818}, {789821, 789821}, {789838, 789838}, + {789844, 789846}, {789855, 789857}, {789882, 789887}, + {789893, 789910}, {789914, 789937}, {789939, 789947}, + {789949, 789949}, {789952, 789958}, {790017, 790064}, + {790066, 790067}, {790080, 790086}, {790145, 790146}, + {790148, 790148}, {790150, 790154}, {790156, 790179}, + {790181, 790181}, {790183, 790192}, {790194, 790195}, + {790205, 790205}, {790208, 790212}, {790214, 790214}, + {790236, 790239}, {790272, 790272}, {790336, 790343}, + {790345, 790380}, {790408, 790412}, {790528, 790570}, + {790591, 790591}, {790608, 790613}, {790618, 790621}, + {790625, 790625}, {790629, 790630}, {790638, 790640}, + {790645, 790657}, {790670, 790670}, {790688, 790725}, + {790727, 790727}, {790733, 790733}, {790736, 790778}, + {790780, 791112}, {791114, 791117}, {791120, 791126}, + {791128, 791128}, {791130, 791133}, {791136, 791176}, + {791178, 791181}, {791184, 791216}, {791218, 791221}, + {791224, 791230}, {791232, 791232}, {791234, 791237}, + {791240, 791254}, {791256, 791312}, {791314, 791317}, + {791320, 791386}, {791424, 791439}, {791456, 791541}, + {791544, 791549}, {791553, 792172}, {792175, 792191}, + {792193, 792218}, {792224, 792298}, {792302, 792312}, + {792320, 792337}, {792351, 792369}, {792384, 792401}, + {792416, 792428}, {792430, 792432}, {792448, 792499}, + {792535, 792535}, {792540, 792540}, {792608, 792696}, + {792704, 792744}, {792746, 792746}, {792752, 792821}, + {792832, 792862}, {792912, 792941}, {792944, 792948}, + {792960, 793003}, {793008, 793033}, {793088, 793110}, + {793120, 793172}, {793255, 793255}, {793349, 793395}, + {793413, 793420}, {793475, 793504}, {793518, 793519}, + {793530, 793573}, {793600, 793635}, {793677, 793679}, + {793690, 793725}, {793728, 793736}, {793744, 793786}, + {793789, 793791}, {793833, 793836}, {793838, 793843}, + {793845, 793846}, {793850, 793850}, {793856, 794047}, + {794112, 794389}, {794392, 794397}, {794400, 794437}, + {794440, 794445}, {794448, 794455}, {794457, 794457}, + {794459, 794459}, {794461, 794461}, {794463, 794493}, + {794496, 794548}, {794550, 794556}, {794558, 794558}, + {794562, 794564}, {794566, 794572}, {794576, 794579}, + {794582, 794587}, {794592, 794604}, {794610, 794612}, + {794614, 794620}, {794737, 794737}, {794751, 794751}, + {794768, 794780}, {794882, 794882}, {794887, 794887}, + {794890, 794899}, {794901, 794901}, {794904, 794909}, + {794916, 794916}, {794918, 794918}, {794920, 794920}, + {794922, 794937}, {794940, 794943}, {794949, 794953}, + {794958, 794958}, {794976, 795016}, {797696, 797924}, + {797931, 797934}, {797938, 797939}, {797952, 797989}, + {797991, 797991}, {797997, 797997}, {798000, 798055}, + {798063, 798063}, {798080, 798102}, {798112, 798118}, + {798120, 798126}, {798128, 798134}, {798136, 798142}, + {798144, 798150}, {798152, 798158}, {798160, 798166}, + {798168, 798174}, {798725, 798727}, {798753, 798761}, + {798769, 798773}, {798776, 798780}, {798785, 798870}, + {798875, 798879}, {798881, 798970}, {798972, 798975}, + {798981, 799023}, {799025, 799118}, {799136, 799167}, + {799216, 799231}, {799744, 806335}, {806400, 828556}, + {828624, 828669}, {828672, 828940}, {828944, 828959}, + {828970, 828971}, {828992, 829038}, {829055, 829085}, + {829088, 829167}, {829207, 829215}, {829218, 829320}, + {829323, 829386}, {829392, 829393}, {829395, 829395}, + {829397, 829401}, {829426, 829441}, {829443, 829445}, + {829447, 829450}, {829452, 829474}, {829504, 829555}, + {829570, 829619}, {829682, 829687}, {829691, 829691}, + {829693, 829694}, {829706, 829733}, {829744, 829766}, + {829792, 829820}, {829828, 829874}, {829903, 829903}, + {829920, 829924}, {829926, 829935}, {829946, 829950}, + {829952, 829992}, {830016, 830018}, {830020, 830027}, + {830048, 830070}, {830074, 830074}, {830078, 830127}, + {830129, 830129}, {830133, 830134}, {830137, 830141}, + {830144, 830144}, {830146, 830146}, {830171, 830173}, + {830176, 830186}, {830194, 830196}, {830209, 830214}, + {830217, 830222}, {830225, 830230}, {830240, 830246}, + {830248, 830254}, {830256, 830298}, {830300, 830313}, + {830320, 830434}, {830464, 841635}, {841648, 841670}, + {841675, 841723}, {850176, 850541}, {850544, 850649}, + {850688, 850694}, {850707, 850711}, {850717, 850717}, + {850719, 850728}, {850730, 850742}, {850744, 850748}, + {850750, 850750}, {850752, 850753}, {850755, 850756}, + {850758, 850865}, {850899, 851261}, {851280, 851343}, + {851346, 851399}, {851440, 851451}, {851568, 851572}, + {851574, 851708}, {851745, 851770}, {851777, 851802}, + {851814, 851902}, {851906, 851911}, {851914, 851919}, + {851922, 851927}, {851930, 851932}, {852004, 852004}, + {852033, 852058}, {852063, 852063}, {852065, 852090}, + {852138, 852138}, {852149, 852149}, {852154, 852154}, + {852160, 852182}, {852184, 852214}, {852216, 852673}, + {852678, 852689}, {852704, 852708}, {852716, 852716}, + {852718, 852718}, {852848, 852852}, {852854, 852855}, + {852858, 852861}, {852863, 852863}, {852870, 852870}, + {852872, 852874}, {852876, 852876}, {852878, 852897}, + {852899, 852981}, {852983, 853121}, {853130, 853295}, + {853297, 853334}, {853337, 853337}, {853344, 853384}, + {853456, 853482}, {853487, 853490}, {853536, 853578}, + {853614, 853615}, {853617, 853715}, {853717, 853717}, + {853733, 853734}, {853742, 853743}, {853754, 853756}, + {853759, 853759}, {853776, 853776}, {853778, 853807}, + {853837, 853925}, {853937, 853937}, {853962, 853994}, + {854004, 854005}, {854010, 854010}, {854016, 854037}, + {854042, 854042}, {854052, 854052}, {854056, 854056}, + {854080, 854104}, {854112, 854122}, {854128, 854151}, + {854153, 854158}, {854176, 854217}, {854276, 854329}, + {854333, 854333}, {854352, 854352}, {854360, 854369}, + {854385, 854400}, {854405, 854412}, {854415, 854416}, + {854419, 854440}, {854442, 854448}, {854450, 854450}, + {854454, 854457}, {854461, 854461}, {854478, 854478}, + {854492, 854493}, {854495, 854497}, {854512, 854513}, + {854524, 854524}, {854533, 854538}, {854543, 854544}, + {854547, 854568}, {854570, 854576}, {854578, 854579}, + {854581, 854582}, {854584, 854585}, {854617, 854620}, + {854622, 854622}, {854642, 854644}, {854661, 854669}, + {854671, 854673}, {854675, 854696}, {854698, 854704}, + {854706, 854707}, {854709, 854713}, {854717, 854717}, + {854736, 854736}, {854752, 854753}, {854777, 854777}, + {854789, 854796}, {854799, 854800}, {854803, 854824}, + {854826, 854832}, {854834, 854835}, {854837, 854841}, + {854845, 854845}, {854876, 854877}, {854879, 854881}, + {854897, 854897}, {854915, 854915}, {854917, 854922}, + {854926, 854928}, {854930, 854933}, {854937, 854938}, + {854940, 854940}, {854942, 854943}, {854947, 854948}, + {854952, 854954}, {854958, 854969}, {854992, 854992}, + {855045, 855052}, {855054, 855056}, {855058, 855080}, + {855082, 855097}, {855101, 855101}, {855128, 855130}, + {855133, 855133}, {855136, 855137}, {855168, 855168}, + {855173, 855180}, {855182, 855184}, {855186, 855208}, + {855210, 855219}, {855221, 855225}, {855229, 855229}, + {855261, 855262}, {855264, 855265}, {855281, 855282}, + {855300, 855308}, {855310, 855312}, {855314, 855354}, + {855357, 855357}, {855374, 855374}, {855380, 855382}, + {855391, 855393}, {855418, 855423}, {855429, 855446}, + {855450, 855473}, {855475, 855483}, {855485, 855485}, + {855488, 855494}, {855553, 855600}, {855602, 855603}, + {855616, 855622}, {855681, 855682}, {855684, 855684}, + {855686, 855690}, {855692, 855715}, {855717, 855717}, + {855719, 855728}, {855730, 855731}, {855741, 855741}, + {855744, 855748}, {855750, 855750}, {855772, 855775}, + {855808, 855808}, {855872, 855879}, {855881, 855916}, + {855944, 855948}, {856064, 856106}, {856127, 856127}, + {856144, 856149}, {856154, 856157}, {856161, 856161}, + {856165, 856166}, {856174, 856176}, {856181, 856193}, + {856206, 856206}, {856224, 856261}, {856263, 856263}, + {856269, 856269}, {856272, 856314}, {856316, 856648}, + {856650, 856653}, {856656, 856662}, {856664, 856664}, + {856666, 856669}, {856672, 856712}, {856714, 856717}, + {856720, 856752}, {856754, 856757}, {856760, 856766}, + {856768, 856768}, {856770, 856773}, {856776, 856790}, + {856792, 856848}, {856850, 856853}, {856856, 856922}, + {856960, 856975}, {856992, 857077}, {857080, 857085}, + {857089, 857708}, {857711, 857727}, {857729, 857754}, + {857760, 857834}, {857838, 857848}, {857856, 857873}, + {857887, 857905}, {857920, 857937}, {857952, 857964}, + {857966, 857968}, {857984, 858035}, {858071, 858071}, + {858076, 858076}, {858144, 858232}, {858240, 858280}, + {858282, 858282}, {858288, 858357}, {858368, 858398}, + {858448, 858477}, {858480, 858484}, {858496, 858539}, + {858544, 858569}, {858624, 858646}, {858656, 858708}, + {858791, 858791}, {858885, 858931}, {858949, 858956}, + {859011, 859040}, {859054, 859055}, {859066, 859109}, + {859136, 859171}, {859213, 859215}, {859226, 859261}, + {859264, 859272}, {859280, 859322}, {859325, 859327}, + {859369, 859372}, {859374, 859379}, {859381, 859382}, + {859386, 859386}, {859392, 859583}, {859648, 859925}, + {859928, 859933}, {859936, 859973}, {859976, 859981}, + {859984, 859991}, {859993, 859993}, {859995, 859995}, + {859997, 859997}, {859999, 860029}, {860032, 860084}, + {860086, 860092}, {860094, 860094}, {860098, 860100}, + {860102, 860108}, {860112, 860115}, {860118, 860123}, + {860128, 860140}, {860146, 860148}, {860150, 860156}, + {860273, 860273}, {860287, 860287}, {860304, 860316}, + {860418, 860418}, {860423, 860423}, {860426, 860435}, + {860437, 860437}, {860440, 860445}, {860452, 860452}, + {860454, 860454}, {860456, 860456}, {860458, 860473}, + {860476, 860479}, {860485, 860489}, {860494, 860494}, + {860512, 860552}, {863232, 863460}, {863467, 863470}, + {863474, 863475}, {863488, 863525}, {863527, 863527}, + {863533, 863533}, {863536, 863591}, {863599, 863599}, + {863616, 863638}, {863648, 863654}, {863656, 863662}, + {863664, 863670}, {863672, 863678}, {863680, 863686}, + {863688, 863694}, {863696, 863702}, {863704, 863710}, + {864261, 864263}, {864289, 864297}, {864305, 864309}, + {864312, 864316}, {864321, 864406}, {864411, 864415}, + {864417, 864506}, {864508, 864511}, {864517, 864559}, + {864561, 864654}, {864672, 864703}, {864752, 864767}, + {865280, 871871}, {871936, 894092}, {894160, 894205}, + {894208, 894476}, {894480, 894495}, {894506, 894507}, + {894528, 894574}, {894591, 894621}, {894624, 894703}, + {894743, 894751}, {894754, 894856}, {894859, 894922}, + {894928, 894929}, {894931, 894931}, {894933, 894937}, + {894962, 894977}, {894979, 894981}, {894983, 894986}, + {894988, 895010}, {895040, 895091}, {895106, 895155}, + {895218, 895223}, {895227, 895227}, {895229, 895230}, + {895242, 895269}, {895280, 895302}, {895328, 895356}, + {895364, 895410}, {895439, 895439}, {895456, 895460}, + {895462, 895471}, {895482, 895486}, {895488, 895528}, + {895552, 895554}, {895556, 895563}, {895584, 895606}, + {895610, 895610}, {895614, 895663}, {895665, 895665}, + {895669, 895670}, {895673, 895677}, {895680, 895680}, + {895682, 895682}, {895707, 895709}, {895712, 895722}, + {895730, 895732}, {895745, 895750}, {895753, 895758}, + {895761, 895766}, {895776, 895782}, {895784, 895790}, + {895792, 895834}, {895836, 895849}, {895856, 895970}, + {896000, 907171}, {907184, 907206}, {907211, 907259}, + {915712, 916077}, {916080, 916185}, {916224, 916230}, + {916243, 916247}, {916253, 916253}, {916255, 916264}, + {916266, 916278}, {916280, 916284}, {916286, 916286}, + {916288, 916289}, {916291, 916292}, {916294, 916401}, + {916435, 916797}, {916816, 916879}, {916882, 916935}, + {916976, 916987}, {917104, 917108}, {917110, 917244}, + {917281, 917306}, {917313, 917338}, {917350, 917438}, + {917442, 917447}, {917450, 917455}, {917458, 917463}, + {917466, 917468}, {917540, 917540}, {917569, 917594}, + {917599, 917599}, {917601, 917626}, {917674, 917674}, + {917685, 917685}, {917690, 917690}, {917696, 917718}, + {917720, 917750}, {917752, 918209}, {918214, 918225}, + {918240, 918244}, {918252, 918252}, {918254, 918254}, + {918384, 918388}, {918390, 918391}, {918394, 918397}, + {918399, 918399}, {918406, 918406}, {918408, 918410}, + {918412, 918412}, {918414, 918433}, {918435, 918517}, + {918519, 918657}, {918666, 918831}, {918833, 918870}, + {918873, 918873}, {918880, 918920}, {918992, 919018}, + {919023, 919026}, {919072, 919114}, {919150, 919151}, + {919153, 919251}, {919253, 919253}, {919269, 919270}, + {919278, 919279}, {919290, 919292}, {919295, 919295}, + {919312, 919312}, {919314, 919343}, {919373, 919461}, + {919473, 919473}, {919498, 919530}, {919540, 919541}, + {919546, 919546}, {919552, 919573}, {919578, 919578}, + {919588, 919588}, {919592, 919592}, {919616, 919640}, + {919648, 919658}, {919664, 919687}, {919689, 919694}, + {919712, 919753}, {919812, 919865}, {919869, 919869}, + {919888, 919888}, {919896, 919905}, {919921, 919936}, + {919941, 919948}, {919951, 919952}, {919955, 919976}, + {919978, 919984}, {919986, 919986}, {919990, 919993}, + {919997, 919997}, {920014, 920014}, {920028, 920029}, + {920031, 920033}, {920048, 920049}, {920060, 920060}, + {920069, 920074}, {920079, 920080}, {920083, 920104}, + {920106, 920112}, {920114, 920115}, {920117, 920118}, + {920120, 920121}, {920153, 920156}, {920158, 920158}, + {920178, 920180}, {920197, 920205}, {920207, 920209}, + {920211, 920232}, {920234, 920240}, {920242, 920243}, + {920245, 920249}, {920253, 920253}, {920272, 920272}, + {920288, 920289}, {920313, 920313}, {920325, 920332}, + {920335, 920336}, {920339, 920360}, {920362, 920368}, + {920370, 920371}, {920373, 920377}, {920381, 920381}, + {920412, 920413}, {920415, 920417}, {920433, 920433}, + {920451, 920451}, {920453, 920458}, {920462, 920464}, + {920466, 920469}, {920473, 920474}, {920476, 920476}, + {920478, 920479}, {920483, 920484}, {920488, 920490}, + {920494, 920505}, {920528, 920528}, {920581, 920588}, + {920590, 920592}, {920594, 920616}, {920618, 920633}, + {920637, 920637}, {920664, 920666}, {920669, 920669}, + {920672, 920673}, {920704, 920704}, {920709, 920716}, + {920718, 920720}, {920722, 920744}, {920746, 920755}, + {920757, 920761}, {920765, 920765}, {920797, 920798}, + {920800, 920801}, {920817, 920818}, {920836, 920844}, + {920846, 920848}, {920850, 920890}, {920893, 920893}, + {920910, 920910}, {920916, 920918}, {920927, 920929}, + {920954, 920959}, {920965, 920982}, {920986, 921009}, + {921011, 921019}, {921021, 921021}, {921024, 921030}, + {921089, 921136}, {921138, 921139}, {921152, 921158}, + {921217, 921218}, {921220, 921220}, {921222, 921226}, + {921228, 921251}, {921253, 921253}, {921255, 921264}, + {921266, 921267}, {921277, 921277}, {921280, 921284}, + {921286, 921286}, {921308, 921311}, {921344, 921344}, + {921408, 921415}, {921417, 921452}, {921480, 921484}, + {921600, 921642}, {921663, 921663}, {921680, 921685}, + {921690, 921693}, {921697, 921697}, {921701, 921702}, + {921710, 921712}, {921717, 921729}, {921742, 921742}, + {921760, 921797}, {921799, 921799}, {921805, 921805}, + {921808, 921850}, {921852, 922184}, {922186, 922189}, + {922192, 922198}, {922200, 922200}, {922202, 922205}, + {922208, 922248}, {922250, 922253}, {922256, 922288}, + {922290, 922293}, {922296, 922302}, {922304, 922304}, + {922306, 922309}, {922312, 922326}, {922328, 922384}, + {922386, 922389}, {922392, 922458}, {922496, 922511}, + {922528, 922613}, {922616, 922621}, {922625, 923244}, + {923247, 923263}, {923265, 923290}, {923296, 923370}, + {923374, 923384}, {923392, 923409}, {923423, 923441}, + {923456, 923473}, {923488, 923500}, {923502, 923504}, + {923520, 923571}, {923607, 923607}, {923612, 923612}, + {923680, 923768}, {923776, 923816}, {923818, 923818}, + {923824, 923893}, {923904, 923934}, {923984, 924013}, + {924016, 924020}, {924032, 924075}, {924080, 924105}, + {924160, 924182}, {924192, 924244}, {924327, 924327}, + {924421, 924467}, {924485, 924492}, {924547, 924576}, + {924590, 924591}, {924602, 924645}, {924672, 924707}, + {924749, 924751}, {924762, 924797}, {924800, 924808}, + {924816, 924858}, {924861, 924863}, {924905, 924908}, + {924910, 924915}, {924917, 924918}, {924922, 924922}, + {924928, 925119}, {925184, 925461}, {925464, 925469}, + {925472, 925509}, {925512, 925517}, {925520, 925527}, + {925529, 925529}, {925531, 925531}, {925533, 925533}, + {925535, 925565}, {925568, 925620}, {925622, 925628}, + {925630, 925630}, {925634, 925636}, {925638, 925644}, + {925648, 925651}, {925654, 925659}, {925664, 925676}, + {925682, 925684}, {925686, 925692}, {925809, 925809}, + {925823, 925823}, {925840, 925852}, {925954, 925954}, + {925959, 925959}, {925962, 925971}, {925973, 925973}, + {925976, 925981}, {925988, 925988}, {925990, 925990}, + {925992, 925992}, {925994, 926009}, {926012, 926015}, + {926021, 926025}, {926030, 926030}, {926048, 926088}, + {928768, 928996}, {929003, 929006}, {929010, 929011}, + {929024, 929061}, {929063, 929063}, {929069, 929069}, + {929072, 929127}, {929135, 929135}, {929152, 929174}, + {929184, 929190}, {929192, 929198}, {929200, 929206}, + {929208, 929214}, {929216, 929222}, {929224, 929230}, + {929232, 929238}, {929240, 929246}, {929797, 929799}, + {929825, 929833}, {929841, 929845}, {929848, 929852}, + {929857, 929942}, {929947, 929951}, {929953, 930042}, + {930044, 930047}, {930053, 930095}, {930097, 930190}, + {930208, 930239}, {930288, 930303}, {930816, 937407}, + {937472, 959628}, {959696, 959741}, {959744, 960012}, + {960016, 960031}, {960042, 960043}, {960064, 960110}, + {960127, 960157}, {960160, 960239}, {960279, 960287}, + {960290, 960392}, {960395, 960458}, {960464, 960465}, + {960467, 960467}, {960469, 960473}, {960498, 960513}, + {960515, 960517}, {960519, 960522}, {960524, 960546}, + {960576, 960627}, {960642, 960691}, {960754, 960759}, + {960763, 960763}, {960765, 960766}, {960778, 960805}, + {960816, 960838}, {960864, 960892}, {960900, 960946}, + {960975, 960975}, {960992, 960996}, {960998, 961007}, + {961018, 961022}, {961024, 961064}, {961088, 961090}, + {961092, 961099}, {961120, 961142}, {961146, 961146}, + {961150, 961199}, {961201, 961201}, {961205, 961206}, + {961209, 961213}, {961216, 961216}, {961218, 961218}, + {961243, 961245}, {961248, 961258}, {961266, 961268}, + {961281, 961286}, {961289, 961294}, {961297, 961302}, + {961312, 961318}, {961320, 961326}, {961328, 961370}, + {961372, 961385}, {961392, 961506}, {961536, 972707}, + {972720, 972742}, {972747, 972795}, {981248, 981613}, + {981616, 981721}, {981760, 981766}, {981779, 981783}, + {981789, 981789}, {981791, 981800}, {981802, 981814}, + {981816, 981820}, {981822, 981822}, {981824, 981825}, + {981827, 981828}, {981830, 981937}, {981971, 982333}, + {982352, 982415}, {982418, 982471}, {982512, 982523}, + {982640, 982644}, {982646, 982780}, {982817, 982842}, + {982849, 982874}, {982886, 982974}, {982978, 982983}, + {982986, 982991}, {982994, 982999}, {983002, 983004}, + {983076, 983076}, {983105, 983130}, {983135, 983135}, + {983137, 983162}, {983210, 983210}, {983221, 983221}, + {983226, 983226}, {983232, 983254}, {983256, 983286}, + {983288, 983745}, {983750, 983761}, {983776, 983780}, + {983788, 983788}, {983790, 983790}, {983920, 983924}, + {983926, 983927}, {983930, 983933}, {983935, 983935}, + {983942, 983942}, {983944, 983946}, {983948, 983948}, + {983950, 983969}, {983971, 984053}, {984055, 984193}, + {984202, 984367}, {984369, 984406}, {984409, 984409}, + {984416, 984456}, {984528, 984554}, {984559, 984562}, + {984608, 984650}, {984686, 984687}, {984689, 984787}, + {984789, 984789}, {984805, 984806}, {984814, 984815}, + {984826, 984828}, {984831, 984831}, {984848, 984848}, + {984850, 984879}, {984909, 984997}, {985009, 985009}, + {985034, 985066}, {985076, 985077}, {985082, 985082}, + {985088, 985109}, {985114, 985114}, {985124, 985124}, + {985128, 985128}, {985152, 985176}, {985184, 985194}, + {985200, 985223}, {985225, 985230}, {985248, 985289}, + {985348, 985401}, {985405, 985405}, {985424, 985424}, + {985432, 985441}, {985457, 985472}, {985477, 985484}, + {985487, 985488}, {985491, 985512}, {985514, 985520}, + {985522, 985522}, {985526, 985529}, {985533, 985533}, + {985550, 985550}, {985564, 985565}, {985567, 985569}, + {985584, 985585}, {985596, 985596}, {985605, 985610}, + {985615, 985616}, {985619, 985640}, {985642, 985648}, + {985650, 985651}, {985653, 985654}, {985656, 985657}, + {985689, 985692}, {985694, 985694}, {985714, 985716}, + {985733, 985741}, {985743, 985745}, {985747, 985768}, + {985770, 985776}, {985778, 985779}, {985781, 985785}, + {985789, 985789}, {985808, 985808}, {985824, 985825}, + {985849, 985849}, {985861, 985868}, {985871, 985872}, + {985875, 985896}, {985898, 985904}, {985906, 985907}, + {985909, 985913}, {985917, 985917}, {985948, 985949}, + {985951, 985953}, {985969, 985969}, {985987, 985987}, + {985989, 985994}, {985998, 986000}, {986002, 986005}, + {986009, 986010}, {986012, 986012}, {986014, 986015}, + {986019, 986020}, {986024, 986026}, {986030, 986041}, + {986064, 986064}, {986117, 986124}, {986126, 986128}, + {986130, 986152}, {986154, 986169}, {986173, 986173}, + {986200, 986202}, {986205, 986205}, {986208, 986209}, + {986240, 986240}, {986245, 986252}, {986254, 986256}, + {986258, 986280}, {986282, 986291}, {986293, 986297}, + {986301, 986301}, {986333, 986334}, {986336, 986337}, + {986353, 986354}, {986372, 986380}, {986382, 986384}, + {986386, 986426}, {986429, 986429}, {986446, 986446}, + {986452, 986454}, {986463, 986465}, {986490, 986495}, + {986501, 986518}, {986522, 986545}, {986547, 986555}, + {986557, 986557}, {986560, 986566}, {986625, 986672}, + {986674, 986675}, {986688, 986694}, {986753, 986754}, + {986756, 986756}, {986758, 986762}, {986764, 986787}, + {986789, 986789}, {986791, 986800}, {986802, 986803}, + {986813, 986813}, {986816, 986820}, {986822, 986822}, + {986844, 986847}, {986880, 986880}, {986944, 986951}, + {986953, 986988}, {987016, 987020}, {987136, 987178}, + {987199, 987199}, {987216, 987221}, {987226, 987229}, + {987233, 987233}, {987237, 987238}, {987246, 987248}, + {987253, 987265}, {987278, 987278}, {987296, 987333}, + {987335, 987335}, {987341, 987341}, {987344, 987386}, + {987388, 987720}, {987722, 987725}, {987728, 987734}, + {987736, 987736}, {987738, 987741}, {987744, 987784}, + {987786, 987789}, {987792, 987824}, {987826, 987829}, + {987832, 987838}, {987840, 987840}, {987842, 987845}, + {987848, 987862}, {987864, 987920}, {987922, 987925}, + {987928, 987994}, {988032, 988047}, {988064, 988149}, + {988152, 988157}, {988161, 988780}, {988783, 988799}, + {988801, 988826}, {988832, 988906}, {988910, 988920}, + {988928, 988945}, {988959, 988977}, {988992, 989009}, + {989024, 989036}, {989038, 989040}, {989056, 989107}, + {989143, 989143}, {989148, 989148}, {989216, 989304}, + {989312, 989352}, {989354, 989354}, {989360, 989429}, + {989440, 989470}, {989520, 989549}, {989552, 989556}, + {989568, 989611}, {989616, 989641}, {989696, 989718}, + {989728, 989780}, {989863, 989863}, {989957, 990003}, + {990021, 990028}, {990083, 990112}, {990126, 990127}, + {990138, 990181}, {990208, 990243}, {990285, 990287}, + {990298, 990333}, {990336, 990344}, {990352, 990394}, + {990397, 990399}, {990441, 990444}, {990446, 990451}, + {990453, 990454}, {990458, 990458}, {990464, 990655}, + {990720, 990997}, {991000, 991005}, {991008, 991045}, + {991048, 991053}, {991056, 991063}, {991065, 991065}, + {991067, 991067}, {991069, 991069}, {991071, 991101}, + {991104, 991156}, {991158, 991164}, {991166, 991166}, + {991170, 991172}, {991174, 991180}, {991184, 991187}, + {991190, 991195}, {991200, 991212}, {991218, 991220}, + {991222, 991228}, {991345, 991345}, {991359, 991359}, + {991376, 991388}, {991490, 991490}, {991495, 991495}, + {991498, 991507}, {991509, 991509}, {991512, 991517}, + {991524, 991524}, {991526, 991526}, {991528, 991528}, + {991530, 991545}, {991548, 991551}, {991557, 991561}, + {991566, 991566}, {991584, 991624}, {994304, 994532}, + {994539, 994542}, {994546, 994547}, {994560, 994597}, + {994599, 994599}, {994605, 994605}, {994608, 994663}, + {994671, 994671}, {994688, 994710}, {994720, 994726}, + {994728, 994734}, {994736, 994742}, {994744, 994750}, + {994752, 994758}, {994760, 994766}, {994768, 994774}, + {994776, 994782}, {995333, 995335}, {995361, 995369}, + {995377, 995381}, {995384, 995388}, {995393, 995478}, + {995483, 995487}, {995489, 995578}, {995580, 995583}, + {995589, 995631}, {995633, 995726}, {995744, 995775}, + {995824, 995839}, {996352, 1002943}, {1003008, 1025164}, + {1025232, 1025277}, {1025280, 1025548}, {1025552, 1025567}, + {1025578, 1025579}, {1025600, 1025646}, {1025663, 1025693}, + {1025696, 1025775}, {1025815, 1025823}, {1025826, 1025928}, + {1025931, 1025994}, {1026000, 1026001}, {1026003, 1026003}, + {1026005, 1026009}, {1026034, 1026049}, {1026051, 1026053}, + {1026055, 1026058}, {1026060, 1026082}, {1026112, 1026163}, + {1026178, 1026227}, {1026290, 1026295}, {1026299, 1026299}, + {1026301, 1026302}, {1026314, 1026341}, {1026352, 1026374}, + {1026400, 1026428}, {1026436, 1026482}, {1026511, 1026511}, + {1026528, 1026532}, {1026534, 1026543}, {1026554, 1026558}, + {1026560, 1026600}, {1026624, 1026626}, {1026628, 1026635}, + {1026656, 1026678}, {1026682, 1026682}, {1026686, 1026735}, + {1026737, 1026737}, {1026741, 1026742}, {1026745, 1026749}, + {1026752, 1026752}, {1026754, 1026754}, {1026779, 1026781}, + {1026784, 1026794}, {1026802, 1026804}, {1026817, 1026822}, + {1026825, 1026830}, {1026833, 1026838}, {1026848, 1026854}, + {1026856, 1026862}, {1026864, 1026906}, {1026908, 1026921}, + {1026928, 1027042}, {1027072, 1038243}, {1038256, 1038278}, + {1038283, 1038331}, {1046784, 1047149}, {1047152, 1047257}, + {1047296, 1047302}, {1047315, 1047319}, {1047325, 1047325}, + {1047327, 1047336}, {1047338, 1047350}, {1047352, 1047356}, + {1047358, 1047358}, {1047360, 1047361}, {1047363, 1047364}, + {1047366, 1047473}, {1047507, 1047869}, {1047888, 1047951}, + {1047954, 1048007}, {1048048, 1048059}, {1048176, 1048180}, + {1048182, 1048316}, {1048353, 1048378}, {1048385, 1048410}, + {1048422, 1048510}, {1048514, 1048519}, {1048522, 1048527}, + {1048530, 1048535}, {1048538, 1048540}, {1048612, 1048612}, + {1048641, 1048666}, {1048671, 1048671}, {1048673, 1048698}, + {1048746, 1048746}, {1048757, 1048757}, {1048762, 1048762}, + {1048768, 1048790}, {1048792, 1048822}, {1048824, 1049281}, + {1049286, 1049297}, {1049312, 1049316}, {1049324, 1049324}, + {1049326, 1049326}, {1049456, 1049460}, {1049462, 1049463}, + {1049466, 1049469}, {1049471, 1049471}, {1049478, 1049478}, + {1049480, 1049482}, {1049484, 1049484}, {1049486, 1049505}, + {1049507, 1049589}, {1049591, 1049729}, {1049738, 1049903}, + {1049905, 1049942}, {1049945, 1049945}, {1049952, 1049992}, + {1050064, 1050090}, {1050095, 1050098}, {1050144, 1050186}, + {1050222, 1050223}, {1050225, 1050323}, {1050325, 1050325}, + {1050341, 1050342}, {1050350, 1050351}, {1050362, 1050364}, + {1050367, 1050367}, {1050384, 1050384}, {1050386, 1050415}, + {1050445, 1050533}, {1050545, 1050545}, {1050570, 1050602}, + {1050612, 1050613}, {1050618, 1050618}, {1050624, 1050645}, + {1050650, 1050650}, {1050660, 1050660}, {1050664, 1050664}, + {1050688, 1050712}, {1050720, 1050730}, {1050736, 1050759}, + {1050761, 1050766}, {1050784, 1050825}, {1050884, 1050937}, + {1050941, 1050941}, {1050960, 1050960}, {1050968, 1050977}, + {1050993, 1051008}, {1051013, 1051020}, {1051023, 1051024}, + {1051027, 1051048}, {1051050, 1051056}, {1051058, 1051058}, + {1051062, 1051065}, {1051069, 1051069}, {1051086, 1051086}, + {1051100, 1051101}, {1051103, 1051105}, {1051120, 1051121}, + {1051132, 1051132}, {1051141, 1051146}, {1051151, 1051152}, + {1051155, 1051176}, {1051178, 1051184}, {1051186, 1051187}, + {1051189, 1051190}, {1051192, 1051193}, {1051225, 1051228}, + {1051230, 1051230}, {1051250, 1051252}, {1051269, 1051277}, + {1051279, 1051281}, {1051283, 1051304}, {1051306, 1051312}, + {1051314, 1051315}, {1051317, 1051321}, {1051325, 1051325}, + {1051344, 1051344}, {1051360, 1051361}, {1051385, 1051385}, + {1051397, 1051404}, {1051407, 1051408}, {1051411, 1051432}, + {1051434, 1051440}, {1051442, 1051443}, {1051445, 1051449}, + {1051453, 1051453}, {1051484, 1051485}, {1051487, 1051489}, + {1051505, 1051505}, {1051523, 1051523}, {1051525, 1051530}, + {1051534, 1051536}, {1051538, 1051541}, {1051545, 1051546}, + {1051548, 1051548}, {1051550, 1051551}, {1051555, 1051556}, + {1051560, 1051562}, {1051566, 1051577}, {1051600, 1051600}, + {1051653, 1051660}, {1051662, 1051664}, {1051666, 1051688}, + {1051690, 1051705}, {1051709, 1051709}, {1051736, 1051738}, + {1051741, 1051741}, {1051744, 1051745}, {1051776, 1051776}, + {1051781, 1051788}, {1051790, 1051792}, {1051794, 1051816}, + {1051818, 1051827}, {1051829, 1051833}, {1051837, 1051837}, + {1051869, 1051870}, {1051872, 1051873}, {1051889, 1051890}, + {1051908, 1051916}, {1051918, 1051920}, {1051922, 1051962}, + {1051965, 1051965}, {1051982, 1051982}, {1051988, 1051990}, + {1051999, 1052001}, {1052026, 1052031}, {1052037, 1052054}, + {1052058, 1052081}, {1052083, 1052091}, {1052093, 1052093}, + {1052096, 1052102}, {1052161, 1052208}, {1052210, 1052211}, + {1052224, 1052230}, {1052289, 1052290}, {1052292, 1052292}, + {1052294, 1052298}, {1052300, 1052323}, {1052325, 1052325}, + {1052327, 1052336}, {1052338, 1052339}, {1052349, 1052349}, + {1052352, 1052356}, {1052358, 1052358}, {1052380, 1052383}, + {1052416, 1052416}, {1052480, 1052487}, {1052489, 1052524}, + {1052552, 1052556}, {1052672, 1052714}, {1052735, 1052735}, + {1052752, 1052757}, {1052762, 1052765}, {1052769, 1052769}, + {1052773, 1052774}, {1052782, 1052784}, {1052789, 1052801}, + {1052814, 1052814}, {1052832, 1052869}, {1052871, 1052871}, + {1052877, 1052877}, {1052880, 1052922}, {1052924, 1053256}, + {1053258, 1053261}, {1053264, 1053270}, {1053272, 1053272}, + {1053274, 1053277}, {1053280, 1053320}, {1053322, 1053325}, + {1053328, 1053360}, {1053362, 1053365}, {1053368, 1053374}, + {1053376, 1053376}, {1053378, 1053381}, {1053384, 1053398}, + {1053400, 1053456}, {1053458, 1053461}, {1053464, 1053530}, + {1053568, 1053583}, {1053600, 1053685}, {1053688, 1053693}, + {1053697, 1054316}, {1054319, 1054335}, {1054337, 1054362}, + {1054368, 1054442}, {1054446, 1054456}, {1054464, 1054481}, + {1054495, 1054513}, {1054528, 1054545}, {1054560, 1054572}, + {1054574, 1054576}, {1054592, 1054643}, {1054679, 1054679}, + {1054684, 1054684}, {1054752, 1054840}, {1054848, 1054888}, + {1054890, 1054890}, {1054896, 1054965}, {1054976, 1055006}, + {1055056, 1055085}, {1055088, 1055092}, {1055104, 1055147}, + {1055152, 1055177}, {1055232, 1055254}, {1055264, 1055316}, + {1055399, 1055399}, {1055493, 1055539}, {1055557, 1055564}, + {1055619, 1055648}, {1055662, 1055663}, {1055674, 1055717}, + {1055744, 1055779}, {1055821, 1055823}, {1055834, 1055869}, + {1055872, 1055880}, {1055888, 1055930}, {1055933, 1055935}, + {1055977, 1055980}, {1055982, 1055987}, {1055989, 1055990}, + {1055994, 1055994}, {1056000, 1056191}, {1056256, 1056533}, + {1056536, 1056541}, {1056544, 1056581}, {1056584, 1056589}, + {1056592, 1056599}, {1056601, 1056601}, {1056603, 1056603}, + {1056605, 1056605}, {1056607, 1056637}, {1056640, 1056692}, + {1056694, 1056700}, {1056702, 1056702}, {1056706, 1056708}, + {1056710, 1056716}, {1056720, 1056723}, {1056726, 1056731}, + {1056736, 1056748}, {1056754, 1056756}, {1056758, 1056764}, + {1056881, 1056881}, {1056895, 1056895}, {1056912, 1056924}, + {1057026, 1057026}, {1057031, 1057031}, {1057034, 1057043}, + {1057045, 1057045}, {1057048, 1057053}, {1057060, 1057060}, + {1057062, 1057062}, {1057064, 1057064}, {1057066, 1057081}, + {1057084, 1057087}, {1057093, 1057097}, {1057102, 1057102}, + {1057120, 1057160}, {1059840, 1060068}, {1060075, 1060078}, + {1060082, 1060083}, {1060096, 1060133}, {1060135, 1060135}, + {1060141, 1060141}, {1060144, 1060199}, {1060207, 1060207}, + {1060224, 1060246}, {1060256, 1060262}, {1060264, 1060270}, + {1060272, 1060278}, {1060280, 1060286}, {1060288, 1060294}, + {1060296, 1060302}, {1060304, 1060310}, {1060312, 1060318}, + {1060869, 1060871}, {1060897, 1060905}, {1060913, 1060917}, + {1060920, 1060924}, {1060929, 1061014}, {1061019, 1061023}, + {1061025, 1061114}, {1061116, 1061119}, {1061125, 1061167}, + {1061169, 1061262}, {1061280, 1061311}, {1061360, 1061375}, + {1061888, 1068479}, {1068544, 1090700}, {1090768, 1090813}, + {1090816, 1091084}, {1091088, 1091103}, {1091114, 1091115}, + {1091136, 1091182}, {1091199, 1091229}, {1091232, 1091311}, + {1091351, 1091359}, {1091362, 1091464}, {1091467, 1091530}, + {1091536, 1091537}, {1091539, 1091539}, {1091541, 1091545}, + {1091570, 1091585}, {1091587, 1091589}, {1091591, 1091594}, + {1091596, 1091618}, {1091648, 1091699}, {1091714, 1091763}, + {1091826, 1091831}, {1091835, 1091835}, {1091837, 1091838}, + {1091850, 1091877}, {1091888, 1091910}, {1091936, 1091964}, + {1091972, 1092018}, {1092047, 1092047}, {1092064, 1092068}, + {1092070, 1092079}, {1092090, 1092094}, {1092096, 1092136}, + {1092160, 1092162}, {1092164, 1092171}, {1092192, 1092214}, + {1092218, 1092218}, {1092222, 1092271}, {1092273, 1092273}, + {1092277, 1092278}, {1092281, 1092285}, {1092288, 1092288}, + {1092290, 1092290}, {1092315, 1092317}, {1092320, 1092330}, + {1092338, 1092340}, {1092353, 1092358}, {1092361, 1092366}, + {1092369, 1092374}, {1092384, 1092390}, {1092392, 1092398}, + {1092400, 1092442}, {1092444, 1092457}, {1092464, 1092578}, + {1092608, 1103779}, {1103792, 1103814}, {1103819, 1103867}, + {1112320, 1112685}, {1112688, 1112793}, {1112832, 1112838}, + {1112851, 1112855}, {1112861, 1112861}, {1112863, 1112872}, + {1112874, 1112886}, {1112888, 1112892}, {1112894, 1112894}, + {1112896, 1112897}, {1112899, 1112900}, {1112902, 1113009}, + {1113043, 1113405}, {1113424, 1113487}, {1113490, 1113543}, + {1113584, 1113595}, {1113712, 1113716}, {1113718, 1113852}, + {1113889, 1113914}, {1113921, 1113946}, {1113958, 1114046}, + {1114050, 1114055}, {1114058, 1114063}, {1114066, 1114071}, + {1114074, 1114076}}; + +ada_really_inline std::bitset<0x10FFFF> init_valid_id_start_mask_unicode() { + std::bitset<0x10FFFF> id_start_mask{}; + for (auto range : valid_id_start_ranges_unicode) { + for (auto r = range[0]; r <= range[1]; r++) { + id_start_mask.set(r); + } + } + return id_start_mask; +} + +static std::bitset<0x10FFFF> valid_id_start_mask_unicode = + init_valid_id_start_mask_unicode(); + +// https://wicg.github.io/urlpattern/#is-a-valid-name-code-point +ada_really_inline bool is_valid_identifier_start(const char32_t& c) noexcept { if (c < 256) { // extended ascii fast path return valid_identifier_start_table[c]; } - // TODO: handle this - return false; + // 256+ + return valid_id_start_mask_unicode[c]; } -static_assert(unicode::is_valid_identifier_start('$')); -static_assert(unicode::is_valid_identifier_start('_')); -static_assert(unicode::is_valid_identifier_start('a')); -static_assert(unicode::is_valid_identifier_start('z')); -static_assert(unicode::is_valid_identifier_start('A')); -static_assert(unicode::is_valid_identifier_start('Z')); -static_assert(!unicode::is_valid_identifier_start('0')); -static_assert(!unicode::is_valid_identifier_start('9')); -static_assert(!unicode::is_valid_identifier_start('\n')); -static_assert(!unicode::is_valid_identifier_start('\\')); -static_assert(!unicode::is_valid_identifier_start('\'')); -static_assert(!unicode::is_valid_identifier_start('*')); -static_assert(!unicode::is_valid_identifier_start('&')); - -constexpr static bool valid_identifier_part_table[] = { +// Valid IdentifierPart unicods points 256+ +// ranges with the regex [$_\u200C\u200D\p{ID_Continue}]/u +// https://tc39.es/ecma262/#prod-IdentifierPart +size_t valid_id_part_ranges_unicode[7299][2] = { + {255, 705}, {710, 721}, {736, 740}, + {748, 748}, {750, 750}, {768, 884}, + {886, 887}, {890, 893}, {895, 895}, + {902, 906}, {908, 908}, {910, 929}, + {931, 1013}, {1015, 1153}, {1155, 1159}, + {1162, 1327}, {1329, 1366}, {1369, 1369}, + {1376, 1416}, {1425, 1469}, {1471, 1471}, + {1473, 1474}, {1476, 1477}, {1479, 1479}, + {1488, 1514}, {1519, 1522}, {1552, 1562}, + {1568, 1641}, {1646, 1747}, {1749, 1756}, + {1759, 1768}, {1770, 1788}, {1791, 1791}, + {1808, 1866}, {1869, 1969}, {1984, 2037}, + {2042, 2042}, {2045, 2045}, {2048, 2093}, + {2112, 2139}, {2144, 2154}, {2160, 2183}, + {2185, 2190}, {2200, 2273}, {2275, 2403}, + {2406, 2415}, {2417, 2435}, {2437, 2444}, + {2447, 2448}, {2451, 2472}, {2474, 2480}, + {2482, 2482}, {2486, 2489}, {2492, 2500}, + {2503, 2504}, {2507, 2510}, {2519, 2519}, + {2524, 2525}, {2527, 2531}, {2534, 2545}, + {2556, 2556}, {2558, 2558}, {2561, 2563}, + {2565, 2570}, {2575, 2576}, {2579, 2600}, + {2602, 2608}, {2610, 2611}, {2613, 2614}, + {2616, 2617}, {2620, 2620}, {2622, 2626}, + {2631, 2632}, {2635, 2637}, {2641, 2641}, + {2649, 2652}, {2654, 2654}, {2662, 2677}, + {2689, 2691}, {2693, 2701}, {2703, 2705}, + {2707, 2728}, {2730, 2736}, {2738, 2739}, + {2741, 2745}, {2748, 2757}, {2759, 2761}, + {2763, 2765}, {2768, 2768}, {2784, 2787}, + {2790, 2799}, {2809, 2815}, {2817, 2819}, + {2821, 2828}, {2831, 2832}, {2835, 2856}, + {2858, 2864}, {2866, 2867}, {2869, 2873}, + {2876, 2884}, {2887, 2888}, {2891, 2893}, + {2901, 2903}, {2908, 2909}, {2911, 2915}, + {2918, 2927}, {2929, 2929}, {2946, 2947}, + {2949, 2954}, {2958, 2960}, {2962, 2965}, + {2969, 2970}, {2972, 2972}, {2974, 2975}, + {2979, 2980}, {2984, 2986}, {2990, 3001}, + {3006, 3010}, {3014, 3016}, {3018, 3021}, + {3024, 3024}, {3031, 3031}, {3046, 3055}, + {3072, 3084}, {3086, 3088}, {3090, 3112}, + {3114, 3129}, {3132, 3140}, {3142, 3144}, + {3146, 3149}, {3157, 3158}, {3160, 3162}, + {3165, 3165}, {3168, 3171}, {3174, 3183}, + {3200, 3203}, {3205, 3212}, {3214, 3216}, + {3218, 3240}, {3242, 3251}, {3253, 3257}, + {3260, 3268}, {3270, 3272}, {3274, 3277}, + {3285, 3286}, {3293, 3294}, {3296, 3299}, + {3302, 3311}, {3313, 3315}, {3328, 3340}, + {3342, 3344}, {3346, 3396}, {3398, 3400}, + {3402, 3406}, {3412, 3415}, {3423, 3427}, + {3430, 3439}, {3450, 3455}, {3457, 3459}, + {3461, 3478}, {3482, 3505}, {3507, 3515}, + {3517, 3517}, {3520, 3526}, {3530, 3530}, + {3535, 3540}, {3542, 3542}, {3544, 3551}, + {3558, 3567}, {3570, 3571}, {3585, 3642}, + {3648, 3662}, {3664, 3673}, {3713, 3714}, + {3716, 3716}, {3718, 3722}, {3724, 3747}, + {3749, 3749}, {3751, 3773}, {3776, 3780}, + {3782, 3782}, {3784, 3790}, {3792, 3801}, + {3804, 3807}, {3840, 3840}, {3864, 3865}, + {3872, 3881}, {3893, 3893}, {3895, 3895}, + {3897, 3897}, {3902, 3911}, {3913, 3948}, + {3953, 3972}, {3974, 3991}, {3993, 4028}, + {4038, 4038}, {4096, 4169}, {4176, 4253}, + {4256, 4293}, {4295, 4295}, {4301, 4301}, + {4304, 4346}, {4348, 4680}, {4682, 4685}, + {4688, 4694}, {4696, 4696}, {4698, 4701}, + {4704, 4744}, {4746, 4749}, {4752, 4784}, + {4786, 4789}, {4792, 4798}, {4800, 4800}, + {4802, 4805}, {4808, 4822}, {4824, 4880}, + {4882, 4885}, {4888, 4954}, {4957, 4959}, + {4969, 4977}, {4992, 5007}, {5024, 5109}, + {5112, 5117}, {5121, 5740}, {5743, 5759}, + {5761, 5786}, {5792, 5866}, {5870, 5880}, + {5888, 5909}, {5919, 5940}, {5952, 5971}, + {5984, 5996}, {5998, 6000}, {6002, 6003}, + {6016, 6099}, {6103, 6103}, {6108, 6109}, + {6112, 6121}, {6155, 6157}, {6159, 6169}, + {6176, 6264}, {6272, 6314}, {6320, 6389}, + {6400, 6430}, {6432, 6443}, {6448, 6459}, + {6470, 6509}, {6512, 6516}, {6528, 6571}, + {6576, 6601}, {6608, 6618}, {6656, 6683}, + {6688, 6750}, {6752, 6780}, {6783, 6793}, + {6800, 6809}, {6823, 6823}, {6832, 6845}, + {6847, 6862}, {6912, 6988}, {6992, 7001}, + {7019, 7027}, {7040, 7155}, {7168, 7223}, + {7232, 7241}, {7245, 7293}, {7296, 7304}, + {7312, 7354}, {7357, 7359}, {7376, 7378}, + {7380, 7418}, {7424, 7957}, {7960, 7965}, + {7968, 8005}, {8008, 8013}, {8016, 8023}, + {8025, 8025}, {8027, 8027}, {8029, 8029}, + {8031, 8061}, {8064, 8116}, {8118, 8124}, + {8126, 8126}, {8130, 8132}, {8134, 8140}, + {8144, 8147}, {8150, 8155}, {8160, 8172}, + {8178, 8180}, {8182, 8188}, {8204, 8205}, + {8255, 8256}, {8276, 8276}, {8305, 8305}, + {8319, 8319}, {8336, 8348}, {8400, 8412}, + {8417, 8417}, {8421, 8432}, {8450, 8450}, + {8455, 8455}, {8458, 8467}, {8469, 8469}, + {8472, 8477}, {8484, 8484}, {8486, 8486}, + {8488, 8488}, {8490, 8505}, {8508, 8511}, + {8517, 8521}, {8526, 8526}, {8544, 8584}, + {11264, 11492}, {11499, 11507}, {11520, 11557}, + {11559, 11559}, {11565, 11565}, {11568, 11623}, + {11631, 11631}, {11647, 11670}, {11680, 11686}, + {11688, 11694}, {11696, 11702}, {11704, 11710}, + {11712, 11718}, {11720, 11726}, {11728, 11734}, + {11736, 11742}, {11744, 11775}, {12293, 12295}, + {12321, 12335}, {12337, 12341}, {12344, 12348}, + {12353, 12438}, {12441, 12447}, {12449, 12538}, + {12540, 12543}, {12549, 12591}, {12593, 12686}, + {12704, 12735}, {12784, 12799}, {13312, 19903}, + {19968, 42124}, {42192, 42237}, {42240, 42508}, + {42512, 42539}, {42560, 42607}, {42612, 42621}, + {42623, 42737}, {42775, 42783}, {42786, 42888}, + {42891, 42954}, {42960, 42961}, {42963, 42963}, + {42965, 42969}, {42994, 43047}, {43052, 43052}, + {43072, 43123}, {43136, 43205}, {43216, 43225}, + {43232, 43255}, {43259, 43259}, {43261, 43309}, + {43312, 43347}, {43360, 43388}, {43392, 43456}, + {43471, 43481}, {43488, 43518}, {43520, 43574}, + {43584, 43597}, {43600, 43609}, {43616, 43638}, + {43642, 43714}, {43739, 43741}, {43744, 43759}, + {43762, 43766}, {43777, 43782}, {43785, 43790}, + {43793, 43798}, {43808, 43814}, {43816, 43822}, + {43824, 43866}, {43868, 43881}, {43888, 44010}, + {44012, 44013}, {44016, 44025}, {44032, 55203}, + {55216, 55238}, {55243, 55291}, {63744, 64109}, + {64112, 64217}, {64256, 64262}, {64275, 64279}, + {64285, 64296}, {64298, 64310}, {64312, 64316}, + {64318, 64318}, {64320, 64321}, {64323, 64324}, + {64326, 64433}, {64467, 64829}, {64848, 64911}, + {64914, 64967}, {65008, 65019}, {65024, 65039}, + {65056, 65071}, {65075, 65076}, {65101, 65103}, + {65136, 65140}, {65142, 65276}, {65296, 65305}, + {65313, 65338}, {65343, 65343}, {65345, 65370}, + {65382, 65470}, {65474, 65479}, {65482, 65487}, + {65490, 65495}, {65498, 65500}, {65572, 65572}, + {65584, 65593}, {65601, 65626}, {65631, 65631}, + {65633, 65658}, {65706, 65706}, {65717, 65717}, + {65719, 65719}, {65722, 65722}, {65728, 65750}, + {65752, 65782}, {65784, 66241}, {66246, 66257}, + {66272, 66276}, {66284, 66284}, {66286, 66286}, + {66304, 66420}, {66422, 66423}, {66426, 66429}, + {66431, 66431}, {66438, 66442}, {66444, 66444}, + {66446, 66465}, {66467, 66549}, {66551, 66689}, + {66691, 66695}, {66698, 66863}, {66865, 66902}, + {66905, 66905}, {66912, 66952}, {66961, 67005}, + {67007, 67007}, {67009, 67010}, {67012, 67013}, + {67015, 67015}, {67024, 67050}, {67055, 67058}, + {67088, 67098}, {67104, 67177}, {67182, 67283}, + {67285, 67292}, {67295, 67304}, {67306, 67324}, + {67327, 67327}, {67344, 67402}, {67405, 67505}, + {67520, 67573}, {67578, 67578}, {67581, 67581}, + {67584, 67629}, {67648, 67675}, {67680, 67690}, + {67696, 67719}, {67721, 67726}, {67736, 67809}, + {67811, 67939}, {67942, 67951}, {67953, 67971}, + {67973, 67980}, {67983, 67984}, {67987, 68008}, + {68010, 68016}, {68018, 68018}, {68022, 68025}, + {68028, 68036}, {68039, 68040}, {68043, 68046}, + {68055, 68055}, {68060, 68061}, {68063, 68067}, + {68070, 68081}, {68092, 68092}, {68094, 68094}, + {68097, 68099}, {68101, 68106}, {68111, 68112}, + {68115, 68136}, {68138, 68144}, {68146, 68147}, + {68149, 68150}, {68152, 68153}, {68156, 68156}, + {68158, 68162}, {68167, 68168}, {68171, 68173}, + {68177, 68177}, {68185, 68188}, {68190, 68190}, + {68198, 68213}, {68225, 68227}, {68229, 68237}, + {68239, 68241}, {68243, 68264}, {68266, 68272}, + {68274, 68275}, {68277, 68281}, {68284, 68293}, + {68295, 68297}, {68299, 68301}, {68304, 68304}, + {68320, 68323}, {68326, 68335}, {68345, 68351}, + {68353, 68355}, {68357, 68364}, {68367, 68368}, + {68371, 68392}, {68394, 68400}, {68402, 68403}, + {68405, 68409}, {68412, 68420}, {68423, 68424}, + {68427, 68429}, {68437, 68439}, {68444, 68445}, + {68447, 68451}, {68454, 68463}, {68465, 68465}, + {68482, 68483}, {68485, 68490}, {68494, 68496}, + {68498, 68501}, {68505, 68506}, {68508, 68508}, + {68510, 68511}, {68515, 68516}, {68520, 68522}, + {68526, 68537}, {68542, 68546}, {68550, 68552}, + {68554, 68557}, {68560, 68560}, {68567, 68567}, + {68582, 68591}, {68608, 68620}, {68622, 68624}, + {68626, 68648}, {68650, 68665}, {68668, 68676}, + {68678, 68680}, {68682, 68685}, {68693, 68694}, + {68696, 68698}, {68701, 68701}, {68704, 68707}, + {68710, 68719}, {68736, 68739}, {68741, 68748}, + {68750, 68752}, {68754, 68776}, {68778, 68787}, + {68789, 68793}, {68796, 68804}, {68806, 68808}, + {68810, 68813}, {68821, 68822}, {68829, 68830}, + {68832, 68835}, {68838, 68847}, {68849, 68851}, + {68864, 68876}, {68878, 68880}, {68882, 68932}, + {68934, 68936}, {68938, 68942}, {68948, 68951}, + {68959, 68963}, {68966, 68975}, {68986, 68991}, + {68993, 68995}, {68997, 69014}, {69018, 69041}, + {69043, 69051}, {69053, 69053}, {69056, 69062}, + {69066, 69066}, {69071, 69076}, {69078, 69078}, + {69080, 69087}, {69094, 69103}, {69106, 69107}, + {69121, 69178}, {69184, 69198}, {69200, 69209}, + {69249, 69250}, {69252, 69252}, {69254, 69258}, + {69260, 69283}, {69285, 69285}, {69287, 69309}, + {69312, 69316}, {69318, 69318}, {69320, 69326}, + {69328, 69337}, {69340, 69343}, {69376, 69376}, + {69400, 69401}, {69408, 69417}, {69429, 69429}, + {69431, 69431}, {69433, 69433}, {69438, 69447}, + {69449, 69484}, {69489, 69508}, {69510, 69527}, + {69529, 69564}, {69574, 69574}, {69632, 69705}, + {69712, 69789}, {69792, 69829}, {69831, 69831}, + {69837, 69837}, {69840, 69882}, {69884, 70216}, + {70218, 70221}, {70224, 70230}, {70232, 70232}, + {70234, 70237}, {70240, 70280}, {70282, 70285}, + {70288, 70320}, {70322, 70325}, {70328, 70334}, + {70336, 70336}, {70338, 70341}, {70344, 70358}, + {70360, 70416}, {70418, 70421}, {70424, 70490}, + {70493, 70495}, {70505, 70513}, {70528, 70543}, + {70560, 70645}, {70648, 70653}, {70657, 71276}, + {71279, 71295}, {71297, 71322}, {71328, 71402}, + {71406, 71416}, {71424, 71445}, {71455, 71476}, + {71488, 71507}, {71520, 71532}, {71534, 71536}, + {71538, 71539}, {71552, 71635}, {71639, 71639}, + {71644, 71645}, {71648, 71657}, {71691, 71693}, + {71695, 71705}, {71712, 71800}, {71808, 71850}, + {71856, 71925}, {71936, 71966}, {71968, 71979}, + {71984, 71995}, {72006, 72045}, {72048, 72052}, + {72064, 72107}, {72112, 72137}, {72144, 72154}, + {72192, 72219}, {72224, 72286}, {72288, 72316}, + {72319, 72329}, {72336, 72345}, {72359, 72359}, + {72368, 72381}, {72383, 72398}, {72448, 72524}, + {72528, 72537}, {72555, 72563}, {72576, 72691}, + {72704, 72759}, {72768, 72777}, {72781, 72829}, + {72832, 72840}, {72848, 72890}, {72893, 72895}, + {72912, 72914}, {72916, 72954}, {72960, 73493}, + {73496, 73501}, {73504, 73541}, {73544, 73549}, + {73552, 73559}, {73561, 73561}, {73563, 73563}, + {73565, 73565}, {73567, 73597}, {73600, 73652}, + {73654, 73660}, {73662, 73662}, {73666, 73668}, + {73670, 73676}, {73680, 73683}, {73686, 73691}, + {73696, 73708}, {73714, 73716}, {73718, 73724}, + {73740, 73741}, {73791, 73792}, {73812, 73812}, + {73841, 73841}, {73855, 73855}, {73872, 73884}, + {73936, 73948}, {73953, 73953}, {73957, 73968}, + {73986, 73986}, {73991, 73991}, {73994, 74003}, + {74005, 74005}, {74008, 74013}, {74020, 74020}, + {74022, 74022}, {74024, 74024}, {74026, 74041}, + {74044, 74047}, {74053, 74057}, {74062, 74062}, + {74080, 74120}, {76800, 77028}, {77035, 77043}, + {77056, 77093}, {77095, 77095}, {77101, 77101}, + {77104, 77159}, {77167, 77167}, {77183, 77206}, + {77216, 77222}, {77224, 77230}, {77232, 77238}, + {77240, 77246}, {77248, 77254}, {77256, 77262}, + {77264, 77270}, {77272, 77278}, {77280, 77311}, + {77829, 77831}, {77857, 77871}, {77873, 77877}, + {77880, 77884}, {77889, 77974}, {77977, 77983}, + {77985, 78074}, {78076, 78079}, {78085, 78127}, + {78129, 78222}, {78240, 78271}, {78320, 78335}, + {78848, 85439}, {85504, 107660}, {107728, 107773}, + {107776, 108044}, {108048, 108075}, {108096, 108143}, + {108148, 108157}, {108159, 108273}, {108311, 108319}, + {108322, 108424}, {108427, 108490}, {108496, 108497}, + {108499, 108499}, {108501, 108505}, {108530, 108583}, + {108588, 108588}, {108608, 108659}, {108672, 108741}, + {108752, 108761}, {108768, 108791}, {108795, 108795}, + {108797, 108845}, {108848, 108883}, {108896, 108924}, + {108928, 108992}, {109007, 109017}, {109024, 109054}, + {109056, 109110}, {109120, 109133}, {109136, 109145}, + {109152, 109174}, {109178, 109250}, {109275, 109277}, + {109280, 109295}, {109298, 109302}, {109313, 109318}, + {109321, 109326}, {109329, 109334}, {109344, 109350}, + {109352, 109358}, {109360, 109402}, {109404, 109417}, + {109424, 109546}, {109548, 109549}, {109552, 109561}, + {109568, 120739}, {120752, 120774}, {120779, 120827}, + {129280, 129645}, {129648, 129753}, {129792, 129798}, + {129811, 129815}, {129821, 129832}, {129834, 129846}, + {129848, 129852}, {129854, 129854}, {129856, 129857}, + {129859, 129860}, {129862, 129969}, {130003, 130365}, + {130384, 130447}, {130450, 130503}, {130544, 130555}, + {130560, 130575}, {130592, 130607}, {130611, 130612}, + {130637, 130639}, {130672, 130676}, {130678, 130812}, + {130832, 130841}, {130849, 130874}, {130879, 130879}, + {130881, 130906}, {130918, 131006}, {131010, 131015}, + {131018, 131023}, {131026, 131031}, {131034, 131036}, + {131108, 131108}, {131120, 131129}, {131137, 131162}, + {131167, 131167}, {131169, 131194}, {131242, 131242}, + {131253, 131253}, {131255, 131255}, {131258, 131258}, + {131264, 131286}, {131288, 131318}, {131320, 131777}, + {131782, 131793}, {131808, 131812}, {131820, 131820}, + {131822, 131822}, {131840, 131956}, {131958, 131959}, + {131962, 131965}, {131967, 131967}, {131974, 131978}, + {131980, 131980}, {131982, 132001}, {132003, 132085}, + {132087, 132225}, {132227, 132231}, {132234, 132399}, + {132401, 132438}, {132441, 132441}, {132448, 132488}, + {132497, 132541}, {132543, 132543}, {132545, 132546}, + {132548, 132549}, {132551, 132551}, {132560, 132586}, + {132591, 132594}, {132624, 132634}, {132640, 132713}, + {132718, 132819}, {132821, 132828}, {132831, 132840}, + {132842, 132860}, {132863, 132863}, {132880, 132938}, + {132941, 133041}, {133056, 133109}, {133114, 133114}, + {133117, 133117}, {133120, 133165}, {133184, 133211}, + {133216, 133226}, {133232, 133255}, {133257, 133262}, + {133272, 133345}, {133347, 133475}, {133478, 133487}, + {133489, 133507}, {133509, 133516}, {133519, 133520}, + {133523, 133544}, {133546, 133552}, {133554, 133554}, + {133558, 133561}, {133564, 133572}, {133575, 133576}, + {133579, 133582}, {133591, 133591}, {133596, 133597}, + {133599, 133603}, {133606, 133617}, {133628, 133628}, + {133630, 133630}, {133633, 133635}, {133637, 133642}, + {133647, 133648}, {133651, 133672}, {133674, 133680}, + {133682, 133683}, {133685, 133686}, {133688, 133689}, + {133692, 133692}, {133694, 133698}, {133703, 133704}, + {133707, 133709}, {133713, 133713}, {133721, 133724}, + {133726, 133726}, {133734, 133749}, {133761, 133763}, + {133765, 133773}, {133775, 133777}, {133779, 133800}, + {133802, 133808}, {133810, 133811}, {133813, 133817}, + {133820, 133829}, {133831, 133833}, {133835, 133837}, + {133840, 133840}, {133856, 133859}, {133862, 133871}, + {133881, 133887}, {133889, 133891}, {133893, 133900}, + {133903, 133904}, {133907, 133928}, {133930, 133936}, + {133938, 133939}, {133941, 133945}, {133948, 133956}, + {133959, 133960}, {133963, 133965}, {133973, 133975}, + {133980, 133981}, {133983, 133987}, {133990, 133999}, + {134001, 134001}, {134018, 134019}, {134021, 134026}, + {134030, 134032}, {134034, 134037}, {134041, 134042}, + {134044, 134044}, {134046, 134047}, {134051, 134052}, + {134056, 134058}, {134062, 134073}, {134078, 134082}, + {134086, 134088}, {134090, 134093}, {134096, 134096}, + {134103, 134103}, {134118, 134127}, {134144, 134156}, + {134158, 134160}, {134162, 134184}, {134186, 134201}, + {134204, 134212}, {134214, 134216}, {134218, 134221}, + {134229, 134230}, {134232, 134234}, {134237, 134237}, + {134240, 134243}, {134246, 134255}, {134272, 134275}, + {134277, 134284}, {134286, 134288}, {134290, 134312}, + {134314, 134323}, {134325, 134329}, {134332, 134340}, + {134342, 134344}, {134346, 134349}, {134357, 134358}, + {134365, 134366}, {134368, 134371}, {134374, 134383}, + {134385, 134387}, {134400, 134412}, {134414, 134416}, + {134418, 134468}, {134470, 134472}, {134474, 134478}, + {134484, 134487}, {134495, 134499}, {134502, 134511}, + {134522, 134527}, {134529, 134531}, {134533, 134550}, + {134554, 134577}, {134579, 134587}, {134589, 134589}, + {134592, 134598}, {134602, 134602}, {134607, 134612}, + {134614, 134614}, {134616, 134623}, {134630, 134639}, + {134642, 134643}, {134657, 134714}, {134720, 134734}, + {134736, 134745}, {134785, 134786}, {134788, 134788}, + {134790, 134794}, {134796, 134819}, {134821, 134821}, + {134823, 134845}, {134848, 134852}, {134854, 134854}, + {134856, 134862}, {134864, 134873}, {134876, 134879}, + {134912, 134912}, {134936, 134937}, {134944, 134953}, + {134965, 134965}, {134967, 134967}, {134969, 134969}, + {134974, 134983}, {134985, 135020}, {135025, 135044}, + {135046, 135063}, {135065, 135100}, {135110, 135110}, + {135168, 135241}, {135248, 135325}, {135328, 135365}, + {135367, 135367}, {135373, 135373}, {135376, 135418}, + {135420, 135752}, {135754, 135757}, {135760, 135766}, + {135768, 135768}, {135770, 135773}, {135776, 135816}, + {135818, 135821}, {135824, 135856}, {135858, 135861}, + {135864, 135870}, {135872, 135872}, {135874, 135877}, + {135880, 135894}, {135896, 135952}, {135954, 135957}, + {135960, 136026}, {136029, 136031}, {136041, 136049}, + {136064, 136079}, {136096, 136181}, {136184, 136189}, + {136193, 136812}, {136815, 136831}, {136833, 136858}, + {136864, 136938}, {136942, 136952}, {136960, 136981}, + {136991, 137012}, {137024, 137043}, {137056, 137068}, + {137070, 137072}, {137074, 137075}, {137088, 137171}, + {137175, 137175}, {137180, 137181}, {137184, 137193}, + {137227, 137229}, {137231, 137241}, {137248, 137336}, + {137344, 137386}, {137392, 137461}, {137472, 137502}, + {137504, 137515}, {137520, 137531}, {137542, 137581}, + {137584, 137588}, {137600, 137643}, {137648, 137673}, + {137680, 137690}, {137728, 137755}, {137760, 137822}, + {137824, 137852}, {137855, 137865}, {137872, 137881}, + {137895, 137895}, {137904, 137917}, {137919, 137934}, + {137984, 138060}, {138064, 138073}, {138091, 138099}, + {138112, 138227}, {138240, 138295}, {138304, 138313}, + {138317, 138365}, {138368, 138376}, {138384, 138426}, + {138429, 138431}, {138448, 138450}, {138452, 138490}, + {138496, 139029}, {139032, 139037}, {139040, 139077}, + {139080, 139085}, {139088, 139095}, {139097, 139097}, + {139099, 139099}, {139101, 139101}, {139103, 139133}, + {139136, 139188}, {139190, 139196}, {139198, 139198}, + {139202, 139204}, {139206, 139212}, {139216, 139219}, + {139222, 139227}, {139232, 139244}, {139250, 139252}, + {139254, 139260}, {139276, 139277}, {139327, 139328}, + {139348, 139348}, {139377, 139377}, {139391, 139391}, + {139408, 139420}, {139472, 139484}, {139489, 139489}, + {139493, 139504}, {139522, 139522}, {139527, 139527}, + {139530, 139539}, {139541, 139541}, {139544, 139549}, + {139556, 139556}, {139558, 139558}, {139560, 139560}, + {139562, 139577}, {139580, 139583}, {139589, 139593}, + {139598, 139598}, {139616, 139656}, {142336, 142564}, + {142571, 142579}, {142592, 142629}, {142631, 142631}, + {142637, 142637}, {142640, 142695}, {142703, 142703}, + {142719, 142742}, {142752, 142758}, {142760, 142766}, + {142768, 142774}, {142776, 142782}, {142784, 142790}, + {142792, 142798}, {142800, 142806}, {142808, 142814}, + {142816, 142847}, {143365, 143367}, {143393, 143407}, + {143409, 143413}, {143416, 143420}, {143425, 143510}, + {143513, 143519}, {143521, 143610}, {143612, 143615}, + {143621, 143663}, {143665, 143758}, {143776, 143807}, + {143856, 143871}, {144384, 150975}, {151040, 173196}, + {173264, 173309}, {173312, 173580}, {173584, 173611}, + {173632, 173679}, {173684, 173693}, {173695, 173809}, + {173847, 173855}, {173858, 173960}, {173963, 174026}, + {174032, 174033}, {174035, 174035}, {174037, 174041}, + {174066, 174119}, {174124, 174124}, {174144, 174195}, + {174208, 174277}, {174288, 174297}, {174304, 174327}, + {174331, 174331}, {174333, 174381}, {174384, 174419}, + {174432, 174460}, {174464, 174528}, {174543, 174553}, + {174560, 174590}, {174592, 174646}, {174656, 174669}, + {174672, 174681}, {174688, 174710}, {174714, 174786}, + {174811, 174813}, {174816, 174831}, {174834, 174838}, + {174849, 174854}, {174857, 174862}, {174865, 174870}, + {174880, 174886}, {174888, 174894}, {174896, 174938}, + {174940, 174953}, {174960, 175082}, {175084, 175085}, + {175088, 175097}, {175104, 186275}, {186288, 186310}, + {186315, 186363}, {194816, 195181}, {195184, 195289}, + {195328, 195334}, {195347, 195351}, {195357, 195368}, + {195370, 195382}, {195384, 195388}, {195390, 195390}, + {195392, 195393}, {195395, 195396}, {195398, 195505}, + {195539, 195901}, {195920, 195983}, {195986, 196039}, + {196080, 196091}, {196096, 196111}, {196128, 196143}, + {196147, 196148}, {196173, 196175}, {196208, 196212}, + {196214, 196348}, {196368, 196377}, {196385, 196410}, + {196415, 196415}, {196417, 196442}, {196454, 196542}, + {196546, 196551}, {196554, 196559}, {196562, 196567}, + {196570, 196572}, {196644, 196644}, {196656, 196665}, + {196673, 196698}, {196703, 196703}, {196705, 196730}, + {196778, 196778}, {196789, 196789}, {196791, 196791}, + {196794, 196794}, {196800, 196822}, {196824, 196854}, + {196856, 197313}, {197318, 197329}, {197344, 197348}, + {197356, 197356}, {197358, 197358}, {197376, 197492}, + {197494, 197495}, {197498, 197501}, {197503, 197503}, + {197510, 197514}, {197516, 197516}, {197518, 197537}, + {197539, 197621}, {197623, 197761}, {197763, 197767}, + {197770, 197935}, {197937, 197974}, {197977, 197977}, + {197984, 198024}, {198033, 198077}, {198079, 198079}, + {198081, 198082}, {198084, 198085}, {198087, 198087}, + {198096, 198122}, {198127, 198130}, {198160, 198170}, + {198176, 198249}, {198254, 198355}, {198357, 198364}, + {198367, 198376}, {198378, 198396}, {198399, 198399}, + {198416, 198474}, {198477, 198577}, {198592, 198645}, + {198650, 198650}, {198653, 198653}, {198656, 198701}, + {198720, 198747}, {198752, 198762}, {198768, 198791}, + {198793, 198798}, {198808, 198881}, {198883, 199011}, + {199014, 199023}, {199025, 199043}, {199045, 199052}, + {199055, 199056}, {199059, 199080}, {199082, 199088}, + {199090, 199090}, {199094, 199097}, {199100, 199108}, + {199111, 199112}, {199115, 199118}, {199127, 199127}, + {199132, 199133}, {199135, 199139}, {199142, 199153}, + {199164, 199164}, {199166, 199166}, {199169, 199171}, + {199173, 199178}, {199183, 199184}, {199187, 199208}, + {199210, 199216}, {199218, 199219}, {199221, 199222}, + {199224, 199225}, {199228, 199228}, {199230, 199234}, + {199239, 199240}, {199243, 199245}, {199249, 199249}, + {199257, 199260}, {199262, 199262}, {199270, 199285}, + {199297, 199299}, {199301, 199309}, {199311, 199313}, + {199315, 199336}, {199338, 199344}, {199346, 199347}, + {199349, 199353}, {199356, 199365}, {199367, 199369}, + {199371, 199373}, {199376, 199376}, {199392, 199395}, + {199398, 199407}, {199417, 199423}, {199425, 199427}, + {199429, 199436}, {199439, 199440}, {199443, 199464}, + {199466, 199472}, {199474, 199475}, {199477, 199481}, + {199484, 199492}, {199495, 199496}, {199499, 199501}, + {199509, 199511}, {199516, 199517}, {199519, 199523}, + {199526, 199535}, {199537, 199537}, {199554, 199555}, + {199557, 199562}, {199566, 199568}, {199570, 199573}, + {199577, 199578}, {199580, 199580}, {199582, 199583}, + {199587, 199588}, {199592, 199594}, {199598, 199609}, + {199614, 199618}, {199622, 199624}, {199626, 199629}, + {199632, 199632}, {199639, 199639}, {199654, 199663}, + {199680, 199692}, {199694, 199696}, {199698, 199720}, + {199722, 199737}, {199740, 199748}, {199750, 199752}, + {199754, 199757}, {199765, 199766}, {199768, 199770}, + {199773, 199773}, {199776, 199779}, {199782, 199791}, + {199808, 199811}, {199813, 199820}, {199822, 199824}, + {199826, 199848}, {199850, 199859}, {199861, 199865}, + {199868, 199876}, {199878, 199880}, {199882, 199885}, + {199893, 199894}, {199901, 199902}, {199904, 199907}, + {199910, 199919}, {199921, 199923}, {199936, 199948}, + {199950, 199952}, {199954, 200004}, {200006, 200008}, + {200010, 200014}, {200020, 200023}, {200031, 200035}, + {200038, 200047}, {200058, 200063}, {200065, 200067}, + {200069, 200086}, {200090, 200113}, {200115, 200123}, + {200125, 200125}, {200128, 200134}, {200138, 200138}, + {200143, 200148}, {200150, 200150}, {200152, 200159}, + {200166, 200175}, {200178, 200179}, {200193, 200250}, + {200256, 200270}, {200272, 200281}, {200321, 200322}, + {200324, 200324}, {200326, 200330}, {200332, 200355}, + {200357, 200357}, {200359, 200381}, {200384, 200388}, + {200390, 200390}, {200392, 200398}, {200400, 200409}, + {200412, 200415}, {200448, 200448}, {200472, 200473}, + {200480, 200489}, {200501, 200501}, {200503, 200503}, + {200505, 200505}, {200510, 200519}, {200521, 200556}, + {200561, 200580}, {200582, 200599}, {200601, 200636}, + {200646, 200646}, {200704, 200777}, {200784, 200861}, + {200864, 200901}, {200903, 200903}, {200909, 200909}, + {200912, 200954}, {200956, 201288}, {201290, 201293}, + {201296, 201302}, {201304, 201304}, {201306, 201309}, + {201312, 201352}, {201354, 201357}, {201360, 201392}, + {201394, 201397}, {201400, 201406}, {201408, 201408}, + {201410, 201413}, {201416, 201430}, {201432, 201488}, + {201490, 201493}, {201496, 201562}, {201565, 201567}, + {201577, 201585}, {201600, 201615}, {201632, 201717}, + {201720, 201725}, {201729, 202348}, {202351, 202367}, + {202369, 202394}, {202400, 202474}, {202478, 202488}, + {202496, 202517}, {202527, 202548}, {202560, 202579}, + {202592, 202604}, {202606, 202608}, {202610, 202611}, + {202624, 202707}, {202711, 202711}, {202716, 202717}, + {202720, 202729}, {202763, 202765}, {202767, 202777}, + {202784, 202872}, {202880, 202922}, {202928, 202997}, + {203008, 203038}, {203040, 203051}, {203056, 203067}, + {203078, 203117}, {203120, 203124}, {203136, 203179}, + {203184, 203209}, {203216, 203226}, {203264, 203291}, + {203296, 203358}, {203360, 203388}, {203391, 203401}, + {203408, 203417}, {203431, 203431}, {203440, 203453}, + {203455, 203470}, {203520, 203596}, {203600, 203609}, + {203627, 203635}, {203648, 203763}, {203776, 203831}, + {203840, 203849}, {203853, 203901}, {203904, 203912}, + {203920, 203962}, {203965, 203967}, {203984, 203986}, + {203988, 204026}, {204032, 204565}, {204568, 204573}, + {204576, 204613}, {204616, 204621}, {204624, 204631}, + {204633, 204633}, {204635, 204635}, {204637, 204637}, + {204639, 204669}, {204672, 204724}, {204726, 204732}, + {204734, 204734}, {204738, 204740}, {204742, 204748}, + {204752, 204755}, {204758, 204763}, {204768, 204780}, + {204786, 204788}, {204790, 204796}, {204812, 204813}, + {204863, 204864}, {204884, 204884}, {204913, 204913}, + {204927, 204927}, {204944, 204956}, {205008, 205020}, + {205025, 205025}, {205029, 205040}, {205058, 205058}, + {205063, 205063}, {205066, 205075}, {205077, 205077}, + {205080, 205085}, {205092, 205092}, {205094, 205094}, + {205096, 205096}, {205098, 205113}, {205116, 205119}, + {205125, 205129}, {205134, 205134}, {205152, 205192}, + {207872, 208100}, {208107, 208115}, {208128, 208165}, + {208167, 208167}, {208173, 208173}, {208176, 208231}, + {208239, 208239}, {208255, 208278}, {208288, 208294}, + {208296, 208302}, {208304, 208310}, {208312, 208318}, + {208320, 208326}, {208328, 208334}, {208336, 208342}, + {208344, 208350}, {208352, 208383}, {208901, 208903}, + {208929, 208943}, {208945, 208949}, {208952, 208956}, + {208961, 209046}, {209049, 209055}, {209057, 209146}, + {209148, 209151}, {209157, 209199}, {209201, 209294}, + {209312, 209343}, {209392, 209407}, {209920, 216511}, + {216576, 238732}, {238800, 238845}, {238848, 239116}, + {239120, 239147}, {239168, 239215}, {239220, 239229}, + {239231, 239345}, {239383, 239391}, {239394, 239496}, + {239499, 239562}, {239568, 239569}, {239571, 239571}, + {239573, 239577}, {239602, 239655}, {239660, 239660}, + {239680, 239731}, {239744, 239813}, {239824, 239833}, + {239840, 239863}, {239867, 239867}, {239869, 239917}, + {239920, 239955}, {239968, 239996}, {240000, 240064}, + {240079, 240089}, {240096, 240126}, {240128, 240182}, + {240192, 240205}, {240208, 240217}, {240224, 240246}, + {240250, 240322}, {240347, 240349}, {240352, 240367}, + {240370, 240374}, {240385, 240390}, {240393, 240398}, + {240401, 240406}, {240416, 240422}, {240424, 240430}, + {240432, 240474}, {240476, 240489}, {240496, 240618}, + {240620, 240621}, {240624, 240633}, {240640, 251811}, + {251824, 251846}, {251851, 251899}, {260352, 260717}, + {260720, 260825}, {260864, 260870}, {260883, 260887}, + {260893, 260904}, {260906, 260918}, {260920, 260924}, + {260926, 260926}, {260928, 260929}, {260931, 260932}, + {260934, 261041}, {261075, 261437}, {261456, 261519}, + {261522, 261575}, {261616, 261627}, {261632, 261647}, + {261664, 261679}, {261683, 261684}, {261709, 261711}, + {261744, 261748}, {261750, 261884}, {261904, 261913}, + {261921, 261946}, {261951, 261951}, {261953, 261978}, + {261990, 262078}, {262082, 262087}, {262090, 262095}, + {262098, 262103}, {262106, 262108}, {262180, 262180}, + {262192, 262201}, {262209, 262234}, {262239, 262239}, + {262241, 262266}, {262314, 262314}, {262325, 262325}, + {262327, 262327}, {262330, 262330}, {262336, 262358}, + {262360, 262390}, {262392, 262849}, {262854, 262865}, + {262880, 262884}, {262892, 262892}, {262894, 262894}, + {262912, 263028}, {263030, 263031}, {263034, 263037}, + {263039, 263039}, {263046, 263050}, {263052, 263052}, + {263054, 263073}, {263075, 263157}, {263159, 263297}, + {263299, 263303}, {263306, 263471}, {263473, 263510}, + {263513, 263513}, {263520, 263560}, {263569, 263613}, + {263615, 263615}, {263617, 263618}, {263620, 263621}, + {263623, 263623}, {263632, 263658}, {263663, 263666}, + {263696, 263706}, {263712, 263785}, {263790, 263891}, + {263893, 263900}, {263903, 263912}, {263914, 263932}, + {263935, 263935}, {263952, 264010}, {264013, 264113}, + {264128, 264181}, {264186, 264186}, {264189, 264189}, + {264192, 264237}, {264256, 264283}, {264288, 264298}, + {264304, 264327}, {264329, 264334}, {264344, 264417}, + {264419, 264547}, {264550, 264559}, {264561, 264579}, + {264581, 264588}, {264591, 264592}, {264595, 264616}, + {264618, 264624}, {264626, 264626}, {264630, 264633}, + {264636, 264644}, {264647, 264648}, {264651, 264654}, + {264663, 264663}, {264668, 264669}, {264671, 264675}, + {264678, 264689}, {264700, 264700}, {264702, 264702}, + {264705, 264707}, {264709, 264714}, {264719, 264720}, + {264723, 264744}, {264746, 264752}, {264754, 264755}, + {264757, 264758}, {264760, 264761}, {264764, 264764}, + {264766, 264770}, {264775, 264776}, {264779, 264781}, + {264785, 264785}, {264793, 264796}, {264798, 264798}, + {264806, 264821}, {264833, 264835}, {264837, 264845}, + {264847, 264849}, {264851, 264872}, {264874, 264880}, + {264882, 264883}, {264885, 264889}, {264892, 264901}, + {264903, 264905}, {264907, 264909}, {264912, 264912}, + {264928, 264931}, {264934, 264943}, {264953, 264959}, + {264961, 264963}, {264965, 264972}, {264975, 264976}, + {264979, 265000}, {265002, 265008}, {265010, 265011}, + {265013, 265017}, {265020, 265028}, {265031, 265032}, + {265035, 265037}, {265045, 265047}, {265052, 265053}, + {265055, 265059}, {265062, 265071}, {265073, 265073}, + {265090, 265091}, {265093, 265098}, {265102, 265104}, + {265106, 265109}, {265113, 265114}, {265116, 265116}, + {265118, 265119}, {265123, 265124}, {265128, 265130}, + {265134, 265145}, {265150, 265154}, {265158, 265160}, + {265162, 265165}, {265168, 265168}, {265175, 265175}, + {265190, 265199}, {265216, 265228}, {265230, 265232}, + {265234, 265256}, {265258, 265273}, {265276, 265284}, + {265286, 265288}, {265290, 265293}, {265301, 265302}, + {265304, 265306}, {265309, 265309}, {265312, 265315}, + {265318, 265327}, {265344, 265347}, {265349, 265356}, + {265358, 265360}, {265362, 265384}, {265386, 265395}, + {265397, 265401}, {265404, 265412}, {265414, 265416}, + {265418, 265421}, {265429, 265430}, {265437, 265438}, + {265440, 265443}, {265446, 265455}, {265457, 265459}, + {265472, 265484}, {265486, 265488}, {265490, 265540}, + {265542, 265544}, {265546, 265550}, {265556, 265559}, + {265567, 265571}, {265574, 265583}, {265594, 265599}, + {265601, 265603}, {265605, 265622}, {265626, 265649}, + {265651, 265659}, {265661, 265661}, {265664, 265670}, + {265674, 265674}, {265679, 265684}, {265686, 265686}, + {265688, 265695}, {265702, 265711}, {265714, 265715}, + {265729, 265786}, {265792, 265806}, {265808, 265817}, + {265857, 265858}, {265860, 265860}, {265862, 265866}, + {265868, 265891}, {265893, 265893}, {265895, 265917}, + {265920, 265924}, {265926, 265926}, {265928, 265934}, + {265936, 265945}, {265948, 265951}, {265984, 265984}, + {266008, 266009}, {266016, 266025}, {266037, 266037}, + {266039, 266039}, {266041, 266041}, {266046, 266055}, + {266057, 266092}, {266097, 266116}, {266118, 266135}, + {266137, 266172}, {266182, 266182}, {266240, 266313}, + {266320, 266397}, {266400, 266437}, {266439, 266439}, + {266445, 266445}, {266448, 266490}, {266492, 266824}, + {266826, 266829}, {266832, 266838}, {266840, 266840}, + {266842, 266845}, {266848, 266888}, {266890, 266893}, + {266896, 266928}, {266930, 266933}, {266936, 266942}, + {266944, 266944}, {266946, 266949}, {266952, 266966}, + {266968, 267024}, {267026, 267029}, {267032, 267098}, + {267101, 267103}, {267113, 267121}, {267136, 267151}, + {267168, 267253}, {267256, 267261}, {267265, 267884}, + {267887, 267903}, {267905, 267930}, {267936, 268010}, + {268014, 268024}, {268032, 268053}, {268063, 268084}, + {268096, 268115}, {268128, 268140}, {268142, 268144}, + {268146, 268147}, {268160, 268243}, {268247, 268247}, + {268252, 268253}, {268256, 268265}, {268299, 268301}, + {268303, 268313}, {268320, 268408}, {268416, 268458}, + {268464, 268533}, {268544, 268574}, {268576, 268587}, + {268592, 268603}, {268614, 268653}, {268656, 268660}, + {268672, 268715}, {268720, 268745}, {268752, 268762}, + {268800, 268827}, {268832, 268894}, {268896, 268924}, + {268927, 268937}, {268944, 268953}, {268967, 268967}, + {268976, 268989}, {268991, 269006}, {269056, 269132}, + {269136, 269145}, {269163, 269171}, {269184, 269299}, + {269312, 269367}, {269376, 269385}, {269389, 269437}, + {269440, 269448}, {269456, 269498}, {269501, 269503}, + {269520, 269522}, {269524, 269562}, {269568, 270101}, + {270104, 270109}, {270112, 270149}, {270152, 270157}, + {270160, 270167}, {270169, 270169}, {270171, 270171}, + {270173, 270173}, {270175, 270205}, {270208, 270260}, + {270262, 270268}, {270270, 270270}, {270274, 270276}, + {270278, 270284}, {270288, 270291}, {270294, 270299}, + {270304, 270316}, {270322, 270324}, {270326, 270332}, + {270348, 270349}, {270399, 270400}, {270420, 270420}, + {270449, 270449}, {270463, 270463}, {270480, 270492}, + {270544, 270556}, {270561, 270561}, {270565, 270576}, + {270594, 270594}, {270599, 270599}, {270602, 270611}, + {270613, 270613}, {270616, 270621}, {270628, 270628}, + {270630, 270630}, {270632, 270632}, {270634, 270649}, + {270652, 270655}, {270661, 270665}, {270670, 270670}, + {270688, 270728}, {273408, 273636}, {273643, 273651}, + {273664, 273701}, {273703, 273703}, {273709, 273709}, + {273712, 273767}, {273775, 273775}, {273791, 273814}, + {273824, 273830}, {273832, 273838}, {273840, 273846}, + {273848, 273854}, {273856, 273862}, {273864, 273870}, + {273872, 273878}, {273880, 273886}, {273888, 273919}, + {274437, 274439}, {274465, 274479}, {274481, 274485}, + {274488, 274492}, {274497, 274582}, {274585, 274591}, + {274593, 274682}, {274684, 274687}, {274693, 274735}, + {274737, 274830}, {274848, 274879}, {274928, 274943}, + {275456, 282047}, {282112, 304268}, {304336, 304381}, + {304384, 304652}, {304656, 304683}, {304704, 304751}, + {304756, 304765}, {304767, 304881}, {304919, 304927}, + {304930, 305032}, {305035, 305098}, {305104, 305105}, + {305107, 305107}, {305109, 305113}, {305138, 305191}, + {305196, 305196}, {305216, 305267}, {305280, 305349}, + {305360, 305369}, {305376, 305399}, {305403, 305403}, + {305405, 305453}, {305456, 305491}, {305504, 305532}, + {305536, 305600}, {305615, 305625}, {305632, 305662}, + {305664, 305718}, {305728, 305741}, {305744, 305753}, + {305760, 305782}, {305786, 305858}, {305883, 305885}, + {305888, 305903}, {305906, 305910}, {305921, 305926}, + {305929, 305934}, {305937, 305942}, {305952, 305958}, + {305960, 305966}, {305968, 306010}, {306012, 306025}, + {306032, 306154}, {306156, 306157}, {306160, 306169}, + {306176, 317347}, {317360, 317382}, {317387, 317435}, + {325888, 326253}, {326256, 326361}, {326400, 326406}, + {326419, 326423}, {326429, 326440}, {326442, 326454}, + {326456, 326460}, {326462, 326462}, {326464, 326465}, + {326467, 326468}, {326470, 326577}, {326611, 326973}, + {326992, 327055}, {327058, 327111}, {327152, 327163}, + {327168, 327183}, {327200, 327215}, {327219, 327220}, + {327245, 327247}, {327280, 327284}, {327286, 327420}, + {327440, 327449}, {327457, 327482}, {327487, 327487}, + {327489, 327514}, {327526, 327614}, {327618, 327623}, + {327626, 327631}, {327634, 327639}, {327642, 327644}, + {327716, 327716}, {327728, 327737}, {327745, 327770}, + {327775, 327775}, {327777, 327802}, {327850, 327850}, + {327861, 327861}, {327863, 327863}, {327866, 327866}, + {327872, 327894}, {327896, 327926}, {327928, 328385}, + {328390, 328401}, {328416, 328420}, {328428, 328428}, + {328430, 328430}, {328448, 328564}, {328566, 328567}, + {328570, 328573}, {328575, 328575}, {328582, 328586}, + {328588, 328588}, {328590, 328609}, {328611, 328693}, + {328695, 328833}, {328835, 328839}, {328842, 329007}, + {329009, 329046}, {329049, 329049}, {329056, 329096}, + {329105, 329149}, {329151, 329151}, {329153, 329154}, + {329156, 329157}, {329159, 329159}, {329168, 329194}, + {329199, 329202}, {329232, 329242}, {329248, 329321}, + {329326, 329427}, {329429, 329436}, {329439, 329448}, + {329450, 329468}, {329471, 329471}, {329488, 329546}, + {329549, 329649}, {329664, 329717}, {329722, 329722}, + {329725, 329725}, {329728, 329773}, {329792, 329819}, + {329824, 329834}, {329840, 329863}, {329865, 329870}, + {329880, 329953}, {329955, 330083}, {330086, 330095}, + {330097, 330115}, {330117, 330124}, {330127, 330128}, + {330131, 330152}, {330154, 330160}, {330162, 330162}, + {330166, 330169}, {330172, 330180}, {330183, 330184}, + {330187, 330190}, {330199, 330199}, {330204, 330205}, + {330207, 330211}, {330214, 330225}, {330236, 330236}, + {330238, 330238}, {330241, 330243}, {330245, 330250}, + {330255, 330256}, {330259, 330280}, {330282, 330288}, + {330290, 330291}, {330293, 330294}, {330296, 330297}, + {330300, 330300}, {330302, 330306}, {330311, 330312}, + {330315, 330317}, {330321, 330321}, {330329, 330332}, + {330334, 330334}, {330342, 330357}, {330369, 330371}, + {330373, 330381}, {330383, 330385}, {330387, 330408}, + {330410, 330416}, {330418, 330419}, {330421, 330425}, + {330428, 330437}, {330439, 330441}, {330443, 330445}, + {330448, 330448}, {330464, 330467}, {330470, 330479}, + {330489, 330495}, {330497, 330499}, {330501, 330508}, + {330511, 330512}, {330515, 330536}, {330538, 330544}, + {330546, 330547}, {330549, 330553}, {330556, 330564}, + {330567, 330568}, {330571, 330573}, {330581, 330583}, + {330588, 330589}, {330591, 330595}, {330598, 330607}, + {330609, 330609}, {330626, 330627}, {330629, 330634}, + {330638, 330640}, {330642, 330645}, {330649, 330650}, + {330652, 330652}, {330654, 330655}, {330659, 330660}, + {330664, 330666}, {330670, 330681}, {330686, 330690}, + {330694, 330696}, {330698, 330701}, {330704, 330704}, + {330711, 330711}, {330726, 330735}, {330752, 330764}, + {330766, 330768}, {330770, 330792}, {330794, 330809}, + {330812, 330820}, {330822, 330824}, {330826, 330829}, + {330837, 330838}, {330840, 330842}, {330845, 330845}, + {330848, 330851}, {330854, 330863}, {330880, 330883}, + {330885, 330892}, {330894, 330896}, {330898, 330920}, + {330922, 330931}, {330933, 330937}, {330940, 330948}, + {330950, 330952}, {330954, 330957}, {330965, 330966}, + {330973, 330974}, {330976, 330979}, {330982, 330991}, + {330993, 330995}, {331008, 331020}, {331022, 331024}, + {331026, 331076}, {331078, 331080}, {331082, 331086}, + {331092, 331095}, {331103, 331107}, {331110, 331119}, + {331130, 331135}, {331137, 331139}, {331141, 331158}, + {331162, 331185}, {331187, 331195}, {331197, 331197}, + {331200, 331206}, {331210, 331210}, {331215, 331220}, + {331222, 331222}, {331224, 331231}, {331238, 331247}, + {331250, 331251}, {331265, 331322}, {331328, 331342}, + {331344, 331353}, {331393, 331394}, {331396, 331396}, + {331398, 331402}, {331404, 331427}, {331429, 331429}, + {331431, 331453}, {331456, 331460}, {331462, 331462}, + {331464, 331470}, {331472, 331481}, {331484, 331487}, + {331520, 331520}, {331544, 331545}, {331552, 331561}, + {331573, 331573}, {331575, 331575}, {331577, 331577}, + {331582, 331591}, {331593, 331628}, {331633, 331652}, + {331654, 331671}, {331673, 331708}, {331718, 331718}, + {331776, 331849}, {331856, 331933}, {331936, 331973}, + {331975, 331975}, {331981, 331981}, {331984, 332026}, + {332028, 332360}, {332362, 332365}, {332368, 332374}, + {332376, 332376}, {332378, 332381}, {332384, 332424}, + {332426, 332429}, {332432, 332464}, {332466, 332469}, + {332472, 332478}, {332480, 332480}, {332482, 332485}, + {332488, 332502}, {332504, 332560}, {332562, 332565}, + {332568, 332634}, {332637, 332639}, {332649, 332657}, + {332672, 332687}, {332704, 332789}, {332792, 332797}, + {332801, 333420}, {333423, 333439}, {333441, 333466}, + {333472, 333546}, {333550, 333560}, {333568, 333589}, + {333599, 333620}, {333632, 333651}, {333664, 333676}, + {333678, 333680}, {333682, 333683}, {333696, 333779}, + {333783, 333783}, {333788, 333789}, {333792, 333801}, + {333835, 333837}, {333839, 333849}, {333856, 333944}, + {333952, 333994}, {334000, 334069}, {334080, 334110}, + {334112, 334123}, {334128, 334139}, {334150, 334189}, + {334192, 334196}, {334208, 334251}, {334256, 334281}, + {334288, 334298}, {334336, 334363}, {334368, 334430}, + {334432, 334460}, {334463, 334473}, {334480, 334489}, + {334503, 334503}, {334512, 334525}, {334527, 334542}, + {334592, 334668}, {334672, 334681}, {334699, 334707}, + {334720, 334835}, {334848, 334903}, {334912, 334921}, + {334925, 334973}, {334976, 334984}, {334992, 335034}, + {335037, 335039}, {335056, 335058}, {335060, 335098}, + {335104, 335637}, {335640, 335645}, {335648, 335685}, + {335688, 335693}, {335696, 335703}, {335705, 335705}, + {335707, 335707}, {335709, 335709}, {335711, 335741}, + {335744, 335796}, {335798, 335804}, {335806, 335806}, + {335810, 335812}, {335814, 335820}, {335824, 335827}, + {335830, 335835}, {335840, 335852}, {335858, 335860}, + {335862, 335868}, {335884, 335885}, {335935, 335936}, + {335956, 335956}, {335985, 335985}, {335999, 335999}, + {336016, 336028}, {336080, 336092}, {336097, 336097}, + {336101, 336112}, {336130, 336130}, {336135, 336135}, + {336138, 336147}, {336149, 336149}, {336152, 336157}, + {336164, 336164}, {336166, 336166}, {336168, 336168}, + {336170, 336185}, {336188, 336191}, {336197, 336201}, + {336206, 336206}, {336224, 336264}, {338944, 339172}, + {339179, 339187}, {339200, 339237}, {339239, 339239}, + {339245, 339245}, {339248, 339303}, {339311, 339311}, + {339327, 339350}, {339360, 339366}, {339368, 339374}, + {339376, 339382}, {339384, 339390}, {339392, 339398}, + {339400, 339406}, {339408, 339414}, {339416, 339422}, + {339424, 339455}, {339973, 339975}, {340001, 340015}, + {340017, 340021}, {340024, 340028}, {340033, 340118}, + {340121, 340127}, {340129, 340218}, {340220, 340223}, + {340229, 340271}, {340273, 340366}, {340384, 340415}, + {340464, 340479}, {340992, 347583}, {347648, 369804}, + {369872, 369917}, {369920, 370188}, {370192, 370219}, + {370240, 370287}, {370292, 370301}, {370303, 370417}, + {370455, 370463}, {370466, 370568}, {370571, 370634}, + {370640, 370641}, {370643, 370643}, {370645, 370649}, + {370674, 370727}, {370732, 370732}, {370752, 370803}, + {370816, 370885}, {370896, 370905}, {370912, 370935}, + {370939, 370939}, {370941, 370989}, {370992, 371027}, + {371040, 371068}, {371072, 371136}, {371151, 371161}, + {371168, 371198}, {371200, 371254}, {371264, 371277}, + {371280, 371289}, {371296, 371318}, {371322, 371394}, + {371419, 371421}, {371424, 371439}, {371442, 371446}, + {371457, 371462}, {371465, 371470}, {371473, 371478}, + {371488, 371494}, {371496, 371502}, {371504, 371546}, + {371548, 371561}, {371568, 371690}, {371692, 371693}, + {371696, 371705}, {371712, 382883}, {382896, 382918}, + {382923, 382971}, {391424, 391789}, {391792, 391897}, + {391936, 391942}, {391955, 391959}, {391965, 391976}, + {391978, 391990}, {391992, 391996}, {391998, 391998}, + {392000, 392001}, {392003, 392004}, {392006, 392113}, + {392147, 392509}, {392528, 392591}, {392594, 392647}, + {392688, 392699}, {392704, 392719}, {392736, 392751}, + {392755, 392756}, {392781, 392783}, {392816, 392820}, + {392822, 392956}, {392976, 392985}, {392993, 393018}, + {393023, 393023}, {393025, 393050}, {393062, 393150}, + {393154, 393159}, {393162, 393167}, {393170, 393175}, + {393178, 393180}, {393252, 393252}, {393264, 393273}, + {393281, 393306}, {393311, 393311}, {393313, 393338}, + {393386, 393386}, {393397, 393397}, {393399, 393399}, + {393402, 393402}, {393408, 393430}, {393432, 393462}, + {393464, 393921}, {393926, 393937}, {393952, 393956}, + {393964, 393964}, {393966, 393966}, {393984, 394100}, + {394102, 394103}, {394106, 394109}, {394111, 394111}, + {394118, 394122}, {394124, 394124}, {394126, 394145}, + {394147, 394229}, {394231, 394369}, {394371, 394375}, + {394378, 394543}, {394545, 394582}, {394585, 394585}, + {394592, 394632}, {394641, 394685}, {394687, 394687}, + {394689, 394690}, {394692, 394693}, {394695, 394695}, + {394704, 394730}, {394735, 394738}, {394768, 394778}, + {394784, 394857}, {394862, 394963}, {394965, 394972}, + {394975, 394984}, {394986, 395004}, {395007, 395007}, + {395024, 395082}, {395085, 395185}, {395200, 395253}, + {395258, 395258}, {395261, 395261}, {395264, 395309}, + {395328, 395355}, {395360, 395370}, {395376, 395399}, + {395401, 395406}, {395416, 395489}, {395491, 395619}, + {395622, 395631}, {395633, 395651}, {395653, 395660}, + {395663, 395664}, {395667, 395688}, {395690, 395696}, + {395698, 395698}, {395702, 395705}, {395708, 395716}, + {395719, 395720}, {395723, 395726}, {395735, 395735}, + {395740, 395741}, {395743, 395747}, {395750, 395761}, + {395772, 395772}, {395774, 395774}, {395777, 395779}, + {395781, 395786}, {395791, 395792}, {395795, 395816}, + {395818, 395824}, {395826, 395827}, {395829, 395830}, + {395832, 395833}, {395836, 395836}, {395838, 395842}, + {395847, 395848}, {395851, 395853}, {395857, 395857}, + {395865, 395868}, {395870, 395870}, {395878, 395893}, + {395905, 395907}, {395909, 395917}, {395919, 395921}, + {395923, 395944}, {395946, 395952}, {395954, 395955}, + {395957, 395961}, {395964, 395973}, {395975, 395977}, + {395979, 395981}, {395984, 395984}, {396000, 396003}, + {396006, 396015}, {396025, 396031}, {396033, 396035}, + {396037, 396044}, {396047, 396048}, {396051, 396072}, + {396074, 396080}, {396082, 396083}, {396085, 396089}, + {396092, 396100}, {396103, 396104}, {396107, 396109}, + {396117, 396119}, {396124, 396125}, {396127, 396131}, + {396134, 396143}, {396145, 396145}, {396162, 396163}, + {396165, 396170}, {396174, 396176}, {396178, 396181}, + {396185, 396186}, {396188, 396188}, {396190, 396191}, + {396195, 396196}, {396200, 396202}, {396206, 396217}, + {396222, 396226}, {396230, 396232}, {396234, 396237}, + {396240, 396240}, {396247, 396247}, {396262, 396271}, + {396288, 396300}, {396302, 396304}, {396306, 396328}, + {396330, 396345}, {396348, 396356}, {396358, 396360}, + {396362, 396365}, {396373, 396374}, {396376, 396378}, + {396381, 396381}, {396384, 396387}, {396390, 396399}, + {396416, 396419}, {396421, 396428}, {396430, 396432}, + {396434, 396456}, {396458, 396467}, {396469, 396473}, + {396476, 396484}, {396486, 396488}, {396490, 396493}, + {396501, 396502}, {396509, 396510}, {396512, 396515}, + {396518, 396527}, {396529, 396531}, {396544, 396556}, + {396558, 396560}, {396562, 396612}, {396614, 396616}, + {396618, 396622}, {396628, 396631}, {396639, 396643}, + {396646, 396655}, {396666, 396671}, {396673, 396675}, + {396677, 396694}, {396698, 396721}, {396723, 396731}, + {396733, 396733}, {396736, 396742}, {396746, 396746}, + {396751, 396756}, {396758, 396758}, {396760, 396767}, + {396774, 396783}, {396786, 396787}, {396801, 396858}, + {396864, 396878}, {396880, 396889}, {396929, 396930}, + {396932, 396932}, {396934, 396938}, {396940, 396963}, + {396965, 396965}, {396967, 396989}, {396992, 396996}, + {396998, 396998}, {397000, 397006}, {397008, 397017}, + {397020, 397023}, {397056, 397056}, {397080, 397081}, + {397088, 397097}, {397109, 397109}, {397111, 397111}, + {397113, 397113}, {397118, 397127}, {397129, 397164}, + {397169, 397188}, {397190, 397207}, {397209, 397244}, + {397254, 397254}, {397312, 397385}, {397392, 397469}, + {397472, 397509}, {397511, 397511}, {397517, 397517}, + {397520, 397562}, {397564, 397896}, {397898, 397901}, + {397904, 397910}, {397912, 397912}, {397914, 397917}, + {397920, 397960}, {397962, 397965}, {397968, 398000}, + {398002, 398005}, {398008, 398014}, {398016, 398016}, + {398018, 398021}, {398024, 398038}, {398040, 398096}, + {398098, 398101}, {398104, 398170}, {398173, 398175}, + {398185, 398193}, {398208, 398223}, {398240, 398325}, + {398328, 398333}, {398337, 398956}, {398959, 398975}, + {398977, 399002}, {399008, 399082}, {399086, 399096}, + {399104, 399125}, {399135, 399156}, {399168, 399187}, + {399200, 399212}, {399214, 399216}, {399218, 399219}, + {399232, 399315}, {399319, 399319}, {399324, 399325}, + {399328, 399337}, {399371, 399373}, {399375, 399385}, + {399392, 399480}, {399488, 399530}, {399536, 399605}, + {399616, 399646}, {399648, 399659}, {399664, 399675}, + {399686, 399725}, {399728, 399732}, {399744, 399787}, + {399792, 399817}, {399824, 399834}, {399872, 399899}, + {399904, 399966}, {399968, 399996}, {399999, 400009}, + {400016, 400025}, {400039, 400039}, {400048, 400061}, + {400063, 400078}, {400128, 400204}, {400208, 400217}, + {400235, 400243}, {400256, 400371}, {400384, 400439}, + {400448, 400457}, {400461, 400509}, {400512, 400520}, + {400528, 400570}, {400573, 400575}, {400592, 400594}, + {400596, 400634}, {400640, 401173}, {401176, 401181}, + {401184, 401221}, {401224, 401229}, {401232, 401239}, + {401241, 401241}, {401243, 401243}, {401245, 401245}, + {401247, 401277}, {401280, 401332}, {401334, 401340}, + {401342, 401342}, {401346, 401348}, {401350, 401356}, + {401360, 401363}, {401366, 401371}, {401376, 401388}, + {401394, 401396}, {401398, 401404}, {401420, 401421}, + {401471, 401472}, {401492, 401492}, {401521, 401521}, + {401535, 401535}, {401552, 401564}, {401616, 401628}, + {401633, 401633}, {401637, 401648}, {401666, 401666}, + {401671, 401671}, {401674, 401683}, {401685, 401685}, + {401688, 401693}, {401700, 401700}, {401702, 401702}, + {401704, 401704}, {401706, 401721}, {401724, 401727}, + {401733, 401737}, {401742, 401742}, {401760, 401800}, + {404480, 404708}, {404715, 404723}, {404736, 404773}, + {404775, 404775}, {404781, 404781}, {404784, 404839}, + {404847, 404847}, {404863, 404886}, {404896, 404902}, + {404904, 404910}, {404912, 404918}, {404920, 404926}, + {404928, 404934}, {404936, 404942}, {404944, 404950}, + {404952, 404958}, {404960, 404991}, {405509, 405511}, + {405537, 405551}, {405553, 405557}, {405560, 405564}, + {405569, 405654}, {405657, 405663}, {405665, 405754}, + {405756, 405759}, {405765, 405807}, {405809, 405902}, + {405920, 405951}, {406000, 406015}, {406528, 413119}, + {413184, 435340}, {435408, 435453}, {435456, 435724}, + {435728, 435755}, {435776, 435823}, {435828, 435837}, + {435839, 435953}, {435991, 435999}, {436002, 436104}, + {436107, 436170}, {436176, 436177}, {436179, 436179}, + {436181, 436185}, {436210, 436263}, {436268, 436268}, + {436288, 436339}, {436352, 436421}, {436432, 436441}, + {436448, 436471}, {436475, 436475}, {436477, 436525}, + {436528, 436563}, {436576, 436604}, {436608, 436672}, + {436687, 436697}, {436704, 436734}, {436736, 436790}, + {436800, 436813}, {436816, 436825}, {436832, 436854}, + {436858, 436930}, {436955, 436957}, {436960, 436975}, + {436978, 436982}, {436993, 436998}, {437001, 437006}, + {437009, 437014}, {437024, 437030}, {437032, 437038}, + {437040, 437082}, {437084, 437097}, {437104, 437226}, + {437228, 437229}, {437232, 437241}, {437248, 448419}, + {448432, 448454}, {448459, 448507}, {456960, 457325}, + {457328, 457433}, {457472, 457478}, {457491, 457495}, + {457501, 457512}, {457514, 457526}, {457528, 457532}, + {457534, 457534}, {457536, 457537}, {457539, 457540}, + {457542, 457649}, {457683, 458045}, {458064, 458127}, + {458130, 458183}, {458224, 458235}, {458240, 458255}, + {458272, 458287}, {458291, 458292}, {458317, 458319}, + {458352, 458356}, {458358, 458492}, {458512, 458521}, + {458529, 458554}, {458559, 458559}, {458561, 458586}, + {458598, 458686}, {458690, 458695}, {458698, 458703}, + {458706, 458711}, {458714, 458716}, {458788, 458788}, + {458800, 458809}, {458817, 458842}, {458847, 458847}, + {458849, 458874}, {458922, 458922}, {458933, 458933}, + {458935, 458935}, {458938, 458938}, {458944, 458966}, + {458968, 458998}, {459000, 459457}, {459462, 459473}, + {459488, 459492}, {459500, 459500}, {459502, 459502}, + {459520, 459636}, {459638, 459639}, {459642, 459645}, + {459647, 459647}, {459654, 459658}, {459660, 459660}, + {459662, 459681}, {459683, 459765}, {459767, 459905}, + {459907, 459911}, {459914, 460079}, {460081, 460118}, + {460121, 460121}, {460128, 460168}, {460177, 460221}, + {460223, 460223}, {460225, 460226}, {460228, 460229}, + {460231, 460231}, {460240, 460266}, {460271, 460274}, + {460304, 460314}, {460320, 460393}, {460398, 460499}, + {460501, 460508}, {460511, 460520}, {460522, 460540}, + {460543, 460543}, {460560, 460618}, {460621, 460721}, + {460736, 460789}, {460794, 460794}, {460797, 460797}, + {460800, 460845}, {460864, 460891}, {460896, 460906}, + {460912, 460935}, {460937, 460942}, {460952, 461025}, + {461027, 461155}, {461158, 461167}, {461169, 461187}, + {461189, 461196}, {461199, 461200}, {461203, 461224}, + {461226, 461232}, {461234, 461234}, {461238, 461241}, + {461244, 461252}, {461255, 461256}, {461259, 461262}, + {461271, 461271}, {461276, 461277}, {461279, 461283}, + {461286, 461297}, {461308, 461308}, {461310, 461310}, + {461313, 461315}, {461317, 461322}, {461327, 461328}, + {461331, 461352}, {461354, 461360}, {461362, 461363}, + {461365, 461366}, {461368, 461369}, {461372, 461372}, + {461374, 461378}, {461383, 461384}, {461387, 461389}, + {461393, 461393}, {461401, 461404}, {461406, 461406}, + {461414, 461429}, {461441, 461443}, {461445, 461453}, + {461455, 461457}, {461459, 461480}, {461482, 461488}, + {461490, 461491}, {461493, 461497}, {461500, 461509}, + {461511, 461513}, {461515, 461517}, {461520, 461520}, + {461536, 461539}, {461542, 461551}, {461561, 461567}, + {461569, 461571}, {461573, 461580}, {461583, 461584}, + {461587, 461608}, {461610, 461616}, {461618, 461619}, + {461621, 461625}, {461628, 461636}, {461639, 461640}, + {461643, 461645}, {461653, 461655}, {461660, 461661}, + {461663, 461667}, {461670, 461679}, {461681, 461681}, + {461698, 461699}, {461701, 461706}, {461710, 461712}, + {461714, 461717}, {461721, 461722}, {461724, 461724}, + {461726, 461727}, {461731, 461732}, {461736, 461738}, + {461742, 461753}, {461758, 461762}, {461766, 461768}, + {461770, 461773}, {461776, 461776}, {461783, 461783}, + {461798, 461807}, {461824, 461836}, {461838, 461840}, + {461842, 461864}, {461866, 461881}, {461884, 461892}, + {461894, 461896}, {461898, 461901}, {461909, 461910}, + {461912, 461914}, {461917, 461917}, {461920, 461923}, + {461926, 461935}, {461952, 461955}, {461957, 461964}, + {461966, 461968}, {461970, 461992}, {461994, 462003}, + {462005, 462009}, {462012, 462020}, {462022, 462024}, + {462026, 462029}, {462037, 462038}, {462045, 462046}, + {462048, 462051}, {462054, 462063}, {462065, 462067}, + {462080, 462092}, {462094, 462096}, {462098, 462148}, + {462150, 462152}, {462154, 462158}, {462164, 462167}, + {462175, 462179}, {462182, 462191}, {462202, 462207}, + {462209, 462211}, {462213, 462230}, {462234, 462257}, + {462259, 462267}, {462269, 462269}, {462272, 462278}, + {462282, 462282}, {462287, 462292}, {462294, 462294}, + {462296, 462303}, {462310, 462319}, {462322, 462323}, + {462337, 462394}, {462400, 462414}, {462416, 462425}, + {462465, 462466}, {462468, 462468}, {462470, 462474}, + {462476, 462499}, {462501, 462501}, {462503, 462525}, + {462528, 462532}, {462534, 462534}, {462536, 462542}, + {462544, 462553}, {462556, 462559}, {462592, 462592}, + {462616, 462617}, {462624, 462633}, {462645, 462645}, + {462647, 462647}, {462649, 462649}, {462654, 462663}, + {462665, 462700}, {462705, 462724}, {462726, 462743}, + {462745, 462780}, {462790, 462790}, {462848, 462921}, + {462928, 463005}, {463008, 463045}, {463047, 463047}, + {463053, 463053}, {463056, 463098}, {463100, 463432}, + {463434, 463437}, {463440, 463446}, {463448, 463448}, + {463450, 463453}, {463456, 463496}, {463498, 463501}, + {463504, 463536}, {463538, 463541}, {463544, 463550}, + {463552, 463552}, {463554, 463557}, {463560, 463574}, + {463576, 463632}, {463634, 463637}, {463640, 463706}, + {463709, 463711}, {463721, 463729}, {463744, 463759}, + {463776, 463861}, {463864, 463869}, {463873, 464492}, + {464495, 464511}, {464513, 464538}, {464544, 464618}, + {464622, 464632}, {464640, 464661}, {464671, 464692}, + {464704, 464723}, {464736, 464748}, {464750, 464752}, + {464754, 464755}, {464768, 464851}, {464855, 464855}, + {464860, 464861}, {464864, 464873}, {464907, 464909}, + {464911, 464921}, {464928, 465016}, {465024, 465066}, + {465072, 465141}, {465152, 465182}, {465184, 465195}, + {465200, 465211}, {465222, 465261}, {465264, 465268}, + {465280, 465323}, {465328, 465353}, {465360, 465370}, + {465408, 465435}, {465440, 465502}, {465504, 465532}, + {465535, 465545}, {465552, 465561}, {465575, 465575}, + {465584, 465597}, {465599, 465614}, {465664, 465740}, + {465744, 465753}, {465771, 465779}, {465792, 465907}, + {465920, 465975}, {465984, 465993}, {465997, 466045}, + {466048, 466056}, {466064, 466106}, {466109, 466111}, + {466128, 466130}, {466132, 466170}, {466176, 466709}, + {466712, 466717}, {466720, 466757}, {466760, 466765}, + {466768, 466775}, {466777, 466777}, {466779, 466779}, + {466781, 466781}, {466783, 466813}, {466816, 466868}, + {466870, 466876}, {466878, 466878}, {466882, 466884}, + {466886, 466892}, {466896, 466899}, {466902, 466907}, + {466912, 466924}, {466930, 466932}, {466934, 466940}, + {466956, 466957}, {467007, 467008}, {467028, 467028}, + {467057, 467057}, {467071, 467071}, {467088, 467100}, + {467152, 467164}, {467169, 467169}, {467173, 467184}, + {467202, 467202}, {467207, 467207}, {467210, 467219}, + {467221, 467221}, {467224, 467229}, {467236, 467236}, + {467238, 467238}, {467240, 467240}, {467242, 467257}, + {467260, 467263}, {467269, 467273}, {467278, 467278}, + {467296, 467336}, {470016, 470244}, {470251, 470259}, + {470272, 470309}, {470311, 470311}, {470317, 470317}, + {470320, 470375}, {470383, 470383}, {470399, 470422}, + {470432, 470438}, {470440, 470446}, {470448, 470454}, + {470456, 470462}, {470464, 470470}, {470472, 470478}, + {470480, 470486}, {470488, 470494}, {470496, 470527}, + {471045, 471047}, {471073, 471087}, {471089, 471093}, + {471096, 471100}, {471105, 471190}, {471193, 471199}, + {471201, 471290}, {471292, 471295}, {471301, 471343}, + {471345, 471438}, {471456, 471487}, {471536, 471551}, + {472064, 478655}, {478720, 500876}, {500944, 500989}, + {500992, 501260}, {501264, 501291}, {501312, 501359}, + {501364, 501373}, {501375, 501489}, {501527, 501535}, + {501538, 501640}, {501643, 501706}, {501712, 501713}, + {501715, 501715}, {501717, 501721}, {501746, 501799}, + {501804, 501804}, {501824, 501875}, {501888, 501957}, + {501968, 501977}, {501984, 502007}, {502011, 502011}, + {502013, 502061}, {502064, 502099}, {502112, 502140}, + {502144, 502208}, {502223, 502233}, {502240, 502270}, + {502272, 502326}, {502336, 502349}, {502352, 502361}, + {502368, 502390}, {502394, 502466}, {502491, 502493}, + {502496, 502511}, {502514, 502518}, {502529, 502534}, + {502537, 502542}, {502545, 502550}, {502560, 502566}, + {502568, 502574}, {502576, 502618}, {502620, 502633}, + {502640, 502762}, {502764, 502765}, {502768, 502777}, + {502784, 513955}, {513968, 513990}, {513995, 514043}, + {522496, 522861}, {522864, 522969}, {523008, 523014}, + {523027, 523031}, {523037, 523048}, {523050, 523062}, + {523064, 523068}, {523070, 523070}, {523072, 523073}, + {523075, 523076}, {523078, 523185}, {523219, 523581}, + {523600, 523663}, {523666, 523719}, {523760, 523771}, + {523776, 523791}, {523808, 523823}, {523827, 523828}, + {523853, 523855}, {523888, 523892}, {523894, 524028}, + {524048, 524057}, {524065, 524090}, {524095, 524095}, + {524097, 524122}, {524134, 524222}, {524226, 524231}, + {524234, 524239}, {524242, 524247}, {524250, 524252}, + {524324, 524324}, {524336, 524345}, {524353, 524378}, + {524383, 524383}, {524385, 524410}, {524458, 524458}, + {524469, 524469}, {524471, 524471}, {524474, 524474}, + {524480, 524502}, {524504, 524534}, {524536, 524993}, + {524998, 525009}, {525024, 525028}, {525036, 525036}, + {525038, 525038}, {525056, 525172}, {525174, 525175}, + {525178, 525181}, {525183, 525183}, {525190, 525194}, + {525196, 525196}, {525198, 525217}, {525219, 525301}, + {525303, 525441}, {525443, 525447}, {525450, 525615}, + {525617, 525654}, {525657, 525657}, {525664, 525704}, + {525713, 525757}, {525759, 525759}, {525761, 525762}, + {525764, 525765}, {525767, 525767}, {525776, 525802}, + {525807, 525810}, {525840, 525850}, {525856, 525929}, + {525934, 526035}, {526037, 526044}, {526047, 526056}, + {526058, 526076}, {526079, 526079}, {526096, 526154}, + {526157, 526257}, {526272, 526325}, {526330, 526330}, + {526333, 526333}, {526336, 526381}, {526400, 526427}, + {526432, 526442}, {526448, 526471}, {526473, 526478}, + {526488, 526561}, {526563, 526691}, {526694, 526703}, + {526705, 526723}, {526725, 526732}, {526735, 526736}, + {526739, 526760}, {526762, 526768}, {526770, 526770}, + {526774, 526777}, {526780, 526788}, {526791, 526792}, + {526795, 526798}, {526807, 526807}, {526812, 526813}, + {526815, 526819}, {526822, 526833}, {526844, 526844}, + {526846, 526846}, {526849, 526851}, {526853, 526858}, + {526863, 526864}, {526867, 526888}, {526890, 526896}, + {526898, 526899}, {526901, 526902}, {526904, 526905}, + {526908, 526908}, {526910, 526914}, {526919, 526920}, + {526923, 526925}, {526929, 526929}, {526937, 526940}, + {526942, 526942}, {526950, 526965}, {526977, 526979}, + {526981, 526989}, {526991, 526993}, {526995, 527016}, + {527018, 527024}, {527026, 527027}, {527029, 527033}, + {527036, 527045}, {527047, 527049}, {527051, 527053}, + {527056, 527056}, {527072, 527075}, {527078, 527087}, + {527097, 527103}, {527105, 527107}, {527109, 527116}, + {527119, 527120}, {527123, 527144}, {527146, 527152}, + {527154, 527155}, {527157, 527161}, {527164, 527172}, + {527175, 527176}, {527179, 527181}, {527189, 527191}, + {527196, 527197}, {527199, 527203}, {527206, 527215}, + {527217, 527217}, {527234, 527235}, {527237, 527242}, + {527246, 527248}, {527250, 527253}, {527257, 527258}, + {527260, 527260}, {527262, 527263}, {527267, 527268}, + {527272, 527274}, {527278, 527289}, {527294, 527298}, + {527302, 527304}, {527306, 527309}, {527312, 527312}, + {527319, 527319}, {527334, 527343}, {527360, 527372}, + {527374, 527376}, {527378, 527400}, {527402, 527417}, + {527420, 527428}, {527430, 527432}, {527434, 527437}, + {527445, 527446}, {527448, 527450}, {527453, 527453}, + {527456, 527459}, {527462, 527471}, {527488, 527491}, + {527493, 527500}, {527502, 527504}, {527506, 527528}, + {527530, 527539}, {527541, 527545}, {527548, 527556}, + {527558, 527560}, {527562, 527565}, {527573, 527574}, + {527581, 527582}, {527584, 527587}, {527590, 527599}, + {527601, 527603}, {527616, 527628}, {527630, 527632}, + {527634, 527684}, {527686, 527688}, {527690, 527694}, + {527700, 527703}, {527711, 527715}, {527718, 527727}, + {527738, 527743}, {527745, 527747}, {527749, 527766}, + {527770, 527793}, {527795, 527803}, {527805, 527805}, + {527808, 527814}, {527818, 527818}, {527823, 527828}, + {527830, 527830}, {527832, 527839}, {527846, 527855}, + {527858, 527859}, {527873, 527930}, {527936, 527950}, + {527952, 527961}, {528001, 528002}, {528004, 528004}, + {528006, 528010}, {528012, 528035}, {528037, 528037}, + {528039, 528061}, {528064, 528068}, {528070, 528070}, + {528072, 528078}, {528080, 528089}, {528092, 528095}, + {528128, 528128}, {528152, 528153}, {528160, 528169}, + {528181, 528181}, {528183, 528183}, {528185, 528185}, + {528190, 528199}, {528201, 528236}, {528241, 528260}, + {528262, 528279}, {528281, 528316}, {528326, 528326}, + {528384, 528457}, {528464, 528541}, {528544, 528581}, + {528583, 528583}, {528589, 528589}, {528592, 528634}, + {528636, 528968}, {528970, 528973}, {528976, 528982}, + {528984, 528984}, {528986, 528989}, {528992, 529032}, + {529034, 529037}, {529040, 529072}, {529074, 529077}, + {529080, 529086}, {529088, 529088}, {529090, 529093}, + {529096, 529110}, {529112, 529168}, {529170, 529173}, + {529176, 529242}, {529245, 529247}, {529257, 529265}, + {529280, 529295}, {529312, 529397}, {529400, 529405}, + {529409, 530028}, {530031, 530047}, {530049, 530074}, + {530080, 530154}, {530158, 530168}, {530176, 530197}, + {530207, 530228}, {530240, 530259}, {530272, 530284}, + {530286, 530288}, {530290, 530291}, {530304, 530387}, + {530391, 530391}, {530396, 530397}, {530400, 530409}, + {530443, 530445}, {530447, 530457}, {530464, 530552}, + {530560, 530602}, {530608, 530677}, {530688, 530718}, + {530720, 530731}, {530736, 530747}, {530758, 530797}, + {530800, 530804}, {530816, 530859}, {530864, 530889}, + {530896, 530906}, {530944, 530971}, {530976, 531038}, + {531040, 531068}, {531071, 531081}, {531088, 531097}, + {531111, 531111}, {531120, 531133}, {531135, 531150}, + {531200, 531276}, {531280, 531289}, {531307, 531315}, + {531328, 531443}, {531456, 531511}, {531520, 531529}, + {531533, 531581}, {531584, 531592}, {531600, 531642}, + {531645, 531647}, {531664, 531666}, {531668, 531706}, + {531712, 532245}, {532248, 532253}, {532256, 532293}, + {532296, 532301}, {532304, 532311}, {532313, 532313}, + {532315, 532315}, {532317, 532317}, {532319, 532349}, + {532352, 532404}, {532406, 532412}, {532414, 532414}, + {532418, 532420}, {532422, 532428}, {532432, 532435}, + {532438, 532443}, {532448, 532460}, {532466, 532468}, + {532470, 532476}, {532492, 532493}, {532543, 532544}, + {532564, 532564}, {532593, 532593}, {532607, 532607}, + {532624, 532636}, {532688, 532700}, {532705, 532705}, + {532709, 532720}, {532738, 532738}, {532743, 532743}, + {532746, 532755}, {532757, 532757}, {532760, 532765}, + {532772, 532772}, {532774, 532774}, {532776, 532776}, + {532778, 532793}, {532796, 532799}, {532805, 532809}, + {532814, 532814}, {532832, 532872}, {535552, 535780}, + {535787, 535795}, {535808, 535845}, {535847, 535847}, + {535853, 535853}, {535856, 535911}, {535919, 535919}, + {535935, 535958}, {535968, 535974}, {535976, 535982}, + {535984, 535990}, {535992, 535998}, {536000, 536006}, + {536008, 536014}, {536016, 536022}, {536024, 536030}, + {536032, 536063}, {536581, 536583}, {536609, 536623}, + {536625, 536629}, {536632, 536636}, {536641, 536726}, + {536729, 536735}, {536737, 536826}, {536828, 536831}, + {536837, 536879}, {536881, 536974}, {536992, 537023}, + {537072, 537087}, {537600, 544191}, {544256, 566412}, + {566480, 566525}, {566528, 566796}, {566800, 566827}, + {566848, 566895}, {566900, 566909}, {566911, 567025}, + {567063, 567071}, {567074, 567176}, {567179, 567242}, + {567248, 567249}, {567251, 567251}, {567253, 567257}, + {567282, 567335}, {567340, 567340}, {567360, 567411}, + {567424, 567493}, {567504, 567513}, {567520, 567543}, + {567547, 567547}, {567549, 567597}, {567600, 567635}, + {567648, 567676}, {567680, 567744}, {567759, 567769}, + {567776, 567806}, {567808, 567862}, {567872, 567885}, + {567888, 567897}, {567904, 567926}, {567930, 568002}, + {568027, 568029}, {568032, 568047}, {568050, 568054}, + {568065, 568070}, {568073, 568078}, {568081, 568086}, + {568096, 568102}, {568104, 568110}, {568112, 568154}, + {568156, 568169}, {568176, 568298}, {568300, 568301}, + {568304, 568313}, {568320, 579491}, {579504, 579526}, + {579531, 579579}, {588032, 588397}, {588400, 588505}, + {588544, 588550}, {588563, 588567}, {588573, 588584}, + {588586, 588598}, {588600, 588604}, {588606, 588606}, + {588608, 588609}, {588611, 588612}, {588614, 588721}, + {588755, 589117}, {589136, 589199}, {589202, 589255}, + {589296, 589307}, {589312, 589327}, {589344, 589359}, + {589363, 589364}, {589389, 589391}, {589424, 589428}, + {589430, 589564}, {589584, 589593}, {589601, 589626}, + {589631, 589631}, {589633, 589658}, {589670, 589758}, + {589762, 589767}, {589770, 589775}, {589778, 589783}, + {589786, 589788}, {589860, 589860}, {589872, 589881}, + {589889, 589914}, {589919, 589919}, {589921, 589946}, + {589994, 589994}, {590005, 590005}, {590007, 590007}, + {590010, 590010}, {590016, 590038}, {590040, 590070}, + {590072, 590529}, {590534, 590545}, {590560, 590564}, + {590572, 590572}, {590574, 590574}, {590592, 590708}, + {590710, 590711}, {590714, 590717}, {590719, 590719}, + {590726, 590730}, {590732, 590732}, {590734, 590753}, + {590755, 590837}, {590839, 590977}, {590979, 590983}, + {590986, 591151}, {591153, 591190}, {591193, 591193}, + {591200, 591240}, {591249, 591293}, {591295, 591295}, + {591297, 591298}, {591300, 591301}, {591303, 591303}, + {591312, 591338}, {591343, 591346}, {591376, 591386}, + {591392, 591465}, {591470, 591571}, {591573, 591580}, + {591583, 591592}, {591594, 591612}, {591615, 591615}, + {591632, 591690}, {591693, 591793}, {591808, 591861}, + {591866, 591866}, {591869, 591869}, {591872, 591917}, + {591936, 591963}, {591968, 591978}, {591984, 592007}, + {592009, 592014}, {592024, 592097}, {592099, 592227}, + {592230, 592239}, {592241, 592259}, {592261, 592268}, + {592271, 592272}, {592275, 592296}, {592298, 592304}, + {592306, 592306}, {592310, 592313}, {592316, 592324}, + {592327, 592328}, {592331, 592334}, {592343, 592343}, + {592348, 592349}, {592351, 592355}, {592358, 592369}, + {592380, 592380}, {592382, 592382}, {592385, 592387}, + {592389, 592394}, {592399, 592400}, {592403, 592424}, + {592426, 592432}, {592434, 592435}, {592437, 592438}, + {592440, 592441}, {592444, 592444}, {592446, 592450}, + {592455, 592456}, {592459, 592461}, {592465, 592465}, + {592473, 592476}, {592478, 592478}, {592486, 592501}, + {592513, 592515}, {592517, 592525}, {592527, 592529}, + {592531, 592552}, {592554, 592560}, {592562, 592563}, + {592565, 592569}, {592572, 592581}, {592583, 592585}, + {592587, 592589}, {592592, 592592}, {592608, 592611}, + {592614, 592623}, {592633, 592639}, {592641, 592643}, + {592645, 592652}, {592655, 592656}, {592659, 592680}, + {592682, 592688}, {592690, 592691}, {592693, 592697}, + {592700, 592708}, {592711, 592712}, {592715, 592717}, + {592725, 592727}, {592732, 592733}, {592735, 592739}, + {592742, 592751}, {592753, 592753}, {592770, 592771}, + {592773, 592778}, {592782, 592784}, {592786, 592789}, + {592793, 592794}, {592796, 592796}, {592798, 592799}, + {592803, 592804}, {592808, 592810}, {592814, 592825}, + {592830, 592834}, {592838, 592840}, {592842, 592845}, + {592848, 592848}, {592855, 592855}, {592870, 592879}, + {592896, 592908}, {592910, 592912}, {592914, 592936}, + {592938, 592953}, {592956, 592964}, {592966, 592968}, + {592970, 592973}, {592981, 592982}, {592984, 592986}, + {592989, 592989}, {592992, 592995}, {592998, 593007}, + {593024, 593027}, {593029, 593036}, {593038, 593040}, + {593042, 593064}, {593066, 593075}, {593077, 593081}, + {593084, 593092}, {593094, 593096}, {593098, 593101}, + {593109, 593110}, {593117, 593118}, {593120, 593123}, + {593126, 593135}, {593137, 593139}, {593152, 593164}, + {593166, 593168}, {593170, 593220}, {593222, 593224}, + {593226, 593230}, {593236, 593239}, {593247, 593251}, + {593254, 593263}, {593274, 593279}, {593281, 593283}, + {593285, 593302}, {593306, 593329}, {593331, 593339}, + {593341, 593341}, {593344, 593350}, {593354, 593354}, + {593359, 593364}, {593366, 593366}, {593368, 593375}, + {593382, 593391}, {593394, 593395}, {593409, 593466}, + {593472, 593486}, {593488, 593497}, {593537, 593538}, + {593540, 593540}, {593542, 593546}, {593548, 593571}, + {593573, 593573}, {593575, 593597}, {593600, 593604}, + {593606, 593606}, {593608, 593614}, {593616, 593625}, + {593628, 593631}, {593664, 593664}, {593688, 593689}, + {593696, 593705}, {593717, 593717}, {593719, 593719}, + {593721, 593721}, {593726, 593735}, {593737, 593772}, + {593777, 593796}, {593798, 593815}, {593817, 593852}, + {593862, 593862}, {593920, 593993}, {594000, 594077}, + {594080, 594117}, {594119, 594119}, {594125, 594125}, + {594128, 594170}, {594172, 594504}, {594506, 594509}, + {594512, 594518}, {594520, 594520}, {594522, 594525}, + {594528, 594568}, {594570, 594573}, {594576, 594608}, + {594610, 594613}, {594616, 594622}, {594624, 594624}, + {594626, 594629}, {594632, 594646}, {594648, 594704}, + {594706, 594709}, {594712, 594778}, {594781, 594783}, + {594793, 594801}, {594816, 594831}, {594848, 594933}, + {594936, 594941}, {594945, 595564}, {595567, 595583}, + {595585, 595610}, {595616, 595690}, {595694, 595704}, + {595712, 595733}, {595743, 595764}, {595776, 595795}, + {595808, 595820}, {595822, 595824}, {595826, 595827}, + {595840, 595923}, {595927, 595927}, {595932, 595933}, + {595936, 595945}, {595979, 595981}, {595983, 595993}, + {596000, 596088}, {596096, 596138}, {596144, 596213}, + {596224, 596254}, {596256, 596267}, {596272, 596283}, + {596294, 596333}, {596336, 596340}, {596352, 596395}, + {596400, 596425}, {596432, 596442}, {596480, 596507}, + {596512, 596574}, {596576, 596604}, {596607, 596617}, + {596624, 596633}, {596647, 596647}, {596656, 596669}, + {596671, 596686}, {596736, 596812}, {596816, 596825}, + {596843, 596851}, {596864, 596979}, {596992, 597047}, + {597056, 597065}, {597069, 597117}, {597120, 597128}, + {597136, 597178}, {597181, 597183}, {597200, 597202}, + {597204, 597242}, {597248, 597781}, {597784, 597789}, + {597792, 597829}, {597832, 597837}, {597840, 597847}, + {597849, 597849}, {597851, 597851}, {597853, 597853}, + {597855, 597885}, {597888, 597940}, {597942, 597948}, + {597950, 597950}, {597954, 597956}, {597958, 597964}, + {597968, 597971}, {597974, 597979}, {597984, 597996}, + {598002, 598004}, {598006, 598012}, {598028, 598029}, + {598079, 598080}, {598100, 598100}, {598129, 598129}, + {598143, 598143}, {598160, 598172}, {598224, 598236}, + {598241, 598241}, {598245, 598256}, {598274, 598274}, + {598279, 598279}, {598282, 598291}, {598293, 598293}, + {598296, 598301}, {598308, 598308}, {598310, 598310}, + {598312, 598312}, {598314, 598329}, {598332, 598335}, + {598341, 598345}, {598350, 598350}, {598368, 598408}, + {601088, 601316}, {601323, 601331}, {601344, 601381}, + {601383, 601383}, {601389, 601389}, {601392, 601447}, + {601455, 601455}, {601471, 601494}, {601504, 601510}, + {601512, 601518}, {601520, 601526}, {601528, 601534}, + {601536, 601542}, {601544, 601550}, {601552, 601558}, + {601560, 601566}, {601568, 601599}, {602117, 602119}, + {602145, 602159}, {602161, 602165}, {602168, 602172}, + {602177, 602262}, {602265, 602271}, {602273, 602362}, + {602364, 602367}, {602373, 602415}, {602417, 602510}, + {602528, 602559}, {602608, 602623}, {603136, 609727}, + {609792, 631948}, {632016, 632061}, {632064, 632332}, + {632336, 632363}, {632384, 632431}, {632436, 632445}, + {632447, 632561}, {632599, 632607}, {632610, 632712}, + {632715, 632778}, {632784, 632785}, {632787, 632787}, + {632789, 632793}, {632818, 632871}, {632876, 632876}, + {632896, 632947}, {632960, 633029}, {633040, 633049}, + {633056, 633079}, {633083, 633083}, {633085, 633133}, + {633136, 633171}, {633184, 633212}, {633216, 633280}, + {633295, 633305}, {633312, 633342}, {633344, 633398}, + {633408, 633421}, {633424, 633433}, {633440, 633462}, + {633466, 633538}, {633563, 633565}, {633568, 633583}, + {633586, 633590}, {633601, 633606}, {633609, 633614}, + {633617, 633622}, {633632, 633638}, {633640, 633646}, + {633648, 633690}, {633692, 633705}, {633712, 633834}, + {633836, 633837}, {633840, 633849}, {633856, 645027}, + {645040, 645062}, {645067, 645115}, {653568, 653933}, + {653936, 654041}, {654080, 654086}, {654099, 654103}, + {654109, 654120}, {654122, 654134}, {654136, 654140}, + {654142, 654142}, {654144, 654145}, {654147, 654148}, + {654150, 654257}, {654291, 654653}, {654672, 654735}, + {654738, 654791}, {654832, 654843}, {654848, 654863}, + {654880, 654895}, {654899, 654900}, {654925, 654927}, + {654960, 654964}, {654966, 655100}, {655120, 655129}, + {655137, 655162}, {655167, 655167}, {655169, 655194}, + {655206, 655294}, {655298, 655303}, {655306, 655311}, + {655314, 655319}, {655322, 655324}, {655396, 655396}, + {655408, 655417}, {655425, 655450}, {655455, 655455}, + {655457, 655482}, {655530, 655530}, {655541, 655541}, + {655543, 655543}, {655546, 655546}, {655552, 655574}, + {655576, 655606}, {655608, 656065}, {656070, 656081}, + {656096, 656100}, {656108, 656108}, {656110, 656110}, + {656128, 656244}, {656246, 656247}, {656250, 656253}, + {656255, 656255}, {656262, 656266}, {656268, 656268}, + {656270, 656289}, {656291, 656373}, {656375, 656513}, + {656515, 656519}, {656522, 656687}, {656689, 656726}, + {656729, 656729}, {656736, 656776}, {656785, 656829}, + {656831, 656831}, {656833, 656834}, {656836, 656837}, + {656839, 656839}, {656848, 656874}, {656879, 656882}, + {656912, 656922}, {656928, 657001}, {657006, 657107}, + {657109, 657116}, {657119, 657128}, {657130, 657148}, + {657151, 657151}, {657168, 657226}, {657229, 657329}, + {657344, 657397}, {657402, 657402}, {657405, 657405}, + {657408, 657453}, {657472, 657499}, {657504, 657514}, + {657520, 657543}, {657545, 657550}, {657560, 657633}, + {657635, 657763}, {657766, 657775}, {657777, 657795}, + {657797, 657804}, {657807, 657808}, {657811, 657832}, + {657834, 657840}, {657842, 657842}, {657846, 657849}, + {657852, 657860}, {657863, 657864}, {657867, 657870}, + {657879, 657879}, {657884, 657885}, {657887, 657891}, + {657894, 657905}, {657916, 657916}, {657918, 657918}, + {657921, 657923}, {657925, 657930}, {657935, 657936}, + {657939, 657960}, {657962, 657968}, {657970, 657971}, + {657973, 657974}, {657976, 657977}, {657980, 657980}, + {657982, 657986}, {657991, 657992}, {657995, 657997}, + {658001, 658001}, {658009, 658012}, {658014, 658014}, + {658022, 658037}, {658049, 658051}, {658053, 658061}, + {658063, 658065}, {658067, 658088}, {658090, 658096}, + {658098, 658099}, {658101, 658105}, {658108, 658117}, + {658119, 658121}, {658123, 658125}, {658128, 658128}, + {658144, 658147}, {658150, 658159}, {658169, 658175}, + {658177, 658179}, {658181, 658188}, {658191, 658192}, + {658195, 658216}, {658218, 658224}, {658226, 658227}, + {658229, 658233}, {658236, 658244}, {658247, 658248}, + {658251, 658253}, {658261, 658263}, {658268, 658269}, + {658271, 658275}, {658278, 658287}, {658289, 658289}, + {658306, 658307}, {658309, 658314}, {658318, 658320}, + {658322, 658325}, {658329, 658330}, {658332, 658332}, + {658334, 658335}, {658339, 658340}, {658344, 658346}, + {658350, 658361}, {658366, 658370}, {658374, 658376}, + {658378, 658381}, {658384, 658384}, {658391, 658391}, + {658406, 658415}, {658432, 658444}, {658446, 658448}, + {658450, 658472}, {658474, 658489}, {658492, 658500}, + {658502, 658504}, {658506, 658509}, {658517, 658518}, + {658520, 658522}, {658525, 658525}, {658528, 658531}, + {658534, 658543}, {658560, 658563}, {658565, 658572}, + {658574, 658576}, {658578, 658600}, {658602, 658611}, + {658613, 658617}, {658620, 658628}, {658630, 658632}, + {658634, 658637}, {658645, 658646}, {658653, 658654}, + {658656, 658659}, {658662, 658671}, {658673, 658675}, + {658688, 658700}, {658702, 658704}, {658706, 658756}, + {658758, 658760}, {658762, 658766}, {658772, 658775}, + {658783, 658787}, {658790, 658799}, {658810, 658815}, + {658817, 658819}, {658821, 658838}, {658842, 658865}, + {658867, 658875}, {658877, 658877}, {658880, 658886}, + {658890, 658890}, {658895, 658900}, {658902, 658902}, + {658904, 658911}, {658918, 658927}, {658930, 658931}, + {658945, 659002}, {659008, 659022}, {659024, 659033}, + {659073, 659074}, {659076, 659076}, {659078, 659082}, + {659084, 659107}, {659109, 659109}, {659111, 659133}, + {659136, 659140}, {659142, 659142}, {659144, 659150}, + {659152, 659161}, {659164, 659167}, {659200, 659200}, + {659224, 659225}, {659232, 659241}, {659253, 659253}, + {659255, 659255}, {659257, 659257}, {659262, 659271}, + {659273, 659308}, {659313, 659332}, {659334, 659351}, + {659353, 659388}, {659398, 659398}, {659456, 659529}, + {659536, 659613}, {659616, 659653}, {659655, 659655}, + {659661, 659661}, {659664, 659706}, {659708, 660040}, + {660042, 660045}, {660048, 660054}, {660056, 660056}, + {660058, 660061}, {660064, 660104}, {660106, 660109}, + {660112, 660144}, {660146, 660149}, {660152, 660158}, + {660160, 660160}, {660162, 660165}, {660168, 660182}, + {660184, 660240}, {660242, 660245}, {660248, 660314}, + {660317, 660319}, {660329, 660337}, {660352, 660367}, + {660384, 660469}, {660472, 660477}, {660481, 661100}, + {661103, 661119}, {661121, 661146}, {661152, 661226}, + {661230, 661240}, {661248, 661269}, {661279, 661300}, + {661312, 661331}, {661344, 661356}, {661358, 661360}, + {661362, 661363}, {661376, 661459}, {661463, 661463}, + {661468, 661469}, {661472, 661481}, {661515, 661517}, + {661519, 661529}, {661536, 661624}, {661632, 661674}, + {661680, 661749}, {661760, 661790}, {661792, 661803}, + {661808, 661819}, {661830, 661869}, {661872, 661876}, + {661888, 661931}, {661936, 661961}, {661968, 661978}, + {662016, 662043}, {662048, 662110}, {662112, 662140}, + {662143, 662153}, {662160, 662169}, {662183, 662183}, + {662192, 662205}, {662207, 662222}, {662272, 662348}, + {662352, 662361}, {662379, 662387}, {662400, 662515}, + {662528, 662583}, {662592, 662601}, {662605, 662653}, + {662656, 662664}, {662672, 662714}, {662717, 662719}, + {662736, 662738}, {662740, 662778}, {662784, 663317}, + {663320, 663325}, {663328, 663365}, {663368, 663373}, + {663376, 663383}, {663385, 663385}, {663387, 663387}, + {663389, 663389}, {663391, 663421}, {663424, 663476}, + {663478, 663484}, {663486, 663486}, {663490, 663492}, + {663494, 663500}, {663504, 663507}, {663510, 663515}, + {663520, 663532}, {663538, 663540}, {663542, 663548}, + {663564, 663565}, {663615, 663616}, {663636, 663636}, + {663665, 663665}, {663679, 663679}, {663696, 663708}, + {663760, 663772}, {663777, 663777}, {663781, 663792}, + {663810, 663810}, {663815, 663815}, {663818, 663827}, + {663829, 663829}, {663832, 663837}, {663844, 663844}, + {663846, 663846}, {663848, 663848}, {663850, 663865}, + {663868, 663871}, {663877, 663881}, {663886, 663886}, + {663904, 663944}, {666624, 666852}, {666859, 666867}, + {666880, 666917}, {666919, 666919}, {666925, 666925}, + {666928, 666983}, {666991, 666991}, {667007, 667030}, + {667040, 667046}, {667048, 667054}, {667056, 667062}, + {667064, 667070}, {667072, 667078}, {667080, 667086}, + {667088, 667094}, {667096, 667102}, {667104, 667135}, + {667653, 667655}, {667681, 667695}, {667697, 667701}, + {667704, 667708}, {667713, 667798}, {667801, 667807}, + {667809, 667898}, {667900, 667903}, {667909, 667951}, + {667953, 668046}, {668064, 668095}, {668144, 668159}, + {668672, 675263}, {675328, 697484}, {697552, 697597}, + {697600, 697868}, {697872, 697899}, {697920, 697967}, + {697972, 697981}, {697983, 698097}, {698135, 698143}, + {698146, 698248}, {698251, 698314}, {698320, 698321}, + {698323, 698323}, {698325, 698329}, {698354, 698407}, + {698412, 698412}, {698432, 698483}, {698496, 698565}, + {698576, 698585}, {698592, 698615}, {698619, 698619}, + {698621, 698669}, {698672, 698707}, {698720, 698748}, + {698752, 698816}, {698831, 698841}, {698848, 698878}, + {698880, 698934}, {698944, 698957}, {698960, 698969}, + {698976, 698998}, {699002, 699074}, {699099, 699101}, + {699104, 699119}, {699122, 699126}, {699137, 699142}, + {699145, 699150}, {699153, 699158}, {699168, 699174}, + {699176, 699182}, {699184, 699226}, {699228, 699241}, + {699248, 699370}, {699372, 699373}, {699376, 699385}, + {699392, 710563}, {710576, 710598}, {710603, 710651}, + {719104, 719469}, {719472, 719577}, {719616, 719622}, + {719635, 719639}, {719645, 719656}, {719658, 719670}, + {719672, 719676}, {719678, 719678}, {719680, 719681}, + {719683, 719684}, {719686, 719793}, {719827, 720189}, + {720208, 720271}, {720274, 720327}, {720368, 720379}, + {720384, 720399}, {720416, 720431}, {720435, 720436}, + {720461, 720463}, {720496, 720500}, {720502, 720636}, + {720656, 720665}, {720673, 720698}, {720703, 720703}, + {720705, 720730}, {720742, 720830}, {720834, 720839}, + {720842, 720847}, {720850, 720855}, {720858, 720860}, + {720932, 720932}, {720944, 720953}, {720961, 720986}, + {720991, 720991}, {720993, 721018}, {721066, 721066}, + {721077, 721077}, {721079, 721079}, {721082, 721082}, + {721088, 721110}, {721112, 721142}, {721144, 721601}, + {721606, 721617}, {721632, 721636}, {721644, 721644}, + {721646, 721646}, {721664, 721780}, {721782, 721783}, + {721786, 721789}, {721791, 721791}, {721798, 721802}, + {721804, 721804}, {721806, 721825}, {721827, 721909}, + {721911, 722049}, {722051, 722055}, {722058, 722223}, + {722225, 722262}, {722265, 722265}, {722272, 722312}, + {722321, 722365}, {722367, 722367}, {722369, 722370}, + {722372, 722373}, {722375, 722375}, {722384, 722410}, + {722415, 722418}, {722448, 722458}, {722464, 722537}, + {722542, 722643}, {722645, 722652}, {722655, 722664}, + {722666, 722684}, {722687, 722687}, {722704, 722762}, + {722765, 722865}, {722880, 722933}, {722938, 722938}, + {722941, 722941}, {722944, 722989}, {723008, 723035}, + {723040, 723050}, {723056, 723079}, {723081, 723086}, + {723096, 723169}, {723171, 723299}, {723302, 723311}, + {723313, 723331}, {723333, 723340}, {723343, 723344}, + {723347, 723368}, {723370, 723376}, {723378, 723378}, + {723382, 723385}, {723388, 723396}, {723399, 723400}, + {723403, 723406}, {723415, 723415}, {723420, 723421}, + {723423, 723427}, {723430, 723441}, {723452, 723452}, + {723454, 723454}, {723457, 723459}, {723461, 723466}, + {723471, 723472}, {723475, 723496}, {723498, 723504}, + {723506, 723507}, {723509, 723510}, {723512, 723513}, + {723516, 723516}, {723518, 723522}, {723527, 723528}, + {723531, 723533}, {723537, 723537}, {723545, 723548}, + {723550, 723550}, {723558, 723573}, {723585, 723587}, + {723589, 723597}, {723599, 723601}, {723603, 723624}, + {723626, 723632}, {723634, 723635}, {723637, 723641}, + {723644, 723653}, {723655, 723657}, {723659, 723661}, + {723664, 723664}, {723680, 723683}, {723686, 723695}, + {723705, 723711}, {723713, 723715}, {723717, 723724}, + {723727, 723728}, {723731, 723752}, {723754, 723760}, + {723762, 723763}, {723765, 723769}, {723772, 723780}, + {723783, 723784}, {723787, 723789}, {723797, 723799}, + {723804, 723805}, {723807, 723811}, {723814, 723823}, + {723825, 723825}, {723842, 723843}, {723845, 723850}, + {723854, 723856}, {723858, 723861}, {723865, 723866}, + {723868, 723868}, {723870, 723871}, {723875, 723876}, + {723880, 723882}, {723886, 723897}, {723902, 723906}, + {723910, 723912}, {723914, 723917}, {723920, 723920}, + {723927, 723927}, {723942, 723951}, {723968, 723980}, + {723982, 723984}, {723986, 724008}, {724010, 724025}, + {724028, 724036}, {724038, 724040}, {724042, 724045}, + {724053, 724054}, {724056, 724058}, {724061, 724061}, + {724064, 724067}, {724070, 724079}, {724096, 724099}, + {724101, 724108}, {724110, 724112}, {724114, 724136}, + {724138, 724147}, {724149, 724153}, {724156, 724164}, + {724166, 724168}, {724170, 724173}, {724181, 724182}, + {724189, 724190}, {724192, 724195}, {724198, 724207}, + {724209, 724211}, {724224, 724236}, {724238, 724240}, + {724242, 724292}, {724294, 724296}, {724298, 724302}, + {724308, 724311}, {724319, 724323}, {724326, 724335}, + {724346, 724351}, {724353, 724355}, {724357, 724374}, + {724378, 724401}, {724403, 724411}, {724413, 724413}, + {724416, 724422}, {724426, 724426}, {724431, 724436}, + {724438, 724438}, {724440, 724447}, {724454, 724463}, + {724466, 724467}, {724481, 724538}, {724544, 724558}, + {724560, 724569}, {724609, 724610}, {724612, 724612}, + {724614, 724618}, {724620, 724643}, {724645, 724645}, + {724647, 724669}, {724672, 724676}, {724678, 724678}, + {724680, 724686}, {724688, 724697}, {724700, 724703}, + {724736, 724736}, {724760, 724761}, {724768, 724777}, + {724789, 724789}, {724791, 724791}, {724793, 724793}, + {724798, 724807}, {724809, 724844}, {724849, 724868}, + {724870, 724887}, {724889, 724924}, {724934, 724934}, + {724992, 725065}, {725072, 725149}, {725152, 725189}, + {725191, 725191}, {725197, 725197}, {725200, 725242}, + {725244, 725576}, {725578, 725581}, {725584, 725590}, + {725592, 725592}, {725594, 725597}, {725600, 725640}, + {725642, 725645}, {725648, 725680}, {725682, 725685}, + {725688, 725694}, {725696, 725696}, {725698, 725701}, + {725704, 725718}, {725720, 725776}, {725778, 725781}, + {725784, 725850}, {725853, 725855}, {725865, 725873}, + {725888, 725903}, {725920, 726005}, {726008, 726013}, + {726017, 726636}, {726639, 726655}, {726657, 726682}, + {726688, 726762}, {726766, 726776}, {726784, 726805}, + {726815, 726836}, {726848, 726867}, {726880, 726892}, + {726894, 726896}, {726898, 726899}, {726912, 726995}, + {726999, 726999}, {727004, 727005}, {727008, 727017}, + {727051, 727053}, {727055, 727065}, {727072, 727160}, + {727168, 727210}, {727216, 727285}, {727296, 727326}, + {727328, 727339}, {727344, 727355}, {727366, 727405}, + {727408, 727412}, {727424, 727467}, {727472, 727497}, + {727504, 727514}, {727552, 727579}, {727584, 727646}, + {727648, 727676}, {727679, 727689}, {727696, 727705}, + {727719, 727719}, {727728, 727741}, {727743, 727758}, + {727808, 727884}, {727888, 727897}, {727915, 727923}, + {727936, 728051}, {728064, 728119}, {728128, 728137}, + {728141, 728189}, {728192, 728200}, {728208, 728250}, + {728253, 728255}, {728272, 728274}, {728276, 728314}, + {728320, 728853}, {728856, 728861}, {728864, 728901}, + {728904, 728909}, {728912, 728919}, {728921, 728921}, + {728923, 728923}, {728925, 728925}, {728927, 728957}, + {728960, 729012}, {729014, 729020}, {729022, 729022}, + {729026, 729028}, {729030, 729036}, {729040, 729043}, + {729046, 729051}, {729056, 729068}, {729074, 729076}, + {729078, 729084}, {729100, 729101}, {729151, 729152}, + {729172, 729172}, {729201, 729201}, {729215, 729215}, + {729232, 729244}, {729296, 729308}, {729313, 729313}, + {729317, 729328}, {729346, 729346}, {729351, 729351}, + {729354, 729363}, {729365, 729365}, {729368, 729373}, + {729380, 729380}, {729382, 729382}, {729384, 729384}, + {729386, 729401}, {729404, 729407}, {729413, 729417}, + {729422, 729422}, {729440, 729480}, {732160, 732388}, + {732395, 732403}, {732416, 732453}, {732455, 732455}, + {732461, 732461}, {732464, 732519}, {732527, 732527}, + {732543, 732566}, {732576, 732582}, {732584, 732590}, + {732592, 732598}, {732600, 732606}, {732608, 732614}, + {732616, 732622}, {732624, 732630}, {732632, 732638}, + {732640, 732671}, {733189, 733191}, {733217, 733231}, + {733233, 733237}, {733240, 733244}, {733249, 733334}, + {733337, 733343}, {733345, 733434}, {733436, 733439}, + {733445, 733487}, {733489, 733582}, {733600, 733631}, + {733680, 733695}, {734208, 740799}, {740864, 763020}, + {763088, 763133}, {763136, 763404}, {763408, 763435}, + {763456, 763503}, {763508, 763517}, {763519, 763633}, + {763671, 763679}, {763682, 763784}, {763787, 763850}, + {763856, 763857}, {763859, 763859}, {763861, 763865}, + {763890, 763943}, {763948, 763948}, {763968, 764019}, + {764032, 764101}, {764112, 764121}, {764128, 764151}, + {764155, 764155}, {764157, 764205}, {764208, 764243}, + {764256, 764284}, {764288, 764352}, {764367, 764377}, + {764384, 764414}, {764416, 764470}, {764480, 764493}, + {764496, 764505}, {764512, 764534}, {764538, 764610}, + {764635, 764637}, {764640, 764655}, {764658, 764662}, + {764673, 764678}, {764681, 764686}, {764689, 764694}, + {764704, 764710}, {764712, 764718}, {764720, 764762}, + {764764, 764777}, {764784, 764906}, {764908, 764909}, + {764912, 764921}, {764928, 776099}, {776112, 776134}, + {776139, 776187}, {784640, 785005}, {785008, 785113}, + {785152, 785158}, {785171, 785175}, {785181, 785192}, + {785194, 785206}, {785208, 785212}, {785214, 785214}, + {785216, 785217}, {785219, 785220}, {785222, 785329}, + {785363, 785725}, {785744, 785807}, {785810, 785863}, + {785904, 785915}, {785920, 785935}, {785952, 785967}, + {785971, 785972}, {785997, 785999}, {786032, 786036}, + {786038, 786172}, {786192, 786201}, {786209, 786234}, + {786239, 786239}, {786241, 786266}, {786278, 786366}, + {786370, 786375}, {786378, 786383}, {786386, 786391}, + {786394, 786396}, {786468, 786468}, {786480, 786489}, + {786497, 786522}, {786527, 786527}, {786529, 786554}, + {786602, 786602}, {786613, 786613}, {786615, 786615}, + {786618, 786618}, {786624, 786646}, {786648, 786678}, + {786680, 787137}, {787142, 787153}, {787168, 787172}, + {787180, 787180}, {787182, 787182}, {787200, 787316}, + {787318, 787319}, {787322, 787325}, {787327, 787327}, + {787334, 787338}, {787340, 787340}, {787342, 787361}, + {787363, 787445}, {787447, 787585}, {787587, 787591}, + {787594, 787759}, {787761, 787798}, {787801, 787801}, + {787808, 787848}, {787857, 787901}, {787903, 787903}, + {787905, 787906}, {787908, 787909}, {787911, 787911}, + {787920, 787946}, {787951, 787954}, {787984, 787994}, + {788000, 788073}, {788078, 788179}, {788181, 788188}, + {788191, 788200}, {788202, 788220}, {788223, 788223}, + {788240, 788298}, {788301, 788401}, {788416, 788469}, + {788474, 788474}, {788477, 788477}, {788480, 788525}, + {788544, 788571}, {788576, 788586}, {788592, 788615}, + {788617, 788622}, {788632, 788705}, {788707, 788835}, + {788838, 788847}, {788849, 788867}, {788869, 788876}, + {788879, 788880}, {788883, 788904}, {788906, 788912}, + {788914, 788914}, {788918, 788921}, {788924, 788932}, + {788935, 788936}, {788939, 788942}, {788951, 788951}, + {788956, 788957}, {788959, 788963}, {788966, 788977}, + {788988, 788988}, {788990, 788990}, {788993, 788995}, + {788997, 789002}, {789007, 789008}, {789011, 789032}, + {789034, 789040}, {789042, 789043}, {789045, 789046}, + {789048, 789049}, {789052, 789052}, {789054, 789058}, + {789063, 789064}, {789067, 789069}, {789073, 789073}, + {789081, 789084}, {789086, 789086}, {789094, 789109}, + {789121, 789123}, {789125, 789133}, {789135, 789137}, + {789139, 789160}, {789162, 789168}, {789170, 789171}, + {789173, 789177}, {789180, 789189}, {789191, 789193}, + {789195, 789197}, {789200, 789200}, {789216, 789219}, + {789222, 789231}, {789241, 789247}, {789249, 789251}, + {789253, 789260}, {789263, 789264}, {789267, 789288}, + {789290, 789296}, {789298, 789299}, {789301, 789305}, + {789308, 789316}, {789319, 789320}, {789323, 789325}, + {789333, 789335}, {789340, 789341}, {789343, 789347}, + {789350, 789359}, {789361, 789361}, {789378, 789379}, + {789381, 789386}, {789390, 789392}, {789394, 789397}, + {789401, 789402}, {789404, 789404}, {789406, 789407}, + {789411, 789412}, {789416, 789418}, {789422, 789433}, + {789438, 789442}, {789446, 789448}, {789450, 789453}, + {789456, 789456}, {789463, 789463}, {789478, 789487}, + {789504, 789516}, {789518, 789520}, {789522, 789544}, + {789546, 789561}, {789564, 789572}, {789574, 789576}, + {789578, 789581}, {789589, 789590}, {789592, 789594}, + {789597, 789597}, {789600, 789603}, {789606, 789615}, + {789632, 789635}, {789637, 789644}, {789646, 789648}, + {789650, 789672}, {789674, 789683}, {789685, 789689}, + {789692, 789700}, {789702, 789704}, {789706, 789709}, + {789717, 789718}, {789725, 789726}, {789728, 789731}, + {789734, 789743}, {789745, 789747}, {789760, 789772}, + {789774, 789776}, {789778, 789828}, {789830, 789832}, + {789834, 789838}, {789844, 789847}, {789855, 789859}, + {789862, 789871}, {789882, 789887}, {789889, 789891}, + {789893, 789910}, {789914, 789937}, {789939, 789947}, + {789949, 789949}, {789952, 789958}, {789962, 789962}, + {789967, 789972}, {789974, 789974}, {789976, 789983}, + {789990, 789999}, {790002, 790003}, {790017, 790074}, + {790080, 790094}, {790096, 790105}, {790145, 790146}, + {790148, 790148}, {790150, 790154}, {790156, 790179}, + {790181, 790181}, {790183, 790205}, {790208, 790212}, + {790214, 790214}, {790216, 790222}, {790224, 790233}, + {790236, 790239}, {790272, 790272}, {790296, 790297}, + {790304, 790313}, {790325, 790325}, {790327, 790327}, + {790329, 790329}, {790334, 790343}, {790345, 790380}, + {790385, 790404}, {790406, 790423}, {790425, 790460}, + {790470, 790470}, {790528, 790601}, {790608, 790685}, + {790688, 790725}, {790727, 790727}, {790733, 790733}, + {790736, 790778}, {790780, 791112}, {791114, 791117}, + {791120, 791126}, {791128, 791128}, {791130, 791133}, + {791136, 791176}, {791178, 791181}, {791184, 791216}, + {791218, 791221}, {791224, 791230}, {791232, 791232}, + {791234, 791237}, {791240, 791254}, {791256, 791312}, + {791314, 791317}, {791320, 791386}, {791389, 791391}, + {791401, 791409}, {791424, 791439}, {791456, 791541}, + {791544, 791549}, {791553, 792172}, {792175, 792191}, + {792193, 792218}, {792224, 792298}, {792302, 792312}, + {792320, 792341}, {792351, 792372}, {792384, 792403}, + {792416, 792428}, {792430, 792432}, {792434, 792435}, + {792448, 792531}, {792535, 792535}, {792540, 792541}, + {792544, 792553}, {792587, 792589}, {792591, 792601}, + {792608, 792696}, {792704, 792746}, {792752, 792821}, + {792832, 792862}, {792864, 792875}, {792880, 792891}, + {792902, 792941}, {792944, 792948}, {792960, 793003}, + {793008, 793033}, {793040, 793050}, {793088, 793115}, + {793120, 793182}, {793184, 793212}, {793215, 793225}, + {793232, 793241}, {793255, 793255}, {793264, 793277}, + {793279, 793294}, {793344, 793420}, {793424, 793433}, + {793451, 793459}, {793472, 793587}, {793600, 793655}, + {793664, 793673}, {793677, 793725}, {793728, 793736}, + {793744, 793786}, {793789, 793791}, {793808, 793810}, + {793812, 793850}, {793856, 794389}, {794392, 794397}, + {794400, 794437}, {794440, 794445}, {794448, 794455}, + {794457, 794457}, {794459, 794459}, {794461, 794461}, + {794463, 794493}, {794496, 794548}, {794550, 794556}, + {794558, 794558}, {794562, 794564}, {794566, 794572}, + {794576, 794579}, {794582, 794587}, {794592, 794604}, + {794610, 794612}, {794614, 794620}, {794636, 794637}, + {794687, 794688}, {794708, 794708}, {794737, 794737}, + {794751, 794751}, {794768, 794780}, {794832, 794844}, + {794849, 794849}, {794853, 794864}, {794882, 794882}, + {794887, 794887}, {794890, 794899}, {794901, 794901}, + {794904, 794909}, {794916, 794916}, {794918, 794918}, + {794920, 794920}, {794922, 794937}, {794940, 794943}, + {794949, 794953}, {794958, 794958}, {794976, 795016}, + {797696, 797924}, {797931, 797939}, {797952, 797989}, + {797991, 797991}, {797997, 797997}, {798000, 798055}, + {798063, 798063}, {798079, 798102}, {798112, 798118}, + {798120, 798126}, {798128, 798134}, {798136, 798142}, + {798144, 798150}, {798152, 798158}, {798160, 798166}, + {798168, 798174}, {798176, 798207}, {798725, 798727}, + {798753, 798767}, {798769, 798773}, {798776, 798780}, + {798785, 798870}, {798873, 798879}, {798881, 798970}, + {798972, 798975}, {798981, 799023}, {799025, 799118}, + {799136, 799167}, {799216, 799231}, {799744, 806335}, + {806400, 828556}, {828624, 828669}, {828672, 828940}, + {828944, 828971}, {828992, 829039}, {829044, 829053}, + {829055, 829169}, {829207, 829215}, {829218, 829320}, + {829323, 829386}, {829392, 829393}, {829395, 829395}, + {829397, 829401}, {829426, 829479}, {829484, 829484}, + {829504, 829555}, {829568, 829637}, {829648, 829657}, + {829664, 829687}, {829691, 829691}, {829693, 829741}, + {829744, 829779}, {829792, 829820}, {829824, 829888}, + {829903, 829913}, {829920, 829950}, {829952, 830006}, + {830016, 830029}, {830032, 830041}, {830048, 830070}, + {830074, 830146}, {830171, 830173}, {830176, 830191}, + {830194, 830198}, {830209, 830214}, {830217, 830222}, + {830225, 830230}, {830240, 830246}, {830248, 830254}, + {830256, 830298}, {830300, 830313}, {830320, 830442}, + {830444, 830445}, {830448, 830457}, {830464, 841635}, + {841648, 841670}, {841675, 841723}, {850176, 850541}, + {850544, 850649}, {850688, 850694}, {850707, 850711}, + {850717, 850728}, {850730, 850742}, {850744, 850748}, + {850750, 850750}, {850752, 850753}, {850755, 850756}, + {850758, 850865}, {850899, 851261}, {851280, 851343}, + {851346, 851399}, {851440, 851451}, {851456, 851471}, + {851488, 851503}, {851507, 851508}, {851533, 851535}, + {851568, 851572}, {851574, 851708}, {851728, 851737}, + {851745, 851770}, {851775, 851775}, {851777, 851802}, + {851814, 851902}, {851906, 851911}, {851914, 851919}, + {851922, 851927}, {851930, 851932}, {852004, 852004}, + {852016, 852025}, {852033, 852058}, {852063, 852063}, + {852065, 852090}, {852138, 852138}, {852149, 852149}, + {852151, 852151}, {852154, 852154}, {852160, 852182}, + {852184, 852214}, {852216, 852673}, {852678, 852689}, + {852704, 852708}, {852716, 852716}, {852718, 852718}, + {852736, 852852}, {852854, 852855}, {852858, 852861}, + {852863, 852863}, {852870, 852874}, {852876, 852876}, + {852878, 852897}, {852899, 852981}, {852983, 853121}, + {853123, 853127}, {853130, 853295}, {853297, 853334}, + {853337, 853337}, {853344, 853384}, {853393, 853437}, + {853439, 853439}, {853441, 853442}, {853444, 853445}, + {853447, 853447}, {853456, 853482}, {853487, 853490}, + {853520, 853530}, {853536, 853609}, {853614, 853715}, + {853717, 853724}, {853727, 853736}, {853738, 853756}, + {853759, 853759}, {853776, 853834}, {853837, 853937}, + {853952, 854005}, {854010, 854010}, {854013, 854013}, + {854016, 854061}, {854080, 854107}, {854112, 854122}, + {854128, 854151}, {854153, 854158}, {854168, 854241}, + {854243, 854371}, {854374, 854383}, {854385, 854403}, + {854405, 854412}, {854415, 854416}, {854419, 854440}, + {854442, 854448}, {854450, 854450}, {854454, 854457}, + {854460, 854468}, {854471, 854472}, {854475, 854478}, + {854487, 854487}, {854492, 854493}, {854495, 854499}, + {854502, 854513}, {854524, 854524}, {854526, 854526}, + {854529, 854531}, {854533, 854538}, {854543, 854544}, + {854547, 854568}, {854570, 854576}, {854578, 854579}, + {854581, 854582}, {854584, 854585}, {854588, 854588}, + {854590, 854594}, {854599, 854600}, {854603, 854605}, + {854609, 854609}, {854617, 854620}, {854622, 854622}, + {854630, 854645}, {854657, 854659}, {854661, 854669}, + {854671, 854673}, {854675, 854696}, {854698, 854704}, + {854706, 854707}, {854709, 854713}, {854716, 854725}, + {854727, 854729}, {854731, 854733}, {854736, 854736}, + {854752, 854755}, {854758, 854767}, {854777, 854783}, + {854785, 854787}, {854789, 854796}, {854799, 854800}, + {854803, 854824}, {854826, 854832}, {854834, 854835}, + {854837, 854841}, {854844, 854852}, {854855, 854856}, + {854859, 854861}, {854869, 854871}, {854876, 854877}, + {854879, 854883}, {854886, 854895}, {854897, 854897}, + {854914, 854915}, {854917, 854922}, {854926, 854928}, + {854930, 854933}, {854937, 854938}, {854940, 854940}, + {854942, 854943}, {854947, 854948}, {854952, 854954}, + {854958, 854969}, {854974, 854978}, {854982, 854984}, + {854986, 854989}, {854992, 854992}, {854999, 854999}, + {855014, 855023}, {855040, 855052}, {855054, 855056}, + {855058, 855080}, {855082, 855097}, {855100, 855108}, + {855110, 855112}, {855114, 855117}, {855125, 855126}, + {855128, 855130}, {855133, 855133}, {855136, 855139}, + {855142, 855151}, {855168, 855171}, {855173, 855180}, + {855182, 855184}, {855186, 855208}, {855210, 855219}, + {855221, 855225}, {855228, 855236}, {855238, 855240}, + {855242, 855245}, {855253, 855254}, {855261, 855262}, + {855264, 855267}, {855270, 855279}, {855281, 855283}, + {855296, 855308}, {855310, 855312}, {855314, 855364}, + {855366, 855368}, {855370, 855374}, {855380, 855383}, + {855391, 855395}, {855398, 855407}, {855418, 855423}, + {855425, 855427}, {855429, 855446}, {855450, 855473}, + {855475, 855483}, {855485, 855485}, {855488, 855494}, + {855498, 855498}, {855503, 855508}, {855510, 855510}, + {855512, 855519}, {855526, 855535}, {855538, 855539}, + {855553, 855610}, {855616, 855630}, {855632, 855641}, + {855681, 855682}, {855684, 855684}, {855686, 855690}, + {855692, 855715}, {855717, 855717}, {855719, 855741}, + {855744, 855748}, {855750, 855750}, {855752, 855758}, + {855760, 855769}, {855772, 855775}, {855808, 855808}, + {855832, 855833}, {855840, 855849}, {855861, 855861}, + {855863, 855863}, {855865, 855865}, {855870, 855879}, + {855881, 855916}, {855921, 855940}, {855942, 855959}, + {855961, 855996}, {856006, 856006}, {856064, 856137}, + {856144, 856221}, {856224, 856261}, {856263, 856263}, + {856269, 856269}, {856272, 856314}, {856316, 856648}, + {856650, 856653}, {856656, 856662}, {856664, 856664}, + {856666, 856669}, {856672, 856712}, {856714, 856717}, + {856720, 856752}, {856754, 856757}, {856760, 856766}, + {856768, 856768}, {856770, 856773}, {856776, 856790}, + {856792, 856848}, {856850, 856853}, {856856, 856922}, + {856925, 856927}, {856937, 856945}, {856960, 856975}, + {856992, 857077}, {857080, 857085}, {857089, 857708}, + {857711, 857727}, {857729, 857754}, {857760, 857834}, + {857838, 857848}, {857856, 857877}, {857887, 857908}, + {857920, 857939}, {857952, 857964}, {857966, 857968}, + {857970, 857971}, {857984, 858067}, {858071, 858071}, + {858076, 858077}, {858080, 858089}, {858123, 858125}, + {858127, 858137}, {858144, 858232}, {858240, 858282}, + {858288, 858357}, {858368, 858398}, {858400, 858411}, + {858416, 858427}, {858438, 858477}, {858480, 858484}, + {858496, 858539}, {858544, 858569}, {858576, 858586}, + {858624, 858651}, {858656, 858718}, {858720, 858748}, + {858751, 858761}, {858768, 858777}, {858791, 858791}, + {858800, 858813}, {858815, 858830}, {858880, 858956}, + {858960, 858969}, {858987, 858995}, {859008, 859123}, + {859136, 859191}, {859200, 859209}, {859213, 859261}, + {859264, 859272}, {859280, 859322}, {859325, 859327}, + {859344, 859346}, {859348, 859386}, {859392, 859925}, + {859928, 859933}, {859936, 859973}, {859976, 859981}, + {859984, 859991}, {859993, 859993}, {859995, 859995}, + {859997, 859997}, {859999, 860029}, {860032, 860084}, + {860086, 860092}, {860094, 860094}, {860098, 860100}, + {860102, 860108}, {860112, 860115}, {860118, 860123}, + {860128, 860140}, {860146, 860148}, {860150, 860156}, + {860172, 860173}, {860223, 860224}, {860244, 860244}, + {860273, 860273}, {860287, 860287}, {860304, 860316}, + {860368, 860380}, {860385, 860385}, {860389, 860400}, + {860418, 860418}, {860423, 860423}, {860426, 860435}, + {860437, 860437}, {860440, 860445}, {860452, 860452}, + {860454, 860454}, {860456, 860456}, {860458, 860473}, + {860476, 860479}, {860485, 860489}, {860494, 860494}, + {860512, 860552}, {863232, 863460}, {863467, 863475}, + {863488, 863525}, {863527, 863527}, {863533, 863533}, + {863536, 863591}, {863599, 863599}, {863615, 863638}, + {863648, 863654}, {863656, 863662}, {863664, 863670}, + {863672, 863678}, {863680, 863686}, {863688, 863694}, + {863696, 863702}, {863704, 863710}, {863712, 863743}, + {864261, 864263}, {864289, 864303}, {864305, 864309}, + {864312, 864316}, {864321, 864406}, {864409, 864415}, + {864417, 864506}, {864508, 864511}, {864517, 864559}, + {864561, 864654}, {864672, 864703}, {864752, 864767}, + {865280, 871871}, {871936, 894092}, {894160, 894205}, + {894208, 894476}, {894480, 894507}, {894528, 894575}, + {894580, 894589}, {894591, 894705}, {894743, 894751}, + {894754, 894856}, {894859, 894922}, {894928, 894929}, + {894931, 894931}, {894933, 894937}, {894962, 895015}, + {895020, 895020}, {895040, 895091}, {895104, 895173}, + {895184, 895193}, {895200, 895223}, {895227, 895227}, + {895229, 895277}, {895280, 895315}, {895328, 895356}, + {895360, 895424}, {895439, 895449}, {895456, 895486}, + {895488, 895542}, {895552, 895565}, {895568, 895577}, + {895584, 895606}, {895610, 895682}, {895707, 895709}, + {895712, 895727}, {895730, 895734}, {895745, 895750}, + {895753, 895758}, {895761, 895766}, {895776, 895782}, + {895784, 895790}, {895792, 895834}, {895836, 895849}, + {895856, 895978}, {895980, 895981}, {895984, 895993}, + {896000, 907171}, {907184, 907206}, {907211, 907259}, + {915712, 916077}, {916080, 916185}, {916224, 916230}, + {916243, 916247}, {916253, 916264}, {916266, 916278}, + {916280, 916284}, {916286, 916286}, {916288, 916289}, + {916291, 916292}, {916294, 916401}, {916435, 916797}, + {916816, 916879}, {916882, 916935}, {916976, 916987}, + {916992, 917007}, {917024, 917039}, {917043, 917044}, + {917069, 917071}, {917104, 917108}, {917110, 917244}, + {917264, 917273}, {917281, 917306}, {917311, 917311}, + {917313, 917338}, {917350, 917438}, {917442, 917447}, + {917450, 917455}, {917458, 917463}, {917466, 917468}, + {917540, 917540}, {917552, 917561}, {917569, 917594}, + {917599, 917599}, {917601, 917626}, {917674, 917674}, + {917685, 917685}, {917687, 917687}, {917690, 917690}, + {917696, 917718}, {917720, 917750}, {917752, 918209}, + {918214, 918225}, {918240, 918244}, {918252, 918252}, + {918254, 918254}, {918272, 918388}, {918390, 918391}, + {918394, 918397}, {918399, 918399}, {918406, 918410}, + {918412, 918412}, {918414, 918433}, {918435, 918517}, + {918519, 918657}, {918659, 918663}, {918666, 918831}, + {918833, 918870}, {918873, 918873}, {918880, 918920}, + {918929, 918973}, {918975, 918975}, {918977, 918978}, + {918980, 918981}, {918983, 918983}, {918992, 919018}, + {919023, 919026}, {919056, 919066}, {919072, 919145}, + {919150, 919251}, {919253, 919260}, {919263, 919272}, + {919274, 919292}, {919295, 919295}, {919312, 919370}, + {919373, 919473}, {919488, 919541}, {919546, 919546}, + {919549, 919549}, {919552, 919597}, {919616, 919643}, + {919648, 919658}, {919664, 919687}, {919689, 919694}, + {919704, 919777}, {919779, 919907}, {919910, 919919}, + {919921, 919939}, {919941, 919948}, {919951, 919952}, + {919955, 919976}, {919978, 919984}, {919986, 919986}, + {919990, 919993}, {919996, 920004}, {920007, 920008}, + {920011, 920014}, {920023, 920023}, {920028, 920029}, + {920031, 920035}, {920038, 920049}, {920060, 920060}, + {920062, 920062}, {920065, 920067}, {920069, 920074}, + {920079, 920080}, {920083, 920104}, {920106, 920112}, + {920114, 920115}, {920117, 920118}, {920120, 920121}, + {920124, 920124}, {920126, 920130}, {920135, 920136}, + {920139, 920141}, {920145, 920145}, {920153, 920156}, + {920158, 920158}, {920166, 920181}, {920193, 920195}, + {920197, 920205}, {920207, 920209}, {920211, 920232}, + {920234, 920240}, {920242, 920243}, {920245, 920249}, + {920252, 920261}, {920263, 920265}, {920267, 920269}, + {920272, 920272}, {920288, 920291}, {920294, 920303}, + {920313, 920319}, {920321, 920323}, {920325, 920332}, + {920335, 920336}, {920339, 920360}, {920362, 920368}, + {920370, 920371}, {920373, 920377}, {920380, 920388}, + {920391, 920392}, {920395, 920397}, {920405, 920407}, + {920412, 920413}, {920415, 920419}, {920422, 920431}, + {920433, 920433}, {920450, 920451}, {920453, 920458}, + {920462, 920464}, {920466, 920469}, {920473, 920474}, + {920476, 920476}, {920478, 920479}, {920483, 920484}, + {920488, 920490}, {920494, 920505}, {920510, 920514}, + {920518, 920520}, {920522, 920525}, {920528, 920528}, + {920535, 920535}, {920550, 920559}, {920576, 920588}, + {920590, 920592}, {920594, 920616}, {920618, 920633}, + {920636, 920644}, {920646, 920648}, {920650, 920653}, + {920661, 920662}, {920664, 920666}, {920669, 920669}, + {920672, 920675}, {920678, 920687}, {920704, 920707}, + {920709, 920716}, {920718, 920720}, {920722, 920744}, + {920746, 920755}, {920757, 920761}, {920764, 920772}, + {920774, 920776}, {920778, 920781}, {920789, 920790}, + {920797, 920798}, {920800, 920803}, {920806, 920815}, + {920817, 920819}, {920832, 920844}, {920846, 920848}, + {920850, 920900}, {920902, 920904}, {920906, 920910}, + {920916, 920919}, {920927, 920931}, {920934, 920943}, + {920954, 920959}, {920961, 920963}, {920965, 920982}, + {920986, 921009}, {921011, 921019}, {921021, 921021}, + {921024, 921030}, {921034, 921034}, {921039, 921044}, + {921046, 921046}, {921048, 921055}, {921062, 921071}, + {921074, 921075}, {921089, 921146}, {921152, 921166}, + {921168, 921177}, {921217, 921218}, {921220, 921220}, + {921222, 921226}, {921228, 921251}, {921253, 921253}, + {921255, 921277}, {921280, 921284}, {921286, 921286}, + {921288, 921294}, {921296, 921305}, {921308, 921311}, + {921344, 921344}, {921368, 921369}, {921376, 921385}, + {921397, 921397}, {921399, 921399}, {921401, 921401}, + {921406, 921415}, {921417, 921452}, {921457, 921476}, + {921478, 921495}, {921497, 921532}, {921542, 921542}, + {921600, 921673}, {921680, 921757}, {921760, 921797}, + {921799, 921799}, {921805, 921805}, {921808, 921850}, + {921852, 922184}, {922186, 922189}, {922192, 922198}, + {922200, 922200}, {922202, 922205}, {922208, 922248}, + {922250, 922253}, {922256, 922288}, {922290, 922293}, + {922296, 922302}, {922304, 922304}, {922306, 922309}, + {922312, 922326}, {922328, 922384}, {922386, 922389}, + {922392, 922458}, {922461, 922463}, {922473, 922481}, + {922496, 922511}, {922528, 922613}, {922616, 922621}, + {922625, 923244}, {923247, 923263}, {923265, 923290}, + {923296, 923370}, {923374, 923384}, {923392, 923413}, + {923423, 923444}, {923456, 923475}, {923488, 923500}, + {923502, 923504}, {923506, 923507}, {923520, 923603}, + {923607, 923607}, {923612, 923613}, {923616, 923625}, + {923659, 923661}, {923663, 923673}, {923680, 923768}, + {923776, 923818}, {923824, 923893}, {923904, 923934}, + {923936, 923947}, {923952, 923963}, {923974, 924013}, + {924016, 924020}, {924032, 924075}, {924080, 924105}, + {924112, 924122}, {924160, 924187}, {924192, 924254}, + {924256, 924284}, {924287, 924297}, {924304, 924313}, + {924327, 924327}, {924336, 924349}, {924351, 924366}, + {924416, 924492}, {924496, 924505}, {924523, 924531}, + {924544, 924659}, {924672, 924727}, {924736, 924745}, + {924749, 924797}, {924800, 924808}, {924816, 924858}, + {924861, 924863}, {924880, 924882}, {924884, 924922}, + {924928, 925461}, {925464, 925469}, {925472, 925509}, + {925512, 925517}, {925520, 925527}, {925529, 925529}, + {925531, 925531}, {925533, 925533}, {925535, 925565}, + {925568, 925620}, {925622, 925628}, {925630, 925630}, + {925634, 925636}, {925638, 925644}, {925648, 925651}, + {925654, 925659}, {925664, 925676}, {925682, 925684}, + {925686, 925692}, {925708, 925709}, {925759, 925760}, + {925780, 925780}, {925809, 925809}, {925823, 925823}, + {925840, 925852}, {925904, 925916}, {925921, 925921}, + {925925, 925936}, {925954, 925954}, {925959, 925959}, + {925962, 925971}, {925973, 925973}, {925976, 925981}, + {925988, 925988}, {925990, 925990}, {925992, 925992}, + {925994, 926009}, {926012, 926015}, {926021, 926025}, + {926030, 926030}, {926048, 926088}, {928768, 928996}, + {929003, 929011}, {929024, 929061}, {929063, 929063}, + {929069, 929069}, {929072, 929127}, {929135, 929135}, + {929151, 929174}, {929184, 929190}, {929192, 929198}, + {929200, 929206}, {929208, 929214}, {929216, 929222}, + {929224, 929230}, {929232, 929238}, {929240, 929246}, + {929248, 929279}, {929797, 929799}, {929825, 929839}, + {929841, 929845}, {929848, 929852}, {929857, 929942}, + {929945, 929951}, {929953, 930042}, {930044, 930047}, + {930053, 930095}, {930097, 930190}, {930208, 930239}, + {930288, 930303}, {930816, 937407}, {937472, 959628}, + {959696, 959741}, {959744, 960012}, {960016, 960043}, + {960064, 960111}, {960116, 960125}, {960127, 960241}, + {960279, 960287}, {960290, 960392}, {960395, 960458}, + {960464, 960465}, {960467, 960467}, {960469, 960473}, + {960498, 960551}, {960556, 960556}, {960576, 960627}, + {960640, 960709}, {960720, 960729}, {960736, 960759}, + {960763, 960763}, {960765, 960813}, {960816, 960851}, + {960864, 960892}, {960896, 960960}, {960975, 960985}, + {960992, 961022}, {961024, 961078}, {961088, 961101}, + {961104, 961113}, {961120, 961142}, {961146, 961218}, + {961243, 961245}, {961248, 961263}, {961266, 961270}, + {961281, 961286}, {961289, 961294}, {961297, 961302}, + {961312, 961318}, {961320, 961326}, {961328, 961370}, + {961372, 961385}, {961392, 961514}, {961516, 961517}, + {961520, 961529}, {961536, 972707}, {972720, 972742}, + {972747, 972795}, {981248, 981613}, {981616, 981721}, + {981760, 981766}, {981779, 981783}, {981789, 981800}, + {981802, 981814}, {981816, 981820}, {981822, 981822}, + {981824, 981825}, {981827, 981828}, {981830, 981937}, + {981971, 982333}, {982352, 982415}, {982418, 982471}, + {982512, 982523}, {982528, 982543}, {982560, 982575}, + {982579, 982580}, {982605, 982607}, {982640, 982644}, + {982646, 982780}, {982800, 982809}, {982817, 982842}, + {982847, 982847}, {982849, 982874}, {982886, 982974}, + {982978, 982983}, {982986, 982991}, {982994, 982999}, + {983002, 983004}, {983076, 983076}, {983088, 983097}, + {983105, 983130}, {983135, 983135}, {983137, 983162}, + {983210, 983210}, {983221, 983221}, {983223, 983223}, + {983226, 983226}, {983232, 983254}, {983256, 983286}, + {983288, 983745}, {983750, 983761}, {983776, 983780}, + {983788, 983788}, {983790, 983790}, {983808, 983924}, + {983926, 983927}, {983930, 983933}, {983935, 983935}, + {983942, 983946}, {983948, 983948}, {983950, 983969}, + {983971, 984053}, {984055, 984193}, {984195, 984199}, + {984202, 984367}, {984369, 984406}, {984409, 984409}, + {984416, 984456}, {984465, 984509}, {984511, 984511}, + {984513, 984514}, {984516, 984517}, {984519, 984519}, + {984528, 984554}, {984559, 984562}, {984592, 984602}, + {984608, 984681}, {984686, 984787}, {984789, 984796}, + {984799, 984808}, {984810, 984828}, {984831, 984831}, + {984848, 984906}, {984909, 985009}, {985024, 985077}, + {985082, 985082}, {985085, 985085}, {985088, 985133}, + {985152, 985179}, {985184, 985194}, {985200, 985223}, + {985225, 985230}, {985240, 985313}, {985315, 985443}, + {985446, 985455}, {985457, 985475}, {985477, 985484}, + {985487, 985488}, {985491, 985512}, {985514, 985520}, + {985522, 985522}, {985526, 985529}, {985532, 985540}, + {985543, 985544}, {985547, 985550}, {985559, 985559}, + {985564, 985565}, {985567, 985571}, {985574, 985585}, + {985596, 985596}, {985598, 985598}, {985601, 985603}, + {985605, 985610}, {985615, 985616}, {985619, 985640}, + {985642, 985648}, {985650, 985651}, {985653, 985654}, + {985656, 985657}, {985660, 985660}, {985662, 985666}, + {985671, 985672}, {985675, 985677}, {985681, 985681}, + {985689, 985692}, {985694, 985694}, {985702, 985717}, + {985729, 985731}, {985733, 985741}, {985743, 985745}, + {985747, 985768}, {985770, 985776}, {985778, 985779}, + {985781, 985785}, {985788, 985797}, {985799, 985801}, + {985803, 985805}, {985808, 985808}, {985824, 985827}, + {985830, 985839}, {985849, 985855}, {985857, 985859}, + {985861, 985868}, {985871, 985872}, {985875, 985896}, + {985898, 985904}, {985906, 985907}, {985909, 985913}, + {985916, 985924}, {985927, 985928}, {985931, 985933}, + {985941, 985943}, {985948, 985949}, {985951, 985955}, + {985958, 985967}, {985969, 985969}, {985986, 985987}, + {985989, 985994}, {985998, 986000}, {986002, 986005}, + {986009, 986010}, {986012, 986012}, {986014, 986015}, + {986019, 986020}, {986024, 986026}, {986030, 986041}, + {986046, 986050}, {986054, 986056}, {986058, 986061}, + {986064, 986064}, {986071, 986071}, {986086, 986095}, + {986112, 986124}, {986126, 986128}, {986130, 986152}, + {986154, 986169}, {986172, 986180}, {986182, 986184}, + {986186, 986189}, {986197, 986198}, {986200, 986202}, + {986205, 986205}, {986208, 986211}, {986214, 986223}, + {986240, 986243}, {986245, 986252}, {986254, 986256}, + {986258, 986280}, {986282, 986291}, {986293, 986297}, + {986300, 986308}, {986310, 986312}, {986314, 986317}, + {986325, 986326}, {986333, 986334}, {986336, 986339}, + {986342, 986351}, {986353, 986355}, {986368, 986380}, + {986382, 986384}, {986386, 986436}, {986438, 986440}, + {986442, 986446}, {986452, 986455}, {986463, 986467}, + {986470, 986479}, {986490, 986495}, {986497, 986499}, + {986501, 986518}, {986522, 986545}, {986547, 986555}, + {986557, 986557}, {986560, 986566}, {986570, 986570}, + {986575, 986580}, {986582, 986582}, {986584, 986591}, + {986598, 986607}, {986610, 986611}, {986625, 986682}, + {986688, 986702}, {986704, 986713}, {986753, 986754}, + {986756, 986756}, {986758, 986762}, {986764, 986787}, + {986789, 986789}, {986791, 986813}, {986816, 986820}, + {986822, 986822}, {986824, 986830}, {986832, 986841}, + {986844, 986847}, {986880, 986880}, {986904, 986905}, + {986912, 986921}, {986933, 986933}, {986935, 986935}, + {986937, 986937}, {986942, 986951}, {986953, 986988}, + {986993, 987012}, {987014, 987031}, {987033, 987068}, + {987078, 987078}, {987136, 987209}, {987216, 987293}, + {987296, 987333}, {987335, 987335}, {987341, 987341}, + {987344, 987386}, {987388, 987720}, {987722, 987725}, + {987728, 987734}, {987736, 987736}, {987738, 987741}, + {987744, 987784}, {987786, 987789}, {987792, 987824}, + {987826, 987829}, {987832, 987838}, {987840, 987840}, + {987842, 987845}, {987848, 987862}, {987864, 987920}, + {987922, 987925}, {987928, 987994}, {987997, 987999}, + {988009, 988017}, {988032, 988047}, {988064, 988149}, + {988152, 988157}, {988161, 988780}, {988783, 988799}, + {988801, 988826}, {988832, 988906}, {988910, 988920}, + {988928, 988949}, {988959, 988980}, {988992, 989011}, + {989024, 989036}, {989038, 989040}, {989042, 989043}, + {989056, 989139}, {989143, 989143}, {989148, 989149}, + {989152, 989161}, {989195, 989197}, {989199, 989209}, + {989216, 989304}, {989312, 989354}, {989360, 989429}, + {989440, 989470}, {989472, 989483}, {989488, 989499}, + {989510, 989549}, {989552, 989556}, {989568, 989611}, + {989616, 989641}, {989648, 989658}, {989696, 989723}, + {989728, 989790}, {989792, 989820}, {989823, 989833}, + {989840, 989849}, {989863, 989863}, {989872, 989885}, + {989887, 989902}, {989952, 990028}, {990032, 990041}, + {990059, 990067}, {990080, 990195}, {990208, 990263}, + {990272, 990281}, {990285, 990333}, {990336, 990344}, + {990352, 990394}, {990397, 990399}, {990416, 990418}, + {990420, 990458}, {990464, 990997}, {991000, 991005}, + {991008, 991045}, {991048, 991053}, {991056, 991063}, + {991065, 991065}, {991067, 991067}, {991069, 991069}, + {991071, 991101}, {991104, 991156}, {991158, 991164}, + {991166, 991166}, {991170, 991172}, {991174, 991180}, + {991184, 991187}, {991190, 991195}, {991200, 991212}, + {991218, 991220}, {991222, 991228}, {991244, 991245}, + {991295, 991296}, {991316, 991316}, {991345, 991345}, + {991359, 991359}, {991376, 991388}, {991440, 991452}, + {991457, 991457}, {991461, 991472}, {991490, 991490}, + {991495, 991495}, {991498, 991507}, {991509, 991509}, + {991512, 991517}, {991524, 991524}, {991526, 991526}, + {991528, 991528}, {991530, 991545}, {991548, 991551}, + {991557, 991561}, {991566, 991566}, {991584, 991624}, + {994304, 994532}, {994539, 994547}, {994560, 994597}, + {994599, 994599}, {994605, 994605}, {994608, 994663}, + {994671, 994671}, {994687, 994710}, {994720, 994726}, + {994728, 994734}, {994736, 994742}, {994744, 994750}, + {994752, 994758}, {994760, 994766}, {994768, 994774}, + {994776, 994782}, {994784, 994815}, {995333, 995335}, + {995361, 995375}, {995377, 995381}, {995384, 995388}, + {995393, 995478}, {995481, 995487}, {995489, 995578}, + {995580, 995583}, {995589, 995631}, {995633, 995726}, + {995744, 995775}, {995824, 995839}, {996352, 1002943}, + {1003008, 1025164}, {1025232, 1025277}, {1025280, 1025548}, + {1025552, 1025579}, {1025600, 1025647}, {1025652, 1025661}, + {1025663, 1025777}, {1025815, 1025823}, {1025826, 1025928}, + {1025931, 1025994}, {1026000, 1026001}, {1026003, 1026003}, + {1026005, 1026009}, {1026034, 1026087}, {1026092, 1026092}, + {1026112, 1026163}, {1026176, 1026245}, {1026256, 1026265}, + {1026272, 1026295}, {1026299, 1026299}, {1026301, 1026349}, + {1026352, 1026387}, {1026400, 1026428}, {1026432, 1026496}, + {1026511, 1026521}, {1026528, 1026558}, {1026560, 1026614}, + {1026624, 1026637}, {1026640, 1026649}, {1026656, 1026678}, + {1026682, 1026754}, {1026779, 1026781}, {1026784, 1026799}, + {1026802, 1026806}, {1026817, 1026822}, {1026825, 1026830}, + {1026833, 1026838}, {1026848, 1026854}, {1026856, 1026862}, + {1026864, 1026906}, {1026908, 1026921}, {1026928, 1027050}, + {1027052, 1027053}, {1027056, 1027065}, {1027072, 1038243}, + {1038256, 1038278}, {1038283, 1038331}, {1046784, 1047149}, + {1047152, 1047257}, {1047296, 1047302}, {1047315, 1047319}, + {1047325, 1047336}, {1047338, 1047350}, {1047352, 1047356}, + {1047358, 1047358}, {1047360, 1047361}, {1047363, 1047364}, + {1047366, 1047473}, {1047507, 1047869}, {1047888, 1047951}, + {1047954, 1048007}, {1048048, 1048059}, {1048064, 1048079}, + {1048096, 1048111}, {1048115, 1048116}, {1048141, 1048143}, + {1048176, 1048180}, {1048182, 1048316}, {1048336, 1048345}, + {1048353, 1048378}, {1048383, 1048383}, {1048385, 1048410}, + {1048422, 1048510}, {1048514, 1048519}, {1048522, 1048527}, + {1048530, 1048535}, {1048538, 1048540}, {1048612, 1048612}, + {1048624, 1048633}, {1048641, 1048666}, {1048671, 1048671}, + {1048673, 1048698}, {1048746, 1048746}, {1048757, 1048757}, + {1048759, 1048759}, {1048762, 1048762}, {1048768, 1048790}, + {1048792, 1048822}, {1048824, 1049281}, {1049286, 1049297}, + {1049312, 1049316}, {1049324, 1049324}, {1049326, 1049326}, + {1049344, 1049460}, {1049462, 1049463}, {1049466, 1049469}, + {1049471, 1049471}, {1049478, 1049482}, {1049484, 1049484}, + {1049486, 1049505}, {1049507, 1049589}, {1049591, 1049729}, + {1049731, 1049735}, {1049738, 1049903}, {1049905, 1049942}, + {1049945, 1049945}, {1049952, 1049992}, {1050001, 1050045}, + {1050047, 1050047}, {1050049, 1050050}, {1050052, 1050053}, + {1050055, 1050055}, {1050064, 1050090}, {1050095, 1050098}, + {1050128, 1050138}, {1050144, 1050217}, {1050222, 1050323}, + {1050325, 1050332}, {1050335, 1050344}, {1050346, 1050364}, + {1050367, 1050367}, {1050384, 1050442}, {1050445, 1050545}, + {1050560, 1050613}, {1050618, 1050618}, {1050621, 1050621}, + {1050624, 1050669}, {1050688, 1050715}, {1050720, 1050730}, + {1050736, 1050759}, {1050761, 1050766}, {1050776, 1050849}, + {1050851, 1050979}, {1050982, 1050991}, {1050993, 1051011}, + {1051013, 1051020}, {1051023, 1051024}, {1051027, 1051048}, + {1051050, 1051056}, {1051058, 1051058}, {1051062, 1051065}, + {1051068, 1051076}, {1051079, 1051080}, {1051083, 1051086}, + {1051095, 1051095}, {1051100, 1051101}, {1051103, 1051107}, + {1051110, 1051121}, {1051132, 1051132}, {1051134, 1051134}, + {1051137, 1051139}, {1051141, 1051146}, {1051151, 1051152}, + {1051155, 1051176}, {1051178, 1051184}, {1051186, 1051187}, + {1051189, 1051190}, {1051192, 1051193}, {1051196, 1051196}, + {1051198, 1051202}, {1051207, 1051208}, {1051211, 1051213}, + {1051217, 1051217}, {1051225, 1051228}, {1051230, 1051230}, + {1051238, 1051253}, {1051265, 1051267}, {1051269, 1051277}, + {1051279, 1051281}, {1051283, 1051304}, {1051306, 1051312}, + {1051314, 1051315}, {1051317, 1051321}, {1051324, 1051333}, + {1051335, 1051337}, {1051339, 1051341}, {1051344, 1051344}, + {1051360, 1051363}, {1051366, 1051375}, {1051385, 1051391}, + {1051393, 1051395}, {1051397, 1051404}, {1051407, 1051408}, + {1051411, 1051432}, {1051434, 1051440}, {1051442, 1051443}, + {1051445, 1051449}, {1051452, 1051460}, {1051463, 1051464}, + {1051467, 1051469}, {1051477, 1051479}, {1051484, 1051485}, + {1051487, 1051491}, {1051494, 1051503}, {1051505, 1051505}, + {1051522, 1051523}, {1051525, 1051530}, {1051534, 1051536}, + {1051538, 1051541}, {1051545, 1051546}, {1051548, 1051548}, + {1051550, 1051551}, {1051555, 1051556}, {1051560, 1051562}, + {1051566, 1051577}, {1051582, 1051586}, {1051590, 1051592}, + {1051594, 1051597}, {1051600, 1051600}, {1051607, 1051607}, + {1051622, 1051631}, {1051648, 1051660}, {1051662, 1051664}, + {1051666, 1051688}, {1051690, 1051705}, {1051708, 1051716}, + {1051718, 1051720}, {1051722, 1051725}, {1051733, 1051734}, + {1051736, 1051738}, {1051741, 1051741}, {1051744, 1051747}, + {1051750, 1051759}, {1051776, 1051779}, {1051781, 1051788}, + {1051790, 1051792}, {1051794, 1051816}, {1051818, 1051827}, + {1051829, 1051833}, {1051836, 1051844}, {1051846, 1051848}, + {1051850, 1051853}, {1051861, 1051862}, {1051869, 1051870}, + {1051872, 1051875}, {1051878, 1051887}, {1051889, 1051891}, + {1051904, 1051916}, {1051918, 1051920}, {1051922, 1051972}, + {1051974, 1051976}, {1051978, 1051982}, {1051988, 1051991}, + {1051999, 1052003}, {1052006, 1052015}, {1052026, 1052031}, + {1052033, 1052035}, {1052037, 1052054}, {1052058, 1052081}, + {1052083, 1052091}, {1052093, 1052093}, {1052096, 1052102}, + {1052106, 1052106}, {1052111, 1052116}, {1052118, 1052118}, + {1052120, 1052127}, {1052134, 1052143}, {1052146, 1052147}, + {1052161, 1052218}, {1052224, 1052238}, {1052240, 1052249}, + {1052289, 1052290}, {1052292, 1052292}, {1052294, 1052298}, + {1052300, 1052323}, {1052325, 1052325}, {1052327, 1052349}, + {1052352, 1052356}, {1052358, 1052358}, {1052360, 1052366}, + {1052368, 1052377}, {1052380, 1052383}, {1052416, 1052416}, + {1052440, 1052441}, {1052448, 1052457}, {1052469, 1052469}, + {1052471, 1052471}, {1052473, 1052473}, {1052478, 1052487}, + {1052489, 1052524}, {1052529, 1052548}, {1052550, 1052567}, + {1052569, 1052604}, {1052614, 1052614}, {1052672, 1052745}, + {1052752, 1052829}, {1052832, 1052869}, {1052871, 1052871}, + {1052877, 1052877}, {1052880, 1052922}, {1052924, 1053256}, + {1053258, 1053261}, {1053264, 1053270}, {1053272, 1053272}, + {1053274, 1053277}, {1053280, 1053320}, {1053322, 1053325}, + {1053328, 1053360}, {1053362, 1053365}, {1053368, 1053374}, + {1053376, 1053376}, {1053378, 1053381}, {1053384, 1053398}, + {1053400, 1053456}, {1053458, 1053461}, {1053464, 1053530}, + {1053533, 1053535}, {1053545, 1053553}, {1053568, 1053583}, + {1053600, 1053685}, {1053688, 1053693}, {1053697, 1054316}, + {1054319, 1054335}, {1054337, 1054362}, {1054368, 1054442}, + {1054446, 1054456}, {1054464, 1054485}, {1054495, 1054516}, + {1054528, 1054547}, {1054560, 1054572}, {1054574, 1054576}, + {1054578, 1054579}, {1054592, 1054675}, {1054679, 1054679}, + {1054684, 1054685}, {1054688, 1054697}, {1054731, 1054733}, + {1054735, 1054745}, {1054752, 1054840}, {1054848, 1054890}, + {1054896, 1054965}, {1054976, 1055006}, {1055008, 1055019}, + {1055024, 1055035}, {1055046, 1055085}, {1055088, 1055092}, + {1055104, 1055147}, {1055152, 1055177}, {1055184, 1055194}, + {1055232, 1055259}, {1055264, 1055326}, {1055328, 1055356}, + {1055359, 1055369}, {1055376, 1055385}, {1055399, 1055399}, + {1055408, 1055421}, {1055423, 1055438}, {1055488, 1055564}, + {1055568, 1055577}, {1055595, 1055603}, {1055616, 1055731}, + {1055744, 1055799}, {1055808, 1055817}, {1055821, 1055869}, + {1055872, 1055880}, {1055888, 1055930}, {1055933, 1055935}, + {1055952, 1055954}, {1055956, 1055994}, {1056000, 1056533}, + {1056536, 1056541}, {1056544, 1056581}, {1056584, 1056589}, + {1056592, 1056599}, {1056601, 1056601}, {1056603, 1056603}, + {1056605, 1056605}, {1056607, 1056637}, {1056640, 1056692}, + {1056694, 1056700}, {1056702, 1056702}, {1056706, 1056708}, + {1056710, 1056716}, {1056720, 1056723}, {1056726, 1056731}, + {1056736, 1056748}, {1056754, 1056756}, {1056758, 1056764}, + {1056780, 1056781}, {1056831, 1056832}, {1056852, 1056852}, + {1056881, 1056881}, {1056895, 1056895}, {1056912, 1056924}, + {1056976, 1056988}, {1056993, 1056993}, {1056997, 1057008}, + {1057026, 1057026}, {1057031, 1057031}, {1057034, 1057043}, + {1057045, 1057045}, {1057048, 1057053}, {1057060, 1057060}, + {1057062, 1057062}, {1057064, 1057064}, {1057066, 1057081}, + {1057084, 1057087}, {1057093, 1057097}, {1057102, 1057102}, + {1057120, 1057160}, {1059840, 1060068}, {1060075, 1060083}, + {1060096, 1060133}, {1060135, 1060135}, {1060141, 1060141}, + {1060144, 1060199}, {1060207, 1060207}, {1060223, 1060246}, + {1060256, 1060262}, {1060264, 1060270}, {1060272, 1060278}, + {1060280, 1060286}, {1060288, 1060294}, {1060296, 1060302}, + {1060304, 1060310}, {1060312, 1060318}, {1060320, 1060351}, + {1060869, 1060871}, {1060897, 1060911}, {1060913, 1060917}, + {1060920, 1060924}, {1060929, 1061014}, {1061017, 1061023}, + {1061025, 1061114}, {1061116, 1061119}, {1061125, 1061167}, + {1061169, 1061262}, {1061280, 1061311}, {1061360, 1061375}, + {1061888, 1068479}, {1068544, 1090700}, {1090768, 1090813}, + {1090816, 1091084}, {1091088, 1091115}, {1091136, 1091183}, + {1091188, 1091197}, {1091199, 1091313}, {1091351, 1091359}, + {1091362, 1091464}, {1091467, 1091530}, {1091536, 1091537}, + {1091539, 1091539}, {1091541, 1091545}, {1091570, 1091623}, + {1091628, 1091628}, {1091648, 1091699}, {1091712, 1091781}, + {1091792, 1091801}, {1091808, 1091831}, {1091835, 1091835}, + {1091837, 1091885}, {1091888, 1091923}, {1091936, 1091964}, + {1091968, 1092032}, {1092047, 1092057}, {1092064, 1092094}, + {1092096, 1092150}, {1092160, 1092173}, {1092176, 1092185}, + {1092192, 1092214}, {1092218, 1092290}, {1092315, 1092317}, + {1092320, 1092335}, {1092338, 1092342}, {1092353, 1092358}, + {1092361, 1092366}, {1092369, 1092374}, {1092384, 1092390}, + {1092392, 1092398}, {1092400, 1092442}, {1092444, 1092457}, + {1092464, 1092586}, {1092588, 1092589}, {1092592, 1092601}, + {1092608, 1103779}, {1103792, 1103814}, {1103819, 1103867}, + {1112320, 1112685}, {1112688, 1112793}, {1112832, 1112838}, + {1112851, 1112855}, {1112861, 1112872}, {1112874, 1112886}, + {1112888, 1112892}, {1112894, 1112894}, {1112896, 1112897}, + {1112899, 1112900}, {1112902, 1113009}, {1113043, 1113405}, + {1113424, 1113487}, {1113490, 1113543}, {1113584, 1113595}, + {1113600, 1113615}, {1113632, 1113647}, {1113651, 1113652}, + {1113677, 1113679}, {1113712, 1113716}, {1113718, 1113852}, + {1113872, 1113881}, {1113889, 1113914}, {1113919, 1113919}, + {1113921, 1113946}, {1113958, 1114046}, {1114050, 1114055}, + {1114058, 1114063}, {1114066, 1114071}, {1114074, 1114076}}; + +ada_really_inline std::bitset<0x10FFFF> init_valid_id_part_mask_unicode() { + std::bitset<0x10FFFF> id_part_mask{}; + for (auto range : valid_id_part_ranges_unicode) { + for (auto r = range[0]; r <= range[1]; r++) { + id_part_mask.set(r); + } + } + return id_part_mask; +} + +static std::bitset<0x10FFFF> valid_id_part_mask_unicode = + init_valid_id_part_mask_unicode(); + +constexpr static bool valid_id_part_table_ascii[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, @@ -292,32 +4898,18 @@ constexpr static bool valid_identifier_part_table[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1}; -static_assert(sizeof(valid_identifier_part_table) == 256); +static_assert(sizeof(valid_id_part_table_ascii) == 256); -ada_really_inline constexpr bool is_valid_identifier_part( - const char32_t c) noexcept { +// https://wicg.github.io/urlpattern/#is-a-valid-name-code-point +ada_really_inline bool is_valid_identifier_part(const char32_t& c) noexcept { if (c < 256) { // extended ascii fast path - return valid_identifier_part_table[c]; + return valid_id_part_table_ascii[c]; } - // TODO: handle this - return false; + // 256+ + return valid_id_part_mask_unicode[c]; } -static_assert(unicode::is_valid_identifier_part('$')); -static_assert(unicode::is_valid_identifier_part('_')); -static_assert(unicode::is_valid_identifier_part('a')); -static_assert(unicode::is_valid_identifier_part('z')); -static_assert(unicode::is_valid_identifier_part('A')); -static_assert(unicode::is_valid_identifier_part('Z')); -static_assert(unicode::is_valid_identifier_part('0')); -static_assert(unicode::is_valid_identifier_part('9')); -static_assert(!unicode::is_valid_identifier_part('\n')); -static_assert(!unicode::is_valid_identifier_part('\\')); -static_assert(!unicode::is_valid_identifier_part('\'')); -static_assert(!unicode::is_valid_identifier_part('*')); -static_assert(!unicode::is_valid_identifier_part('&')); - ada_really_inline constexpr bool is_ascii_hex_digit(const char c) noexcept { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index f01f0d620..5e439df1f 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -1,17 +1,201 @@ +#include "ada/unicode.h" #include "ada/urlpattern.h" -#include "common_defs.h" +#include namespace ada { + ada_really_inline bool is_valid_name_code_point(const char32_t& c, - bool is_first) { - // To perform is a valid name code point given a Unicode code point and a - // boolean first: If first is true return the result of checking if code + bool is_first) noexcept { + return is_first ? unicode::is_valid_identifier_start(c) + : ada::unicode::is_valid_identifier_part(c); +} + +ada_really_inline bool is_ascii(char32_t c) { return c < 0x80; } + +enum class TOKEN_TYPE { + OPEN, + CLOSE, + REGEXP, + NAME, + CHAR, + ESCAPED_CHAR, + OTHER_MODIFIER, + ASTERISK, + END, + INVALID_CHAR +}; + +enum class POLICY { STRICT, LENIENT }; + +struct TOKEN { + TOKEN_TYPE token; + size_t start; + size_t end; +}; + +ada_really_inline std::forward_list tokenize(std::string_view input, + POLICY policy) { + // Need to deal with Unicode points, so convert to std::u32string_view + std::forward_list tokens{}; + size_t input_size = input.size(); + + // TODO: convert input to utf32 + const auto error_or_invalid = [&](const std::string_view msg, size_t start, + size_t end) { + if (policy != POLICY::LENIENT) { + throw std::invalid_argument(std::string(msg)); + } + tokens.push_front({TOKEN_TYPE::INVALID_CHAR, start, end}); + }; + + size_t index = 0; + while (index < input_size) { + switch (input[index]) { + case '*': { + tokens.push_front({TOKEN_TYPE::ASTERISK, index, index}); + ++index; + break; + } + case '+': + case '?': { + tokens.push_front({TOKEN_TYPE::OTHER_MODIFIER, index, index}); + ++index; + break; + } + case '\\': { + if (index == input_size - 1) { + error_or_invalid("should scape something", index, index); + index++; + } + + tokens.push_front({TOKEN_TYPE::ESCAPED_CHAR, ++index, index}); + break; + } + case '{': { + tokens.push_front({TOKEN_TYPE::OPEN, index, index}); + ++index; + break; + } + case '}': { + tokens.push_front({TOKEN_TYPE::CLOSE, index, index}); + ++index; + break; + } + case ':': { + // If valid code point is false, break. + // Set name position to tokenizer’s next index. + size_t start, end; + start = index + 1; + end = start; + + if ((end < input_size) && + is_valid_name_code_point(input[end], /*is_first=*/true)) { + ++end; + while (end < input_size && + is_valid_name_code_point(input[end], /*is_first=*/false)) { + ++end; + } + } else { + // First character is not a valid name code point, so there's a + // missing parameter name. + error_or_invalid("missing parameter name", start, end); + continue; + } + + tokens.push_front({TOKEN_TYPE::NAME, start, end}); + + index = end; + break; + } + case '(': { + size_t regexp_start, regexp, depth; + regexp_start = index + 1; + regexp = regexp_start; + depth = 1; + + bool error = false; + while (regexp < input_size) { + // If regexp position equals regexp start and tokenizer’s code point + // is U+003F (?): + // Run process a tokenizing error given tokenizer, regexp start, and + // tokenizer’s index. + // Set error to true. + if (!is_ascii(input[regexp])) { + error_or_invalid("invalid char for regex", regexp, regexp); - // is contained in the IdentifierStart set of code points. - if (is_first) { - return c <= 255 ? unicode::is_identifier_start(c) : false; + error = true; + break; + } + if (input[regexp] == '?' && (regexp == regexp_start)) { + error_or_invalid("malformed regex", regexp, regexp); + + error = true; + break; + } + if (input[regexp] == '\\') { + if (regexp == input_size - 1) { + error_or_invalid("malformed regex", regexp, regexp); + + error = true; + break; + } + ++regexp; + if (!is_ascii(input[regexp])) { + error_or_invalid("invalid char for regex", regexp, regexp); + + error = true; + break; + } + ++regexp; + continue; + } + + if (input[regexp] == ')') { + --depth; + if (depth == 0) { + ++regexp; + } + } else if (input[regexp] == '(') { + ++depth; + if (regexp == input_size - 1) { + error_or_invalid("malformed regex", regexp, regexp); + + error = true; + break; + } + if (input[regexp + 1] != '?') { + error_or_invalid("malformed regex", regexp, regexp); + + error = true; + break; + } + ++regexp; + } + + ++regexp; + + if (error) continue; + + if (depth) { + error_or_invalid("malformed regex", regexp, regexp); + break; + } + + if ((regexp - regexp_start) == 0) { + error_or_invalid("malformed regex", regexp, regexp); + } + + tokens.push_front({TOKEN_TYPE::REGEXP, regexp_start, regexp}); + index = regexp; + } + } + } + + tokens.push_front({TOKEN_TYPE::CHAR, index, index}); } - return c <= 255 ? unicode::is_identifier_part(c) : false; + + tokens.push_front({TOKEN_TYPE::END, index, index}); + return tokens; } } // namespace ada \ No newline at end of file From 842f5b1e2bfe47cc1ed8f9ac204d570ba72f902b Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 9 May 2023 17:16:06 -0300 Subject: [PATCH 03/23] urlpattern: adds missing eof --- include/ada/urlpattern.h | 2 +- src/urlpattern.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index 3c8755ebf..5f714bcdf 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -79,4 +79,4 @@ struct urlpattern { } // namespace ada -#endif \ No newline at end of file +#endif diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index 5e439df1f..844047b8e 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -198,4 +198,4 @@ ada_really_inline std::forward_list tokenize(std::string_view input, return tokens; } -} // namespace ada \ No newline at end of file +} // namespace ada From ee41c6f6fd506d62bd5c22c690df8ce150b08f59 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 9 May 2023 17:42:38 -0300 Subject: [PATCH 04/23] urlpattern: adds bitset lib --- src/unicode.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/unicode.cpp b/src/unicode.cpp index 04d8707ad..54df2790d 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -8,6 +8,7 @@ ADA_PUSH_DISABLE_ALL_WARNINGS ADA_POP_DISABLE_WARNINGS #include +#include namespace ada::unicode { From df58be47481d760f581d6e04c8261d4fa26b3ddb Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Wed, 10 May 2023 08:47:07 -0300 Subject: [PATCH 05/23] urlpattern: adds comments to unicode.h --- include/ada/unicode.h | 13 +++++++++++++ src/urlpattern.cpp | 4 ++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/include/ada/unicode.h b/include/ada/unicode.h index ecf4881fb..4da831a71 100644 --- a/include/ada/unicode.h +++ b/include/ada/unicode.h @@ -202,7 +202,20 @@ ada_really_inline size_t percent_encode_index(const std::string_view input, */ constexpr bool to_lower_ascii(char* input, size_t length) noexcept; +/** + * Returns true if the Unicode code point is a valid JavaScript identifier part + * (IdentifierPart). A JavaScript IdentifierPart is either an UnicodeIDContinue, + * $, , or an UnicodeEscapeSequence. + * @see https://tc39.es/ecma262/#prod-IdentifierPart + */ bool is_valid_identifier_part(const char32_t& c) noexcept; + +/** + * Returns true if the Unicode code point is a valid JavaScript identifier start + * (IdentifierStart). A JavaScript IdentifierStart is either an UnicodeIDStart, + * $, _ or an UnicodeEscapeSequence. + * @see https://tc39.es/ecma262/#prod-IdentifierStart + */ bool is_valid_identifier_start(const char32_t& c) noexcept; } // namespace ada::unicode diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index 844047b8e..1630802bc 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -7,7 +7,7 @@ namespace ada { ada_really_inline bool is_valid_name_code_point(const char32_t& c, bool is_first) noexcept { return is_first ? unicode::is_valid_identifier_start(c) - : ada::unicode::is_valid_identifier_part(c); + : unicode::is_valid_identifier_part(c); } ada_really_inline bool is_ascii(char32_t c) { return c < 0x80; } @@ -65,7 +65,7 @@ ada_really_inline std::forward_list tokenize(std::string_view input, case '\\': { if (index == input_size - 1) { error_or_invalid("should scape something", index, index); - index++; + ++index; } tokens.push_front({TOKEN_TYPE::ESCAPED_CHAR, ++index, index}); From 582a64913f0a49d85122ccada13fc39864cd8385 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Wed, 10 May 2023 08:54:20 -0300 Subject: [PATCH 06/23] urlpattern: component_result -> urlpattern_component_result --- include/ada/urlpattern.h | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index 5f714bcdf..b6574fa9f 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -10,14 +10,14 @@ namespace ada { -ada_really_inline bool is_valid_name_code_point(const char32_t& c, +ada_really_inline bool is_valid_name_code_point(const char32_t &c, bool is_first) noexcept; struct urlpattern_options { bool ignore_case = false; }; -struct component_result { +struct urlpattern_component_result { std::string_view input; std::unordered_map> groups; }; @@ -35,32 +35,32 @@ struct urlpattern_init { }; union input_union { - urlpattern_options urlpattern_init; + urlpattern_init init; std::string_view str; }; typedef input_union urlpattern_input; struct urlpattern_result { - component_result protocol; - component_result username; - component_result password; - component_result hostname; - component_result port; - component_result pathname; - component_result search; - component_result hash; + urlpattern_component_result protocol; + urlpattern_component_result username; + urlpattern_component_result password; + urlpattern_component_result hostname; + urlpattern_component_result port; + urlpattern_component_result pathname; + urlpattern_component_result search; + urlpattern_component_result hash; urlpattern_input input[]; }; struct urlpattern { - urlpattern(urlpattern_input input, std::string_view base_url, - std::optional options); + urlpattern(urlpattern_input &input, std::string_view base_url, + std::optional &options); - urlpattern(std::optional input, - std::optional); + urlpattern(std::optional &input, + std::optional &options); - bool test(std::optional input, + bool test(std::optional &input, std::optional base_url); std::optional exec( From 0516de469e785fbe165cd4d4806e393e81be24d3 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Thu, 11 May 2023 20:12:00 -0300 Subject: [PATCH 07/23] urlpattern: wip constructors --- include/ada/urlpattern.h | 22 ++++----------- src/unicode.cpp | 20 ++++--------- src/urlpattern.cpp | 61 ++++++++++++++++++++++++++++++---------- 3 files changed, 57 insertions(+), 46 deletions(-) diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index b6574fa9f..5de413eb7 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -34,13 +34,7 @@ struct urlpattern_init { std::string_view base_url; }; -union input_union { - urlpattern_init init; - std::string_view str; -}; - -typedef input_union urlpattern_input; - +template struct urlpattern_result { urlpattern_component_result protocol; urlpattern_component_result username; @@ -54,19 +48,13 @@ struct urlpattern_result { }; struct urlpattern { - urlpattern(urlpattern_input &input, std::string_view base_url, + // TODO: improve DX.. maybe create one constructor for each case and + // make them call the right/following constructors 'under the hood' + urlpattern(std::string_view input, std::optional base_url, std::optional &options); - - urlpattern(std::optional &input, + urlpattern(urlpattern_init &input, std::optional &options); - bool test(std::optional &input, - std::optional base_url); - - std::optional exec( - std::optional input, - std::optional base_url); - const std::string_view protocol; const std::string_view username; const std::string_view password; diff --git a/src/unicode.cpp b/src/unicode.cpp index 54df2790d..4e917555a 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -241,7 +241,7 @@ static_assert(unicode::is_alnum_plus('b')); // https://tc39.es/ecma262/#prod-IdentifierStart // up to the extented ascii, with the regex /[$_\p{ID_Start}]/u -constexpr static bool valid_identifier_start_table[] = { +constexpr static bool valid_id_start_table_ascii[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, @@ -254,7 +254,7 @@ constexpr static bool valid_identifier_start_table[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1}; -static_assert(sizeof(valid_identifier_start_table) == 256); +static_assert(sizeof(valid_id_start_table_ascii) == 256); // Valid IdentifierStart unicods points 256+ // ranges obtained with the regex /[$_\p{ID_Start}]/u @@ -2427,12 +2427,8 @@ static std::bitset<0x10FFFF> valid_id_start_mask_unicode = // https://wicg.github.io/urlpattern/#is-a-valid-name-code-point ada_really_inline bool is_valid_identifier_start(const char32_t& c) noexcept { - if (c < 256) { - // extended ascii fast path - return valid_identifier_start_table[c]; - } - // 256+ - return valid_id_start_mask_unicode[c]; + return c < 256 ? /* extended ascii fast path */ valid_id_start_table_ascii[c] + : valid_id_start_mask_unicode[c]; } // Valid IdentifierPart unicods points 256+ @@ -4903,12 +4899,8 @@ static_assert(sizeof(valid_id_part_table_ascii) == 256); // https://wicg.github.io/urlpattern/#is-a-valid-name-code-point ada_really_inline bool is_valid_identifier_part(const char32_t& c) noexcept { - if (c < 256) { - // extended ascii fast path - return valid_id_part_table_ascii[c]; - } - // 256+ - return valid_id_part_mask_unicode[c]; + return c < 256 ? /* extended ascii fast-path*/ valid_id_part_table_ascii[c] + : valid_id_part_mask_unicode[c]; } ada_really_inline constexpr bool is_ascii_hex_digit(const char c) noexcept { diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index 1630802bc..82f0a5cb8 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -1,10 +1,16 @@ +#include <_ctype.h> #include "ada/unicode.h" #include "ada/urlpattern.h" -#include + +#include +#include +#include +#include +#include namespace ada { -ada_really_inline bool is_valid_name_code_point(const char32_t& c, +ada_really_inline bool is_valid_name_code_point(const char32_t &c, bool is_first) noexcept { return is_first ? unicode::is_valid_identifier_start(c) : unicode::is_valid_identifier_part(c); @@ -33,10 +39,10 @@ struct TOKEN { size_t end; }; -ada_really_inline std::forward_list tokenize(std::string_view input, - POLICY policy) { +ada_really_inline std::vector tokenize(std::string_view input, + POLICY policy) { // Need to deal with Unicode points, so convert to std::u32string_view - std::forward_list tokens{}; + std::vector tokens{}; size_t input_size = input.size(); // TODO: convert input to utf32 @@ -45,20 +51,20 @@ ada_really_inline std::forward_list tokenize(std::string_view input, if (policy != POLICY::LENIENT) { throw std::invalid_argument(std::string(msg)); } - tokens.push_front({TOKEN_TYPE::INVALID_CHAR, start, end}); + tokens.push_back({TOKEN_TYPE::INVALID_CHAR, start, end}); }; size_t index = 0; while (index < input_size) { switch (input[index]) { case '*': { - tokens.push_front({TOKEN_TYPE::ASTERISK, index, index}); + tokens.push_back({TOKEN_TYPE::ASTERISK, index, index}); ++index; break; } case '+': case '?': { - tokens.push_front({TOKEN_TYPE::OTHER_MODIFIER, index, index}); + tokens.push_back({TOKEN_TYPE::OTHER_MODIFIER, index, index}); ++index; break; } @@ -68,16 +74,16 @@ ada_really_inline std::forward_list tokenize(std::string_view input, ++index; } - tokens.push_front({TOKEN_TYPE::ESCAPED_CHAR, ++index, index}); + tokens.push_back({TOKEN_TYPE::ESCAPED_CHAR, ++index, index}); break; } case '{': { - tokens.push_front({TOKEN_TYPE::OPEN, index, index}); + tokens.push_back({TOKEN_TYPE::OPEN, index, index}); ++index; break; } case '}': { - tokens.push_front({TOKEN_TYPE::CLOSE, index, index}); + tokens.push_back({TOKEN_TYPE::CLOSE, index, index}); ++index; break; } @@ -102,7 +108,7 @@ ada_really_inline std::forward_list tokenize(std::string_view input, continue; } - tokens.push_front({TOKEN_TYPE::NAME, start, end}); + tokens.push_back({TOKEN_TYPE::NAME, start, end}); index = end; break; @@ -185,17 +191,42 @@ ada_really_inline std::forward_list tokenize(std::string_view input, error_or_invalid("malformed regex", regexp, regexp); } - tokens.push_front({TOKEN_TYPE::REGEXP, regexp_start, regexp}); + tokens.push_back({TOKEN_TYPE::REGEXP, regexp_start, regexp}); index = regexp; } } } - tokens.push_front({TOKEN_TYPE::CHAR, index, index}); + tokens.push_back({TOKEN_TYPE::CHAR, index, index}); } - tokens.push_front({TOKEN_TYPE::END, index, index}); + tokens.push_back({TOKEN_TYPE::END, index, index}); return tokens; } +// https://wicg.github.io/urlpattern/#constructor-string-parser +ada_really_inline urlpattern_init string_parser(std::string_view input) { + // A constructor string parser has an associated token list, a token list, + // which must be set upon creation. + std::vector token_list = tokenize(input, POLICY::LENIENT); + urlpattern_init result{}; + + size_t index = 0; + while(index < token_list.size()) { + + } + + return result; +} + +// The new URLPattern(input, baseURL, options) constructor steps are: +// Run initialize given this, input, baseURL, and options. +urlpattern::urlpattern(std::string_view input, + std::optional base_url, + std::optional &options) {} + +urlpattern::urlpattern<>( + const std::string_view &input, const std::string_view base_url, + const std::optional &options) {} + } // namespace ada From 179a06510ac0ed691d0bf9a516c76694b8e57f84 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sat, 13 May 2023 12:22:22 -0300 Subject: [PATCH 08/23] urlpattern: WIP contructor_string_parser --- src/urlpattern.cpp | 201 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 164 insertions(+), 37 deletions(-) diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index 82f0a5cb8..ecb1d6ee4 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -1,6 +1,7 @@ #include <_ctype.h> #include "ada/unicode.h" #include "ada/urlpattern.h" +#include "ada/ada_idna.h" #include #include @@ -34,56 +35,53 @@ enum class TOKEN_TYPE { enum class POLICY { STRICT, LENIENT }; struct TOKEN { - TOKEN_TYPE token; - size_t start; - size_t end; + TOKEN_TYPE type; + std::u32string_view value; }; -ada_really_inline std::vector tokenize(std::string_view input, +ada_really_inline std::vector tokenize(std::u32string_view input, POLICY policy) { - // Need to deal with Unicode points, so convert to std::u32string_view std::vector tokens{}; size_t input_size = input.size(); - // TODO: convert input to utf32 - const auto error_or_invalid = [&](const std::string_view msg, size_t start, - size_t end) { + const auto error_or_invalid = [&](const std::string_view msg, + const std::u32string_view value) { if (policy != POLICY::LENIENT) { throw std::invalid_argument(std::string(msg)); } - tokens.push_back({TOKEN_TYPE::INVALID_CHAR, start, end}); + tokens.push_back({TOKEN_TYPE::INVALID_CHAR, value}); }; size_t index = 0; while (index < input_size) { switch (input[index]) { case '*': { - tokens.push_back({TOKEN_TYPE::ASTERISK, index, index}); + tokens.push_back({TOKEN_TYPE::ASTERISK, input.substr(index, 1)}); ++index; break; } case '+': case '?': { - tokens.push_back({TOKEN_TYPE::OTHER_MODIFIER, index, index}); + tokens.push_back({TOKEN_TYPE::OTHER_MODIFIER, input.substr(index, 1)}); ++index; break; } case '\\': { + ++index; if (index == input_size - 1) { - error_or_invalid("should scape something", index, index); - ++index; + error_or_invalid("should scape something", input.substr(index, 1)); } - tokens.push_back({TOKEN_TYPE::ESCAPED_CHAR, ++index, index}); + tokens.push_back({TOKEN_TYPE::ESCAPED_CHAR, input.substr(index, 1)}); break; } case '{': { - tokens.push_back({TOKEN_TYPE::OPEN, index, index}); + tokens.push_back({TOKEN_TYPE::OPEN, input.substr(index, 1)}); ++index; break; } case '}': { - tokens.push_back({TOKEN_TYPE::CLOSE, index, index}); + tokens.push_back({TOKEN_TYPE::CLOSE, input.substr(index, 1)}); ++index; break; } @@ -104,11 +102,12 @@ ada_really_inline std::vector tokenize(std::string_view input, } else { // First character is not a valid name code point, so there's a // missing parameter name. - error_or_invalid("missing parameter name", start, end); + error_or_invalid("missing parameter name", + input.substr(start, end - start)); continue; } - tokens.push_back({TOKEN_TYPE::NAME, start, end}); + tokens.push_back({TOKEN_TYPE::NAME, input.substr(start, end - start)}); index = end; break; @@ -127,27 +126,28 @@ ada_really_inline std::vector tokenize(std::string_view input, // tokenizer’s index. // Set error to true. if (!is_ascii(input[regexp])) { - error_or_invalid("invalid char for regex", regexp, regexp); + error_or_invalid("invalid char for regex", input.substr(regexp, 1)); error = true; break; } if (input[regexp] == '?' && (regexp == regexp_start)) { - error_or_invalid("malformed regex", regexp, regexp); + error_or_invalid("malformed regex", input.substr(regexp, 1)); error = true; break; } if (input[regexp] == '\\') { if (regexp == input_size - 1) { - error_or_invalid("malformed regex", regexp, regexp); + error_or_invalid("malformed regex", input.substr(regexp, 1)); error = true; break; } ++regexp; if (!is_ascii(input[regexp])) { - error_or_invalid("invalid char for regex", regexp, regexp); + error_or_invalid("invalid char for regex", + input.substr(regexp, 1)); error = true; break; @@ -164,13 +164,13 @@ ada_really_inline std::vector tokenize(std::string_view input, } else if (input[regexp] == '(') { ++depth; if (regexp == input_size - 1) { - error_or_invalid("malformed regex", regexp, regexp); + error_or_invalid("malformed regex", input.substr(regexp, 1)); error = true; break; } if (input[regexp + 1] != '?') { - error_or_invalid("malformed regex", regexp, regexp); + error_or_invalid("malformed regex", input.substr(regexp, 1)); error = true; break; @@ -183,37 +183,166 @@ ada_really_inline std::vector tokenize(std::string_view input, if (error) continue; if (depth) { - error_or_invalid("malformed regex", regexp, regexp); + error_or_invalid("malformed regex", input.substr(regexp, 1)); break; } if ((regexp - regexp_start) == 0) { - error_or_invalid("malformed regex", regexp, regexp); + error_or_invalid("malformed regex", input.substr(regexp, 1)); } - tokens.push_back({TOKEN_TYPE::REGEXP, regexp_start, regexp}); + tokens.push_back({TOKEN_TYPE::REGEXP, + input.substr(regexp_start, regexp - regexp_start)}); index = regexp; } } } - tokens.push_back({TOKEN_TYPE::CHAR, index, index}); + // TODO: maybe group the TOKEN_TYPE::CHARs to make tokens cheaper + tokens.push_back({TOKEN_TYPE::CHAR, input.substr(index, 1)}); } - tokens.push_back({TOKEN_TYPE::END, index, index}); + tokens.push_back({TOKEN_TYPE::END, input.substr(index, 1)}); return tokens; } +// https://wicg.github.io/urlpattern/#get-a-safe-token +ada_really_inline TOKEN get_safe_token(std::vector &token_list, + size_t &index) { + // 1. If index is less than parser’s token list's size, then return parser’s + // token list[index]. + if (index < token_list.size()) return token_list[index]; + // 2. Assert: parser’s token list's size is greater than or equal to 1. + // TODO: messages for the asserts? conditional and then throw error? + assert(token_list.size() >= 1); + // 3. Let last index be parser’s token list's size − 1. + size_t last_index = token_list.size() - 1; + // 4. Let token be parser’s token list[last index]. + TOKEN token = token_list[last_index]; + // 5. Assert: token’s type is "end". + assert(token.type == TOKEN_TYPE::END); + return token; +} + +// https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char +ada_really_inline bool is_nonspecial_pattern_char( + std::vector &token_list, size_t &index, const char32_t &c) { + // 1. Let token be the result of running get a safe token given parser and + // index. + // TODO: maybe return just the index to make it cheaper + TOKEN token = get_safe_token(token_list, index); + + // 2. If token’s value is not value, then return false. + if (token.value[0] == c) { + return false; + } + + // 3. If any of the following are true : + // token’s type is "char"; + // token’s type is "escaped-char"; + // or token’s type is "invalid-char", + // then return true. + if (token.type == TOKEN_TYPE::CHAR || + token.type == TOKEN_TYPE::ESCAPED_CHAR || + token.type == TOKEN_TYPE::INVALID_CHAR) { + return true; + } + return false; +} + +// https://wicg.github.io/urlpattern/#is-a-hash-prefix +ada_really_inline bool is_hash_prefix(std::vector &token_list, + size_t &index) { + // Return the result of running is a non-special pattern char given parser, + // parser’s token index and "#". + return is_nonspecial_pattern_char(token_list, index, '#'); +} + +/* +A constructor string parser has an associated state, a string, initially set to +"init". It must be one of the following: + + "init" + "protocol" + "authority" + "username" + "password" + "hostname" + "port" + "pathname" + "search" + "hash" + "done" +*/ + +enum PARSER_STATE { + INIT, + PROTOCOL, + AUTHORITY, + USERNAME, + PASSWORD, + HOSTNAME, + PORT, + PATHNAME, + SEARCH, + HASH, + DONE +}; + // https://wicg.github.io/urlpattern/#constructor-string-parser -ada_really_inline urlpattern_init string_parser(std::string_view input) { +ada_really_inline urlpattern_init +contructor_string_parser(std::u32string_view input) { // A constructor string parser has an associated token list, a token list, // which must be set upon creation. std::vector token_list = tokenize(input, POLICY::LENIENT); urlpattern_init result{}; + // A constructor string parser has an associated state, a string, initially + // set to "init" + PARSER_STATE state = INIT; + + // https://wicg.github.io/urlpattern/#change-state + const auto change_state = [&](PARSER_STATE &new_state, size_t &skip) { + // If parser’s state is not "init", not "authority", and not "done", then + // set parser’s result[parser’s state] to the result of running make a + // component string given parser. + if (state != INIT && state != AUTHORITY && state != DONE) { + result[""] + } + }; + + // https://wicg.github.io/urlpattern/#rewind + const auto rewind = [](size_t &index, size_t &token_increment) { + index = 0; + token_increment = 0; + }; + size_t index = 0; - while(index < token_list.size()) { - + size_t token_increment = 1; + // While parser’s token index is less than parser’s token list size: + while (index < token_list.size()) { + // If parser’s token list[parser’s token index]'s type is "end" then: + // If parser’s state is "init": + if (token_list[index].type == TOKEN_TYPE::END) { + if (state == INIT) { + // If we reached the end of the string in the "init" state, then we + // failed to find a protocol terminator and this must be a relative + // URLPattern constructor string. + + // Run rewind given parser. We next determine at which component the + // relative pattern begins Relative pathnames are most common, but URLs + // and URLPattern constructor strings can begin with the search or hash + // components as well. + rewind(index, token_increment); + + // We next determine at which component the relative pattern begins. + // Relative pathnames are most common, but URLs and URLPattern + // constructor strings can begin with the search or hash components as + // well. + if (is_hash_prefix(token_list, index)) { + } + } + } } return result; @@ -223,10 +352,8 @@ ada_really_inline urlpattern_init string_parser(std::string_view input) { // Run initialize given this, input, baseURL, and options. urlpattern::urlpattern(std::string_view input, std::optional base_url, - std::optional &options) {} - -urlpattern::urlpattern<>( - const std::string_view &input, const std::string_view base_url, - const std::optional &options) {} + std::optional &options) { + // convert input to utf32 +} } // namespace ada From 2e80ab3073ff7743c78f8defa97aeb9f878eea0e Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sat, 13 May 2023 22:50:06 -0300 Subject: [PATCH 09/23] urlpattern: introducing canonicalize_protocol --- src/urlpattern.cpp | 560 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 448 insertions(+), 112 deletions(-) diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index ecb1d6ee4..71576640e 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -2,7 +2,9 @@ #include "ada/unicode.h" #include "ada/urlpattern.h" #include "ada/ada_idna.h" +#include "ada/implementation.h" +#include #include #include #include @@ -11,6 +13,8 @@ namespace ada { +const static std::u32string DUMMY_URL = U"://dummy.test"; + ada_really_inline bool is_valid_name_code_point(const char32_t &c, bool is_first) noexcept { return is_first ? unicode::is_valid_identifier_start(c) @@ -19,6 +23,29 @@ ada_really_inline bool is_valid_name_code_point(const char32_t &c, ada_really_inline bool is_ascii(char32_t c) { return c < 0x80; } +// https://wicg.github.io/urlpattern/#canonicalize-a-protocol +ada_really_inline std::u32string_view canonicalize_protocol( + std::u32string_view protocol) { + // If value is the empty string, return value. + if (protocol.empty()) return protocol; + + // Let dummyURL be a new URL record. + // Let parseResult be the result of running the basic URL parser given value + // followed by "://dummy.test", with dummyURL as url. + + // TODO: make it cheaper + std::u32string url = std::u32string(protocol) + DUMMY_URL; + + auto utf8_size = ada::idna::utf8_length_from_utf32(url.data(), url.size()); + std::string final_utf8_url(utf8_size, '\0'); + ada::idna::utf32_to_utf8(url.data(), url.size(), final_utf8_url.data()); + + if (ada::can_parse(final_utf8_url)) { + return protocol; + } + throw std::invalid_argument("invalid protocol scheme"); +} + enum class TOKEN_TYPE { OPEN, CLOSE, @@ -36,7 +63,8 @@ enum class POLICY { STRICT, LENIENT }; struct TOKEN { TOKEN_TYPE type; - std::u32string_view value; + size_t value_start; + size_t value_end; }; ada_really_inline std::vector tokenize(std::u32string_view input, @@ -45,43 +73,48 @@ ada_really_inline std::vector tokenize(std::u32string_view input, size_t input_size = input.size(); const auto error_or_invalid = [&](const std::string_view msg, - const std::u32string_view value) { + size_t &value_start, size_t &value_end) { if (policy != POLICY::LENIENT) { throw std::invalid_argument(std::string(msg)); } - tokens.push_back({TOKEN_TYPE::INVALID_CHAR, value}); + tokens.push_back({TOKEN_TYPE::INVALID_CHAR, value_start, value_end}); }; size_t index = 0; while (index < input_size) { switch (input[index]) { case '*': { - tokens.push_back({TOKEN_TYPE::ASTERISK, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::ASTERISK, index, index}); ++index; break; } case '+': case '?': { - tokens.push_back({TOKEN_TYPE::OTHER_MODIFIER, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::OTHER_MODIFIER, /*value_start*/ index, + /*value_end*/ index}); ++index; break; } case '\\': { ++index; if (index == input_size - 1) { - error_or_invalid("should scape something", input.substr(index, 1)); + error_or_invalid("should scape something", /*value_start*/ index, + /*value_end*/ index); } - tokens.push_back({TOKEN_TYPE::ESCAPED_CHAR, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::ESCAPED_CHAR, /*value_start*/ index, + /*value_end*/ index}); break; } case '{': { - tokens.push_back({TOKEN_TYPE::OPEN, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::OPEN, /*value_start*/ index, + /*value_end*/ index}); ++index; break; } case '}': { - tokens.push_back({TOKEN_TYPE::CLOSE, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::CLOSE, /*value_start*/ index, + /*value_end*/ index}); ++index; break; } @@ -103,11 +136,12 @@ ada_really_inline std::vector tokenize(std::u32string_view input, // First character is not a valid name code point, so there's a // missing parameter name. error_or_invalid("missing parameter name", - input.substr(start, end - start)); + /*value_start*/ index, + /*value_end*/ index); continue; } - tokens.push_back({TOKEN_TYPE::NAME, input.substr(start, end - start)}); + tokens.push_back({TOKEN_TYPE::NAME, start, end}); index = end; break; @@ -126,28 +160,27 @@ ada_really_inline std::vector tokenize(std::u32string_view input, // tokenizer’s index. // Set error to true. if (!is_ascii(input[regexp])) { - error_or_invalid("invalid char for regex", input.substr(regexp, 1)); + error_or_invalid("invalid char for regex", regexp_start, regexp); error = true; break; } if (input[regexp] == '?' && (regexp == regexp_start)) { - error_or_invalid("malformed regex", input.substr(regexp, 1)); + error_or_invalid("malformed regex", regexp, regexp); error = true; break; } if (input[regexp] == '\\') { if (regexp == input_size - 1) { - error_or_invalid("malformed regex", input.substr(regexp, 1)); + error_or_invalid("malformed regex", regexp, regexp); error = true; break; } ++regexp; if (!is_ascii(input[regexp])) { - error_or_invalid("invalid char for regex", - input.substr(regexp, 1)); + error_or_invalid("invalid char for regex", regexp, regexp); error = true; break; @@ -164,13 +197,13 @@ ada_really_inline std::vector tokenize(std::u32string_view input, } else if (input[regexp] == '(') { ++depth; if (regexp == input_size - 1) { - error_or_invalid("malformed regex", input.substr(regexp, 1)); + error_or_invalid("malformed regex", regexp, regexp); error = true; break; } if (input[regexp + 1] != '?') { - error_or_invalid("malformed regex", input.substr(regexp, 1)); + error_or_invalid("malformed regex", regexp, regexp); error = true; break; @@ -183,57 +216,177 @@ ada_really_inline std::vector tokenize(std::u32string_view input, if (error) continue; if (depth) { - error_or_invalid("malformed regex", input.substr(regexp, 1)); + error_or_invalid("malformed regex", regexp, regexp); break; } if ((regexp - regexp_start) == 0) { - error_or_invalid("malformed regex", input.substr(regexp, 1)); + error_or_invalid("malformed regex", regexp, regexp); } - tokens.push_back({TOKEN_TYPE::REGEXP, - input.substr(regexp_start, regexp - regexp_start)}); + tokens.push_back({TOKEN_TYPE::REGEXP, regexp_start, regexp}); index = regexp; } } } // TODO: maybe group the TOKEN_TYPE::CHARs to make tokens cheaper - tokens.push_back({TOKEN_TYPE::CHAR, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::CHAR, /*value_start*/ index, + /*value_end*/ index}); } - tokens.push_back({TOKEN_TYPE::END, input.substr(index, 1)}); + tokens.push_back({TOKEN_TYPE::END, /*value_start*/ index, + /*value_end*/ index}); return tokens; } +enum PARSER_STATE { + INIT, + PROTOCOL, + AUTHORITY, + USERNAME, + PASSWORD, + HOSTNAME, + PORT, + PATHNAME, + SEARCH, + HASH, + DONE +}; + +// https://wicg.github.io/urlpattern/#constructor-string-parser +struct constructor_string_parser { + constructor_string_parser(std::u32string_view input); + + // https://wicg.github.io/urlpattern/#parse-a-constructor-string + ada_really_inline void parse(); + + // https://wicg.github.io/urlpattern/#change-state + ada_really_inline void change_state(PARSER_STATE new_state, size_t skip); + + // https://wicg.github.io/urlpattern/#rewind + ada_really_inline void rewind(); + + // https://wicg.github.io/urlpattern/#rewind-and-set-state + ada_really_inline void rewind_and_set_state(PARSER_STATE new_state); + + // https://wicg.github.io/urlpattern/#is-a-hash-prefix + ada_really_inline bool is_hash_prefix(); + + // https://wicg.github.io/urlpattern/#is-a-search-prefix + ada_really_inline bool is_search_prefix(); + + // https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char + ada_really_inline bool is_nonspecial_pattern_char(const char32_t &c); + + // https://wicg.github.io/urlpattern/#get-a-safe-token + ada_really_inline TOKEN *get_safe_token(size_t &index); + + // https://wicg.github.io/urlpattern/#is-a-group-open + ada_really_inline bool is_group_open(); + + // https://wicg.github.io/urlpattern/#is-a-group-close + ada_really_inline bool is_group_close(); + + // https://wicg.github.io/urlpattern/#is-a-protocol-suffix + ada_really_inline bool is_protocol_suffix(); + + // https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag + ada_really_inline void compute_protocol_matches_special_scheme_flag(); + + // https://wicg.github.io/urlpattern/#make-a-component-string + ada_really_inline std::u32string_view make_component_string(); + + // https://wicg.github.io/urlpattern/#compile-a-component + ada_really_inline void compile_component(); + + std::u32string_view input; + PARSER_STATE state; + urlpattern_init result; + std::vector token_list; + size_t component_start; + size_t token_index; + size_t token_increment; + size_t group_depth; + size_t hostname_ipv6_bracket_depth; + bool protocol_matches_special_scheme; +}; + // https://wicg.github.io/urlpattern/#get-a-safe-token -ada_really_inline TOKEN get_safe_token(std::vector &token_list, - size_t &index) { +ada_really_inline TOKEN *constructor_string_parser::get_safe_token( + size_t &index) { // 1. If index is less than parser’s token list's size, then return parser’s // token list[index]. - if (index < token_list.size()) return token_list[index]; + if (index < token_list.size()) return &token_list[index]; // 2. Assert: parser’s token list's size is greater than or equal to 1. // TODO: messages for the asserts? conditional and then throw error? assert(token_list.size() >= 1); // 3. Let last index be parser’s token list's size − 1. size_t last_index = token_list.size() - 1; // 4. Let token be parser’s token list[last index]. - TOKEN token = token_list[last_index]; // 5. Assert: token’s type is "end". - assert(token.type == TOKEN_TYPE::END); - return token; + assert(token_list[last_index] == TOKEN_TYPE::END); + return &token_list[last_index]; +} + +ada_really_inline bool constructor_string_parser::is_search_prefix() { + // If result of running is a non-special pattern char given parser, parser’s + // token index and "?" is true, then return true. + if (is_nonspecial_pattern_char('?')) { + return true; + } + + // If parser’s token list[parser’s token index]'s value is not "?", then + // return false. + + TOKEN *token = &token_list[token_index]; + + // TODO: improve this: + if (token->value_end - token->value_start != 0) return false; + + const char32_t c = '?'; + if (input.find(&c, token->value_start, 1) == std::u32string_view::npos) { + return false; + } + + // Let previous index be parser’s token index − 1. + size_t prev_index = token_index - 1; + if (prev_index < 0) return true; + + // Let previous token be the result of running get a safe token given parser + // and previous index. + TOKEN *prev_safe_token = get_safe_token(prev_index); + + // If any of the following are true, then return false: + // + // previous token’s type is "name". + // previous token’s type is "regexp". + // previous token’s type is "close". + // previous token’s type is "asterisk". + if (prev_safe_token->type == TOKEN_TYPE::NAME || + prev_safe_token->type == TOKEN_TYPE::REGEXP || + prev_safe_token->type == TOKEN_TYPE::CLOSE || + prev_safe_token->type == TOKEN_TYPE::ASTERISK) { + return false; + } + + return true; } // https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char -ada_really_inline bool is_nonspecial_pattern_char( - std::vector &token_list, size_t &index, const char32_t &c) { +ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( + const char32_t &c) { // 1. Let token be the result of running get a safe token given parser and // index. - // TODO: maybe return just the index to make it cheaper - TOKEN token = get_safe_token(token_list, index); + TOKEN *safe_token = get_safe_token(token_index); // 2. If token’s value is not value, then return false. - if (token.value[0] == c) { + // + + // TODO: improve this: + if (safe_token->value_end - safe_token->value_start != 0) return false; + + if (input.find(&c, safe_token->value_start, 1) == std::u32string_view::npos) { return false; } @@ -242,112 +395,295 @@ ada_really_inline bool is_nonspecial_pattern_char( // token’s type is "escaped-char"; // or token’s type is "invalid-char", // then return true. - if (token.type == TOKEN_TYPE::CHAR || - token.type == TOKEN_TYPE::ESCAPED_CHAR || - token.type == TOKEN_TYPE::INVALID_CHAR) { + if (safe_token->type == TOKEN_TYPE::CHAR || + safe_token->type == TOKEN_TYPE::ESCAPED_CHAR || + safe_token->type == TOKEN_TYPE::INVALID_CHAR) { return true; } return false; } // https://wicg.github.io/urlpattern/#is-a-hash-prefix -ada_really_inline bool is_hash_prefix(std::vector &token_list, - size_t &index) { +ada_really_inline bool constructor_string_parser::is_hash_prefix() { // Return the result of running is a non-special pattern char given parser, // parser’s token index and "#". - return is_nonspecial_pattern_char(token_list, index, '#'); + return is_nonspecial_pattern_char('#'); } -/* -A constructor string parser has an associated state, a string, initially set to -"init". It must be one of the following: - - "init" - "protocol" - "authority" - "username" - "password" - "hostname" - "port" - "pathname" - "search" - "hash" - "done" -*/ +// A constructor string parser is a struct. +// +// A constructor string parser has an associated input, a string, which must +// be set upon creation. +// +// A constructor string parser has an associated token list, a token list, +// which must be set upon creation. +// +// A constructor string parser has an associated result, a URLPatternInit, +// initially set to a new URLPatternInit. +// +// A constructor string parser has an associated component start, a number, +// initially set to 0. +// +// A constructor string parser has an associated token index, a number, +// initially set to 0. +// +// A constructor string parser has an associated token increment, a number, +// initially set to 1. +// +// A constructor string parser has an associated group depth, a number, +// initially set to 0. +// +// A constructor string parser has an associated hostname IPv6 bracket +// depth, a number, initially set to 0. +// +// A constructor string parser has an associated protocol matches a special +// scheme flag, a boolean, initially set to false. +// +// A constructor string parser has an associated state, a string, initially +// set to "init". It must be one of the following: +// +// "init" +// "protocol" +// "authority" +// "username" +// "password" +// "hostname" +// "port" +// "pathname" +// "search" +// "hash" +// "done" +constructor_string_parser::constructor_string_parser(std::u32string_view view) { + input = view; + token_list = tokenize(view, POLICY::LENIENT); + result = urlpattern_init(); + component_start = 0; + token_index = 0; + token_increment = 0; + group_depth = 0; + hostname_ipv6_bracket_depth = 0; + protocol_matches_special_scheme = 0; + state = INIT; +} -enum PARSER_STATE { - INIT, - PROTOCOL, - AUTHORITY, - USERNAME, - PASSWORD, - HOSTNAME, - PORT, - PATHNAME, - SEARCH, - HASH, - DONE -}; +ada_really_inline void constructor_string_parser::rewind() { + token_index = component_start; + token_increment = 0; +} -// https://wicg.github.io/urlpattern/#constructor-string-parser -ada_really_inline urlpattern_init -contructor_string_parser(std::u32string_view input) { - // A constructor string parser has an associated token list, a token list, - // which must be set upon creation. - std::vector token_list = tokenize(input, POLICY::LENIENT); - urlpattern_init result{}; +ada_really_inline void constructor_string_parser::rewind_and_set_state( + PARSER_STATE new_state) { + // Run rewind given parser. + // Set parser’s state to state. - // A constructor string parser has an associated state, a string, initially - // set to "init" - PARSER_STATE state = INIT; + rewind(); + state = new_state; +} - // https://wicg.github.io/urlpattern/#change-state - const auto change_state = [&](PARSER_STATE &new_state, size_t &skip) { - // If parser’s state is not "init", not "authority", and not "done", then - // set parser’s result[parser’s state] to the result of running make a - // component string given parser. - if (state != INIT && state != AUTHORITY && state != DONE) { - result[""] - } - }; +ada_really_inline bool constructor_string_parser::is_group_open() { + // If parser’s token list[parser’s token index]'s type is "open", then + // return true. Else return false. + return token_list[token_index].type == TOKEN_TYPE::OPEN; +} - // https://wicg.github.io/urlpattern/#rewind - const auto rewind = [](size_t &index, size_t &token_increment) { - index = 0; - token_increment = 0; - }; +ada_really_inline bool constructor_string_parser::is_group_close() { + // If parser’s token list[parser’s token index]'s type is "close", then + // return + // true. Else return false. + return token_list[token_index].type == TOKEN_TYPE::CLOSE; +} - size_t index = 0; - size_t token_increment = 1; - // While parser’s token index is less than parser’s token list size: - while (index < token_list.size()) { +ada_really_inline bool constructor_string_parser::is_protocol_suffix() { + // Return the result of running is a non-special pattern char given parser, + // parser’s token index, and ":". + return is_nonspecial_pattern_char(':'); +} + +ada_really_inline void constructor_string_parser::compile_component() {} + +ada_really_inline std::u32string_view +constructor_string_parser::make_component_string() { + // Assert: parser’s token index is less than parser’s token list's size. + assert(token_index < token_list.size()); + + // Let token be parser’s token list[parser’s token index]. + // TOKEN *token = &token_list[token_index]; + + // Let component start token be the result of running get a safe token given + // parser and parser’s component start. + TOKEN *safe_token = get_safe_token(component_start); + + // Let component start input index be component start token’s index. + size_t component_start_index = safe_token->value_start; + + // Let end index be token’s index. + size_t end = token_list[token_index].value_start; + + // Return the code point substring from component start input index to end + // index within parser’s input. + return input.substr(component_start_index, end); +} + +ada_really_inline void +constructor_string_parser::compute_protocol_matches_special_scheme_flag() { + std::u32string_view protocol = make_component_string(); + // Let protocol component be the result of compiling a component given + // protocol string, canonicalize a protocol, and default options. +} + +ada_really_inline void constructor_string_parser::parse() { + // 2. While parser’s token index is less than parser’s token list size: + while (token_index < token_list.size()) { + // Set parser’s token increment to 1. + token_increment = 1; // If parser’s token list[parser’s token index]'s type is "end" then: - // If parser’s state is "init": - if (token_list[index].type == TOKEN_TYPE::END) { - if (state == INIT) { - // If we reached the end of the string in the "init" state, then we - // failed to find a protocol terminator and this must be a relative - // URLPattern constructor string. - // Run rewind given parser. We next determine at which component the - // relative pattern begins Relative pathnames are most common, but URLs - // and URLPattern constructor strings can begin with the search or hash - // components as well. - rewind(index, token_increment); + if (token_list[token_index].type == TOKEN_TYPE::END) { + if (state == INIT) { + // If parser’s state is "init": + // Run rewind given parser. + rewind(); // We next determine at which component the relative pattern begins. // Relative pathnames are most common, but URLs and URLPattern // constructor strings can begin with the search or hash components as // well. - if (is_hash_prefix(token_list, index)) { + + // If the result of running is a hash prefix given parser is true, then + // run change state given parser, "hash" and 1. + if (is_hash_prefix()) { + change_state(HASH, 1); + } else if (is_search_prefix()) { + // Else if the result of running is a search prefix given parser is + // true + // Run change state given parser, "search" and 1 + // Set parser’s result["hash"] to the empty string. + change_state(SEARCH, 1); + result.hash = ""; + } else { + // Run change state given parser, "pathname" and 0. + change_state(PATHNAME, 0); + // Set parser’s result["search"] to the empty string. + result.search = ""; + result.hash = ""; } + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + continue; + } + + if (state == AUTHORITY) { + // If we reached the end of the string in the "authority" state, then we + // failed to find an "@". Therefore there is no username or password. + + // Run rewind and set state given parser, and "hostname". + rewind_and_set_state(PARSER_STATE::HOSTNAME); + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + + continue; + } + + // Run change state given parser, "done" and 0. + change_state(PARSER_STATE::DONE, 0); + break; + } + + if (is_group_open()) { + // Increment parser’s group depth by 1. + ++group_depth; + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + continue; + } + + // If parser’s group depth is greater than 0: + if (group_depth > 0) { + // If the result of running is a group close given parser is true, then + // decrement parser’s group depth by 1. + if (is_group_close()) { + --group_depth; + } else { + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + continue; } } - } - return result; + // Switch on parser’s state and run the associated steps: + switch (state) { + case INIT: { + if (is_protocol_suffix()) { + // We found a protocol suffix, so this must be an absolute URLPattern + // constructor string. Therefore initialize all component to the empty + // string. + result.username = ""; + result.password = ""; + result.hostname = ""; + result.port = ""; + result.pathname = ""; + result.search = ""; + result.hash = ""; + + // Run rewind and set state given parser and "protocol". + rewind_and_set_state(PROTOCOL); + } + break; + } + case PROTOCOL: { + if (is_protocol_suffix()) { + } + } + } + } } +ada_really_inline void constructor_string_parser::change_state( + PARSER_STATE new_state, size_t skip) { + // 1. If parser’s state is not "init", not "authority", and not "done", then + // set parser’s result[parser’s state] to the result of running make a + // component string given parser. + if (state != INIT && state != AUTHORITY && state != DONE) { + // TODO improve this: + switch (state) { + case PROTOCOL: + result.protocol = ""; + break; + case USERNAME: + result.username = ""; + break; + case PASSWORD: + result.password = ""; + break; + case HOSTNAME: + result.hostname = ""; + break; + case PORT: + result.port = ""; + break; + case PATHNAME: + result.pathname = ""; + break; + case SEARCH: + result.search = ""; + break; + case HASH: + result.hash = ""; + break; + default: + break; + } + } + // 2. Set parser’s state to new state. + state = new_state; + // 3. Increment parser’s token index by skip. + token_index += skip; + // 4. Set parser’s component start to parser’s token index. + component_start = token_index; + // 5. Set parser’s token increment to 0. + token_increment = 0; +}; + // The new URLPattern(input, baseURL, options) constructor steps are: // Run initialize given this, input, baseURL, and options. urlpattern::urlpattern(std::string_view input, From 17ee73db37100d8aabb1673fc1fe061a10c042a0 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sat, 13 May 2023 23:43:56 -0300 Subject: [PATCH 10/23] urlpatter: adds pragma regions --- include/ada/urlpattern.h | 3 + src/urlpattern.cpp | 425 ++++++++++++++++++--------------------- 2 files changed, 201 insertions(+), 227 deletions(-) diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index 5de413eb7..ef7f48b2f 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -13,7 +13,10 @@ namespace ada { ada_really_inline bool is_valid_name_code_point(const char32_t &c, bool is_first) noexcept; +// https://wicg.github.io/urlpattern/#options struct urlpattern_options { + std::string_view delimiter = ""; + std::string_view prefix = ""; bool ignore_case = false; }; diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index 71576640e..953b90a1f 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -46,6 +46,17 @@ ada_really_inline std::u32string_view canonicalize_protocol( throw std::invalid_argument("invalid protocol scheme"); } +// https://wicg.github.io/urlpattern/#compile-a-component +ada_really_inline std::string_view compile_component( + std::u32string_view input, std::function &callback, + urlpattern_options &options) { + // If input is null, then set input to "*". + if (input.empty()) return "*"; +} + +// ########## TOKENIZER ########## +#pragma region TOKENIZER + enum class TOKEN_TYPE { OPEN, CLOSE, @@ -59,14 +70,14 @@ enum class TOKEN_TYPE { INVALID_CHAR }; -enum class POLICY { STRICT, LENIENT }; - struct TOKEN { TOKEN_TYPE type; size_t value_start; size_t value_end; }; +enum class POLICY { STRICT, LENIENT }; + ada_really_inline std::vector tokenize(std::u32string_view input, POLICY policy) { std::vector tokens{}; @@ -239,6 +250,10 @@ ada_really_inline std::vector tokenize(std::u32string_view input, /*value_end*/ index}); return tokens; } +#pragma endregion TOKENIZER + +// ########## CONSTRUCTOR STRING PARSER ########## +#pragma region CONSTRUCTOR STRING PARSER enum PARSER_STATE { INIT, @@ -297,240 +312,25 @@ struct constructor_string_parser { // https://wicg.github.io/urlpattern/#make-a-component-string ada_really_inline std::u32string_view make_component_string(); - // https://wicg.github.io/urlpattern/#compile-a-component - ada_really_inline void compile_component(); - std::u32string_view input; - PARSER_STATE state; - urlpattern_init result; std::vector token_list; - size_t component_start; - size_t token_index; - size_t token_increment; - size_t group_depth; - size_t hostname_ipv6_bracket_depth; - bool protocol_matches_special_scheme; + size_t component_start = 0; + size_t token_index = 0; + size_t token_increment = 0; + size_t group_depth = 0; + size_t hostname_ipv6_bracket_depth = 0; + bool protocol_matches_special_scheme = false; + PARSER_STATE state = INIT; + urlpattern_init result = urlpattern_init(); }; -// https://wicg.github.io/urlpattern/#get-a-safe-token -ada_really_inline TOKEN *constructor_string_parser::get_safe_token( - size_t &index) { - // 1. If index is less than parser’s token list's size, then return parser’s - // token list[index]. - if (index < token_list.size()) return &token_list[index]; - // 2. Assert: parser’s token list's size is greater than or equal to 1. - // TODO: messages for the asserts? conditional and then throw error? - assert(token_list.size() >= 1); - // 3. Let last index be parser’s token list's size − 1. - size_t last_index = token_list.size() - 1; - // 4. Let token be parser’s token list[last index]. - // 5. Assert: token’s type is "end". - assert(token_list[last_index] == TOKEN_TYPE::END); - return &token_list[last_index]; -} - -ada_really_inline bool constructor_string_parser::is_search_prefix() { - // If result of running is a non-special pattern char given parser, parser’s - // token index and "?" is true, then return true. - if (is_nonspecial_pattern_char('?')) { - return true; - } - - // If parser’s token list[parser’s token index]'s value is not "?", then - // return false. - - TOKEN *token = &token_list[token_index]; - - // TODO: improve this: - if (token->value_end - token->value_start != 0) return false; - - const char32_t c = '?'; - if (input.find(&c, token->value_start, 1) == std::u32string_view::npos) { - return false; - } - - // Let previous index be parser’s token index − 1. - size_t prev_index = token_index - 1; - if (prev_index < 0) return true; - - // Let previous token be the result of running get a safe token given parser - // and previous index. - TOKEN *prev_safe_token = get_safe_token(prev_index); - - // If any of the following are true, then return false: - // - // previous token’s type is "name". - // previous token’s type is "regexp". - // previous token’s type is "close". - // previous token’s type is "asterisk". - if (prev_safe_token->type == TOKEN_TYPE::NAME || - prev_safe_token->type == TOKEN_TYPE::REGEXP || - prev_safe_token->type == TOKEN_TYPE::CLOSE || - prev_safe_token->type == TOKEN_TYPE::ASTERISK) { - return false; - } - - return true; -} - -// https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char -ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( - const char32_t &c) { - // 1. Let token be the result of running get a safe token given parser and - // index. - TOKEN *safe_token = get_safe_token(token_index); - - // 2. If token’s value is not value, then return false. - // - - // TODO: improve this: - if (safe_token->value_end - safe_token->value_start != 0) return false; - - if (input.find(&c, safe_token->value_start, 1) == std::u32string_view::npos) { - return false; - } - - // 3. If any of the following are true : - // token’s type is "char"; - // token’s type is "escaped-char"; - // or token’s type is "invalid-char", - // then return true. - if (safe_token->type == TOKEN_TYPE::CHAR || - safe_token->type == TOKEN_TYPE::ESCAPED_CHAR || - safe_token->type == TOKEN_TYPE::INVALID_CHAR) { - return true; - } - return false; -} - -// https://wicg.github.io/urlpattern/#is-a-hash-prefix -ada_really_inline bool constructor_string_parser::is_hash_prefix() { - // Return the result of running is a non-special pattern char given parser, - // parser’s token index and "#". - return is_nonspecial_pattern_char('#'); -} - -// A constructor string parser is a struct. -// -// A constructor string parser has an associated input, a string, which must -// be set upon creation. -// -// A constructor string parser has an associated token list, a token list, -// which must be set upon creation. -// -// A constructor string parser has an associated result, a URLPatternInit, -// initially set to a new URLPatternInit. -// -// A constructor string parser has an associated component start, a number, -// initially set to 0. -// -// A constructor string parser has an associated token index, a number, -// initially set to 0. -// -// A constructor string parser has an associated token increment, a number, -// initially set to 1. -// -// A constructor string parser has an associated group depth, a number, -// initially set to 0. -// -// A constructor string parser has an associated hostname IPv6 bracket -// depth, a number, initially set to 0. -// -// A constructor string parser has an associated protocol matches a special -// scheme flag, a boolean, initially set to false. -// -// A constructor string parser has an associated state, a string, initially -// set to "init". It must be one of the following: -// -// "init" -// "protocol" -// "authority" -// "username" -// "password" -// "hostname" -// "port" -// "pathname" -// "search" -// "hash" -// "done" +// https://wicg.github.io/urlpattern/#constructor-string-parser constructor_string_parser::constructor_string_parser(std::u32string_view view) { input = view; token_list = tokenize(view, POLICY::LENIENT); - result = urlpattern_init(); - component_start = 0; - token_index = 0; - token_increment = 0; - group_depth = 0; - hostname_ipv6_bracket_depth = 0; - protocol_matches_special_scheme = 0; - state = INIT; -} - -ada_really_inline void constructor_string_parser::rewind() { - token_index = component_start; - token_increment = 0; -} - -ada_really_inline void constructor_string_parser::rewind_and_set_state( - PARSER_STATE new_state) { - // Run rewind given parser. - // Set parser’s state to state. - - rewind(); - state = new_state; -} - -ada_really_inline bool constructor_string_parser::is_group_open() { - // If parser’s token list[parser’s token index]'s type is "open", then - // return true. Else return false. - return token_list[token_index].type == TOKEN_TYPE::OPEN; -} - -ada_really_inline bool constructor_string_parser::is_group_close() { - // If parser’s token list[parser’s token index]'s type is "close", then - // return - // true. Else return false. - return token_list[token_index].type == TOKEN_TYPE::CLOSE; -} - -ada_really_inline bool constructor_string_parser::is_protocol_suffix() { - // Return the result of running is a non-special pattern char given parser, - // parser’s token index, and ":". - return is_nonspecial_pattern_char(':'); -} - -ada_really_inline void constructor_string_parser::compile_component() {} - -ada_really_inline std::u32string_view -constructor_string_parser::make_component_string() { - // Assert: parser’s token index is less than parser’s token list's size. - assert(token_index < token_list.size()); - - // Let token be parser’s token list[parser’s token index]. - // TOKEN *token = &token_list[token_index]; - - // Let component start token be the result of running get a safe token given - // parser and parser’s component start. - TOKEN *safe_token = get_safe_token(component_start); - - // Let component start input index be component start token’s index. - size_t component_start_index = safe_token->value_start; - - // Let end index be token’s index. - size_t end = token_list[token_index].value_start; - - // Return the code point substring from component start input index to end - // index within parser’s input. - return input.substr(component_start_index, end); -} - -ada_really_inline void -constructor_string_parser::compute_protocol_matches_special_scheme_flag() { - std::u32string_view protocol = make_component_string(); - // Let protocol component be the result of compiling a component given - // protocol string, canonicalize a protocol, and default options. } +// https://wicg.github.io/urlpattern/#parse-a-constructor-string ada_really_inline void constructor_string_parser::parse() { // 2. While parser’s token index is less than parser’s token list size: while (token_index < token_list.size()) { @@ -638,6 +438,7 @@ ada_really_inline void constructor_string_parser::parse() { } } +// https://wicg.github.io/urlpattern/#change-state ada_really_inline void constructor_string_parser::change_state( PARSER_STATE new_state, size_t skip) { // 1. If parser’s state is not "init", not "authority", and not "done", then @@ -684,6 +485,176 @@ ada_really_inline void constructor_string_parser::change_state( token_increment = 0; }; +// https://wicg.github.io/urlpattern/#rewind +ada_really_inline void constructor_string_parser::rewind() { + token_index = component_start; + token_increment = 0; +} + +// https://wicg.github.io/urlpattern/#rewind-and-set-state +ada_really_inline void constructor_string_parser::rewind_and_set_state( + PARSER_STATE new_state) { + // Run rewind given parser. + // Set parser’s state to state. + + rewind(); + state = new_state; +} + +// https://wicg.github.io/urlpattern/#is-a-hash-prefix +ada_really_inline bool constructor_string_parser::is_hash_prefix() { + // Return the result of running is a non-special pattern char given parser, + // parser’s token index and "#". + return is_nonspecial_pattern_char('#'); +} + +// https://wicg.github.io/urlpattern/#is-a-search-prefix +ada_really_inline bool constructor_string_parser::is_search_prefix() { + // If result of running is a non-special pattern char given parser, parser’s + // token index and "?" is true, then return true. + if (is_nonspecial_pattern_char('?')) { + return true; + } + + // If parser’s token list[parser’s token index]'s value is not "?", then + // return false. + + TOKEN *token = &token_list[token_index]; + + // TODO: improve this: + if (token->value_end - token->value_start != 0) return false; + + const char32_t c = '?'; + if (input.find(&c, token->value_start, 1) == std::u32string_view::npos) { + return false; + } + + // Let previous index be parser’s token index − 1. + size_t prev_index = token_index - 1; + if (prev_index < 0) return true; + + // Let previous token be the result of running get a safe token given parser + // and previous index. + TOKEN *prev_safe_token = get_safe_token(prev_index); + + // If any of the following are true, then return false: + // + // previous token’s type is "name". + // previous token’s type is "regexp". + // previous token’s type is "close". + // previous token’s type is "asterisk". + if (prev_safe_token->type == TOKEN_TYPE::NAME || + prev_safe_token->type == TOKEN_TYPE::REGEXP || + prev_safe_token->type == TOKEN_TYPE::CLOSE || + prev_safe_token->type == TOKEN_TYPE::ASTERISK) { + return false; + } + + return true; +} + +// https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char +ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( + const char32_t &c) { + // 1. Let token be the result of running get a safe token given parser and + // index. + TOKEN *safe_token = get_safe_token(token_index); + + // 2. If token’s value is not value, then return false. + // + + // TODO: improve this: + if (safe_token->value_end - safe_token->value_start != 0) return false; + + if (input.find(&c, safe_token->value_start, 1) == std::u32string_view::npos) { + return false; + } + + // 3. If any of the following are true : + // token’s type is "char"; + // token’s type is "escaped-char"; + // or token’s type is "invalid-char", + // then return true. + if (safe_token->type == TOKEN_TYPE::CHAR || + safe_token->type == TOKEN_TYPE::ESCAPED_CHAR || + safe_token->type == TOKEN_TYPE::INVALID_CHAR) { + return true; + } + return false; +} + +// https://wicg.github.io/urlpattern/#get-a-safe-token +ada_really_inline TOKEN *constructor_string_parser::get_safe_token( + size_t &index) { + // 1. If index is less than parser’s token list's size, then return parser’s + // token list[index]. + if (index < token_list.size()) return &token_list[index]; + // 2. Assert: parser’s token list's size is greater than or equal to 1. + // TODO: messages for the asserts? conditional and then throw error? + assert(token_list.size() >= 1); + // 3. Let last index be parser’s token list's size − 1. + size_t last_index = token_list.size() - 1; + // 4. Let token be parser’s token list[last index]. + // 5. Assert: token’s type is "end". + assert(token_list[last_index] == TOKEN_TYPE::END); + return &token_list[last_index]; +} + +// https://wicg.github.io/urlpattern/#is-a-group-open +ada_really_inline bool constructor_string_parser::is_group_open() { + // If parser’s token list[parser’s token index]'s type is "open", then + // return true. Else return false. + return token_list[token_index].type == TOKEN_TYPE::OPEN; +} + +// https://wicg.github.io/urlpattern/#is-a-group-close +ada_really_inline bool constructor_string_parser::is_group_close() { + // If parser’s token list[parser’s token index]'s type is "close", then + // return + // true. Else return false. + return token_list[token_index].type == TOKEN_TYPE::CLOSE; +} + +// https://wicg.github.io/urlpattern/#is-a-protocol-suffix +ada_really_inline bool constructor_string_parser::is_protocol_suffix() { + // Return the result of running is a non-special pattern char given parser, + // parser’s token index, and ":". + return is_nonspecial_pattern_char(':'); +} + +// https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag +ada_really_inline void +constructor_string_parser::compute_protocol_matches_special_scheme_flag() { + std::u32string_view protocol = make_component_string(); + // Let protocol component be the result of compiling a component given + // protocol string, canonicalize a protocol, and default options. +} + +// https://wicg.github.io/urlpattern/#make-a-component-string +ada_really_inline std::u32string_view +constructor_string_parser::make_component_string() { + // Assert: parser’s token index is less than parser’s token list's size. + assert(token_index < token_list.size()); + + // Let token be parser’s token list[parser’s token index]. + // TOKEN *token = &token_list[token_index]; + + // Let component start token be the result of running get a safe token given + // parser and parser’s component start. + TOKEN *safe_token = get_safe_token(component_start); + + // Let component start input index be component start token’s index. + size_t component_start_index = safe_token->value_start; + + // Let end index be token’s index. + size_t end = token_list[token_index].value_start; + + // Return the code point substring from component start input index to end + // index within parser’s input. + return input.substr(component_start_index, end); +} +#pragma endregion CONSTRUCTOR STRING PARSER + // The new URLPattern(input, baseURL, options) constructor steps are: // Run initialize given this, input, baseURL, and options. urlpattern::urlpattern(std::string_view input, From 9ae30c4f5f9e53419790fb82a8d7e0fb9a9625b2 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sun, 14 May 2023 21:29:39 -0300 Subject: [PATCH 11/23] urlpattern: breakdown in multiple files --- include/ada.h | 4 + include/ada/ada_idna.h | 2 +- include/ada/urlpattern.h | 28 +- include/ada/urlpattern_base.h | 28 + .../urlpattern_constructor_string_parser.h | 81 +++ include/ada/urlpattern_pattern_parser.h | 70 ++ include/ada/urlpattern_tokenizer.h | 71 ++ src/ada.cpp | 3 + src/urlpattern.cpp | 652 +----------------- src/urlpattern_constructor_string_parser.cpp | 373 ++++++++++ src/urlpattern_pattern_parser.cpp | 167 +++++ src/urlpattern_tokenizer.cpp | 226 ++++++ 12 files changed, 1033 insertions(+), 672 deletions(-) create mode 100644 include/ada/urlpattern_base.h create mode 100644 include/ada/urlpattern_constructor_string_parser.h create mode 100644 include/ada/urlpattern_pattern_parser.h create mode 100644 include/ada/urlpattern_tokenizer.h create mode 100644 src/urlpattern_constructor_string_parser.cpp create mode 100644 src/urlpattern_pattern_parser.cpp create mode 100644 src/urlpattern_tokenizer.cpp diff --git a/include/ada.h b/include/ada.h index 9ca33aa46..ee4c29fba 100644 --- a/include/ada.h +++ b/include/ada.h @@ -23,6 +23,10 @@ #include "ada/url_components.h" #include "ada/url_aggregator.h" #include "ada/url_aggregator-inl.h" +#include "ada/urlpattern_base.h" +#include "ada/urlpattern_tokenizer.h" +#include "ada/urlpattern_constructor_string_parser.h" +#include "ada/urlpattern_pattern_parser.h" #include "ada/urlpattern.h" // Public API diff --git a/include/ada/ada_idna.h b/include/ada/ada_idna.h index 536a339d8..c0823f887 100644 --- a/include/ada/ada_idna.h +++ b/include/ada/ada_idna.h @@ -1,4 +1,4 @@ -/* auto-generated on 2023-05-07 19:12:14 -0400. Do not edit! */ +/* auto-generated on 2023-04-26 14:14:42 -0400. Do not edit! */ /* begin file include/idna.h */ #ifndef ADA_IDNA_H #define ADA_IDNA_H diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index ef7f48b2f..9ee4ec463 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -3,40 +3,20 @@ #include "ada/common_defs.h" +#include "urlpattern_base.h" + #include -#include #include #include -namespace ada { - -ada_really_inline bool is_valid_name_code_point(const char32_t &c, - bool is_first) noexcept; - +namespace ada::urlpattern { // https://wicg.github.io/urlpattern/#options -struct urlpattern_options { - std::string_view delimiter = ""; - std::string_view prefix = ""; - bool ignore_case = false; -}; struct urlpattern_component_result { std::string_view input; std::unordered_map> groups; }; -struct urlpattern_init { - std::string_view protocol; - std::string_view username; - std::string_view password; - std::string_view hostname; - std::string_view port; - std::string_view pathname; - std::string_view search; - std::string_view hash; - std::string_view base_url; -}; - template struct urlpattern_result { urlpattern_component_result protocol; @@ -68,6 +48,6 @@ struct urlpattern { const std::string_view hash; }; -} // namespace ada +} // namespace ada::urlpattern #endif diff --git a/include/ada/urlpattern_base.h b/include/ada/urlpattern_base.h new file mode 100644 index 000000000..23534fc4c --- /dev/null +++ b/include/ada/urlpattern_base.h @@ -0,0 +1,28 @@ +#ifndef ADA_URLPATTERN_BASE_H +#define ADA_URLPATTERN_BASE_H + +#include + +namespace ada::urlpattern { + +struct urlpattern_options { + std::string_view delimiter = ""; + std::string_view prefix = ""; + bool ignore_case = false; +}; + +struct urlpattern_init { + std::string_view protocol; + std::string_view username; + std::string_view password; + std::string_view hostname; + std::string_view port; + std::string_view pathname; + std::string_view search; + std::string_view hash; + std::string_view base_url; +}; + +} // namespace ada::urlpattern + +#endif \ No newline at end of file diff --git a/include/ada/urlpattern_constructor_string_parser.h b/include/ada/urlpattern_constructor_string_parser.h new file mode 100644 index 000000000..43007b48f --- /dev/null +++ b/include/ada/urlpattern_constructor_string_parser.h @@ -0,0 +1,81 @@ +#ifndef ADA_URLPATTERN_CONSTRUCTOR_STRING_PARSER_H +#define ADA_URLPATTERN_CONSTRUCTOR_STRING_PARSER_H + +#include "ada/helpers.h" + +#include "ada/urlpattern_base.h" +#include "ada/urlpattern_tokenizer.h" + +namespace ada::urlpattern { + +enum class PARSER_STATE : uint8_t { + INIT, + PROTOCOL, + AUTHORITY, + USERNAME, + PASSWORD, + HOSTNAME, + PORT, + PATHNAME, + SEARCH, + HASH, + DONE +}; + +// https://wicg.github.io/urlpattern/#constructor-string-parser +struct constructor_string_parser { + ada_really_inline constructor_string_parser(std::u32string_view input); + + // https://wicg.github.io/urlpattern/#parse-a-constructor-string + ada_really_inline void parse(); + + // https://wicg.github.io/urlpattern/#change-state + ada_really_inline void change_state(PARSER_STATE new_state, size_t skip); + + // https://wicg.github.io/urlpattern/#rewind + ada_really_inline void rewind(); + + // https://wicg.github.io/urlpattern/#rewind-and-set-state + ada_really_inline void rewind_and_set_state(PARSER_STATE new_state); + + // https://wicg.github.io/urlpattern/#is-a-hash-prefix + ada_really_inline bool is_hash_prefix(); + + // https://wicg.github.io/urlpattern/#is-a-search-prefix + ada_really_inline bool is_search_prefix(); + + // https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char + ada_really_inline bool is_nonspecial_pattern_char(const char32_t &c); + + // https://wicg.github.io/urlpattern/#get-a-safe-token + ada_really_inline token *get_safe_token(size_t &index); + + // https://wicg.github.io/urlpattern/#is-a-group-open + ada_really_inline bool is_group_open(); + + // https://wicg.github.io/urlpattern/#is-a-group-close + ada_really_inline bool is_group_close(); + + // https://wicg.github.io/urlpattern/#is-a-protocol-suffix + ada_really_inline bool is_protocol_suffix(); + + // https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag + ada_really_inline void compute_protocol_matches_special_scheme_flag(); + + // https://wicg.github.io/urlpattern/#make-a-component-string + ada_really_inline std::u32string_view make_component_string(); + + std::u32string_view input; + std::vector token_list; + size_t component_start = 0; + size_t token_index = 0; + size_t token_increment = 0; + size_t group_depth = 0; + size_t hostname_ipv6_bracket_depth = 0; + bool protocol_matches_special_scheme = false; + urlpattern_init result = urlpattern_init(); + PARSER_STATE state = PARSER_STATE::INIT; +}; +} // namespace ada::urlpattern + +#endif \ No newline at end of file diff --git a/include/ada/urlpattern_pattern_parser.h b/include/ada/urlpattern_pattern_parser.h new file mode 100644 index 000000000..e0a13fd4f --- /dev/null +++ b/include/ada/urlpattern_pattern_parser.h @@ -0,0 +1,70 @@ +#ifndef ADA_URLPATTERN_PATTERN_PARSER_H +#define ADA_URLPATTERN_PATTERN_PARSER_H + +#include "ada/helpers.h" + +#include "ada/urlpattern_base.h" +#include "ada/urlpattern_tokenizer.h" + +#include + +namespace ada::urlpattern { + +enum class PART_TYPE : uint8_t { + FIXED_TEXT, + REGEXP, + SEGMENT_WILDCARD, + FULL_WILDCARD +}; +enum class PART_MODIFIER : uint8_t { + NONE, + OPTIONAL, + ZERO_OR_MORE, + ONE_OR_MORE +}; + +// https://wicg.github.io/urlpattern/#part +struct part { + PART_TYPE type; + PART_MODIFIER modifier; + std::string_view value; + std::string_view name{}; + std::string_view prefix{}; + std::string_view suffix{}; +}; + +// https://wicg.github.io/urlpattern/#pattern-parser +struct pattern_parser { + // https://wicg.github.io/urlpattern/#parse-a-pattern-string + ada_really_inline std::vector parse_pattern_string( + std::u32string_view input, urlpattern_options &options, + std::function &encoding); + + // https://wicg.github.io/urlpattern/#try-to-consume-a-token + ada_really_inline std::optional try_to_consume_token( + TOKEN_TYPE type); + + // https://wicg.github.io/urlpattern/#try-to-consume-a-regexp-or-wildcard-token + ada_really_inline std::optional + try_to_consume_regexp_or_wildcard_token(std::optional &name_token); + + // https://wicg.github.io/urlpattern/#maybe-add-a-part-from-the-pending-fixed-value + ada_really_inline void maybe_add_part_from_pendind_fixed_value(); + + std::vector token_list; + std::function encoding_callback; + std::string segment_wildcard_regexp; + std::u32string pending_fixed_value{}; + size_t index = 0; + size_t next_numeric_name = 0; + std::vector part_list{}; + + private: + ada_really_inline pattern_parser( + std::function &encoding, + std::string_view wildcard_regexp); +}; + +} // namespace ada::urlpattern + +#endif \ No newline at end of file diff --git a/include/ada/urlpattern_tokenizer.h b/include/ada/urlpattern_tokenizer.h new file mode 100644 index 000000000..1e66b095e --- /dev/null +++ b/include/ada/urlpattern_tokenizer.h @@ -0,0 +1,71 @@ +#ifndef ADA_URLPATTERN_TOKENIZER_H +#define ADA_URLPATTERN_TOKENIZER_H + +#include "ada/helpers.h" + +#include +#include +#include + +namespace ada::urlpattern { + +enum class TOKEN_TYPE : uint8_t { + OPEN, + CLOSE, + REGEXP, + NAME, + CHAR, + ESCAPED_CHAR, + OTHER_MODIFIER, + ASTERISK, + END, + INVALID_CHAR +}; + +struct token { + TOKEN_TYPE type; + size_t value_start; + size_t value_end; +}; + +enum class POLICY : uint8_t { STRICT, LENIENT }; + +// https://wicg.github.io/urlpattern/#tokenizer +struct tokenizer { + std::u32string_view input{}; + POLICY policy = POLICY::STRICT; + std::vector token_list{}; + size_t index = 0; + size_t next_index = 0; + char32_t code_point; + + /** + * Tokenize is a step in the approach used by the URLPattern API for parsing + * patterns. + * @see https://wicg.github.io/urlpattern/#tokenize and + * https://wicg.github.io/urlpattern/#parsing-patterns + */ + static std::vector tokenize(std::u32string_view input, POLICY policy); + + // https://wicg.github.io/urlpattern/#seek-and-get-the-next-code-point + ada_really_inline void seek_and_get_next_code_point(); + + // https://wicg.github.io/urlpattern/#get-the-next-code-point + ada_really_inline void get_next_code_point(); + + // https://wicg.github.io/urlpattern/#add-a-token + ada_really_inline void add_token(TOKEN_TYPE type, size_t next_pos, + size_t value_start, size_t value_end); + + // https://wicg.github.io/urlpattern/#process-a-tokenizing-error + ada_really_inline void process_tokenizing_error(std::string_view msg, + size_t value_start, + size_t value_end); + + private: + tokenizer(); +}; + +} // namespace ada::urlpattern + +#endif \ No newline at end of file diff --git a/src/ada.cpp b/src/ada.cpp index 398f11a8f..5ab919840 100644 --- a/src/ada.cpp +++ b/src/ada.cpp @@ -10,5 +10,8 @@ #include "parser.cpp" #include "url_components.cpp" #include "url_aggregator.cpp" +#include "urlpattern_tokenizer.cpp" +#include "urlpattern_constructor_string_parser.cpp" +#include "urlpattern_pattern_parser" #include "urlpattern.cpp" #include "ada_c.cpp" diff --git a/src/urlpattern.cpp b/src/urlpattern.cpp index 953b90a1f..e4b22cc05 100644 --- a/src/urlpattern.cpp +++ b/src/urlpattern.cpp @@ -1,659 +1,17 @@ -#include <_ctype.h> #include "ada/unicode.h" #include "ada/urlpattern.h" +#include "ada/urlpattern_tokenizer.h" #include "ada/ada_idna.h" #include "ada/implementation.h" +#include +#include #include #include #include -#include -#include #include -namespace ada { - -const static std::u32string DUMMY_URL = U"://dummy.test"; - -ada_really_inline bool is_valid_name_code_point(const char32_t &c, - bool is_first) noexcept { - return is_first ? unicode::is_valid_identifier_start(c) - : unicode::is_valid_identifier_part(c); -} - -ada_really_inline bool is_ascii(char32_t c) { return c < 0x80; } - -// https://wicg.github.io/urlpattern/#canonicalize-a-protocol -ada_really_inline std::u32string_view canonicalize_protocol( - std::u32string_view protocol) { - // If value is the empty string, return value. - if (protocol.empty()) return protocol; - - // Let dummyURL be a new URL record. - // Let parseResult be the result of running the basic URL parser given value - // followed by "://dummy.test", with dummyURL as url. - - // TODO: make it cheaper - std::u32string url = std::u32string(protocol) + DUMMY_URL; - - auto utf8_size = ada::idna::utf8_length_from_utf32(url.data(), url.size()); - std::string final_utf8_url(utf8_size, '\0'); - ada::idna::utf32_to_utf8(url.data(), url.size(), final_utf8_url.data()); - - if (ada::can_parse(final_utf8_url)) { - return protocol; - } - throw std::invalid_argument("invalid protocol scheme"); -} - -// https://wicg.github.io/urlpattern/#compile-a-component -ada_really_inline std::string_view compile_component( - std::u32string_view input, std::function &callback, - urlpattern_options &options) { - // If input is null, then set input to "*". - if (input.empty()) return "*"; -} - -// ########## TOKENIZER ########## -#pragma region TOKENIZER - -enum class TOKEN_TYPE { - OPEN, - CLOSE, - REGEXP, - NAME, - CHAR, - ESCAPED_CHAR, - OTHER_MODIFIER, - ASTERISK, - END, - INVALID_CHAR -}; - -struct TOKEN { - TOKEN_TYPE type; - size_t value_start; - size_t value_end; -}; - -enum class POLICY { STRICT, LENIENT }; - -ada_really_inline std::vector tokenize(std::u32string_view input, - POLICY policy) { - std::vector tokens{}; - size_t input_size = input.size(); - - const auto error_or_invalid = [&](const std::string_view msg, - size_t &value_start, size_t &value_end) { - if (policy != POLICY::LENIENT) { - throw std::invalid_argument(std::string(msg)); - } - tokens.push_back({TOKEN_TYPE::INVALID_CHAR, value_start, value_end}); - }; - - size_t index = 0; - while (index < input_size) { - switch (input[index]) { - case '*': { - tokens.push_back({TOKEN_TYPE::ASTERISK, index, index}); - ++index; - break; - } - case '+': - case '?': { - tokens.push_back({TOKEN_TYPE::OTHER_MODIFIER, /*value_start*/ index, - /*value_end*/ index}); - ++index; - break; - } - case '\\': { - ++index; - if (index == input_size - 1) { - error_or_invalid("should scape something", /*value_start*/ index, - /*value_end*/ index); - } - - tokens.push_back({TOKEN_TYPE::ESCAPED_CHAR, /*value_start*/ index, - /*value_end*/ index}); - break; - } - case '{': { - tokens.push_back({TOKEN_TYPE::OPEN, /*value_start*/ index, - /*value_end*/ index}); - ++index; - break; - } - case '}': { - tokens.push_back({TOKEN_TYPE::CLOSE, /*value_start*/ index, - /*value_end*/ index}); - ++index; - break; - } - case ':': { - // If valid code point is false, break. - // Set name position to tokenizer’s next index. - size_t start, end; - start = index + 1; - end = start; - - if ((end < input_size) && - is_valid_name_code_point(input[end], /*is_first=*/true)) { - ++end; - while (end < input_size && - is_valid_name_code_point(input[end], /*is_first=*/false)) { - ++end; - } - } else { - // First character is not a valid name code point, so there's a - // missing parameter name. - error_or_invalid("missing parameter name", - /*value_start*/ index, - /*value_end*/ index); - continue; - } - - tokens.push_back({TOKEN_TYPE::NAME, start, end}); - - index = end; - break; - } - case '(': { - size_t regexp_start, regexp, depth; - regexp_start = index + 1; - regexp = regexp_start; - depth = 1; - - bool error = false; - while (regexp < input_size) { - // If regexp position equals regexp start and tokenizer’s code point - // is U+003F (?): - // Run process a tokenizing error given tokenizer, regexp start, and - // tokenizer’s index. - // Set error to true. - if (!is_ascii(input[regexp])) { - error_or_invalid("invalid char for regex", regexp_start, regexp); - - error = true; - break; - } - if (input[regexp] == '?' && (regexp == regexp_start)) { - error_or_invalid("malformed regex", regexp, regexp); - - error = true; - break; - } - if (input[regexp] == '\\') { - if (regexp == input_size - 1) { - error_or_invalid("malformed regex", regexp, regexp); - - error = true; - break; - } - ++regexp; - if (!is_ascii(input[regexp])) { - error_or_invalid("invalid char for regex", regexp, regexp); - - error = true; - break; - } - ++regexp; - continue; - } - - if (input[regexp] == ')') { - --depth; - if (depth == 0) { - ++regexp; - } - } else if (input[regexp] == '(') { - ++depth; - if (regexp == input_size - 1) { - error_or_invalid("malformed regex", regexp, regexp); - - error = true; - break; - } - if (input[regexp + 1] != '?') { - error_or_invalid("malformed regex", regexp, regexp); - - error = true; - break; - } - ++regexp; - } - - ++regexp; - - if (error) continue; - - if (depth) { - error_or_invalid("malformed regex", regexp, regexp); - break; - } - - if ((regexp - regexp_start) == 0) { - error_or_invalid("malformed regex", regexp, regexp); - } - - tokens.push_back({TOKEN_TYPE::REGEXP, regexp_start, regexp}); - index = regexp; - } - } - } - - // TODO: maybe group the TOKEN_TYPE::CHARs to make tokens cheaper - tokens.push_back({TOKEN_TYPE::CHAR, /*value_start*/ index, - /*value_end*/ index}); - } - - tokens.push_back({TOKEN_TYPE::END, /*value_start*/ index, - /*value_end*/ index}); - return tokens; -} -#pragma endregion TOKENIZER - -// ########## CONSTRUCTOR STRING PARSER ########## -#pragma region CONSTRUCTOR STRING PARSER - -enum PARSER_STATE { - INIT, - PROTOCOL, - AUTHORITY, - USERNAME, - PASSWORD, - HOSTNAME, - PORT, - PATHNAME, - SEARCH, - HASH, - DONE -}; - -// https://wicg.github.io/urlpattern/#constructor-string-parser -struct constructor_string_parser { - constructor_string_parser(std::u32string_view input); - - // https://wicg.github.io/urlpattern/#parse-a-constructor-string - ada_really_inline void parse(); - - // https://wicg.github.io/urlpattern/#change-state - ada_really_inline void change_state(PARSER_STATE new_state, size_t skip); - - // https://wicg.github.io/urlpattern/#rewind - ada_really_inline void rewind(); - - // https://wicg.github.io/urlpattern/#rewind-and-set-state - ada_really_inline void rewind_and_set_state(PARSER_STATE new_state); - - // https://wicg.github.io/urlpattern/#is-a-hash-prefix - ada_really_inline bool is_hash_prefix(); - - // https://wicg.github.io/urlpattern/#is-a-search-prefix - ada_really_inline bool is_search_prefix(); - - // https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char - ada_really_inline bool is_nonspecial_pattern_char(const char32_t &c); - - // https://wicg.github.io/urlpattern/#get-a-safe-token - ada_really_inline TOKEN *get_safe_token(size_t &index); - - // https://wicg.github.io/urlpattern/#is-a-group-open - ada_really_inline bool is_group_open(); - - // https://wicg.github.io/urlpattern/#is-a-group-close - ada_really_inline bool is_group_close(); - - // https://wicg.github.io/urlpattern/#is-a-protocol-suffix - ada_really_inline bool is_protocol_suffix(); - - // https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag - ada_really_inline void compute_protocol_matches_special_scheme_flag(); - - // https://wicg.github.io/urlpattern/#make-a-component-string - ada_really_inline std::u32string_view make_component_string(); - - std::u32string_view input; - std::vector token_list; - size_t component_start = 0; - size_t token_index = 0; - size_t token_increment = 0; - size_t group_depth = 0; - size_t hostname_ipv6_bracket_depth = 0; - bool protocol_matches_special_scheme = false; - PARSER_STATE state = INIT; - urlpattern_init result = urlpattern_init(); -}; - -// https://wicg.github.io/urlpattern/#constructor-string-parser -constructor_string_parser::constructor_string_parser(std::u32string_view view) { - input = view; - token_list = tokenize(view, POLICY::LENIENT); -} - -// https://wicg.github.io/urlpattern/#parse-a-constructor-string -ada_really_inline void constructor_string_parser::parse() { - // 2. While parser’s token index is less than parser’s token list size: - while (token_index < token_list.size()) { - // Set parser’s token increment to 1. - token_increment = 1; - // If parser’s token list[parser’s token index]'s type is "end" then: - - if (token_list[token_index].type == TOKEN_TYPE::END) { - if (state == INIT) { - // If parser’s state is "init": - // Run rewind given parser. - rewind(); - - // We next determine at which component the relative pattern begins. - // Relative pathnames are most common, but URLs and URLPattern - // constructor strings can begin with the search or hash components as - // well. - - // If the result of running is a hash prefix given parser is true, then - // run change state given parser, "hash" and 1. - if (is_hash_prefix()) { - change_state(HASH, 1); - } else if (is_search_prefix()) { - // Else if the result of running is a search prefix given parser is - // true - // Run change state given parser, "search" and 1 - // Set parser’s result["hash"] to the empty string. - change_state(SEARCH, 1); - result.hash = ""; - } else { - // Run change state given parser, "pathname" and 0. - change_state(PATHNAME, 0); - // Set parser’s result["search"] to the empty string. - result.search = ""; - result.hash = ""; - } - // Increment parser’s token index by parser’s token increment. - token_index += token_increment; - continue; - } - - if (state == AUTHORITY) { - // If we reached the end of the string in the "authority" state, then we - // failed to find an "@". Therefore there is no username or password. - - // Run rewind and set state given parser, and "hostname". - rewind_and_set_state(PARSER_STATE::HOSTNAME); - // Increment parser’s token index by parser’s token increment. - token_index += token_increment; - - continue; - } - - // Run change state given parser, "done" and 0. - change_state(PARSER_STATE::DONE, 0); - break; - } - - if (is_group_open()) { - // Increment parser’s group depth by 1. - ++group_depth; - // Increment parser’s token index by parser’s token increment. - token_index += token_increment; - continue; - } - - // If parser’s group depth is greater than 0: - if (group_depth > 0) { - // If the result of running is a group close given parser is true, then - // decrement parser’s group depth by 1. - if (is_group_close()) { - --group_depth; - } else { - // Increment parser’s token index by parser’s token increment. - token_index += token_increment; - continue; - } - } - - // Switch on parser’s state and run the associated steps: - switch (state) { - case INIT: { - if (is_protocol_suffix()) { - // We found a protocol suffix, so this must be an absolute URLPattern - // constructor string. Therefore initialize all component to the empty - // string. - result.username = ""; - result.password = ""; - result.hostname = ""; - result.port = ""; - result.pathname = ""; - result.search = ""; - result.hash = ""; - - // Run rewind and set state given parser and "protocol". - rewind_and_set_state(PROTOCOL); - } - break; - } - case PROTOCOL: { - if (is_protocol_suffix()) { - } - } - } - } -} - -// https://wicg.github.io/urlpattern/#change-state -ada_really_inline void constructor_string_parser::change_state( - PARSER_STATE new_state, size_t skip) { - // 1. If parser’s state is not "init", not "authority", and not "done", then - // set parser’s result[parser’s state] to the result of running make a - // component string given parser. - if (state != INIT && state != AUTHORITY && state != DONE) { - // TODO improve this: - switch (state) { - case PROTOCOL: - result.protocol = ""; - break; - case USERNAME: - result.username = ""; - break; - case PASSWORD: - result.password = ""; - break; - case HOSTNAME: - result.hostname = ""; - break; - case PORT: - result.port = ""; - break; - case PATHNAME: - result.pathname = ""; - break; - case SEARCH: - result.search = ""; - break; - case HASH: - result.hash = ""; - break; - default: - break; - } - } - // 2. Set parser’s state to new state. - state = new_state; - // 3. Increment parser’s token index by skip. - token_index += skip; - // 4. Set parser’s component start to parser’s token index. - component_start = token_index; - // 5. Set parser’s token increment to 0. - token_increment = 0; -}; - -// https://wicg.github.io/urlpattern/#rewind -ada_really_inline void constructor_string_parser::rewind() { - token_index = component_start; - token_increment = 0; -} - -// https://wicg.github.io/urlpattern/#rewind-and-set-state -ada_really_inline void constructor_string_parser::rewind_and_set_state( - PARSER_STATE new_state) { - // Run rewind given parser. - // Set parser’s state to state. - - rewind(); - state = new_state; -} - -// https://wicg.github.io/urlpattern/#is-a-hash-prefix -ada_really_inline bool constructor_string_parser::is_hash_prefix() { - // Return the result of running is a non-special pattern char given parser, - // parser’s token index and "#". - return is_nonspecial_pattern_char('#'); -} - -// https://wicg.github.io/urlpattern/#is-a-search-prefix -ada_really_inline bool constructor_string_parser::is_search_prefix() { - // If result of running is a non-special pattern char given parser, parser’s - // token index and "?" is true, then return true. - if (is_nonspecial_pattern_char('?')) { - return true; - } - - // If parser’s token list[parser’s token index]'s value is not "?", then - // return false. - - TOKEN *token = &token_list[token_index]; - - // TODO: improve this: - if (token->value_end - token->value_start != 0) return false; - - const char32_t c = '?'; - if (input.find(&c, token->value_start, 1) == std::u32string_view::npos) { - return false; - } - - // Let previous index be parser’s token index − 1. - size_t prev_index = token_index - 1; - if (prev_index < 0) return true; - - // Let previous token be the result of running get a safe token given parser - // and previous index. - TOKEN *prev_safe_token = get_safe_token(prev_index); - - // If any of the following are true, then return false: - // - // previous token’s type is "name". - // previous token’s type is "regexp". - // previous token’s type is "close". - // previous token’s type is "asterisk". - if (prev_safe_token->type == TOKEN_TYPE::NAME || - prev_safe_token->type == TOKEN_TYPE::REGEXP || - prev_safe_token->type == TOKEN_TYPE::CLOSE || - prev_safe_token->type == TOKEN_TYPE::ASTERISK) { - return false; - } - - return true; -} - -// https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char -ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( - const char32_t &c) { - // 1. Let token be the result of running get a safe token given parser and - // index. - TOKEN *safe_token = get_safe_token(token_index); - - // 2. If token’s value is not value, then return false. - // - - // TODO: improve this: - if (safe_token->value_end - safe_token->value_start != 0) return false; - - if (input.find(&c, safe_token->value_start, 1) == std::u32string_view::npos) { - return false; - } - - // 3. If any of the following are true : - // token’s type is "char"; - // token’s type is "escaped-char"; - // or token’s type is "invalid-char", - // then return true. - if (safe_token->type == TOKEN_TYPE::CHAR || - safe_token->type == TOKEN_TYPE::ESCAPED_CHAR || - safe_token->type == TOKEN_TYPE::INVALID_CHAR) { - return true; - } - return false; -} - -// https://wicg.github.io/urlpattern/#get-a-safe-token -ada_really_inline TOKEN *constructor_string_parser::get_safe_token( - size_t &index) { - // 1. If index is less than parser’s token list's size, then return parser’s - // token list[index]. - if (index < token_list.size()) return &token_list[index]; - // 2. Assert: parser’s token list's size is greater than or equal to 1. - // TODO: messages for the asserts? conditional and then throw error? - assert(token_list.size() >= 1); - // 3. Let last index be parser’s token list's size − 1. - size_t last_index = token_list.size() - 1; - // 4. Let token be parser’s token list[last index]. - // 5. Assert: token’s type is "end". - assert(token_list[last_index] == TOKEN_TYPE::END); - return &token_list[last_index]; -} - -// https://wicg.github.io/urlpattern/#is-a-group-open -ada_really_inline bool constructor_string_parser::is_group_open() { - // If parser’s token list[parser’s token index]'s type is "open", then - // return true. Else return false. - return token_list[token_index].type == TOKEN_TYPE::OPEN; -} - -// https://wicg.github.io/urlpattern/#is-a-group-close -ada_really_inline bool constructor_string_parser::is_group_close() { - // If parser’s token list[parser’s token index]'s type is "close", then - // return - // true. Else return false. - return token_list[token_index].type == TOKEN_TYPE::CLOSE; -} - -// https://wicg.github.io/urlpattern/#is-a-protocol-suffix -ada_really_inline bool constructor_string_parser::is_protocol_suffix() { - // Return the result of running is a non-special pattern char given parser, - // parser’s token index, and ":". - return is_nonspecial_pattern_char(':'); -} - -// https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag -ada_really_inline void -constructor_string_parser::compute_protocol_matches_special_scheme_flag() { - std::u32string_view protocol = make_component_string(); - // Let protocol component be the result of compiling a component given - // protocol string, canonicalize a protocol, and default options. -} - -// https://wicg.github.io/urlpattern/#make-a-component-string -ada_really_inline std::u32string_view -constructor_string_parser::make_component_string() { - // Assert: parser’s token index is less than parser’s token list's size. - assert(token_index < token_list.size()); - - // Let token be parser’s token list[parser’s token index]. - // TOKEN *token = &token_list[token_index]; - - // Let component start token be the result of running get a safe token given - // parser and parser’s component start. - TOKEN *safe_token = get_safe_token(component_start); - - // Let component start input index be component start token’s index. - size_t component_start_index = safe_token->value_start; - - // Let end index be token’s index. - size_t end = token_list[token_index].value_start; - - // Return the code point substring from component start input index to end - // index within parser’s input. - return input.substr(component_start_index, end); -} -#pragma endregion CONSTRUCTOR STRING PARSER +namespace ada::urlpattern { // The new URLPattern(input, baseURL, options) constructor steps are: // Run initialize given this, input, baseURL, and options. @@ -663,4 +21,4 @@ urlpattern::urlpattern(std::string_view input, // convert input to utf32 } -} // namespace ada +} // namespace ada::urlpattern diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp new file mode 100644 index 000000000..1d6badfa2 --- /dev/null +++ b/src/urlpattern_constructor_string_parser.cpp @@ -0,0 +1,373 @@ +#include "ada/implementation.h" + +#include "ada/urlpattern_constructor_string_parser.h" +#include "ada/urlpattern_tokenizer.h" + +namespace ada::urlpattern { + +// https://wicg.github.io/urlpattern/#canonicalize-a-protocol +// TODO: maybe make it receive a utf8 string at this point already +ada_really_inline std::u32string_view canonicalize_protocol( + std::u32string_view protocol) { + // If value is the empty string, return value. + if (protocol.empty()) return protocol; + + // Let dummyURL be a new URL record. + // Let parseResult be the result of running the basic URL parser given value + // followed by "://dummy.test", with dummyURL as url. + + // TODO: make it cheaper + std::u32string url = std::u32string(protocol) + U"://dummy.test"; + + auto utf8_size = ada::idna::utf8_length_from_utf32(url.data(), url.size()); + std::string final_utf8_url(utf8_size, '\0'); + ada::idna::utf32_to_utf8(url.data(), url.size(), final_utf8_url.data()); + + if (ada::can_parse(final_utf8_url)) { + return protocol; + } + throw std::invalid_argument("invalid protocol scheme"); +} + +// https://wicg.github.io/urlpattern/#compile-a-component +ada_really_inline std::string_view compile_component( + std::u32string_view input, std::function &callback, + urlpattern_options &options) { + // If input is null, then set input to "*". + if (input.empty()) input = "*"; +} + +// https://wicg.github.io/urlpattern/#constructor-string-parser +ada_really_inline constructor_string_parser::constructor_string_parser( + std::u32string_view view) { + input = view; + token_list = tokenizer::tokenize(view, POLICY::LENIENT); +} + +// https://wicg.github.io/urlpattern/#parse-a-constructor-string +ada_really_inline void constructor_string_parser::parse() { + // 2. While parser’s token index is less than parser’s token list size: + while (token_index < token_list.size()) { + // Set parser’s token increment to 1. + token_increment = 1; + // If parser’s token list[parser’s token index]'s type is "end" then: + + if (token_list[token_index].type == TOKEN_TYPE::END) { + if (state == PARSER_STATE::INIT) { + // If parser’s state is "init": + // Run rewind given parser. + rewind(); + + // We next determine at which component the relative pattern begins. + // Relative pathnames are most common, but URLs and URLPattern + // constructor strings can begin with the search or hash components as + // well. + + // If the result of running is a hash prefix given parser is true, then + // run change state given parser, "hash" and 1. + if (is_hash_prefix()) { + change_state(PARSER_STATE::HASH, 1); + } else if (is_search_prefix()) { + // Else if the result of running is a search prefix given parser is + // true + // Run change state given parser, "search" and 1 + // Set parser’s result["hash"] to the empty string. + change_state(PARSER_STATE::SEARCH, 1); + result.hash = ""; + } else { + // Run change state given parser, "pathname" and 0. + change_state(PARSER_STATE::PATHNAME, 0); + // Set parser’s result["search"] to the empty string. + result.search = ""; + result.hash = ""; + } + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + continue; + } + + if (state == PARSER_STATE::AUTHORITY) { + // If we reached the end of the string in the "authority" state, then we + // failed to find an "@". Therefore there is no username or password. + + // Run rewind and set state given parser, and "hostname". + rewind_and_set_state(PARSER_STATE::HOSTNAME); + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + + continue; + } + + // Run change state given parser, "done" and 0. + change_state(PARSER_STATE::DONE, 0); + break; + } + + if (is_group_open()) { + // Increment parser’s group depth by 1. + ++group_depth; + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + continue; + } + + // If parser’s group depth is greater than 0: + if (group_depth > 0) { + // If the result of running is a group close given parser is true, then + // decrement parser’s group depth by 1. + if (is_group_close()) { + --group_depth; + } else { + // Increment parser’s token index by parser’s token increment. + token_index += token_increment; + continue; + } + } + + // Switch on parser’s state and run the associated steps: + switch (state) { + case PARSER_STATE::INIT: { + if (is_protocol_suffix()) { + // We found a protocol suffix, so this must be an absolute URLPattern + // constructor string. Therefore initialize all component to the empty + // string. + result.username = ""; + result.password = ""; + result.hostname = ""; + result.port = ""; + result.pathname = ""; + result.search = ""; + result.hash = ""; + + // Run rewind and set state given parser and "protocol". + rewind_and_set_state(PARSER_STATE::PROTOCOL); + } + break; + } + case PARSER_STATE::PROTOCOL: { + if (is_protocol_suffix()) { + } + } + } + } +} + +// https://wicg.github.io/urlpattern/#change-state +ada_really_inline void constructor_string_parser::change_state( + PARSER_STATE new_state, size_t skip) { + // 1. If parser’s state is not "init", not "authority", and not "done", then + // set parser’s result[parser’s state] to the result of running make a + // component string given parser. + if (state != PARSER_STATE::INIT && state != PARSER_STATE::AUTHORITY && + state != PARSER_STATE::DONE) { + // TODO improve this: + switch (state) { + case PARSER_STATE::PROTOCOL: + result.protocol = ""; + break; + case PARSER_STATE::USERNAME: + result.username = ""; + break; + case PARSER_STATE::PASSWORD: + result.password = ""; + break; + case PARSER_STATE::HOSTNAME: + result.hostname = ""; + break; + case PARSER_STATE::PORT: + result.port = ""; + break; + case PARSER_STATE::PATHNAME: + result.pathname = ""; + break; + case PARSER_STATE::SEARCH: + result.search = ""; + break; + case PARSER_STATE::HASH: + result.hash = ""; + break; + default: + break; + } + } + // 2. Set parser’s state to new state. + state = new_state; + // 3. Increment parser’s token index by skip. + token_index += skip; + // 4. Set parser’s component start to parser’s token index. + component_start = token_index; + // 5. Set parser’s token increment to 0. + token_increment = 0; +}; + +// https://wicg.github.io/urlpattern/#rewind +ada_really_inline void constructor_string_parser::rewind() { + token_index = component_start; + token_increment = 0; +} + +// https://wicg.github.io/urlpattern/#rewind-and-set-state +ada_really_inline void constructor_string_parser::rewind_and_set_state( + PARSER_STATE new_state) { + // Run rewind given parser. + // Set parser’s state to state. + + rewind(); + state = new_state; +} + +// https://wicg.github.io/urlpattern/#is-a-hash-prefix +ada_really_inline bool constructor_string_parser::is_hash_prefix() { + // Return the result of running is a non-special pattern char given parser, + // parser’s token index and "#". + return is_nonspecial_pattern_char('#'); +} + +// https://wicg.github.io/urlpattern/#is-a-search-prefix +ada_really_inline bool constructor_string_parser::is_search_prefix() { + // If result of running is a non-special pattern char given parser, parser’s + // token index and "?" is true, then return true. + if (is_nonspecial_pattern_char('?')) { + return true; + } + + // If parser’s token list[parser’s token index]'s value is not "?", then + // return false. + + token *curr_token = &token_list[token_index]; + + // TODO: improve this: + + if (curr_token->value_end - curr_token->value_start != 0) return false; + + const char32_t c = '?'; + if (input.find(&c, curr_token->value_start, 1) == std::u32string_view::npos) { + return false; + } + + // Let previous index be parser’s token index − 1. + size_t prev_index = token_index - 1; + if (prev_index < 0) return true; + + // Let previous token be the result of running get a safe token given parser + // and previous index. + token *prev_safe_token = get_safe_token(prev_index); + + // If any of the following are true, then return false: + // + // previous token’s type is "name". + // previous token’s type is "regexp". + // previous token’s type is "close". + // previous token’s type is "asterisk". + if (prev_safe_token->type == TOKEN_TYPE::NAME || + prev_safe_token->type == TOKEN_TYPE::REGEXP || + prev_safe_token->type == TOKEN_TYPE::CLOSE || + prev_safe_token->type == TOKEN_TYPE::ASTERISK) { + return false; + } + + return true; +} + +// https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char +ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( + const char32_t &c) { + // 1. Let token be the result of running get a safe token given parser and + // index. + token *safe_token = get_safe_token(token_index); + + // 2. If token’s value is not value, then return false. + // + + // TODO: improve this: + if (safe_token->value_end - safe_token->value_start != 0) return false; + + if (input.find(&c, safe_token->value_start, 1) == std::u32string_view::npos) { + return false; + } + + // 3. If any of the following are true : + // token’s type is "char"; + // token’s type is "escaped-char"; + // or token’s type is "invalid-char", + // then return true. + if (safe_token->type == TOKEN_TYPE::CHAR || + safe_token->type == TOKEN_TYPE::ESCAPED_CHAR || + safe_token->type == TOKEN_TYPE::INVALID_CHAR) { + return true; + } + return false; +} + +// https://wicg.github.io/urlpattern/#get-a-safe-token +ada_really_inline token *constructor_string_parser::get_safe_token( + size_t &index) { + // 1. If index is less than parser’s token list's size, then return parser’s + // token list[index]. + if (index < token_list.size()) return &token_list[index]; + // 2. Assert: parser’s token list's size is greater than or equal to 1. + // TODO: messages for the asserts? conditional and then throw error? + assert(token_list.size() >= 1); + // 3. Let last index be parser’s token list's size − 1. + size_t last_index = token_list.size() - 1; + // 4. Let token be parser’s token list[last index]. + // 5. Assert: token’s type is "end". + assert(token_list[last_index] == TOKEN_TYPE::END); + return &token_list[last_index]; +} + +// https://wicg.github.io/urlpattern/#is-a-group-open +ada_really_inline bool constructor_string_parser::is_group_open() { + // If parser’s token list[parser’s token index]'s type is "open", then + // return true. Else return false. + return token_list[token_index].type == TOKEN_TYPE::OPEN; +} + +// https://wicg.github.io/urlpattern/#is-a-group-close +ada_really_inline bool constructor_string_parser::is_group_close() { + // If parser’s token list[parser’s token index]'s type is "close", then + // return + // true. Else return false. + return token_list[token_index].type == TOKEN_TYPE::CLOSE; +} + +// https://wicg.github.io/urlpattern/#is-a-protocol-suffix +ada_really_inline bool constructor_string_parser::is_protocol_suffix() { + // Return the result of running is a non-special pattern char given parser, + // parser’s token index, and ":". + return is_nonspecial_pattern_char(':'); +} + +// https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag +ada_really_inline void +constructor_string_parser::compute_protocol_matches_special_scheme_flag() { + std::u32string_view protocol = make_component_string(); + // Let protocol component be the result of compiling a component given + // protocol string, canonicalize a protocol, and default options. +} + +// https://wicg.github.io/urlpattern/#make-a-component-string +ada_really_inline std::u32string_view +constructor_string_parser::make_component_string() { + // Assert: parser’s token index is less than parser’s token list's size. + assert(token_index < token_list.size()); + + // Let token be parser’s token list[parser’s token index]. + // TOKEN *token = &token_list[token_index]; + + // Let component start token be the result of running get a safe token given + // parser and parser’s component start. + token *safe_token = get_safe_token(component_start); + + // Let component start input index be component start token’s index. + size_t component_start_index = safe_token->value_start; + + // Let end index be token’s index. + size_t end = token_list[token_index].value_start; + + // Return the code point substring from component start input index to end + // index within parser’s input. + return input.substr(component_start_index, end); +} + +} // namespace ada::urlpattern diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp new file mode 100644 index 000000000..aebf91c3e --- /dev/null +++ b/src/urlpattern_pattern_parser.cpp @@ -0,0 +1,167 @@ +#include "ada/urlpattern_pattern_parser.h" +#include "ada/urlpattern_tokenizer.h" + +namespace ada::urlpattern { + +ada_really_inline pattern_parser::pattern_parser( + std::function &encoding, + std::string_view wildcard_regexp) { + encoding_callback = encoding; + + segment_wildcard_regexp = wildcard_regexp; +} + +// https://wicg.github.io/urlpattern/#escape-a-regexp-string +ada_really_inline std::string escape_regexp_string(std::string_view input) { + assert(ada::idna::is_ascii(input)); + + // // TODO: make it cheaper + // size_t u8input_size = + // ada::idna::utf8_length_from_utf32(input.data(), input.size()); + // std::string final_u8input(u8input_size, '\0'); + // ada::idna::utf32_to_utf8(input.data(), input.size(), + // final_u8input.data()); + + std::string result = ""; + size_t index = 0; + while (index < input.size()) { + size_t pos = input.find_first_of(".+*?^${}()[]|/\\)"); + if (pos == std::string_view::npos) { + result += input.substr(index, input.size()); + break; + } + result.append(input.substr(index, pos)).append("\\"); + result += input[pos]; + index = pos + 1; + } + return result; +} + +// https://wicg.github.io/urlpattern/#maybe-add-a-part-from-the-pending-fixed-value +ada_really_inline void +pattern_parser::maybe_add_part_from_pendind_fixed_value() { + // If parser’s pending fixed value is the empty string, then return. + if (pending_fixed_value.empty()) { + return; + } + + // Let encoded value be the result of running parser’s encoding callback given + // parser’s pending fixed value. + std::string_view encoded_value = encoding_callback(pending_fixed_value); + + // Set parser’s pending fixed value to the empty strin + pending_fixed_value.clear(); + // Let part be a new part whose type is "fixed-text", value is encoded value, + // and modifier is "none". + auto p = part(); + p.type = PART_TYPE::FIXED_TEXT; + p.modifier = PART_MODIFIER::NONE; + p.value = encoded_value; + + // Append part to parser’s part list. + part_list.push_back(p); +} + +// https://wicg.github.io/urlpattern/#generate-a-segment-wildcard-regexp +ada_really_inline std::string generate_segment_wildcard_regexp( + urlpattern_options &options) { + // Let result be "[^". + std::string result = "[^"; + + // Append the result of running escape a regexp string given options’s + // delimiter code point to the end of result. + result.append(escape_regexp_string(options.delimiter)).append("]+?"); + + // Append "]+?" to the end of result. + return result; +} + +ada_really_inline std::optional pattern_parser::try_to_consume_token( + TOKEN_TYPE type) { + // Assert: parser’s index is less than parser’s token list size. + assert(index < token_list.size()); + // Let next token be parser’s token list[parser’s index]. + token *next_token = &token_list[index]; + + // If next token’s type is not type return null. + if (next_token->type != type) { + return std::nullopt; + } + + // Increment parser’s index by 1. + ++index; + return next_token; +} + +ada_really_inline std::optional +pattern_parser::try_to_consume_regexp_or_wildcard_token( + std::optional &name_token) { + // Let token be the result of running try to consume a token given parser and + // "regexp". + std::optional regexp_or_wildcard = + try_to_consume_token(TOKEN_TYPE::REGEXP); + + // If name token is null and token is null, then set token to the result of + // running try to consume a token given parser and "asterisk". + if (!name_token.has_value() && !regexp_or_wildcard.has_value()) { + regexp_or_wildcard = try_to_consume_token(TOKEN_TYPE::ASTERISK); + } + + return regexp_or_wildcard; +} + +// https://wicg.github.io/urlpattern/#parse-a-pattern-string +ada_really_inline std::vector pattern_parser::parse_pattern_string( + std::u32string_view input, urlpattern_options &options, + std::function &encoding) { + // Let parser be a new pattern parser whose encoding callback is encoding + // callback and segment wildcard regexp is the result of running generate a + // segment wildcard regexp given options. + + std::string seg_wildcard_regexp = generate_segment_wildcard_regexp(options); + pattern_parser parser = pattern_parser(encoding, seg_wildcard_regexp); + + // Set parser’s token list to the result of running tokenize given input and + // "strict". + token_list = tokenizer::tokenize(input, POLICY::STRICT); + // While parser’s index is less than parser’s token list's size: + while (index < token_list.size()) { + // Let char token be the result of running try to consume a token given + // parser and "char". + std::optional char_token = try_to_consume_token(TOKEN_TYPE::CHAR); + + // Let name token be the result of running try to consume a token given + // parser and "name". + std::optional name_token = try_to_consume_token(TOKEN_TYPE::NAME); + + // Let regexp or wildcard token be the result of running try to consume a + // regexp or wildcard token given parser and name token. + std::optional regexp_or_wildcard = + try_to_consume_regexp_or_wildcard_token(name_token); + + // If name token is not null or regexp or wildcard token is not null: + if (name_token.has_value() || regexp_or_wildcard.has_value()) { + // If there is a matching group, we need to add the part immediately. + // Let prefix be the empty string. + // If char token is not null then set prefix to char token’s value. + std::u32string prefix{}; + if (char_token.has_value()) { + prefix.append(input.substr(char_token.value()->value_start, + char_token.value()->value_end + 1)); + } + + // If prefix is not the empty string and not options’s prefix code point: + if (!prefix.empty() && prefix != options.prefix) { + // Append prefix to the end of parser’s pending fixed value. + pending_fixed_value.append(prefix); + // Set prefix to the empty string. + prefix.clear(); + } + + // Run maybe add a part from the pending fixed value given parser. + maybe_add_part_from_pendind_fixed_value(); + } + } +} + +} // namespace ada::urlpattern \ No newline at end of file diff --git a/src/urlpattern_tokenizer.cpp b/src/urlpattern_tokenizer.cpp new file mode 100644 index 000000000..2d7a6b199 --- /dev/null +++ b/src/urlpattern_tokenizer.cpp @@ -0,0 +1,226 @@ +#include "ada/urlpattern_tokenizer.h" +#include "ada/unicode.h" +#include "ada/urlpattern.h" + +namespace ada::urlpattern { + +ada_really_inline bool is_valid_name_code_point(const char32_t &c, + bool is_first) noexcept { + return is_first ? unicode::is_valid_identifier_start(c) + : unicode::is_valid_identifier_part(c); +} + +ada_really_inline bool is_ascii(char32_t &c) { return c < 0x80; } + +// https://wicg.github.io/urlpattern/#seek-and-get-the-next-code-point +ada_really_inline void tokenizer::seek_and_get_next_code_point() { + next_index = index; + get_next_code_point(); +} + +// https://wicg.github.io/urlpattern/#get-the-next-code-point +ada_really_inline void tokenizer::get_next_code_point() { + // Set tokenizer’s code point to the Unicode code point in tokenizer’s input + // at the position indicated by tokenizer’s next index. + code_point = input[next_index]; + + // Increment tokenizer’s next index by 1. + ++next_index; +} + +// https://wicg.github.io/urlpattern/#add-a-token +ada_really_inline void tokenizer::add_token(TOKEN_TYPE type, size_t next_pos, + size_t value_start, + size_t value_end) { + // Let token be a new token. + token new_token = token(); + new_token.type = type; + new_token.value_start = value_start; + new_token.value_end = value_end; + + token_list.push_back(new_token); + index = next_pos; +} + +ada_really_inline void tokenizer::process_tokenizing_error(std::string_view msg, + size_t value_start, + size_t value_end) { + if (policy != POLICY::LENIENT) { + throw std::invalid_argument(std::string(msg)); + } + + token_list.push_back({TOKEN_TYPE::INVALID_CHAR, value_start, value_end}); +} + +std::vector tokenizer::tokenize(std::u32string_view _input, + ada::urlpattern::POLICY _policy) { + // Let tokenizer be a new tokenizer. + tokenizer t = tokenizer(); + + // Set tokenizer’s input to input. + t.input = _input; + + // Set tokenizer’s policy to policy. + t.policy = _policy; + + // While tokenizer’s index is less than tokenizer’s input's code point length: + while (t.index < t.input.size()) { + t.seek_and_get_next_code_point(); + switch (t.code_point) { + case '*': { + t.add_token(TOKEN_TYPE::ASTERISK, t.next_index, t.index, t.index); + break; + } + case '+': + case '?': { + t.add_token(TOKEN_TYPE::OTHER_MODIFIER, t.next_index, t.index, t.index); + break; + } + case '\\': { + // If tokenizer’s index is equal to tokenizer’s input's code point + // length − 1: + if (t.index == t.input.size() - 1) { + t.process_tokenizing_error("should scape something", + /*value_start*/ t.index, + /*value_end*/ t.index); + } + + t.add_token(TOKEN_TYPE::ESCAPED_CHAR, t.next_index, t.index, t.index); + break; + } + case '{': { + t.add_token(TOKEN_TYPE::OPEN, t.next_index, t.index, t.index); + break; + } + case '}': { + t.add_token(TOKEN_TYPE::CLOSE, t.next_index, t.index, t.index); + break; + } + case ':': { + // If valid code point is false, break. + // Set name position to tokenizer’s next index. + size_t name_start, name_position; + name_position = t.next_index; + + // While name position is less than tokenizer’s input's code point + // length: + while (name_position < t.input.size()) { + t.seek_and_get_next_code_point(); + // Let first code point be true if name position equals name start and + // false otherwise. + if (name_position == name_start && + !is_valid_name_code_point(t.input[t.code_point], + /*is_first=*/true)) { + break; + } else if (!is_valid_name_code_point(t.input[t.code_point], + /*is_first=*/false)) { + break; + } + name_position = t.next_index; + } + if (name_position <= name_start) { + t.process_tokenizing_error("missing pattern name", name_start, + t.index); + continue; + } + t.add_token(TOKEN_TYPE::NAME, t.next_index, name_start, name_position); + continue; + } + case '(': { + size_t regexp_start, regexp_position, depth; + regexp_position = t.next_index; + regexp_start = regexp_position; + depth = 1; + + bool error = false; + while (regexp_position < t.input.size()) { + t.seek_and_get_next_code_point(); + if (!is_ascii(t.code_point)) { + t.process_tokenizing_error("invalid char for regex", regexp_start, + regexp_position); + + error = true; + break; + } + if (t.code_point == '?' && (regexp_position == regexp_start)) { + t.process_tokenizing_error("malformed regex", regexp_start, + t.index); + + error = true; + break; + } + if (t.code_point == '\\') { + if (regexp_position == t.input.size() - 1) { + t.process_tokenizing_error("malformed regex", regexp_start, + t.index); + + error = true; + break; + } + t.get_next_code_point(); + if (!is_ascii(t.code_point)) { + t.process_tokenizing_error("invalid char for regex", regexp_start, + t.index); + + error = true; + break; + } + regexp_position = t.next_index; + continue; + } + + if (t.code_point == ')') { + --depth; + if (depth == 0) { + regexp_position = t.next_index; + } + } else if (t.code_point == '(') { + ++depth; + if (regexp_position == t.input.size() - 1) { + t.process_tokenizing_error("malformed regex", regexp_start, + t.index); + + error = true; + break; + } + size_t tmp_pos = t.next_index; + t.get_next_code_point(); + + if (t.code_point != '?') { + t.process_tokenizing_error("malformed regex", regexp_start, + t.index); + + error = true; + break; + } + t.next_index = tmp_pos; + } + + if (error) continue; + + if (depth) { + t.process_tokenizing_error("malformed regex", regexp_start, + t.index); + break; + } + + if ((regexp_position - regexp_start) == 0) { + t.process_tokenizing_error("malformed regex", regexp_start, + t.index); + } + + t.add_token(TOKEN_TYPE::REGEXP, /*next_pos=*/regexp_position, + regexp_start, regexp_position); + } + } + default: { + // TODO: maybe group the TOKEN_TYPE::CHARs to make tokens cheaper + t.add_token(TOKEN_TYPE::CHAR, t.next_index, t.index, t.index); + } + } + } + t.add_token(TOKEN_TYPE::END, t.next_index, t.index, t.index); + return t.token_list; +} + +} // namespace ada::urlpattern \ No newline at end of file From 95e5c70025398bade384fea9f399beb3d3ae626d Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sun, 14 May 2023 22:02:42 -0300 Subject: [PATCH 12/23] urlpattern: minor fixes --- .../urlpattern_constructor_string_parser.h | 8 +- include/ada/urlpattern_pattern_parser.h | 2 +- src/urlpattern_constructor_string_parser.cpp | 79 ++++++++++--------- src/urlpattern_pattern_parser.cpp | 19 +++-- 4 files changed, 59 insertions(+), 49 deletions(-) diff --git a/include/ada/urlpattern_constructor_string_parser.h b/include/ada/urlpattern_constructor_string_parser.h index 43007b48f..c8a5bea06 100644 --- a/include/ada/urlpattern_constructor_string_parser.h +++ b/include/ada/urlpattern_constructor_string_parser.h @@ -24,10 +24,9 @@ enum class PARSER_STATE : uint8_t { // https://wicg.github.io/urlpattern/#constructor-string-parser struct constructor_string_parser { - ada_really_inline constructor_string_parser(std::u32string_view input); - // https://wicg.github.io/urlpattern/#parse-a-constructor-string - ada_really_inline void parse(); + static ada_really_inline void parse_contructor_string( + std::u32string_view input); // https://wicg.github.io/urlpattern/#change-state ada_really_inline void change_state(PARSER_STATE new_state, size_t skip); @@ -75,6 +74,9 @@ struct constructor_string_parser { bool protocol_matches_special_scheme = false; urlpattern_init result = urlpattern_init(); PARSER_STATE state = PARSER_STATE::INIT; + + private: + ada_really_inline constructor_string_parser(std::u32string_view input); }; } // namespace ada::urlpattern diff --git a/include/ada/urlpattern_pattern_parser.h b/include/ada/urlpattern_pattern_parser.h index e0a13fd4f..0981384c7 100644 --- a/include/ada/urlpattern_pattern_parser.h +++ b/include/ada/urlpattern_pattern_parser.h @@ -36,7 +36,7 @@ struct part { // https://wicg.github.io/urlpattern/#pattern-parser struct pattern_parser { // https://wicg.github.io/urlpattern/#parse-a-pattern-string - ada_really_inline std::vector parse_pattern_string( + static ada_really_inline std::vector parse_pattern_string( std::u32string_view input, urlpattern_options &options, std::function &encoding); diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp index 1d6badfa2..83c5ed967 100644 --- a/src/urlpattern_constructor_string_parser.cpp +++ b/src/urlpattern_constructor_string_parser.cpp @@ -45,18 +45,23 @@ ada_really_inline constructor_string_parser::constructor_string_parser( } // https://wicg.github.io/urlpattern/#parse-a-constructor-string -ada_really_inline void constructor_string_parser::parse() { +ada_really_inline void constructor_string_parser::parse_contructor_string( + std::u32string_view input) { + // Let parser be a new constructor string parser whose input is input and + // token list is the result of running tokenize given input and "lenient". + auto p = constructor_string_parser(input); + // 2. While parser’s token index is less than parser’s token list size: - while (token_index < token_list.size()) { + while (p.token_index < p.token_list.size()) { // Set parser’s token increment to 1. - token_increment = 1; + p.token_increment = 1; // If parser’s token list[parser’s token index]'s type is "end" then: - if (token_list[token_index].type == TOKEN_TYPE::END) { - if (state == PARSER_STATE::INIT) { + if (p.token_list[p.token_index].type == TOKEN_TYPE::END) { + if (p.state == PARSER_STATE::INIT) { // If parser’s state is "init": // Run rewind given parser. - rewind(); + p.rewind(); // We next determine at which component the relative pattern begins. // Relative pathnames are most common, but URLs and URLPattern @@ -65,87 +70,87 @@ ada_really_inline void constructor_string_parser::parse() { // If the result of running is a hash prefix given parser is true, then // run change state given parser, "hash" and 1. - if (is_hash_prefix()) { - change_state(PARSER_STATE::HASH, 1); - } else if (is_search_prefix()) { + if (p.is_hash_prefix()) { + p.change_state(PARSER_STATE::HASH, 1); + } else if (p.is_search_prefix()) { // Else if the result of running is a search prefix given parser is // true // Run change state given parser, "search" and 1 // Set parser’s result["hash"] to the empty string. - change_state(PARSER_STATE::SEARCH, 1); - result.hash = ""; + p.change_state(PARSER_STATE::SEARCH, 1); + p.result.hash = ""; } else { // Run change state given parser, "pathname" and 0. - change_state(PARSER_STATE::PATHNAME, 0); + p.change_state(PARSER_STATE::PATHNAME, 0); // Set parser’s result["search"] to the empty string. - result.search = ""; - result.hash = ""; + p.result.search = ""; + p.result.hash = ""; } // Increment parser’s token index by parser’s token increment. - token_index += token_increment; + p.token_index += p.token_increment; continue; } - if (state == PARSER_STATE::AUTHORITY) { + if (p.state == PARSER_STATE::AUTHORITY) { // If we reached the end of the string in the "authority" state, then we // failed to find an "@". Therefore there is no username or password. // Run rewind and set state given parser, and "hostname". - rewind_and_set_state(PARSER_STATE::HOSTNAME); + p.rewind_and_set_state(PARSER_STATE::HOSTNAME); // Increment parser’s token index by parser’s token increment. - token_index += token_increment; + p.token_index += p.token_increment; continue; } // Run change state given parser, "done" and 0. - change_state(PARSER_STATE::DONE, 0); + p.change_state(PARSER_STATE::DONE, 0); break; } - if (is_group_open()) { + if (p.is_group_open()) { // Increment parser’s group depth by 1. - ++group_depth; + ++p.group_depth; // Increment parser’s token index by parser’s token increment. - token_index += token_increment; + p.token_index += p.token_increment; continue; } // If parser’s group depth is greater than 0: - if (group_depth > 0) { + if (p.group_depth > 0) { // If the result of running is a group close given parser is true, then // decrement parser’s group depth by 1. - if (is_group_close()) { - --group_depth; + if (p.is_group_close()) { + --p.group_depth; } else { // Increment parser’s token index by parser’s token increment. - token_index += token_increment; + p.token_index += p.token_increment; continue; } } // Switch on parser’s state and run the associated steps: - switch (state) { + switch (p.state) { case PARSER_STATE::INIT: { - if (is_protocol_suffix()) { + if (p.is_protocol_suffix()) { // We found a protocol suffix, so this must be an absolute URLPattern // constructor string. Therefore initialize all component to the empty // string. - result.username = ""; - result.password = ""; - result.hostname = ""; - result.port = ""; - result.pathname = ""; - result.search = ""; - result.hash = ""; + p.result.username = ""; + p.result.password = ""; + p.result.hostname = ""; + p.result.port = ""; + p.result.pathname = ""; + p.result.search = ""; + p.result.hash = ""; // Run rewind and set state given parser and "protocol". - rewind_and_set_state(PARSER_STATE::PROTOCOL); + p.rewind_and_set_state(PARSER_STATE::PROTOCOL); } break; } case PARSER_STATE::PROTOCOL: { - if (is_protocol_suffix()) { + if (p.is_protocol_suffix()) { } } } diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp index aebf91c3e..bfc6a6ebb 100644 --- a/src/urlpattern_pattern_parser.cpp +++ b/src/urlpattern_pattern_parser.cpp @@ -119,25 +119,28 @@ ada_really_inline std::vector pattern_parser::parse_pattern_string( // segment wildcard regexp given options. std::string seg_wildcard_regexp = generate_segment_wildcard_regexp(options); - pattern_parser parser = pattern_parser(encoding, seg_wildcard_regexp); + pattern_parser p = pattern_parser(encoding, seg_wildcard_regexp); // Set parser’s token list to the result of running tokenize given input and // "strict". - token_list = tokenizer::tokenize(input, POLICY::STRICT); + p.token_list = tokenizer::tokenize(input, POLICY::STRICT); + // While parser’s index is less than parser’s token list's size: - while (index < token_list.size()) { + while (p.index < p.token_list.size()) { // Let char token be the result of running try to consume a token given // parser and "char". - std::optional char_token = try_to_consume_token(TOKEN_TYPE::CHAR); + std::optional char_token = + p.try_to_consume_token(TOKEN_TYPE::CHAR); // Let name token be the result of running try to consume a token given // parser and "name". - std::optional name_token = try_to_consume_token(TOKEN_TYPE::NAME); + std::optional name_token = + p.try_to_consume_token(TOKEN_TYPE::NAME); // Let regexp or wildcard token be the result of running try to consume a // regexp or wildcard token given parser and name token. std::optional regexp_or_wildcard = - try_to_consume_regexp_or_wildcard_token(name_token); + p.try_to_consume_regexp_or_wildcard_token(name_token); // If name token is not null or regexp or wildcard token is not null: if (name_token.has_value() || regexp_or_wildcard.has_value()) { @@ -153,13 +156,13 @@ ada_really_inline std::vector pattern_parser::parse_pattern_string( // If prefix is not the empty string and not options’s prefix code point: if (!prefix.empty() && prefix != options.prefix) { // Append prefix to the end of parser’s pending fixed value. - pending_fixed_value.append(prefix); + p.pending_fixed_value.append(prefix); // Set prefix to the empty string. prefix.clear(); } // Run maybe add a part from the pending fixed value given parser. - maybe_add_part_from_pendind_fixed_value(); + p.maybe_add_part_from_pendind_fixed_value(); } } } From b9041fbb93e2a629ca608d08a67ee319f8681d00 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sun, 14 May 2023 23:41:29 -0300 Subject: [PATCH 13/23] urlpattern: fixup to make it compile --- include/ada/urlpattern.h | 2 +- include/ada/urlpattern_base.h | 6 ++++ include/ada/urlpattern_pattern_parser.h | 6 ++-- include/ada/urlpattern_tokenizer.h | 19 +++++------- src/ada.cpp | 2 +- src/urlpattern_constructor_string_parser.cpp | 8 ++--- src/urlpattern_pattern_parser.cpp | 32 +++++++++++--------- src/urlpattern_tokenizer.cpp | 10 +++--- 8 files changed, 46 insertions(+), 39 deletions(-) diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index 9ee4ec463..25437e963 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -3,7 +3,7 @@ #include "ada/common_defs.h" -#include "urlpattern_base.h" +#include "ada/urlpattern_base.h" #include #include diff --git a/include/ada/urlpattern_base.h b/include/ada/urlpattern_base.h index 23534fc4c..be7cb5808 100644 --- a/include/ada/urlpattern_base.h +++ b/include/ada/urlpattern_base.h @@ -11,6 +11,12 @@ struct urlpattern_options { bool ignore_case = false; }; +struct u32urlpattern_options { + std::u32string_view delimiter = U""; + std::u32string_view prefix = U""; + bool ignore_case = false; +}; + struct urlpattern_init { std::string_view protocol; std::string_view username; diff --git a/include/ada/urlpattern_pattern_parser.h b/include/ada/urlpattern_pattern_parser.h index 0981384c7..4cc6eb0ef 100644 --- a/include/ada/urlpattern_pattern_parser.h +++ b/include/ada/urlpattern_pattern_parser.h @@ -37,7 +37,7 @@ struct part { struct pattern_parser { // https://wicg.github.io/urlpattern/#parse-a-pattern-string static ada_really_inline std::vector parse_pattern_string( - std::u32string_view input, urlpattern_options &options, + std::u32string_view input, u32urlpattern_options &options, std::function &encoding); // https://wicg.github.io/urlpattern/#try-to-consume-a-token @@ -53,7 +53,7 @@ struct pattern_parser { std::vector token_list; std::function encoding_callback; - std::string segment_wildcard_regexp; + std::u32string segment_wildcard_regexp; std::u32string pending_fixed_value{}; size_t index = 0; size_t next_numeric_name = 0; @@ -62,7 +62,7 @@ struct pattern_parser { private: ada_really_inline pattern_parser( std::function &encoding, - std::string_view wildcard_regexp); + std::u32string_view wildcard_regexp); }; } // namespace ada::urlpattern diff --git a/include/ada/urlpattern_tokenizer.h b/include/ada/urlpattern_tokenizer.h index 1e66b095e..318f6d231 100644 --- a/include/ada/urlpattern_tokenizer.h +++ b/include/ada/urlpattern_tokenizer.h @@ -39,14 +39,6 @@ struct tokenizer { size_t next_index = 0; char32_t code_point; - /** - * Tokenize is a step in the approach used by the URLPattern API for parsing - * patterns. - * @see https://wicg.github.io/urlpattern/#tokenize and - * https://wicg.github.io/urlpattern/#parsing-patterns - */ - static std::vector tokenize(std::u32string_view input, POLICY policy); - // https://wicg.github.io/urlpattern/#seek-and-get-the-next-code-point ada_really_inline void seek_and_get_next_code_point(); @@ -61,11 +53,16 @@ struct tokenizer { ada_really_inline void process_tokenizing_error(std::string_view msg, size_t value_start, size_t value_end); - - private: - tokenizer(); }; +/** + * Tokenize is a step in the approach used by the URLPattern API for parsing + * patterns. + * @see https://wicg.github.io/urlpattern/#tokenize and + * https://wicg.github.io/urlpattern/#parsing-patterns + */ +std::vector tokenize(std::u32string_view input, POLICY policy); + } // namespace ada::urlpattern #endif \ No newline at end of file diff --git a/src/ada.cpp b/src/ada.cpp index 5ab919840..cd6abdc5c 100644 --- a/src/ada.cpp +++ b/src/ada.cpp @@ -12,6 +12,6 @@ #include "url_aggregator.cpp" #include "urlpattern_tokenizer.cpp" #include "urlpattern_constructor_string_parser.cpp" -#include "urlpattern_pattern_parser" +#include "urlpattern_pattern_parser.cpp" #include "urlpattern.cpp" #include "ada_c.cpp" diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp index 83c5ed967..8797471a3 100644 --- a/src/urlpattern_constructor_string_parser.cpp +++ b/src/urlpattern_constructor_string_parser.cpp @@ -1,7 +1,7 @@ #include "ada/implementation.h" -#include "ada/urlpattern_constructor_string_parser.h" #include "ada/urlpattern_tokenizer.h" +#include "ada/urlpattern_constructor_string_parser.h" namespace ada::urlpattern { @@ -32,16 +32,16 @@ ada_really_inline std::u32string_view canonicalize_protocol( // https://wicg.github.io/urlpattern/#compile-a-component ada_really_inline std::string_view compile_component( std::u32string_view input, std::function &callback, - urlpattern_options &options) { + u32urlpattern_options &options) { // If input is null, then set input to "*". - if (input.empty()) input = "*"; + if (input.empty()) input = U"*"; } // https://wicg.github.io/urlpattern/#constructor-string-parser ada_really_inline constructor_string_parser::constructor_string_parser( std::u32string_view view) { input = view; - token_list = tokenizer::tokenize(view, POLICY::LENIENT); + token_list = tokenize(view, POLICY::LENIENT); } // https://wicg.github.io/urlpattern/#parse-a-constructor-string diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp index bfc6a6ebb..d5d71e38d 100644 --- a/src/urlpattern_pattern_parser.cpp +++ b/src/urlpattern_pattern_parser.cpp @@ -1,18 +1,19 @@ -#include "ada/urlpattern_pattern_parser.h" #include "ada/urlpattern_tokenizer.h" +#include "ada/urlpattern_pattern_parser.h" namespace ada::urlpattern { ada_really_inline pattern_parser::pattern_parser( std::function &encoding, - std::string_view wildcard_regexp) { + std::u32string_view wildcard_regexp) { encoding_callback = encoding; segment_wildcard_regexp = wildcard_regexp; } // https://wicg.github.io/urlpattern/#escape-a-regexp-string -ada_really_inline std::string escape_regexp_string(std::string_view input) { +ada_really_inline std::u32string escape_regexp_string( + std::u32string_view input) { assert(ada::idna::is_ascii(input)); // // TODO: make it cheaper @@ -22,15 +23,15 @@ ada_really_inline std::string escape_regexp_string(std::string_view input) { // ada::idna::utf32_to_utf8(input.data(), input.size(), // final_u8input.data()); - std::string result = ""; + std::u32string result = U""; size_t index = 0; while (index < input.size()) { - size_t pos = input.find_first_of(".+*?^${}()[]|/\\)"); + size_t pos = input.find_first_of(U".+*?^${}()[]|/\\)"); if (pos == std::string_view::npos) { result += input.substr(index, input.size()); break; } - result.append(input.substr(index, pos)).append("\\"); + result.append(input.substr(index, pos)).append(U"\\"); result += input[pos]; index = pos + 1; } @@ -63,14 +64,14 @@ pattern_parser::maybe_add_part_from_pendind_fixed_value() { } // https://wicg.github.io/urlpattern/#generate-a-segment-wildcard-regexp -ada_really_inline std::string generate_segment_wildcard_regexp( - urlpattern_options &options) { +ada_really_inline std::u32string generate_segment_wildcard_regexp( + u32urlpattern_options &options) { // Let result be "[^". - std::string result = "[^"; + std::u32string result = U"[^"; // Append the result of running escape a regexp string given options’s // delimiter code point to the end of result. - result.append(escape_regexp_string(options.delimiter)).append("]+?"); + result.append(escape_regexp_string(options.delimiter)).append(U"]+?"); // Append "]+?" to the end of result. return result; @@ -112,18 +113,19 @@ pattern_parser::try_to_consume_regexp_or_wildcard_token( // https://wicg.github.io/urlpattern/#parse-a-pattern-string ada_really_inline std::vector pattern_parser::parse_pattern_string( - std::u32string_view input, urlpattern_options &options, + std::u32string_view input, u32urlpattern_options &options, std::function &encoding) { // Let parser be a new pattern parser whose encoding callback is encoding // callback and segment wildcard regexp is the result of running generate a // segment wildcard regexp given options. - std::string seg_wildcard_regexp = generate_segment_wildcard_regexp(options); - pattern_parser p = pattern_parser(encoding, seg_wildcard_regexp); + std::u32string seg_wildcard_regexp = + generate_segment_wildcard_regexp(options); + auto p = pattern_parser(encoding, seg_wildcard_regexp); // Set parser’s token list to the result of running tokenize given input and // "strict". - p.token_list = tokenizer::tokenize(input, POLICY::STRICT); + p.token_list = tokenize(input, POLICY::STRICT); // While parser’s index is less than parser’s token list's size: while (p.index < p.token_list.size()) { @@ -165,6 +167,8 @@ ada_really_inline std::vector pattern_parser::parse_pattern_string( p.maybe_add_part_from_pendind_fixed_value(); } } + + return p.part_list; } } // namespace ada::urlpattern \ No newline at end of file diff --git a/src/urlpattern_tokenizer.cpp b/src/urlpattern_tokenizer.cpp index 2d7a6b199..2ff2f84e3 100644 --- a/src/urlpattern_tokenizer.cpp +++ b/src/urlpattern_tokenizer.cpp @@ -42,9 +42,8 @@ ada_really_inline void tokenizer::add_token(TOKEN_TYPE type, size_t next_pos, index = next_pos; } -ada_really_inline void tokenizer::process_tokenizing_error(std::string_view msg, - size_t value_start, - size_t value_end) { +void tokenizer::process_tokenizing_error(std::string_view msg, + size_t value_start, size_t value_end) { if (policy != POLICY::LENIENT) { throw std::invalid_argument(std::string(msg)); } @@ -52,8 +51,8 @@ ada_really_inline void tokenizer::process_tokenizing_error(std::string_view msg, token_list.push_back({TOKEN_TYPE::INVALID_CHAR, value_start, value_end}); } -std::vector tokenizer::tokenize(std::u32string_view _input, - ada::urlpattern::POLICY _policy) { +std::vector tokenize(std::u32string_view _input, + ada::urlpattern::POLICY _policy) { // Let tokenizer be a new tokenizer. tokenizer t = tokenizer(); @@ -101,6 +100,7 @@ std::vector tokenizer::tokenize(std::u32string_view _input, // Set name position to tokenizer’s next index. size_t name_start, name_position; name_position = t.next_index; + name_start = name_position; // While name position is less than tokenizer’s input's code point // length: From 5651a1f1b8a49527b26a3f38a126e51b5b6efa1a Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Mon, 15 May 2023 01:13:20 -0300 Subject: [PATCH 14/23] urlpattern: adds missing cassert lib + fixes --- include/ada.h | 2 + include/ada/url.h | 1 + include/ada/urlpattern_canonicalization.h | 13 +++++++ .../urlpattern_constructor_string_parser.h | 11 +++--- include/ada/urlpattern_internals.h | 15 ++++++++ include/ada/urlpattern_pattern_parser.h | 17 ++++----- src/ada.cpp | 2 + src/urlpattern_canonicalization.cpp | 32 ++++++++++++++++ src/urlpattern_constructor_string_parser.cpp | 37 ++----------------- src/urlpattern_internals.cpp | 13 +++++++ src/urlpattern_pattern_parser.cpp | 4 +- src/urlpattern_tokenizer.cpp | 2 +- 12 files changed, 98 insertions(+), 51 deletions(-) create mode 100644 include/ada/urlpattern_canonicalization.h create mode 100644 include/ada/urlpattern_internals.h create mode 100644 src/urlpattern_canonicalization.cpp create mode 100644 src/urlpattern_internals.cpp diff --git a/include/ada.h b/include/ada.h index ee4c29fba..bdf95e0c1 100644 --- a/include/ada.h +++ b/include/ada.h @@ -24,6 +24,8 @@ #include "ada/url_aggregator.h" #include "ada/url_aggregator-inl.h" #include "ada/urlpattern_base.h" +#include "ada/urlpattern_canonicalization.h" +#include "ada/urlpattern_internals.h" #include "ada/urlpattern_tokenizer.h" #include "ada/urlpattern_constructor_string_parser.h" #include "ada/urlpattern_pattern_parser.h" diff --git a/include/ada/url.h b/include/ada/url.h index 81137fe8d..b499bd386 100644 --- a/include/ada/url.h +++ b/include/ada/url.h @@ -13,6 +13,7 @@ #include "ada/unicode.h" #include "ada/url_base.h" #include "ada/url_components.h" +#include "ada/helpers.h" #include #include diff --git a/include/ada/urlpattern_canonicalization.h b/include/ada/urlpattern_canonicalization.h new file mode 100644 index 000000000..512c8c53b --- /dev/null +++ b/include/ada/urlpattern_canonicalization.h @@ -0,0 +1,13 @@ +#ifndef ADA_URLPATTERN_CANONICALIZATION_H +#define ADA_URLPATTERN_CANONICALIZATION_H + +#include + +namespace ada::urlpattern { + +// Encoding Callbacks +std::u32string_view canonicalize_protocol(std::u32string_view protocol); + +} // namespace ada::urlpattern + +#endif diff --git a/include/ada/urlpattern_constructor_string_parser.h b/include/ada/urlpattern_constructor_string_parser.h index c8a5bea06..4dd0226ae 100644 --- a/include/ada/urlpattern_constructor_string_parser.h +++ b/include/ada/urlpattern_constructor_string_parser.h @@ -24,9 +24,7 @@ enum class PARSER_STATE : uint8_t { // https://wicg.github.io/urlpattern/#constructor-string-parser struct constructor_string_parser { - // https://wicg.github.io/urlpattern/#parse-a-constructor-string - static ada_really_inline void parse_contructor_string( - std::u32string_view input); + ada_really_inline constructor_string_parser(std::u32string_view input); // https://wicg.github.io/urlpattern/#change-state ada_really_inline void change_state(PARSER_STATE new_state, size_t skip); @@ -74,10 +72,11 @@ struct constructor_string_parser { bool protocol_matches_special_scheme = false; urlpattern_init result = urlpattern_init(); PARSER_STATE state = PARSER_STATE::INIT; - - private: - ada_really_inline constructor_string_parser(std::u32string_view input); }; + +// https://wicg.github.io/urlpattern/#parse-a-constructor-string +void parse_contructor_string(std::u32string_view input); + } // namespace ada::urlpattern #endif \ No newline at end of file diff --git a/include/ada/urlpattern_internals.h b/include/ada/urlpattern_internals.h new file mode 100644 index 000000000..ce12757f8 --- /dev/null +++ b/include/ada/urlpattern_internals.h @@ -0,0 +1,15 @@ +#ifndef ADA_URLPATTERN_INTERNALS_H +#define ADA_URLPATTERN_INTERNALS_H + +#include "ada/urlpattern_base.h" +#include + +namespace ada::urlpattern { + +std::string_view compile_component(std::u32string_view input, + std::function &callback, + u32urlpattern_options &options); + +} + +#endif \ No newline at end of file diff --git a/include/ada/urlpattern_pattern_parser.h b/include/ada/urlpattern_pattern_parser.h index 4cc6eb0ef..ef16f8863 100644 --- a/include/ada/urlpattern_pattern_parser.h +++ b/include/ada/urlpattern_pattern_parser.h @@ -35,10 +35,9 @@ struct part { // https://wicg.github.io/urlpattern/#pattern-parser struct pattern_parser { - // https://wicg.github.io/urlpattern/#parse-a-pattern-string - static ada_really_inline std::vector parse_pattern_string( - std::u32string_view input, u32urlpattern_options &options, - std::function &encoding); + ada_really_inline pattern_parser( + std::function &encoding, + std::u32string_view wildcard_regexp); // https://wicg.github.io/urlpattern/#try-to-consume-a-token ada_really_inline std::optional try_to_consume_token( @@ -58,13 +57,13 @@ struct pattern_parser { size_t index = 0; size_t next_numeric_name = 0; std::vector part_list{}; - - private: - ada_really_inline pattern_parser( - std::function &encoding, - std::u32string_view wildcard_regexp); }; +// https://wicg.github.io/urlpattern/#parse-a-pattern-string +std::vector parse_pattern_string( + std::u32string_view input, u32urlpattern_options &options, + std::function &encoding); + } // namespace ada::urlpattern #endif \ No newline at end of file diff --git a/src/ada.cpp b/src/ada.cpp index cd6abdc5c..bbae5d946 100644 --- a/src/ada.cpp +++ b/src/ada.cpp @@ -13,5 +13,7 @@ #include "urlpattern_tokenizer.cpp" #include "urlpattern_constructor_string_parser.cpp" #include "urlpattern_pattern_parser.cpp" +#include "urlpattern_internals.cpp" +#include "urlpattern_canonicalization.cpp" #include "urlpattern.cpp" #include "ada_c.cpp" diff --git a/src/urlpattern_canonicalization.cpp b/src/urlpattern_canonicalization.cpp new file mode 100644 index 000000000..104fdd1f9 --- /dev/null +++ b/src/urlpattern_canonicalization.cpp @@ -0,0 +1,32 @@ +#include "ada/urlpattern_canonicalization.h" + +#include "ada/ada_idna.h" +#include "ada/implementation.h" +#include + +namespace ada::urlpattern { + +// https://wicg.githu b.io/urlpattern/#canonicalize-a-protocol +// TODO: maybe make it receive a utf8 string at this point already +std::u32string_view canonicalize_protocol(std::u32string_view protocol) { + // If value is the empty string, return value. + if (protocol.empty()) return protocol; + + // Let dummyURL be a new URL record. + // Let parseResult be the result of running the basic URL parser given value + // followed by "://dummy.test", with dummyURL as url. + + // TODO: make it cheaper + std::u32string url = std::u32string(protocol) + U"://dummy.test"; + + auto utf8_size = ada::idna::utf8_length_from_utf32(url.data(), url.size()); + std::string final_utf8_url(utf8_size, '\0'); + ada::idna::utf32_to_utf8(url.data(), url.size(), final_utf8_url.data()); + + if (ada::can_parse(final_utf8_url)) { + return protocol; + } + throw std::invalid_argument("invalid protocol scheme"); +} + +} // namespace ada::urlpattern \ No newline at end of file diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp index 8797471a3..109790b31 100644 --- a/src/urlpattern_constructor_string_parser.cpp +++ b/src/urlpattern_constructor_string_parser.cpp @@ -1,42 +1,12 @@ #include "ada/implementation.h" +#include + #include "ada/urlpattern_tokenizer.h" #include "ada/urlpattern_constructor_string_parser.h" namespace ada::urlpattern { -// https://wicg.github.io/urlpattern/#canonicalize-a-protocol -// TODO: maybe make it receive a utf8 string at this point already -ada_really_inline std::u32string_view canonicalize_protocol( - std::u32string_view protocol) { - // If value is the empty string, return value. - if (protocol.empty()) return protocol; - - // Let dummyURL be a new URL record. - // Let parseResult be the result of running the basic URL parser given value - // followed by "://dummy.test", with dummyURL as url. - - // TODO: make it cheaper - std::u32string url = std::u32string(protocol) + U"://dummy.test"; - - auto utf8_size = ada::idna::utf8_length_from_utf32(url.data(), url.size()); - std::string final_utf8_url(utf8_size, '\0'); - ada::idna::utf32_to_utf8(url.data(), url.size(), final_utf8_url.data()); - - if (ada::can_parse(final_utf8_url)) { - return protocol; - } - throw std::invalid_argument("invalid protocol scheme"); -} - -// https://wicg.github.io/urlpattern/#compile-a-component -ada_really_inline std::string_view compile_component( - std::u32string_view input, std::function &callback, - u32urlpattern_options &options) { - // If input is null, then set input to "*". - if (input.empty()) input = U"*"; -} - // https://wicg.github.io/urlpattern/#constructor-string-parser ada_really_inline constructor_string_parser::constructor_string_parser( std::u32string_view view) { @@ -45,8 +15,7 @@ ada_really_inline constructor_string_parser::constructor_string_parser( } // https://wicg.github.io/urlpattern/#parse-a-constructor-string -ada_really_inline void constructor_string_parser::parse_contructor_string( - std::u32string_view input) { +void parse_contructor_string(std::u32string_view input) { // Let parser be a new constructor string parser whose input is input and // token list is the result of running tokenize given input and "lenient". auto p = constructor_string_parser(input); diff --git a/src/urlpattern_internals.cpp b/src/urlpattern_internals.cpp new file mode 100644 index 000000000..84a2a95cc --- /dev/null +++ b/src/urlpattern_internals.cpp @@ -0,0 +1,13 @@ +#include "ada/urlpattern_internals.h" + +namespace ada::urlpattern { + +// https://wicg.github.io/urlpattern/#compile-a-component +std::string_view compile_component(std::u32string_view input, + std::function &callback, + u32urlpattern_options &options) { + // If input is null, then set input to "*". + if (input.empty()) input = U"*"; +} + +} // namespace ada::urlpattern \ No newline at end of file diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp index d5d71e38d..cb06dfb4e 100644 --- a/src/urlpattern_pattern_parser.cpp +++ b/src/urlpattern_pattern_parser.cpp @@ -1,6 +1,8 @@ #include "ada/urlpattern_tokenizer.h" #include "ada/urlpattern_pattern_parser.h" +#include + namespace ada::urlpattern { ada_really_inline pattern_parser::pattern_parser( @@ -112,7 +114,7 @@ pattern_parser::try_to_consume_regexp_or_wildcard_token( } // https://wicg.github.io/urlpattern/#parse-a-pattern-string -ada_really_inline std::vector pattern_parser::parse_pattern_string( +std::vector parse_pattern_string( std::u32string_view input, u32urlpattern_options &options, std::function &encoding) { // Let parser be a new pattern parser whose encoding callback is encoding diff --git a/src/urlpattern_tokenizer.cpp b/src/urlpattern_tokenizer.cpp index 2ff2f84e3..2f53dde1b 100644 --- a/src/urlpattern_tokenizer.cpp +++ b/src/urlpattern_tokenizer.cpp @@ -54,7 +54,7 @@ void tokenizer::process_tokenizing_error(std::string_view msg, std::vector tokenize(std::u32string_view _input, ada::urlpattern::POLICY _policy) { // Let tokenizer be a new tokenizer. - tokenizer t = tokenizer(); + auto t = tokenizer(); // Set tokenizer’s input to input. t.input = _input; From ca4955585ff60e604036cd9d573e0a0b0a8684a4 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Mon, 15 May 2023 01:15:54 -0300 Subject: [PATCH 15/23] urlpattern: fix assert for token type --- src/urlpattern_constructor_string_parser.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp index 109790b31..fb218e9ed 100644 --- a/src/urlpattern_constructor_string_parser.cpp +++ b/src/urlpattern_constructor_string_parser.cpp @@ -286,7 +286,7 @@ ada_really_inline token *constructor_string_parser::get_safe_token( size_t last_index = token_list.size() - 1; // 4. Let token be parser’s token list[last index]. // 5. Assert: token’s type is "end". - assert(token_list[last_index] == TOKEN_TYPE::END); + assert(token_list[last_index].type == TOKEN_TYPE::END); return &token_list[last_index]; } From 58342b3732ab930ba73a47f08abeb1aeee504a53 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sat, 20 May 2023 20:59:47 -0300 Subject: [PATCH 16/23] urlpattern: introducing tests for tokenizer --- src/urlpattern_tokenizer.cpp | 66 +- tests/CMakeLists.txt | 5 + tests/urlpattern/CMakeLists.txt | 5 + tests/urlpattern/tokenizer.json | 1772 ++++++++++++++++++++++++++ tests/urlpattern_tokenizer_tests.cpp | 96 ++ 5 files changed, 1926 insertions(+), 18 deletions(-) create mode 100644 tests/urlpattern/CMakeLists.txt create mode 100644 tests/urlpattern/tokenizer.json create mode 100644 tests/urlpattern_tokenizer_tests.cpp diff --git a/src/urlpattern_tokenizer.cpp b/src/urlpattern_tokenizer.cpp index 2f53dde1b..7ee6f2ca4 100644 --- a/src/urlpattern_tokenizer.cpp +++ b/src/urlpattern_tokenizer.cpp @@ -2,6 +2,8 @@ #include "ada/unicode.h" #include "ada/urlpattern.h" +#include + namespace ada::urlpattern { ada_really_inline bool is_valid_name_code_point(const char32_t &c, @@ -14,7 +16,10 @@ ada_really_inline bool is_ascii(char32_t &c) { return c < 0x80; } // https://wicg.github.io/urlpattern/#seek-and-get-the-next-code-point ada_really_inline void tokenizer::seek_and_get_next_code_point() { - next_index = index; + // Set tokenizer’s next index to index. + index = next_index; + + // Run get the next code point given tokenizer. get_next_code_point(); } @@ -22,7 +27,7 @@ ada_really_inline void tokenizer::seek_and_get_next_code_point() { ada_really_inline void tokenizer::get_next_code_point() { // Set tokenizer’s code point to the Unicode code point in tokenizer’s input // at the position indicated by tokenizer’s next index. - code_point = input[next_index]; + code_point = input[index]; // Increment tokenizer’s next index by 1. ++next_index; @@ -64,58 +69,81 @@ std::vector tokenize(std::u32string_view _input, // While tokenizer’s index is less than tokenizer’s input's code point length: while (t.index < t.input.size()) { + std::cout << t.code_point << std::endl; + // Run seek and get the next code point given tokenizer and tokenizer’s + // index. t.seek_and_get_next_code_point(); + switch (t.code_point) { case '*': { + // Run add a token with default position and length given tokenizer and + // "asterisk". t.add_token(TOKEN_TYPE::ASTERISK, t.next_index, t.index, t.index); - break; + continue; } case '+': case '?': { t.add_token(TOKEN_TYPE::OTHER_MODIFIER, t.next_index, t.index, t.index); - break; + continue; } case '\\': { // If tokenizer’s index is equal to tokenizer’s input's code point // length − 1: if (t.index == t.input.size() - 1) { + // Run process a tokenizing error given tokenizer, tokenizer’s next + // index, and tokenizer’s index. t.process_tokenizing_error("should scape something", /*value_start*/ t.index, /*value_end*/ t.index); + continue; } + // Run get the next code point given tokenizer. + t.get_next_code_point(); + + // Run add a token with default length given tokenizer, "escaped-char", + // tokenizer’s next index, and escaped index. t.add_token(TOKEN_TYPE::ESCAPED_CHAR, t.next_index, t.index, t.index); - break; + continue; } case '{': { t.add_token(TOKEN_TYPE::OPEN, t.next_index, t.index, t.index); - break; + continue; } case '}': { t.add_token(TOKEN_TYPE::CLOSE, t.next_index, t.index, t.index); - break; + continue; } case ':': { - // If valid code point is false, break. - // Set name position to tokenizer’s next index. + // Let name position be tokenizer’s next index. size_t name_start, name_position; name_position = t.next_index; + + // Let name start be name position. name_start = name_position; // While name position is less than tokenizer’s input's code point // length: while (name_position < t.input.size()) { + // Run seek and get the next code point given tokenizer and name + // position. + std::cout << "NEXT INDEX" << t.next_index << std::endl; t.seek_and_get_next_code_point(); + // Let first code point be true if name position equals name start and // false otherwise. - if (name_position == name_start && - !is_valid_name_code_point(t.input[t.code_point], - /*is_first=*/true)) { - break; - } else if (!is_valid_name_code_point(t.input[t.code_point], - /*is_first=*/false)) { - break; - } + bool first_code_point = name_position == name_start; + + // Let valid code point be the result of running is a valid name code + // point given tokenizer’s code point and first code point. + bool valid_code_point = + is_valid_name_code_point(t.input[t.code_point], + /*is_first=*/first_code_point); + + // If valid code point is false break. + if (!valid_code_point) break; + + // Set name position to tokenizer’s next index. name_position = t.next_index; } if (name_position <= name_start) { @@ -201,16 +229,18 @@ std::vector tokenize(std::u32string_view _input, if (depth) { t.process_tokenizing_error("malformed regex", regexp_start, t.index); - break; + continue; } if ((regexp_position - regexp_start) == 0) { t.process_tokenizing_error("malformed regex", regexp_start, t.index); + continue; } t.add_token(TOKEN_TYPE::REGEXP, /*next_pos=*/regexp_position, regexp_start, regexp_position); + continue; } } default: { diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a55a5a2c9..940f389f1 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,4 +1,5 @@ add_subdirectory(wpt) +add_subdirectory(urlpattern) set(ADA_TEST_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../) if(MSVC) @@ -10,18 +11,21 @@ link_libraries(ada) include(GoogleTest) +add_executable(urlpattern_tokenizer_tests urlpattern_tokenizer_tests.cpp) add_executable(wpt_tests wpt_tests.cpp) add_executable(url_components url_components.cpp) add_executable(basic_tests basic_tests.cpp) add_executable(from_file_tests from_file_tests.cpp) add_executable(ada_c ada_c.cpp) +target_link_libraries(urlpattern_tokenizer_tests PRIVATE simdjson GTest::gtest_main) target_link_libraries(wpt_tests PRIVATE simdjson GTest::gtest_main) target_link_libraries(url_components PRIVATE simdjson GTest::gtest_main) target_link_libraries(basic_tests PRIVATE simdjson GTest::gtest_main) target_link_libraries(from_file_tests PRIVATE simdjson GTest::gtest_main) target_link_libraries(ada_c PRIVATE simdjson GTest::gtest_main) +gtest_discover_tests(urlpattern_tokenizer_tests) gtest_discover_tests(wpt_tests) gtest_discover_tests(url_components) gtest_discover_tests(basic_tests) @@ -38,6 +42,7 @@ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") endif() if(MSVC OR MINGW) + target_compile_definitions(urlpattern_tokenizer_tests PRIVATE _CRT_SECURE_NO_WARNINGS) target_compile_definitions(wpt_tests PRIVATE _CRT_SECURE_NO_WARNINGS) target_compile_definitions(url_components PRIVATE _CRT_SECURE_NO_WARNINGS) target_compile_definitions(basic_fuzzer PRIVATE _CRT_SECURE_NO_WARNINGS) diff --git a/tests/urlpattern/CMakeLists.txt b/tests/urlpattern/CMakeLists.txt new file mode 100644 index 000000000..d2802e530 --- /dev/null +++ b/tests/urlpattern/CMakeLists.txt @@ -0,0 +1,5 @@ + +file(GLOB_RECURSE urlpattern_files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.json) +foreach(urlpattern_file ${urlpattern_files}) + configure_file(${urlpattern_file} ${urlpattern_file} COPYONLY) +endforeach(urlpattern_file) diff --git a/tests/urlpattern/tokenizer.json b/tests/urlpattern/tokenizer.json new file mode 100644 index 000000000..98bdd7064 --- /dev/null +++ b/tests/urlpattern/tokenizer.json @@ -0,0 +1,1772 @@ +[ + { + "input": "https://example.com/foo/:bar([^/]*)?", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "NAME", + "value_start": 24, + "value_end": 27 + }, + { + "type": "REGEX", + "value_start": 28, + "value_end": 33 + }, + { + "type": "OTHER_MODIFIER", + "value_start": 35, + "value_end": 36 + }, + { + "type": "END", + "value_start": 36, + "value_end": 36 + } + ] + }, + { + "input": "http{s}?://*.example.com/books/:id", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "OPEN", + "value_start": 4, + "value_end": 5 + }, + { + "type": "CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CLOSE", + "value_start": 6, + "value_end": 7 + }, + { + "type": "OTHER_MODIFIER", + "value_start": 7, + "value_end": 8 + }, + { + "type": "INVALID_CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "ASTERISK", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "CHAR", + "value_start": 26, + "value_end": 27 + }, + { + "type": "CHAR", + "value_start": 27, + "value_end": 28 + }, + { + "type": "CHAR", + "value_start": 28, + "value_end": 29 + }, + { + "type": "CHAR", + "value_start": 29, + "value_end": 30 + }, + { + "type": "CHAR", + "value_start": 30, + "value_end": 31 + }, + { + "type": "NAME", + "value_start": 31, + "value_end": 33 + }, + { + "type": "END", + "value_start": 34, + "value_end": 34 + } + ] + }, + { + "input": "https://example.com/2023/may/*", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "CHAR", + "value_start": 26, + "value_end": 27 + }, + { + "type": "CHAR", + "value_start": 27, + "value_end": 28 + }, + { + "type": "CHAR", + "value_start": 28, + "value_end": 29 + }, + { + "type": "ASTERISK", + "value_start": 29, + "value_end": 30 + }, + { + "type": "END", + "value_start": 30, + "value_end": 30 + } + ] + }, + { + "input": "https://example.com/books/:id", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "NAME", + "value_start": 26, + "value_end": 28 + }, + { + "type": "END", + "value_start": 29, + "value_end": 29 + } + ] + }, + { + "input": "http://example.com/:name/", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "INVALID_CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "NAME", + "value_start": 19, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "END", + "value_start": 25, + "value_end": 25 + } + ] + }, + { + "input": "https://example.com/books/:你好", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "NAME", + "value_start": 26, + "value_end": 28 + }, + { + "type": "END", + "value_start": 29, + "value_end": 29 + } + ] + }, + { + "input": "https://example.com/books/:你好/:日本語", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "NAME", + "value_start": 26, + "value_end": 28 + }, + { + "type": "CHAR", + "value_start": 29, + "value_end": 30 + }, + { + "type": "NAME", + "value_start": 30, + "value_end": 33 + }, + { + "type": "END", + "value_start": 34, + "value_end": 34 + } + ] + }, + { + "input": "https://example.com/books/:你好/:𝒳", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "NAME", + "value_start": 26, + "value_end": 28 + }, + { + "type": "CHAR", + "value_start": 29, + "value_end": 30 + }, + { + "type": "INVALID_CHAR", + "value_start": 30, + "value_end": 31 + }, + { + "type": "CHAR", + "value_start": 31, + "value_end": 32 + }, + { + "type": "CHAR", + "value_start": 32, + "value_end": 33 + }, + { + "type": "END", + "value_start": 33, + "value_end": 33 + } + ] + }, + { + "input": "https://example.com/books/:футбол", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "NAME", + "value_start": 26, + "value_end": 32 + }, + { + "type": "END", + "value_start": 33, + "value_end": 33 + } + ] + }, + { + "input": "https://example.com/books/:नमस्ते", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "NAME", + "value_start": 26, + "value_end": 32 + }, + { + "type": "END", + "value_start": 33, + "value_end": 33 + } + ] + }, + { + "input": "https://example.com/books/:𐤀", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "INVALID_CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "CHAR", + "value_start": 23, + "value_end": 24 + }, + { + "type": "CHAR", + "value_start": 24, + "value_end": 25 + }, + { + "type": "CHAR", + "value_start": 25, + "value_end": 26 + }, + { + "type": "INVALID_CHAR", + "value_start": 26, + "value_end": 27 + }, + { + "type": "CHAR", + "value_start": 27, + "value_end": 28 + }, + { + "type": "CHAR", + "value_start": 28, + "value_end": 29 + }, + { + "type": "END", + "value_start": 29, + "value_end": 29 + } + ] + }, + { + "input": "http://www.example.com/", + "output": [ + { + "type": "CHAR", + "value_start": 0, + "value_end": 1 + }, + { + "type": "CHAR", + "value_start": 1, + "value_end": 2 + }, + { + "type": "CHAR", + "value_start": 2, + "value_end": 3 + }, + { + "type": "CHAR", + "value_start": 3, + "value_end": 4 + }, + { + "type": "INVALID_CHAR", + "value_start": 4, + "value_end": 5 + }, + { + "type": "CHAR", + "value_start": 5, + "value_end": 6 + }, + { + "type": "CHAR", + "value_start": 6, + "value_end": 7 + }, + { + "type": "CHAR", + "value_start": 7, + "value_end": 8 + }, + { + "type": "CHAR", + "value_start": 8, + "value_end": 9 + }, + { + "type": "CHAR", + "value_start": 9, + "value_end": 10 + }, + { + "type": "CHAR", + "value_start": 10, + "value_end": 11 + }, + { + "type": "CHAR", + "value_start": 11, + "value_end": 12 + }, + { + "type": "CHAR", + "value_start": 12, + "value_end": 13 + }, + { + "type": "CHAR", + "value_start": 13, + "value_end": 14 + }, + { + "type": "CHAR", + "value_start": 14, + "value_end": 15 + }, + { + "type": "CHAR", + "value_start": 15, + "value_end": 16 + }, + { + "type": "CHAR", + "value_start": 16, + "value_end": 17 + }, + { + "type": "CHAR", + "value_start": 17, + "value_end": 18 + }, + { + "type": "CHAR", + "value_start": 18, + "value_end": 19 + }, + { + "type": "CHAR", + "value_start": 19, + "value_end": 20 + }, + { + "type": "CHAR", + "value_start": 20, + "value_end": 21 + }, + { + "type": "CHAR", + "value_start": 21, + "value_end": 22 + }, + { + "type": "CHAR", + "value_start": 22, + "value_end": 23 + }, + { + "type": "END", + "value_start": 23, + "value_end": 23 + } + ] + } +] diff --git a/tests/urlpattern_tokenizer_tests.cpp b/tests/urlpattern_tokenizer_tests.cpp new file mode 100644 index 000000000..ba7098408 --- /dev/null +++ b/tests/urlpattern_tokenizer_tests.cpp @@ -0,0 +1,96 @@ +#include +#include +#include + +#include "ada.h" +#include "ada/urlpattern_tokenizer.h" +#include "gtest/gtest.h" +#include "simdjson.h" + +using namespace simdjson; +using namespace ada; + +bool operator!=(const urlpattern::token& lhs, const urlpattern::token& rhs) { + return !(lhs.type == rhs.type && lhs.value_end == rhs.value_end && + lhs.value_start == rhs.value_start); +} + +bool is_token_list_equal(std::vector& first, + std::vector& second) { + if (first.size() != second.size()) return false; + for (size_t i = 0; i < first.size(); i++) { + if (first[i] != second[i]) { + return false; + } + } + return true; +} + +std::u32string to_utf32(std::string_view utf8) { + size_t utf32_length = + ada::idna::utf32_length_from_utf8(utf8.data(), utf8.size()); + std::u32string utf32(utf32_length, '\0'); + idna::utf8_to_utf32(utf8.data(), utf8.size(), utf32.data()); + + return utf32; +} + +std::vector arr_token_from_json( + ondemand::array& raw_token_arr) { + auto token_type_from_string = [](std::string_view type) { + if (type == "OPEN") return urlpattern::TOKEN_TYPE::OPEN; + if (type == "CLOSE") return urlpattern::TOKEN_TYPE::CLOSE; + if (type == "REGEXP") return urlpattern::TOKEN_TYPE::REGEXP; + if (type == "NAME") return urlpattern::TOKEN_TYPE::NAME; + if (type == "CHAR") return urlpattern::TOKEN_TYPE::CHAR; + if (type == "ESCAPED_CHAR") return urlpattern::TOKEN_TYPE::ESCAPED_CHAR; + if (type == "OTHER_MODIFIER") return urlpattern::TOKEN_TYPE::OTHER_MODIFIER; + if (type == "ASTERISK") return urlpattern::TOKEN_TYPE::ASTERISK; + if (type == "END") return urlpattern::TOKEN_TYPE::END; + if (type == "INVALID_CHAR") return urlpattern::TOKEN_TYPE::INVALID_CHAR; + + unreachable(); + }; + + std::vector arr_token{}; + for (auto raw_token : raw_token_arr) { + auto t = urlpattern::token(); + t.value_start = raw_token["value_start"].get_int64(); + t.value_end = raw_token["value_end"].get_int64(); + t.type = token_type_from_string(raw_token["type"].get_string()); + arr_token.push_back(t); + } + + return arr_token; +} + +std::string_view TOKENIZER_TESTDATA = "urlpattern/tokenizer.json"; + +TEST(urlpattern_tests, tokenize) { + ondemand::parser parser; + padded_string json = padded_string::load(TOKENIZER_TESTDATA); + + ondemand::document doc = parser.iterate(json); + try { + for (auto test_case : doc.get_array()) { + ondemand::object object = test_case.get_object(); + + std::string_view utf8_input = object["input"].get_string(); + auto utf32_input = to_utf32(utf8_input); + + ondemand::array raw_expected_output = object["output"].get_array(); + auto expected_output = arr_token_from_json(raw_expected_output); + + auto tokens = + urlpattern::tokenize(utf32_input, urlpattern::POLICY::LENIENT); + + ASSERT_TRUE(is_token_list_equal(expected_output, tokens)); + } + } catch (simdjson::simdjson_error& error) { + std::cerr << "JSON error: " << error.what() << " near " + << doc.current_location() << " in " << TOKENIZER_TESTDATA + << std::endl; + FAIL(); + } + SUCCEED(); +} \ No newline at end of file From 3f5fac879e4d17b3a1430222899342067ac86b0b Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 6 Jun 2023 23:46:44 -0300 Subject: [PATCH 17/23] urlpattern: update id_start and id_part tables --- src/unicode.cpp | 4958 ++++------------------------------------------- 1 file changed, 370 insertions(+), 4588 deletions(-) diff --git a/src/unicode.cpp b/src/unicode.cpp index 43bd14d6a..23912b638 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -315,2158 +315,173 @@ static_assert(sizeof(valid_id_start_table_ascii) == 256); // Valid IdentifierStart unicods points 256+ // ranges obtained with the regex /[$_\p{ID_Start}]/u // https://tc39.es/ecma262/#prod-IdentifierStart -size_t valid_id_start_ranges_unicode[6451][2] = { - {255, 705}, {710, 721}, {736, 740}, - {748, 748}, {750, 750}, {880, 884}, - {886, 887}, {890, 893}, {895, 895}, - {902, 902}, {904, 906}, {908, 908}, - {910, 929}, {931, 1013}, {1015, 1153}, - {1162, 1327}, {1329, 1366}, {1369, 1369}, - {1376, 1416}, {1488, 1514}, {1519, 1522}, - {1568, 1610}, {1646, 1647}, {1649, 1747}, - {1749, 1749}, {1765, 1766}, {1774, 1775}, - {1786, 1788}, {1791, 1791}, {1808, 1808}, - {1810, 1839}, {1869, 1957}, {1969, 1969}, - {1994, 2026}, {2036, 2037}, {2042, 2042}, - {2048, 2069}, {2074, 2074}, {2084, 2084}, - {2088, 2088}, {2112, 2136}, {2144, 2154}, - {2160, 2183}, {2185, 2190}, {2208, 2249}, - {2308, 2361}, {2365, 2365}, {2384, 2384}, - {2392, 2401}, {2417, 2432}, {2437, 2444}, - {2447, 2448}, {2451, 2472}, {2474, 2480}, - {2482, 2482}, {2486, 2489}, {2493, 2493}, - {2510, 2510}, {2524, 2525}, {2527, 2529}, - {2544, 2545}, {2556, 2556}, {2565, 2570}, - {2575, 2576}, {2579, 2600}, {2602, 2608}, - {2610, 2611}, {2613, 2614}, {2616, 2617}, - {2649, 2652}, {2654, 2654}, {2674, 2676}, - {2693, 2701}, {2703, 2705}, {2707, 2728}, - {2730, 2736}, {2738, 2739}, {2741, 2745}, - {2749, 2749}, {2768, 2768}, {2784, 2785}, - {2809, 2809}, {2821, 2828}, {2831, 2832}, - {2835, 2856}, {2858, 2864}, {2866, 2867}, - {2869, 2873}, {2877, 2877}, {2908, 2909}, - {2911, 2913}, {2929, 2929}, {2947, 2947}, - {2949, 2954}, {2958, 2960}, {2962, 2965}, - {2969, 2970}, {2972, 2972}, {2974, 2975}, - {2979, 2980}, {2984, 2986}, {2990, 3001}, - {3024, 3024}, {3077, 3084}, {3086, 3088}, - {3090, 3112}, {3114, 3129}, {3133, 3133}, - {3160, 3162}, {3165, 3165}, {3168, 3169}, - {3200, 3200}, {3205, 3212}, {3214, 3216}, - {3218, 3240}, {3242, 3251}, {3253, 3257}, - {3261, 3261}, {3293, 3294}, {3296, 3297}, - {3313, 3314}, {3332, 3340}, {3342, 3344}, - {3346, 3386}, {3389, 3389}, {3406, 3406}, - {3412, 3414}, {3423, 3425}, {3450, 3455}, - {3461, 3478}, {3482, 3505}, {3507, 3515}, - {3517, 3517}, {3520, 3526}, {3585, 3632}, - {3634, 3635}, {3648, 3654}, {3713, 3714}, - {3716, 3716}, {3718, 3722}, {3724, 3747}, - {3749, 3749}, {3751, 3760}, {3762, 3763}, - {3773, 3773}, {3776, 3780}, {3782, 3782}, - {3804, 3807}, {3840, 3840}, {3904, 3911}, - {3913, 3948}, {3976, 3980}, {4096, 4138}, - {4159, 4159}, {4176, 4181}, {4186, 4189}, - {4193, 4193}, {4197, 4198}, {4206, 4208}, - {4213, 4225}, {4238, 4238}, {4256, 4293}, - {4295, 4295}, {4301, 4301}, {4304, 4346}, - {4348, 4680}, {4682, 4685}, {4688, 4694}, - {4696, 4696}, {4698, 4701}, {4704, 4744}, - {4746, 4749}, {4752, 4784}, {4786, 4789}, - {4792, 4798}, {4800, 4800}, {4802, 4805}, - {4808, 4822}, {4824, 4880}, {4882, 4885}, - {4888, 4954}, {4992, 5007}, {5024, 5109}, - {5112, 5117}, {5121, 5740}, {5743, 5759}, - {5761, 5786}, {5792, 5866}, {5870, 5880}, - {5888, 5905}, {5919, 5937}, {5952, 5969}, - {5984, 5996}, {5998, 6000}, {6016, 6067}, - {6103, 6103}, {6108, 6108}, {6176, 6264}, - {6272, 6312}, {6314, 6314}, {6320, 6389}, - {6400, 6430}, {6480, 6509}, {6512, 6516}, - {6528, 6571}, {6576, 6601}, {6656, 6678}, - {6688, 6740}, {6823, 6823}, {6917, 6963}, - {6981, 6988}, {7043, 7072}, {7086, 7087}, - {7098, 7141}, {7168, 7203}, {7245, 7247}, - {7258, 7293}, {7296, 7304}, {7312, 7354}, - {7357, 7359}, {7401, 7404}, {7406, 7411}, - {7413, 7414}, {7418, 7418}, {7424, 7615}, - {7680, 7957}, {7960, 7965}, {7968, 8005}, - {8008, 8013}, {8016, 8023}, {8025, 8025}, - {8027, 8027}, {8029, 8029}, {8031, 8061}, - {8064, 8116}, {8118, 8124}, {8126, 8126}, - {8130, 8132}, {8134, 8140}, {8144, 8147}, - {8150, 8155}, {8160, 8172}, {8178, 8180}, - {8182, 8188}, {8305, 8305}, {8319, 8319}, - {8336, 8348}, {8450, 8450}, {8455, 8455}, - {8458, 8467}, {8469, 8469}, {8472, 8477}, - {8484, 8484}, {8486, 8486}, {8488, 8488}, - {8490, 8505}, {8508, 8511}, {8517, 8521}, - {8526, 8526}, {8544, 8584}, {11264, 11492}, - {11499, 11502}, {11506, 11507}, {11520, 11557}, - {11559, 11559}, {11565, 11565}, {11568, 11623}, - {11631, 11631}, {11648, 11670}, {11680, 11686}, - {11688, 11694}, {11696, 11702}, {11704, 11710}, - {11712, 11718}, {11720, 11726}, {11728, 11734}, - {11736, 11742}, {12293, 12295}, {12321, 12329}, - {12337, 12341}, {12344, 12348}, {12353, 12438}, - {12443, 12447}, {12449, 12538}, {12540, 12543}, - {12549, 12591}, {12593, 12686}, {12704, 12735}, - {12784, 12799}, {13312, 19903}, {19968, 42124}, - {42192, 42237}, {42240, 42508}, {42512, 42527}, - {42538, 42539}, {42560, 42606}, {42623, 42653}, - {42656, 42735}, {42775, 42783}, {42786, 42888}, - {42891, 42954}, {42960, 42961}, {42963, 42963}, - {42965, 42969}, {42994, 43009}, {43011, 43013}, - {43015, 43018}, {43020, 43042}, {43072, 43123}, - {43138, 43187}, {43250, 43255}, {43259, 43259}, - {43261, 43262}, {43274, 43301}, {43312, 43334}, - {43360, 43388}, {43396, 43442}, {43471, 43471}, - {43488, 43492}, {43494, 43503}, {43514, 43518}, - {43520, 43560}, {43584, 43586}, {43588, 43595}, - {43616, 43638}, {43642, 43642}, {43646, 43695}, - {43697, 43697}, {43701, 43702}, {43705, 43709}, - {43712, 43712}, {43714, 43714}, {43739, 43741}, - {43744, 43754}, {43762, 43764}, {43777, 43782}, - {43785, 43790}, {43793, 43798}, {43808, 43814}, - {43816, 43822}, {43824, 43866}, {43868, 43881}, - {43888, 44002}, {44032, 55203}, {55216, 55238}, - {55243, 55291}, {63744, 64109}, {64112, 64217}, - {64256, 64262}, {64275, 64279}, {64285, 64285}, - {64287, 64296}, {64298, 64310}, {64312, 64316}, - {64318, 64318}, {64320, 64321}, {64323, 64324}, - {64326, 64433}, {64467, 64829}, {64848, 64911}, - {64914, 64967}, {65008, 65019}, {65136, 65140}, - {65142, 65276}, {65313, 65338}, {65345, 65370}, - {65382, 65470}, {65474, 65479}, {65482, 65487}, - {65490, 65495}, {65498, 65500}, {65572, 65572}, - {65601, 65626}, {65631, 65631}, {65633, 65658}, - {65706, 65706}, {65717, 65717}, {65722, 65722}, - {65728, 65750}, {65752, 65782}, {65784, 66241}, - {66246, 66257}, {66272, 66276}, {66284, 66284}, - {66286, 66286}, {66416, 66420}, {66422, 66423}, - {66426, 66429}, {66431, 66431}, {66438, 66438}, - {66440, 66442}, {66444, 66444}, {66446, 66465}, - {66467, 66549}, {66551, 66689}, {66698, 66863}, - {66865, 66902}, {66905, 66905}, {66912, 66952}, - {67024, 67050}, {67055, 67058}, {67104, 67146}, - {67182, 67183}, {67185, 67283}, {67285, 67285}, - {67301, 67302}, {67310, 67311}, {67322, 67324}, - {67327, 67327}, {67344, 67344}, {67346, 67375}, - {67405, 67493}, {67505, 67505}, {67530, 67562}, - {67572, 67573}, {67578, 67578}, {67584, 67605}, - {67610, 67610}, {67620, 67620}, {67624, 67624}, - {67648, 67672}, {67680, 67690}, {67696, 67719}, - {67721, 67726}, {67744, 67785}, {67844, 67897}, - {67901, 67901}, {67920, 67920}, {67928, 67937}, - {67953, 67968}, {67973, 67980}, {67983, 67984}, - {67987, 68008}, {68010, 68016}, {68018, 68018}, - {68022, 68025}, {68029, 68029}, {68046, 68046}, - {68060, 68061}, {68063, 68065}, {68080, 68081}, - {68092, 68092}, {68101, 68106}, {68111, 68112}, - {68115, 68136}, {68138, 68144}, {68146, 68147}, - {68149, 68150}, {68152, 68153}, {68185, 68188}, - {68190, 68190}, {68210, 68212}, {68229, 68237}, - {68239, 68241}, {68243, 68264}, {68266, 68272}, - {68274, 68275}, {68277, 68281}, {68285, 68285}, - {68304, 68304}, {68320, 68321}, {68345, 68345}, - {68357, 68364}, {68367, 68368}, {68371, 68392}, - {68394, 68400}, {68402, 68403}, {68405, 68409}, - {68413, 68413}, {68444, 68445}, {68447, 68449}, - {68465, 68465}, {68483, 68483}, {68485, 68490}, - {68494, 68496}, {68498, 68501}, {68505, 68506}, - {68508, 68508}, {68510, 68511}, {68515, 68516}, - {68520, 68522}, {68526, 68537}, {68560, 68560}, - {68613, 68620}, {68622, 68624}, {68626, 68648}, - {68650, 68665}, {68669, 68669}, {68696, 68698}, - {68701, 68701}, {68704, 68705}, {68736, 68736}, - {68741, 68748}, {68750, 68752}, {68754, 68776}, - {68778, 68787}, {68789, 68793}, {68797, 68797}, - {68829, 68830}, {68832, 68833}, {68849, 68850}, - {68868, 68876}, {68878, 68880}, {68882, 68922}, - {68925, 68925}, {68942, 68942}, {68948, 68950}, - {68959, 68961}, {68986, 68991}, {68997, 69014}, - {69018, 69041}, {69043, 69051}, {69053, 69053}, - {69056, 69062}, {69121, 69168}, {69170, 69171}, - {69184, 69190}, {69249, 69250}, {69252, 69252}, - {69254, 69258}, {69260, 69283}, {69285, 69285}, - {69287, 69296}, {69298, 69299}, {69309, 69309}, - {69312, 69316}, {69318, 69318}, {69340, 69343}, - {69376, 69376}, {69440, 69447}, {69449, 69484}, - {69512, 69516}, {69632, 69674}, {69695, 69695}, - {69712, 69717}, {69722, 69725}, {69729, 69729}, - {69733, 69734}, {69742, 69744}, {69749, 69761}, - {69774, 69774}, {69792, 69829}, {69831, 69831}, - {69837, 69837}, {69840, 69882}, {69884, 70216}, - {70218, 70221}, {70224, 70230}, {70232, 70232}, - {70234, 70237}, {70240, 70280}, {70282, 70285}, - {70288, 70320}, {70322, 70325}, {70328, 70334}, - {70336, 70336}, {70338, 70341}, {70344, 70358}, - {70360, 70416}, {70418, 70421}, {70424, 70490}, - {70528, 70543}, {70560, 70645}, {70648, 70653}, - {70657, 71276}, {71279, 71295}, {71297, 71322}, - {71328, 71402}, {71406, 71416}, {71424, 71441}, - {71455, 71473}, {71488, 71505}, {71520, 71532}, - {71534, 71536}, {71552, 71603}, {71639, 71639}, - {71644, 71644}, {71712, 71800}, {71808, 71848}, - {71850, 71850}, {71856, 71925}, {71936, 71966}, - {72016, 72045}, {72048, 72052}, {72064, 72107}, - {72112, 72137}, {72192, 72214}, {72224, 72276}, - {72359, 72359}, {72453, 72499}, {72517, 72524}, - {72579, 72608}, {72622, 72623}, {72634, 72677}, - {72704, 72739}, {72781, 72783}, {72794, 72829}, - {72832, 72840}, {72848, 72890}, {72893, 72895}, - {72937, 72940}, {72942, 72947}, {72949, 72950}, - {72954, 72954}, {72960, 73151}, {73216, 73493}, - {73496, 73501}, {73504, 73541}, {73544, 73549}, - {73552, 73559}, {73561, 73561}, {73563, 73563}, - {73565, 73565}, {73567, 73597}, {73600, 73652}, - {73654, 73660}, {73662, 73662}, {73666, 73668}, - {73670, 73676}, {73680, 73683}, {73686, 73691}, - {73696, 73708}, {73714, 73716}, {73718, 73724}, - {73841, 73841}, {73855, 73855}, {73872, 73884}, - {73986, 73986}, {73991, 73991}, {73994, 74003}, - {74005, 74005}, {74008, 74013}, {74020, 74020}, - {74022, 74022}, {74024, 74024}, {74026, 74041}, - {74044, 74047}, {74053, 74057}, {74062, 74062}, - {74080, 74120}, {76800, 77028}, {77035, 77038}, - {77042, 77043}, {77056, 77093}, {77095, 77095}, - {77101, 77101}, {77104, 77159}, {77167, 77167}, - {77184, 77206}, {77216, 77222}, {77224, 77230}, - {77232, 77238}, {77240, 77246}, {77248, 77254}, - {77256, 77262}, {77264, 77270}, {77272, 77278}, - {77829, 77831}, {77857, 77865}, {77873, 77877}, - {77880, 77884}, {77889, 77974}, {77979, 77983}, - {77985, 78074}, {78076, 78079}, {78085, 78127}, - {78129, 78222}, {78240, 78271}, {78320, 78335}, - {78848, 85439}, {85504, 107660}, {107728, 107773}, - {107776, 108044}, {108048, 108063}, {108074, 108075}, - {108096, 108142}, {108159, 108189}, {108192, 108271}, - {108311, 108319}, {108322, 108424}, {108427, 108490}, - {108496, 108497}, {108499, 108499}, {108501, 108505}, - {108530, 108545}, {108547, 108549}, {108551, 108554}, - {108556, 108578}, {108608, 108659}, {108674, 108723}, - {108786, 108791}, {108795, 108795}, {108797, 108798}, - {108810, 108837}, {108848, 108870}, {108896, 108924}, - {108932, 108978}, {109007, 109007}, {109024, 109028}, - {109030, 109039}, {109050, 109054}, {109056, 109096}, - {109120, 109122}, {109124, 109131}, {109152, 109174}, - {109178, 109178}, {109182, 109231}, {109233, 109233}, - {109237, 109238}, {109241, 109245}, {109248, 109248}, - {109250, 109250}, {109275, 109277}, {109280, 109290}, - {109298, 109300}, {109313, 109318}, {109321, 109326}, - {109329, 109334}, {109344, 109350}, {109352, 109358}, - {109360, 109402}, {109404, 109417}, {109424, 109538}, - {109568, 120739}, {120752, 120774}, {120779, 120827}, - {129280, 129645}, {129648, 129753}, {129792, 129798}, - {129811, 129815}, {129821, 129821}, {129823, 129832}, - {129834, 129846}, {129848, 129852}, {129854, 129854}, - {129856, 129857}, {129859, 129860}, {129862, 129969}, - {130003, 130365}, {130384, 130447}, {130450, 130503}, - {130544, 130555}, {130672, 130676}, {130678, 130812}, - {130849, 130874}, {130881, 130906}, {130918, 131006}, - {131010, 131015}, {131018, 131023}, {131026, 131031}, - {131034, 131036}, {131108, 131108}, {131137, 131162}, - {131167, 131167}, {131169, 131194}, {131242, 131242}, - {131253, 131253}, {131258, 131258}, {131264, 131286}, - {131288, 131318}, {131320, 131777}, {131782, 131793}, - {131808, 131812}, {131820, 131820}, {131822, 131822}, - {131952, 131956}, {131958, 131959}, {131962, 131965}, - {131967, 131967}, {131974, 131974}, {131976, 131978}, - {131980, 131980}, {131982, 132001}, {132003, 132085}, - {132087, 132225}, {132234, 132399}, {132401, 132438}, - {132441, 132441}, {132448, 132488}, {132560, 132586}, - {132591, 132594}, {132640, 132682}, {132718, 132719}, - {132721, 132819}, {132821, 132821}, {132837, 132838}, - {132846, 132847}, {132858, 132860}, {132863, 132863}, - {132880, 132880}, {132882, 132911}, {132941, 133029}, - {133041, 133041}, {133066, 133098}, {133108, 133109}, - {133114, 133114}, {133120, 133141}, {133146, 133146}, - {133156, 133156}, {133160, 133160}, {133184, 133208}, - {133216, 133226}, {133232, 133255}, {133257, 133262}, - {133280, 133321}, {133380, 133433}, {133437, 133437}, - {133456, 133456}, {133464, 133473}, {133489, 133504}, - {133509, 133516}, {133519, 133520}, {133523, 133544}, - {133546, 133552}, {133554, 133554}, {133558, 133561}, - {133565, 133565}, {133582, 133582}, {133596, 133597}, - {133599, 133601}, {133616, 133617}, {133628, 133628}, - {133637, 133642}, {133647, 133648}, {133651, 133672}, - {133674, 133680}, {133682, 133683}, {133685, 133686}, - {133688, 133689}, {133721, 133724}, {133726, 133726}, - {133746, 133748}, {133765, 133773}, {133775, 133777}, - {133779, 133800}, {133802, 133808}, {133810, 133811}, - {133813, 133817}, {133821, 133821}, {133840, 133840}, - {133856, 133857}, {133881, 133881}, {133893, 133900}, - {133903, 133904}, {133907, 133928}, {133930, 133936}, - {133938, 133939}, {133941, 133945}, {133949, 133949}, - {133980, 133981}, {133983, 133985}, {134001, 134001}, - {134019, 134019}, {134021, 134026}, {134030, 134032}, - {134034, 134037}, {134041, 134042}, {134044, 134044}, - {134046, 134047}, {134051, 134052}, {134056, 134058}, - {134062, 134073}, {134096, 134096}, {134149, 134156}, - {134158, 134160}, {134162, 134184}, {134186, 134201}, - {134205, 134205}, {134232, 134234}, {134237, 134237}, - {134240, 134241}, {134272, 134272}, {134277, 134284}, - {134286, 134288}, {134290, 134312}, {134314, 134323}, - {134325, 134329}, {134333, 134333}, {134365, 134366}, - {134368, 134369}, {134385, 134386}, {134404, 134412}, - {134414, 134416}, {134418, 134458}, {134461, 134461}, - {134478, 134478}, {134484, 134486}, {134495, 134497}, - {134522, 134527}, {134533, 134550}, {134554, 134577}, - {134579, 134587}, {134589, 134589}, {134592, 134598}, - {134657, 134704}, {134706, 134707}, {134720, 134726}, - {134785, 134786}, {134788, 134788}, {134790, 134794}, - {134796, 134819}, {134821, 134821}, {134823, 134832}, - {134834, 134835}, {134845, 134845}, {134848, 134852}, - {134854, 134854}, {134876, 134879}, {134912, 134912}, - {134976, 134983}, {134985, 135020}, {135048, 135052}, - {135168, 135210}, {135231, 135231}, {135248, 135253}, - {135258, 135261}, {135265, 135265}, {135269, 135270}, - {135278, 135280}, {135285, 135297}, {135310, 135310}, - {135328, 135365}, {135367, 135367}, {135373, 135373}, - {135376, 135418}, {135420, 135752}, {135754, 135757}, - {135760, 135766}, {135768, 135768}, {135770, 135773}, - {135776, 135816}, {135818, 135821}, {135824, 135856}, - {135858, 135861}, {135864, 135870}, {135872, 135872}, - {135874, 135877}, {135880, 135894}, {135896, 135952}, - {135954, 135957}, {135960, 136026}, {136064, 136079}, - {136096, 136181}, {136184, 136189}, {136193, 136812}, - {136815, 136831}, {136833, 136858}, {136864, 136938}, - {136942, 136952}, {136960, 136977}, {136991, 137009}, - {137024, 137041}, {137056, 137068}, {137070, 137072}, - {137088, 137139}, {137175, 137175}, {137180, 137180}, - {137248, 137336}, {137344, 137384}, {137386, 137386}, - {137392, 137461}, {137472, 137502}, {137552, 137581}, - {137584, 137588}, {137600, 137643}, {137648, 137673}, - {137728, 137750}, {137760, 137812}, {137895, 137895}, - {137989, 138035}, {138053, 138060}, {138115, 138144}, - {138158, 138159}, {138170, 138213}, {138240, 138275}, - {138317, 138319}, {138330, 138365}, {138368, 138376}, - {138384, 138426}, {138429, 138431}, {138473, 138476}, - {138478, 138483}, {138485, 138486}, {138490, 138490}, - {138496, 138687}, {138752, 139029}, {139032, 139037}, - {139040, 139077}, {139080, 139085}, {139088, 139095}, - {139097, 139097}, {139099, 139099}, {139101, 139101}, - {139103, 139133}, {139136, 139188}, {139190, 139196}, - {139198, 139198}, {139202, 139204}, {139206, 139212}, - {139216, 139219}, {139222, 139227}, {139232, 139244}, - {139250, 139252}, {139254, 139260}, {139377, 139377}, - {139391, 139391}, {139408, 139420}, {139522, 139522}, - {139527, 139527}, {139530, 139539}, {139541, 139541}, - {139544, 139549}, {139556, 139556}, {139558, 139558}, - {139560, 139560}, {139562, 139577}, {139580, 139583}, - {139589, 139593}, {139598, 139598}, {139616, 139656}, - {142336, 142564}, {142571, 142574}, {142578, 142579}, - {142592, 142629}, {142631, 142631}, {142637, 142637}, - {142640, 142695}, {142703, 142703}, {142720, 142742}, - {142752, 142758}, {142760, 142766}, {142768, 142774}, - {142776, 142782}, {142784, 142790}, {142792, 142798}, - {142800, 142806}, {142808, 142814}, {143365, 143367}, - {143393, 143401}, {143409, 143413}, {143416, 143420}, - {143425, 143510}, {143515, 143519}, {143521, 143610}, - {143612, 143615}, {143621, 143663}, {143665, 143758}, - {143776, 143807}, {143856, 143871}, {144384, 150975}, - {151040, 173196}, {173264, 173309}, {173312, 173580}, - {173584, 173599}, {173610, 173611}, {173632, 173678}, - {173695, 173725}, {173728, 173807}, {173847, 173855}, - {173858, 173960}, {173963, 174026}, {174032, 174033}, - {174035, 174035}, {174037, 174041}, {174066, 174081}, - {174083, 174085}, {174087, 174090}, {174092, 174114}, - {174144, 174195}, {174210, 174259}, {174322, 174327}, - {174331, 174331}, {174333, 174334}, {174346, 174373}, - {174384, 174406}, {174432, 174460}, {174468, 174514}, - {174543, 174543}, {174560, 174564}, {174566, 174575}, - {174586, 174590}, {174592, 174632}, {174656, 174658}, - {174660, 174667}, {174688, 174710}, {174714, 174714}, - {174718, 174767}, {174769, 174769}, {174773, 174774}, - {174777, 174781}, {174784, 174784}, {174786, 174786}, - {174811, 174813}, {174816, 174826}, {174834, 174836}, - {174849, 174854}, {174857, 174862}, {174865, 174870}, - {174880, 174886}, {174888, 174894}, {174896, 174938}, - {174940, 174953}, {174960, 175074}, {175104, 186275}, - {186288, 186310}, {186315, 186363}, {194816, 195181}, - {195184, 195289}, {195328, 195334}, {195347, 195351}, - {195357, 195357}, {195359, 195368}, {195370, 195382}, - {195384, 195388}, {195390, 195390}, {195392, 195393}, - {195395, 195396}, {195398, 195505}, {195539, 195901}, - {195920, 195983}, {195986, 196039}, {196080, 196091}, - {196208, 196212}, {196214, 196348}, {196385, 196410}, - {196417, 196442}, {196454, 196542}, {196546, 196551}, - {196554, 196559}, {196562, 196567}, {196570, 196572}, - {196644, 196644}, {196673, 196698}, {196703, 196703}, - {196705, 196730}, {196778, 196778}, {196789, 196789}, - {196794, 196794}, {196800, 196822}, {196824, 196854}, - {196856, 197313}, {197318, 197329}, {197344, 197348}, - {197356, 197356}, {197358, 197358}, {197488, 197492}, - {197494, 197495}, {197498, 197501}, {197503, 197503}, - {197510, 197510}, {197512, 197514}, {197516, 197516}, - {197518, 197537}, {197539, 197621}, {197623, 197761}, - {197770, 197935}, {197937, 197974}, {197977, 197977}, - {197984, 198024}, {198096, 198122}, {198127, 198130}, - {198176, 198218}, {198254, 198255}, {198257, 198355}, - {198357, 198357}, {198373, 198374}, {198382, 198383}, - {198394, 198396}, {198399, 198399}, {198416, 198416}, - {198418, 198447}, {198477, 198565}, {198577, 198577}, - {198602, 198634}, {198644, 198645}, {198650, 198650}, - {198656, 198677}, {198682, 198682}, {198692, 198692}, - {198696, 198696}, {198720, 198744}, {198752, 198762}, - {198768, 198791}, {198793, 198798}, {198816, 198857}, - {198916, 198969}, {198973, 198973}, {198992, 198992}, - {199000, 199009}, {199025, 199040}, {199045, 199052}, - {199055, 199056}, {199059, 199080}, {199082, 199088}, - {199090, 199090}, {199094, 199097}, {199101, 199101}, - {199118, 199118}, {199132, 199133}, {199135, 199137}, - {199152, 199153}, {199164, 199164}, {199173, 199178}, - {199183, 199184}, {199187, 199208}, {199210, 199216}, - {199218, 199219}, {199221, 199222}, {199224, 199225}, - {199257, 199260}, {199262, 199262}, {199282, 199284}, - {199301, 199309}, {199311, 199313}, {199315, 199336}, - {199338, 199344}, {199346, 199347}, {199349, 199353}, - {199357, 199357}, {199376, 199376}, {199392, 199393}, - {199417, 199417}, {199429, 199436}, {199439, 199440}, - {199443, 199464}, {199466, 199472}, {199474, 199475}, - {199477, 199481}, {199485, 199485}, {199516, 199517}, - {199519, 199521}, {199537, 199537}, {199555, 199555}, - {199557, 199562}, {199566, 199568}, {199570, 199573}, - {199577, 199578}, {199580, 199580}, {199582, 199583}, - {199587, 199588}, {199592, 199594}, {199598, 199609}, - {199632, 199632}, {199685, 199692}, {199694, 199696}, - {199698, 199720}, {199722, 199737}, {199741, 199741}, - {199768, 199770}, {199773, 199773}, {199776, 199777}, - {199808, 199808}, {199813, 199820}, {199822, 199824}, - {199826, 199848}, {199850, 199859}, {199861, 199865}, - {199869, 199869}, {199901, 199902}, {199904, 199905}, - {199921, 199922}, {199940, 199948}, {199950, 199952}, - {199954, 199994}, {199997, 199997}, {200014, 200014}, - {200020, 200022}, {200031, 200033}, {200058, 200063}, - {200069, 200086}, {200090, 200113}, {200115, 200123}, - {200125, 200125}, {200128, 200134}, {200193, 200240}, - {200242, 200243}, {200256, 200262}, {200321, 200322}, - {200324, 200324}, {200326, 200330}, {200332, 200355}, - {200357, 200357}, {200359, 200368}, {200370, 200371}, - {200381, 200381}, {200384, 200388}, {200390, 200390}, - {200412, 200415}, {200448, 200448}, {200512, 200519}, - {200521, 200556}, {200584, 200588}, {200704, 200746}, - {200767, 200767}, {200784, 200789}, {200794, 200797}, - {200801, 200801}, {200805, 200806}, {200814, 200816}, - {200821, 200833}, {200846, 200846}, {200864, 200901}, - {200903, 200903}, {200909, 200909}, {200912, 200954}, - {200956, 201288}, {201290, 201293}, {201296, 201302}, - {201304, 201304}, {201306, 201309}, {201312, 201352}, - {201354, 201357}, {201360, 201392}, {201394, 201397}, - {201400, 201406}, {201408, 201408}, {201410, 201413}, - {201416, 201430}, {201432, 201488}, {201490, 201493}, - {201496, 201562}, {201600, 201615}, {201632, 201717}, - {201720, 201725}, {201729, 202348}, {202351, 202367}, - {202369, 202394}, {202400, 202474}, {202478, 202488}, - {202496, 202513}, {202527, 202545}, {202560, 202577}, - {202592, 202604}, {202606, 202608}, {202624, 202675}, - {202711, 202711}, {202716, 202716}, {202784, 202872}, - {202880, 202920}, {202922, 202922}, {202928, 202997}, - {203008, 203038}, {203088, 203117}, {203120, 203124}, - {203136, 203179}, {203184, 203209}, {203264, 203286}, - {203296, 203348}, {203431, 203431}, {203525, 203571}, - {203589, 203596}, {203651, 203680}, {203694, 203695}, - {203706, 203749}, {203776, 203811}, {203853, 203855}, - {203866, 203901}, {203904, 203912}, {203920, 203962}, - {203965, 203967}, {204009, 204012}, {204014, 204019}, - {204021, 204022}, {204026, 204026}, {204032, 204223}, - {204288, 204565}, {204568, 204573}, {204576, 204613}, - {204616, 204621}, {204624, 204631}, {204633, 204633}, - {204635, 204635}, {204637, 204637}, {204639, 204669}, - {204672, 204724}, {204726, 204732}, {204734, 204734}, - {204738, 204740}, {204742, 204748}, {204752, 204755}, - {204758, 204763}, {204768, 204780}, {204786, 204788}, - {204790, 204796}, {204913, 204913}, {204927, 204927}, - {204944, 204956}, {205058, 205058}, {205063, 205063}, - {205066, 205075}, {205077, 205077}, {205080, 205085}, - {205092, 205092}, {205094, 205094}, {205096, 205096}, - {205098, 205113}, {205116, 205119}, {205125, 205129}, - {205134, 205134}, {205152, 205192}, {207872, 208100}, - {208107, 208110}, {208114, 208115}, {208128, 208165}, - {208167, 208167}, {208173, 208173}, {208176, 208231}, - {208239, 208239}, {208256, 208278}, {208288, 208294}, - {208296, 208302}, {208304, 208310}, {208312, 208318}, - {208320, 208326}, {208328, 208334}, {208336, 208342}, - {208344, 208350}, {208901, 208903}, {208929, 208937}, - {208945, 208949}, {208952, 208956}, {208961, 209046}, - {209051, 209055}, {209057, 209146}, {209148, 209151}, - {209157, 209199}, {209201, 209294}, {209312, 209343}, - {209392, 209407}, {209920, 216511}, {216576, 238732}, - {238800, 238845}, {238848, 239116}, {239120, 239135}, - {239146, 239147}, {239168, 239214}, {239231, 239261}, - {239264, 239343}, {239383, 239391}, {239394, 239496}, - {239499, 239562}, {239568, 239569}, {239571, 239571}, - {239573, 239577}, {239602, 239617}, {239619, 239621}, - {239623, 239626}, {239628, 239650}, {239680, 239731}, - {239746, 239795}, {239858, 239863}, {239867, 239867}, - {239869, 239870}, {239882, 239909}, {239920, 239942}, - {239968, 239996}, {240004, 240050}, {240079, 240079}, - {240096, 240100}, {240102, 240111}, {240122, 240126}, - {240128, 240168}, {240192, 240194}, {240196, 240203}, - {240224, 240246}, {240250, 240250}, {240254, 240303}, - {240305, 240305}, {240309, 240310}, {240313, 240317}, - {240320, 240320}, {240322, 240322}, {240347, 240349}, - {240352, 240362}, {240370, 240372}, {240385, 240390}, - {240393, 240398}, {240401, 240406}, {240416, 240422}, - {240424, 240430}, {240432, 240474}, {240476, 240489}, - {240496, 240610}, {240640, 251811}, {251824, 251846}, - {251851, 251899}, {260352, 260717}, {260720, 260825}, - {260864, 260870}, {260883, 260887}, {260893, 260893}, - {260895, 260904}, {260906, 260918}, {260920, 260924}, - {260926, 260926}, {260928, 260929}, {260931, 260932}, - {260934, 261041}, {261075, 261437}, {261456, 261519}, - {261522, 261575}, {261616, 261627}, {261744, 261748}, - {261750, 261884}, {261921, 261946}, {261953, 261978}, - {261990, 262078}, {262082, 262087}, {262090, 262095}, - {262098, 262103}, {262106, 262108}, {262180, 262180}, - {262209, 262234}, {262239, 262239}, {262241, 262266}, - {262314, 262314}, {262325, 262325}, {262330, 262330}, - {262336, 262358}, {262360, 262390}, {262392, 262849}, - {262854, 262865}, {262880, 262884}, {262892, 262892}, - {262894, 262894}, {263024, 263028}, {263030, 263031}, - {263034, 263037}, {263039, 263039}, {263046, 263046}, - {263048, 263050}, {263052, 263052}, {263054, 263073}, - {263075, 263157}, {263159, 263297}, {263306, 263471}, - {263473, 263510}, {263513, 263513}, {263520, 263560}, - {263632, 263658}, {263663, 263666}, {263712, 263754}, - {263790, 263791}, {263793, 263891}, {263893, 263893}, - {263909, 263910}, {263918, 263919}, {263930, 263932}, - {263935, 263935}, {263952, 263952}, {263954, 263983}, - {264013, 264101}, {264113, 264113}, {264138, 264170}, - {264180, 264181}, {264186, 264186}, {264192, 264213}, - {264218, 264218}, {264228, 264228}, {264232, 264232}, - {264256, 264280}, {264288, 264298}, {264304, 264327}, - {264329, 264334}, {264352, 264393}, {264452, 264505}, - {264509, 264509}, {264528, 264528}, {264536, 264545}, - {264561, 264576}, {264581, 264588}, {264591, 264592}, - {264595, 264616}, {264618, 264624}, {264626, 264626}, - {264630, 264633}, {264637, 264637}, {264654, 264654}, - {264668, 264669}, {264671, 264673}, {264688, 264689}, - {264700, 264700}, {264709, 264714}, {264719, 264720}, - {264723, 264744}, {264746, 264752}, {264754, 264755}, - {264757, 264758}, {264760, 264761}, {264793, 264796}, - {264798, 264798}, {264818, 264820}, {264837, 264845}, - {264847, 264849}, {264851, 264872}, {264874, 264880}, - {264882, 264883}, {264885, 264889}, {264893, 264893}, - {264912, 264912}, {264928, 264929}, {264953, 264953}, - {264965, 264972}, {264975, 264976}, {264979, 265000}, - {265002, 265008}, {265010, 265011}, {265013, 265017}, - {265021, 265021}, {265052, 265053}, {265055, 265057}, - {265073, 265073}, {265091, 265091}, {265093, 265098}, - {265102, 265104}, {265106, 265109}, {265113, 265114}, - {265116, 265116}, {265118, 265119}, {265123, 265124}, - {265128, 265130}, {265134, 265145}, {265168, 265168}, - {265221, 265228}, {265230, 265232}, {265234, 265256}, - {265258, 265273}, {265277, 265277}, {265304, 265306}, - {265309, 265309}, {265312, 265313}, {265344, 265344}, - {265349, 265356}, {265358, 265360}, {265362, 265384}, - {265386, 265395}, {265397, 265401}, {265405, 265405}, - {265437, 265438}, {265440, 265441}, {265457, 265458}, - {265476, 265484}, {265486, 265488}, {265490, 265530}, - {265533, 265533}, {265550, 265550}, {265556, 265558}, - {265567, 265569}, {265594, 265599}, {265605, 265622}, - {265626, 265649}, {265651, 265659}, {265661, 265661}, - {265664, 265670}, {265729, 265776}, {265778, 265779}, - {265792, 265798}, {265857, 265858}, {265860, 265860}, - {265862, 265866}, {265868, 265891}, {265893, 265893}, - {265895, 265904}, {265906, 265907}, {265917, 265917}, - {265920, 265924}, {265926, 265926}, {265948, 265951}, - {265984, 265984}, {266048, 266055}, {266057, 266092}, - {266120, 266124}, {266240, 266282}, {266303, 266303}, - {266320, 266325}, {266330, 266333}, {266337, 266337}, - {266341, 266342}, {266350, 266352}, {266357, 266369}, - {266382, 266382}, {266400, 266437}, {266439, 266439}, - {266445, 266445}, {266448, 266490}, {266492, 266824}, - {266826, 266829}, {266832, 266838}, {266840, 266840}, - {266842, 266845}, {266848, 266888}, {266890, 266893}, - {266896, 266928}, {266930, 266933}, {266936, 266942}, - {266944, 266944}, {266946, 266949}, {266952, 266966}, - {266968, 267024}, {267026, 267029}, {267032, 267098}, - {267136, 267151}, {267168, 267253}, {267256, 267261}, - {267265, 267884}, {267887, 267903}, {267905, 267930}, - {267936, 268010}, {268014, 268024}, {268032, 268049}, - {268063, 268081}, {268096, 268113}, {268128, 268140}, - {268142, 268144}, {268160, 268211}, {268247, 268247}, - {268252, 268252}, {268320, 268408}, {268416, 268456}, - {268458, 268458}, {268464, 268533}, {268544, 268574}, - {268624, 268653}, {268656, 268660}, {268672, 268715}, - {268720, 268745}, {268800, 268822}, {268832, 268884}, - {268967, 268967}, {269061, 269107}, {269125, 269132}, - {269187, 269216}, {269230, 269231}, {269242, 269285}, - {269312, 269347}, {269389, 269391}, {269402, 269437}, - {269440, 269448}, {269456, 269498}, {269501, 269503}, - {269545, 269548}, {269550, 269555}, {269557, 269558}, - {269562, 269562}, {269568, 269759}, {269824, 270101}, - {270104, 270109}, {270112, 270149}, {270152, 270157}, - {270160, 270167}, {270169, 270169}, {270171, 270171}, - {270173, 270173}, {270175, 270205}, {270208, 270260}, - {270262, 270268}, {270270, 270270}, {270274, 270276}, - {270278, 270284}, {270288, 270291}, {270294, 270299}, - {270304, 270316}, {270322, 270324}, {270326, 270332}, - {270449, 270449}, {270463, 270463}, {270480, 270492}, - {270594, 270594}, {270599, 270599}, {270602, 270611}, - {270613, 270613}, {270616, 270621}, {270628, 270628}, - {270630, 270630}, {270632, 270632}, {270634, 270649}, - {270652, 270655}, {270661, 270665}, {270670, 270670}, - {270688, 270728}, {273408, 273636}, {273643, 273646}, - {273650, 273651}, {273664, 273701}, {273703, 273703}, - {273709, 273709}, {273712, 273767}, {273775, 273775}, - {273792, 273814}, {273824, 273830}, {273832, 273838}, - {273840, 273846}, {273848, 273854}, {273856, 273862}, - {273864, 273870}, {273872, 273878}, {273880, 273886}, - {274437, 274439}, {274465, 274473}, {274481, 274485}, - {274488, 274492}, {274497, 274582}, {274587, 274591}, - {274593, 274682}, {274684, 274687}, {274693, 274735}, - {274737, 274830}, {274848, 274879}, {274928, 274943}, - {275456, 282047}, {282112, 304268}, {304336, 304381}, - {304384, 304652}, {304656, 304671}, {304682, 304683}, - {304704, 304750}, {304767, 304797}, {304800, 304879}, - {304919, 304927}, {304930, 305032}, {305035, 305098}, - {305104, 305105}, {305107, 305107}, {305109, 305113}, - {305138, 305153}, {305155, 305157}, {305159, 305162}, - {305164, 305186}, {305216, 305267}, {305282, 305331}, - {305394, 305399}, {305403, 305403}, {305405, 305406}, - {305418, 305445}, {305456, 305478}, {305504, 305532}, - {305540, 305586}, {305615, 305615}, {305632, 305636}, - {305638, 305647}, {305658, 305662}, {305664, 305704}, - {305728, 305730}, {305732, 305739}, {305760, 305782}, - {305786, 305786}, {305790, 305839}, {305841, 305841}, - {305845, 305846}, {305849, 305853}, {305856, 305856}, - {305858, 305858}, {305883, 305885}, {305888, 305898}, - {305906, 305908}, {305921, 305926}, {305929, 305934}, - {305937, 305942}, {305952, 305958}, {305960, 305966}, - {305968, 306010}, {306012, 306025}, {306032, 306146}, - {306176, 317347}, {317360, 317382}, {317387, 317435}, - {325888, 326253}, {326256, 326361}, {326400, 326406}, - {326419, 326423}, {326429, 326429}, {326431, 326440}, - {326442, 326454}, {326456, 326460}, {326462, 326462}, - {326464, 326465}, {326467, 326468}, {326470, 326577}, - {326611, 326973}, {326992, 327055}, {327058, 327111}, - {327152, 327163}, {327280, 327284}, {327286, 327420}, - {327457, 327482}, {327489, 327514}, {327526, 327614}, - {327618, 327623}, {327626, 327631}, {327634, 327639}, - {327642, 327644}, {327716, 327716}, {327745, 327770}, - {327775, 327775}, {327777, 327802}, {327850, 327850}, - {327861, 327861}, {327866, 327866}, {327872, 327894}, - {327896, 327926}, {327928, 328385}, {328390, 328401}, - {328416, 328420}, {328428, 328428}, {328430, 328430}, - {328560, 328564}, {328566, 328567}, {328570, 328573}, - {328575, 328575}, {328582, 328582}, {328584, 328586}, - {328588, 328588}, {328590, 328609}, {328611, 328693}, - {328695, 328833}, {328842, 329007}, {329009, 329046}, - {329049, 329049}, {329056, 329096}, {329168, 329194}, - {329199, 329202}, {329248, 329290}, {329326, 329327}, - {329329, 329427}, {329429, 329429}, {329445, 329446}, - {329454, 329455}, {329466, 329468}, {329471, 329471}, - {329488, 329488}, {329490, 329519}, {329549, 329637}, - {329649, 329649}, {329674, 329706}, {329716, 329717}, - {329722, 329722}, {329728, 329749}, {329754, 329754}, - {329764, 329764}, {329768, 329768}, {329792, 329816}, - {329824, 329834}, {329840, 329863}, {329865, 329870}, - {329888, 329929}, {329988, 330041}, {330045, 330045}, - {330064, 330064}, {330072, 330081}, {330097, 330112}, - {330117, 330124}, {330127, 330128}, {330131, 330152}, - {330154, 330160}, {330162, 330162}, {330166, 330169}, - {330173, 330173}, {330190, 330190}, {330204, 330205}, - {330207, 330209}, {330224, 330225}, {330236, 330236}, - {330245, 330250}, {330255, 330256}, {330259, 330280}, - {330282, 330288}, {330290, 330291}, {330293, 330294}, - {330296, 330297}, {330329, 330332}, {330334, 330334}, - {330354, 330356}, {330373, 330381}, {330383, 330385}, - {330387, 330408}, {330410, 330416}, {330418, 330419}, - {330421, 330425}, {330429, 330429}, {330448, 330448}, - {330464, 330465}, {330489, 330489}, {330501, 330508}, - {330511, 330512}, {330515, 330536}, {330538, 330544}, - {330546, 330547}, {330549, 330553}, {330557, 330557}, - {330588, 330589}, {330591, 330593}, {330609, 330609}, - {330627, 330627}, {330629, 330634}, {330638, 330640}, - {330642, 330645}, {330649, 330650}, {330652, 330652}, - {330654, 330655}, {330659, 330660}, {330664, 330666}, - {330670, 330681}, {330704, 330704}, {330757, 330764}, - {330766, 330768}, {330770, 330792}, {330794, 330809}, - {330813, 330813}, {330840, 330842}, {330845, 330845}, - {330848, 330849}, {330880, 330880}, {330885, 330892}, - {330894, 330896}, {330898, 330920}, {330922, 330931}, - {330933, 330937}, {330941, 330941}, {330973, 330974}, - {330976, 330977}, {330993, 330994}, {331012, 331020}, - {331022, 331024}, {331026, 331066}, {331069, 331069}, - {331086, 331086}, {331092, 331094}, {331103, 331105}, - {331130, 331135}, {331141, 331158}, {331162, 331185}, - {331187, 331195}, {331197, 331197}, {331200, 331206}, - {331265, 331312}, {331314, 331315}, {331328, 331334}, - {331393, 331394}, {331396, 331396}, {331398, 331402}, - {331404, 331427}, {331429, 331429}, {331431, 331440}, - {331442, 331443}, {331453, 331453}, {331456, 331460}, - {331462, 331462}, {331484, 331487}, {331520, 331520}, - {331584, 331591}, {331593, 331628}, {331656, 331660}, - {331776, 331818}, {331839, 331839}, {331856, 331861}, - {331866, 331869}, {331873, 331873}, {331877, 331878}, - {331886, 331888}, {331893, 331905}, {331918, 331918}, - {331936, 331973}, {331975, 331975}, {331981, 331981}, - {331984, 332026}, {332028, 332360}, {332362, 332365}, - {332368, 332374}, {332376, 332376}, {332378, 332381}, - {332384, 332424}, {332426, 332429}, {332432, 332464}, - {332466, 332469}, {332472, 332478}, {332480, 332480}, - {332482, 332485}, {332488, 332502}, {332504, 332560}, - {332562, 332565}, {332568, 332634}, {332672, 332687}, - {332704, 332789}, {332792, 332797}, {332801, 333420}, - {333423, 333439}, {333441, 333466}, {333472, 333546}, - {333550, 333560}, {333568, 333585}, {333599, 333617}, - {333632, 333649}, {333664, 333676}, {333678, 333680}, - {333696, 333747}, {333783, 333783}, {333788, 333788}, - {333856, 333944}, {333952, 333992}, {333994, 333994}, - {334000, 334069}, {334080, 334110}, {334160, 334189}, - {334192, 334196}, {334208, 334251}, {334256, 334281}, - {334336, 334358}, {334368, 334420}, {334503, 334503}, - {334597, 334643}, {334661, 334668}, {334723, 334752}, - {334766, 334767}, {334778, 334821}, {334848, 334883}, - {334925, 334927}, {334938, 334973}, {334976, 334984}, - {334992, 335034}, {335037, 335039}, {335081, 335084}, - {335086, 335091}, {335093, 335094}, {335098, 335098}, - {335104, 335295}, {335360, 335637}, {335640, 335645}, - {335648, 335685}, {335688, 335693}, {335696, 335703}, - {335705, 335705}, {335707, 335707}, {335709, 335709}, - {335711, 335741}, {335744, 335796}, {335798, 335804}, - {335806, 335806}, {335810, 335812}, {335814, 335820}, - {335824, 335827}, {335830, 335835}, {335840, 335852}, - {335858, 335860}, {335862, 335868}, {335985, 335985}, - {335999, 335999}, {336016, 336028}, {336130, 336130}, - {336135, 336135}, {336138, 336147}, {336149, 336149}, - {336152, 336157}, {336164, 336164}, {336166, 336166}, - {336168, 336168}, {336170, 336185}, {336188, 336191}, - {336197, 336201}, {336206, 336206}, {336224, 336264}, - {338944, 339172}, {339179, 339182}, {339186, 339187}, - {339200, 339237}, {339239, 339239}, {339245, 339245}, - {339248, 339303}, {339311, 339311}, {339328, 339350}, - {339360, 339366}, {339368, 339374}, {339376, 339382}, - {339384, 339390}, {339392, 339398}, {339400, 339406}, - {339408, 339414}, {339416, 339422}, {339973, 339975}, - {340001, 340009}, {340017, 340021}, {340024, 340028}, - {340033, 340118}, {340123, 340127}, {340129, 340218}, - {340220, 340223}, {340229, 340271}, {340273, 340366}, - {340384, 340415}, {340464, 340479}, {340992, 347583}, - {347648, 369804}, {369872, 369917}, {369920, 370188}, - {370192, 370207}, {370218, 370219}, {370240, 370286}, - {370303, 370333}, {370336, 370415}, {370455, 370463}, - {370466, 370568}, {370571, 370634}, {370640, 370641}, - {370643, 370643}, {370645, 370649}, {370674, 370689}, - {370691, 370693}, {370695, 370698}, {370700, 370722}, - {370752, 370803}, {370818, 370867}, {370930, 370935}, - {370939, 370939}, {370941, 370942}, {370954, 370981}, - {370992, 371014}, {371040, 371068}, {371076, 371122}, - {371151, 371151}, {371168, 371172}, {371174, 371183}, - {371194, 371198}, {371200, 371240}, {371264, 371266}, - {371268, 371275}, {371296, 371318}, {371322, 371322}, - {371326, 371375}, {371377, 371377}, {371381, 371382}, - {371385, 371389}, {371392, 371392}, {371394, 371394}, - {371419, 371421}, {371424, 371434}, {371442, 371444}, - {371457, 371462}, {371465, 371470}, {371473, 371478}, - {371488, 371494}, {371496, 371502}, {371504, 371546}, - {371548, 371561}, {371568, 371682}, {371712, 382883}, - {382896, 382918}, {382923, 382971}, {391424, 391789}, - {391792, 391897}, {391936, 391942}, {391955, 391959}, - {391965, 391965}, {391967, 391976}, {391978, 391990}, - {391992, 391996}, {391998, 391998}, {392000, 392001}, - {392003, 392004}, {392006, 392113}, {392147, 392509}, - {392528, 392591}, {392594, 392647}, {392688, 392699}, - {392816, 392820}, {392822, 392956}, {392993, 393018}, - {393025, 393050}, {393062, 393150}, {393154, 393159}, - {393162, 393167}, {393170, 393175}, {393178, 393180}, - {393252, 393252}, {393281, 393306}, {393311, 393311}, - {393313, 393338}, {393386, 393386}, {393397, 393397}, - {393402, 393402}, {393408, 393430}, {393432, 393462}, - {393464, 393921}, {393926, 393937}, {393952, 393956}, - {393964, 393964}, {393966, 393966}, {394096, 394100}, - {394102, 394103}, {394106, 394109}, {394111, 394111}, - {394118, 394118}, {394120, 394122}, {394124, 394124}, - {394126, 394145}, {394147, 394229}, {394231, 394369}, - {394378, 394543}, {394545, 394582}, {394585, 394585}, - {394592, 394632}, {394704, 394730}, {394735, 394738}, - {394784, 394826}, {394862, 394863}, {394865, 394963}, - {394965, 394965}, {394981, 394982}, {394990, 394991}, - {395002, 395004}, {395007, 395007}, {395024, 395024}, - {395026, 395055}, {395085, 395173}, {395185, 395185}, - {395210, 395242}, {395252, 395253}, {395258, 395258}, - {395264, 395285}, {395290, 395290}, {395300, 395300}, - {395304, 395304}, {395328, 395352}, {395360, 395370}, - {395376, 395399}, {395401, 395406}, {395424, 395465}, - {395524, 395577}, {395581, 395581}, {395600, 395600}, - {395608, 395617}, {395633, 395648}, {395653, 395660}, - {395663, 395664}, {395667, 395688}, {395690, 395696}, - {395698, 395698}, {395702, 395705}, {395709, 395709}, - {395726, 395726}, {395740, 395741}, {395743, 395745}, - {395760, 395761}, {395772, 395772}, {395781, 395786}, - {395791, 395792}, {395795, 395816}, {395818, 395824}, - {395826, 395827}, {395829, 395830}, {395832, 395833}, - {395865, 395868}, {395870, 395870}, {395890, 395892}, - {395909, 395917}, {395919, 395921}, {395923, 395944}, - {395946, 395952}, {395954, 395955}, {395957, 395961}, - {395965, 395965}, {395984, 395984}, {396000, 396001}, - {396025, 396025}, {396037, 396044}, {396047, 396048}, - {396051, 396072}, {396074, 396080}, {396082, 396083}, - {396085, 396089}, {396093, 396093}, {396124, 396125}, - {396127, 396129}, {396145, 396145}, {396163, 396163}, - {396165, 396170}, {396174, 396176}, {396178, 396181}, - {396185, 396186}, {396188, 396188}, {396190, 396191}, - {396195, 396196}, {396200, 396202}, {396206, 396217}, - {396240, 396240}, {396293, 396300}, {396302, 396304}, - {396306, 396328}, {396330, 396345}, {396349, 396349}, - {396376, 396378}, {396381, 396381}, {396384, 396385}, - {396416, 396416}, {396421, 396428}, {396430, 396432}, - {396434, 396456}, {396458, 396467}, {396469, 396473}, - {396477, 396477}, {396509, 396510}, {396512, 396513}, - {396529, 396530}, {396548, 396556}, {396558, 396560}, - {396562, 396602}, {396605, 396605}, {396622, 396622}, - {396628, 396630}, {396639, 396641}, {396666, 396671}, - {396677, 396694}, {396698, 396721}, {396723, 396731}, - {396733, 396733}, {396736, 396742}, {396801, 396848}, - {396850, 396851}, {396864, 396870}, {396929, 396930}, - {396932, 396932}, {396934, 396938}, {396940, 396963}, - {396965, 396965}, {396967, 396976}, {396978, 396979}, - {396989, 396989}, {396992, 396996}, {396998, 396998}, - {397020, 397023}, {397056, 397056}, {397120, 397127}, - {397129, 397164}, {397192, 397196}, {397312, 397354}, - {397375, 397375}, {397392, 397397}, {397402, 397405}, - {397409, 397409}, {397413, 397414}, {397422, 397424}, - {397429, 397441}, {397454, 397454}, {397472, 397509}, - {397511, 397511}, {397517, 397517}, {397520, 397562}, - {397564, 397896}, {397898, 397901}, {397904, 397910}, - {397912, 397912}, {397914, 397917}, {397920, 397960}, - {397962, 397965}, {397968, 398000}, {398002, 398005}, - {398008, 398014}, {398016, 398016}, {398018, 398021}, - {398024, 398038}, {398040, 398096}, {398098, 398101}, - {398104, 398170}, {398208, 398223}, {398240, 398325}, - {398328, 398333}, {398337, 398956}, {398959, 398975}, - {398977, 399002}, {399008, 399082}, {399086, 399096}, - {399104, 399121}, {399135, 399153}, {399168, 399185}, - {399200, 399212}, {399214, 399216}, {399232, 399283}, - {399319, 399319}, {399324, 399324}, {399392, 399480}, - {399488, 399528}, {399530, 399530}, {399536, 399605}, - {399616, 399646}, {399696, 399725}, {399728, 399732}, - {399744, 399787}, {399792, 399817}, {399872, 399894}, - {399904, 399956}, {400039, 400039}, {400133, 400179}, - {400197, 400204}, {400259, 400288}, {400302, 400303}, - {400314, 400357}, {400384, 400419}, {400461, 400463}, - {400474, 400509}, {400512, 400520}, {400528, 400570}, - {400573, 400575}, {400617, 400620}, {400622, 400627}, - {400629, 400630}, {400634, 400634}, {400640, 400831}, - {400896, 401173}, {401176, 401181}, {401184, 401221}, - {401224, 401229}, {401232, 401239}, {401241, 401241}, - {401243, 401243}, {401245, 401245}, {401247, 401277}, - {401280, 401332}, {401334, 401340}, {401342, 401342}, - {401346, 401348}, {401350, 401356}, {401360, 401363}, - {401366, 401371}, {401376, 401388}, {401394, 401396}, - {401398, 401404}, {401521, 401521}, {401535, 401535}, - {401552, 401564}, {401666, 401666}, {401671, 401671}, - {401674, 401683}, {401685, 401685}, {401688, 401693}, - {401700, 401700}, {401702, 401702}, {401704, 401704}, - {401706, 401721}, {401724, 401727}, {401733, 401737}, - {401742, 401742}, {401760, 401800}, {404480, 404708}, - {404715, 404718}, {404722, 404723}, {404736, 404773}, - {404775, 404775}, {404781, 404781}, {404784, 404839}, - {404847, 404847}, {404864, 404886}, {404896, 404902}, - {404904, 404910}, {404912, 404918}, {404920, 404926}, - {404928, 404934}, {404936, 404942}, {404944, 404950}, - {404952, 404958}, {405509, 405511}, {405537, 405545}, - {405553, 405557}, {405560, 405564}, {405569, 405654}, - {405659, 405663}, {405665, 405754}, {405756, 405759}, - {405765, 405807}, {405809, 405902}, {405920, 405951}, - {406000, 406015}, {406528, 413119}, {413184, 435340}, - {435408, 435453}, {435456, 435724}, {435728, 435743}, - {435754, 435755}, {435776, 435822}, {435839, 435869}, - {435872, 435951}, {435991, 435999}, {436002, 436104}, - {436107, 436170}, {436176, 436177}, {436179, 436179}, - {436181, 436185}, {436210, 436225}, {436227, 436229}, - {436231, 436234}, {436236, 436258}, {436288, 436339}, - {436354, 436403}, {436466, 436471}, {436475, 436475}, - {436477, 436478}, {436490, 436517}, {436528, 436550}, - {436576, 436604}, {436612, 436658}, {436687, 436687}, - {436704, 436708}, {436710, 436719}, {436730, 436734}, - {436736, 436776}, {436800, 436802}, {436804, 436811}, - {436832, 436854}, {436858, 436858}, {436862, 436911}, - {436913, 436913}, {436917, 436918}, {436921, 436925}, - {436928, 436928}, {436930, 436930}, {436955, 436957}, - {436960, 436970}, {436978, 436980}, {436993, 436998}, - {437001, 437006}, {437009, 437014}, {437024, 437030}, - {437032, 437038}, {437040, 437082}, {437084, 437097}, - {437104, 437218}, {437248, 448419}, {448432, 448454}, - {448459, 448507}, {456960, 457325}, {457328, 457433}, - {457472, 457478}, {457491, 457495}, {457501, 457501}, - {457503, 457512}, {457514, 457526}, {457528, 457532}, - {457534, 457534}, {457536, 457537}, {457539, 457540}, - {457542, 457649}, {457683, 458045}, {458064, 458127}, - {458130, 458183}, {458224, 458235}, {458352, 458356}, - {458358, 458492}, {458529, 458554}, {458561, 458586}, - {458598, 458686}, {458690, 458695}, {458698, 458703}, - {458706, 458711}, {458714, 458716}, {458788, 458788}, - {458817, 458842}, {458847, 458847}, {458849, 458874}, - {458922, 458922}, {458933, 458933}, {458938, 458938}, - {458944, 458966}, {458968, 458998}, {459000, 459457}, - {459462, 459473}, {459488, 459492}, {459500, 459500}, - {459502, 459502}, {459632, 459636}, {459638, 459639}, - {459642, 459645}, {459647, 459647}, {459654, 459654}, - {459656, 459658}, {459660, 459660}, {459662, 459681}, - {459683, 459765}, {459767, 459905}, {459914, 460079}, - {460081, 460118}, {460121, 460121}, {460128, 460168}, - {460240, 460266}, {460271, 460274}, {460320, 460362}, - {460398, 460399}, {460401, 460499}, {460501, 460501}, - {460517, 460518}, {460526, 460527}, {460538, 460540}, - {460543, 460543}, {460560, 460560}, {460562, 460591}, - {460621, 460709}, {460721, 460721}, {460746, 460778}, - {460788, 460789}, {460794, 460794}, {460800, 460821}, - {460826, 460826}, {460836, 460836}, {460840, 460840}, - {460864, 460888}, {460896, 460906}, {460912, 460935}, - {460937, 460942}, {460960, 461001}, {461060, 461113}, - {461117, 461117}, {461136, 461136}, {461144, 461153}, - {461169, 461184}, {461189, 461196}, {461199, 461200}, - {461203, 461224}, {461226, 461232}, {461234, 461234}, - {461238, 461241}, {461245, 461245}, {461262, 461262}, - {461276, 461277}, {461279, 461281}, {461296, 461297}, - {461308, 461308}, {461317, 461322}, {461327, 461328}, - {461331, 461352}, {461354, 461360}, {461362, 461363}, - {461365, 461366}, {461368, 461369}, {461401, 461404}, - {461406, 461406}, {461426, 461428}, {461445, 461453}, - {461455, 461457}, {461459, 461480}, {461482, 461488}, - {461490, 461491}, {461493, 461497}, {461501, 461501}, - {461520, 461520}, {461536, 461537}, {461561, 461561}, - {461573, 461580}, {461583, 461584}, {461587, 461608}, - {461610, 461616}, {461618, 461619}, {461621, 461625}, - {461629, 461629}, {461660, 461661}, {461663, 461665}, - {461681, 461681}, {461699, 461699}, {461701, 461706}, - {461710, 461712}, {461714, 461717}, {461721, 461722}, - {461724, 461724}, {461726, 461727}, {461731, 461732}, - {461736, 461738}, {461742, 461753}, {461776, 461776}, - {461829, 461836}, {461838, 461840}, {461842, 461864}, - {461866, 461881}, {461885, 461885}, {461912, 461914}, - {461917, 461917}, {461920, 461921}, {461952, 461952}, - {461957, 461964}, {461966, 461968}, {461970, 461992}, - {461994, 462003}, {462005, 462009}, {462013, 462013}, - {462045, 462046}, {462048, 462049}, {462065, 462066}, - {462084, 462092}, {462094, 462096}, {462098, 462138}, - {462141, 462141}, {462158, 462158}, {462164, 462166}, - {462175, 462177}, {462202, 462207}, {462213, 462230}, - {462234, 462257}, {462259, 462267}, {462269, 462269}, - {462272, 462278}, {462337, 462384}, {462386, 462387}, - {462400, 462406}, {462465, 462466}, {462468, 462468}, - {462470, 462474}, {462476, 462499}, {462501, 462501}, - {462503, 462512}, {462514, 462515}, {462525, 462525}, - {462528, 462532}, {462534, 462534}, {462556, 462559}, - {462592, 462592}, {462656, 462663}, {462665, 462700}, - {462728, 462732}, {462848, 462890}, {462911, 462911}, - {462928, 462933}, {462938, 462941}, {462945, 462945}, - {462949, 462950}, {462958, 462960}, {462965, 462977}, - {462990, 462990}, {463008, 463045}, {463047, 463047}, - {463053, 463053}, {463056, 463098}, {463100, 463432}, - {463434, 463437}, {463440, 463446}, {463448, 463448}, - {463450, 463453}, {463456, 463496}, {463498, 463501}, - {463504, 463536}, {463538, 463541}, {463544, 463550}, - {463552, 463552}, {463554, 463557}, {463560, 463574}, - {463576, 463632}, {463634, 463637}, {463640, 463706}, - {463744, 463759}, {463776, 463861}, {463864, 463869}, - {463873, 464492}, {464495, 464511}, {464513, 464538}, - {464544, 464618}, {464622, 464632}, {464640, 464657}, - {464671, 464689}, {464704, 464721}, {464736, 464748}, - {464750, 464752}, {464768, 464819}, {464855, 464855}, - {464860, 464860}, {464928, 465016}, {465024, 465064}, - {465066, 465066}, {465072, 465141}, {465152, 465182}, - {465232, 465261}, {465264, 465268}, {465280, 465323}, - {465328, 465353}, {465408, 465430}, {465440, 465492}, - {465575, 465575}, {465669, 465715}, {465733, 465740}, - {465795, 465824}, {465838, 465839}, {465850, 465893}, - {465920, 465955}, {465997, 465999}, {466010, 466045}, - {466048, 466056}, {466064, 466106}, {466109, 466111}, - {466153, 466156}, {466158, 466163}, {466165, 466166}, - {466170, 466170}, {466176, 466367}, {466432, 466709}, - {466712, 466717}, {466720, 466757}, {466760, 466765}, - {466768, 466775}, {466777, 466777}, {466779, 466779}, - {466781, 466781}, {466783, 466813}, {466816, 466868}, - {466870, 466876}, {466878, 466878}, {466882, 466884}, - {466886, 466892}, {466896, 466899}, {466902, 466907}, - {466912, 466924}, {466930, 466932}, {466934, 466940}, - {467057, 467057}, {467071, 467071}, {467088, 467100}, - {467202, 467202}, {467207, 467207}, {467210, 467219}, - {467221, 467221}, {467224, 467229}, {467236, 467236}, - {467238, 467238}, {467240, 467240}, {467242, 467257}, - {467260, 467263}, {467269, 467273}, {467278, 467278}, - {467296, 467336}, {470016, 470244}, {470251, 470254}, - {470258, 470259}, {470272, 470309}, {470311, 470311}, - {470317, 470317}, {470320, 470375}, {470383, 470383}, - {470400, 470422}, {470432, 470438}, {470440, 470446}, - {470448, 470454}, {470456, 470462}, {470464, 470470}, - {470472, 470478}, {470480, 470486}, {470488, 470494}, - {471045, 471047}, {471073, 471081}, {471089, 471093}, - {471096, 471100}, {471105, 471190}, {471195, 471199}, - {471201, 471290}, {471292, 471295}, {471301, 471343}, - {471345, 471438}, {471456, 471487}, {471536, 471551}, - {472064, 478655}, {478720, 500876}, {500944, 500989}, - {500992, 501260}, {501264, 501279}, {501290, 501291}, - {501312, 501358}, {501375, 501405}, {501408, 501487}, - {501527, 501535}, {501538, 501640}, {501643, 501706}, - {501712, 501713}, {501715, 501715}, {501717, 501721}, - {501746, 501761}, {501763, 501765}, {501767, 501770}, - {501772, 501794}, {501824, 501875}, {501890, 501939}, - {502002, 502007}, {502011, 502011}, {502013, 502014}, - {502026, 502053}, {502064, 502086}, {502112, 502140}, - {502148, 502194}, {502223, 502223}, {502240, 502244}, - {502246, 502255}, {502266, 502270}, {502272, 502312}, - {502336, 502338}, {502340, 502347}, {502368, 502390}, - {502394, 502394}, {502398, 502447}, {502449, 502449}, - {502453, 502454}, {502457, 502461}, {502464, 502464}, - {502466, 502466}, {502491, 502493}, {502496, 502506}, - {502514, 502516}, {502529, 502534}, {502537, 502542}, - {502545, 502550}, {502560, 502566}, {502568, 502574}, - {502576, 502618}, {502620, 502633}, {502640, 502754}, - {502784, 513955}, {513968, 513990}, {513995, 514043}, - {522496, 522861}, {522864, 522969}, {523008, 523014}, - {523027, 523031}, {523037, 523037}, {523039, 523048}, - {523050, 523062}, {523064, 523068}, {523070, 523070}, - {523072, 523073}, {523075, 523076}, {523078, 523185}, - {523219, 523581}, {523600, 523663}, {523666, 523719}, - {523760, 523771}, {523888, 523892}, {523894, 524028}, - {524065, 524090}, {524097, 524122}, {524134, 524222}, - {524226, 524231}, {524234, 524239}, {524242, 524247}, - {524250, 524252}, {524324, 524324}, {524353, 524378}, - {524383, 524383}, {524385, 524410}, {524458, 524458}, - {524469, 524469}, {524474, 524474}, {524480, 524502}, - {524504, 524534}, {524536, 524993}, {524998, 525009}, - {525024, 525028}, {525036, 525036}, {525038, 525038}, - {525168, 525172}, {525174, 525175}, {525178, 525181}, - {525183, 525183}, {525190, 525190}, {525192, 525194}, - {525196, 525196}, {525198, 525217}, {525219, 525301}, - {525303, 525441}, {525450, 525615}, {525617, 525654}, - {525657, 525657}, {525664, 525704}, {525776, 525802}, - {525807, 525810}, {525856, 525898}, {525934, 525935}, - {525937, 526035}, {526037, 526037}, {526053, 526054}, - {526062, 526063}, {526074, 526076}, {526079, 526079}, - {526096, 526096}, {526098, 526127}, {526157, 526245}, - {526257, 526257}, {526282, 526314}, {526324, 526325}, - {526330, 526330}, {526336, 526357}, {526362, 526362}, - {526372, 526372}, {526376, 526376}, {526400, 526424}, - {526432, 526442}, {526448, 526471}, {526473, 526478}, - {526496, 526537}, {526596, 526649}, {526653, 526653}, - {526672, 526672}, {526680, 526689}, {526705, 526720}, - {526725, 526732}, {526735, 526736}, {526739, 526760}, - {526762, 526768}, {526770, 526770}, {526774, 526777}, - {526781, 526781}, {526798, 526798}, {526812, 526813}, - {526815, 526817}, {526832, 526833}, {526844, 526844}, - {526853, 526858}, {526863, 526864}, {526867, 526888}, - {526890, 526896}, {526898, 526899}, {526901, 526902}, - {526904, 526905}, {526937, 526940}, {526942, 526942}, - {526962, 526964}, {526981, 526989}, {526991, 526993}, - {526995, 527016}, {527018, 527024}, {527026, 527027}, - {527029, 527033}, {527037, 527037}, {527056, 527056}, - {527072, 527073}, {527097, 527097}, {527109, 527116}, - {527119, 527120}, {527123, 527144}, {527146, 527152}, - {527154, 527155}, {527157, 527161}, {527165, 527165}, - {527196, 527197}, {527199, 527201}, {527217, 527217}, - {527235, 527235}, {527237, 527242}, {527246, 527248}, - {527250, 527253}, {527257, 527258}, {527260, 527260}, - {527262, 527263}, {527267, 527268}, {527272, 527274}, - {527278, 527289}, {527312, 527312}, {527365, 527372}, - {527374, 527376}, {527378, 527400}, {527402, 527417}, - {527421, 527421}, {527448, 527450}, {527453, 527453}, - {527456, 527457}, {527488, 527488}, {527493, 527500}, - {527502, 527504}, {527506, 527528}, {527530, 527539}, - {527541, 527545}, {527549, 527549}, {527581, 527582}, - {527584, 527585}, {527601, 527602}, {527620, 527628}, - {527630, 527632}, {527634, 527674}, {527677, 527677}, - {527694, 527694}, {527700, 527702}, {527711, 527713}, - {527738, 527743}, {527749, 527766}, {527770, 527793}, - {527795, 527803}, {527805, 527805}, {527808, 527814}, - {527873, 527920}, {527922, 527923}, {527936, 527942}, - {528001, 528002}, {528004, 528004}, {528006, 528010}, - {528012, 528035}, {528037, 528037}, {528039, 528048}, - {528050, 528051}, {528061, 528061}, {528064, 528068}, - {528070, 528070}, {528092, 528095}, {528128, 528128}, - {528192, 528199}, {528201, 528236}, {528264, 528268}, - {528384, 528426}, {528447, 528447}, {528464, 528469}, - {528474, 528477}, {528481, 528481}, {528485, 528486}, - {528494, 528496}, {528501, 528513}, {528526, 528526}, - {528544, 528581}, {528583, 528583}, {528589, 528589}, - {528592, 528634}, {528636, 528968}, {528970, 528973}, - {528976, 528982}, {528984, 528984}, {528986, 528989}, - {528992, 529032}, {529034, 529037}, {529040, 529072}, - {529074, 529077}, {529080, 529086}, {529088, 529088}, - {529090, 529093}, {529096, 529110}, {529112, 529168}, - {529170, 529173}, {529176, 529242}, {529280, 529295}, - {529312, 529397}, {529400, 529405}, {529409, 530028}, - {530031, 530047}, {530049, 530074}, {530080, 530154}, - {530158, 530168}, {530176, 530193}, {530207, 530225}, - {530240, 530257}, {530272, 530284}, {530286, 530288}, - {530304, 530355}, {530391, 530391}, {530396, 530396}, - {530464, 530552}, {530560, 530600}, {530602, 530602}, - {530608, 530677}, {530688, 530718}, {530768, 530797}, - {530800, 530804}, {530816, 530859}, {530864, 530889}, - {530944, 530966}, {530976, 531028}, {531111, 531111}, - {531205, 531251}, {531269, 531276}, {531331, 531360}, - {531374, 531375}, {531386, 531429}, {531456, 531491}, - {531533, 531535}, {531546, 531581}, {531584, 531592}, - {531600, 531642}, {531645, 531647}, {531689, 531692}, - {531694, 531699}, {531701, 531702}, {531706, 531706}, - {531712, 531903}, {531968, 532245}, {532248, 532253}, - {532256, 532293}, {532296, 532301}, {532304, 532311}, - {532313, 532313}, {532315, 532315}, {532317, 532317}, - {532319, 532349}, {532352, 532404}, {532406, 532412}, - {532414, 532414}, {532418, 532420}, {532422, 532428}, - {532432, 532435}, {532438, 532443}, {532448, 532460}, - {532466, 532468}, {532470, 532476}, {532593, 532593}, - {532607, 532607}, {532624, 532636}, {532738, 532738}, - {532743, 532743}, {532746, 532755}, {532757, 532757}, - {532760, 532765}, {532772, 532772}, {532774, 532774}, - {532776, 532776}, {532778, 532793}, {532796, 532799}, - {532805, 532809}, {532814, 532814}, {532832, 532872}, - {535552, 535780}, {535787, 535790}, {535794, 535795}, - {535808, 535845}, {535847, 535847}, {535853, 535853}, - {535856, 535911}, {535919, 535919}, {535936, 535958}, - {535968, 535974}, {535976, 535982}, {535984, 535990}, - {535992, 535998}, {536000, 536006}, {536008, 536014}, - {536016, 536022}, {536024, 536030}, {536581, 536583}, - {536609, 536617}, {536625, 536629}, {536632, 536636}, - {536641, 536726}, {536731, 536735}, {536737, 536826}, - {536828, 536831}, {536837, 536879}, {536881, 536974}, - {536992, 537023}, {537072, 537087}, {537600, 544191}, - {544256, 566412}, {566480, 566525}, {566528, 566796}, - {566800, 566815}, {566826, 566827}, {566848, 566894}, - {566911, 566941}, {566944, 567023}, {567063, 567071}, - {567074, 567176}, {567179, 567242}, {567248, 567249}, - {567251, 567251}, {567253, 567257}, {567282, 567297}, - {567299, 567301}, {567303, 567306}, {567308, 567330}, - {567360, 567411}, {567426, 567475}, {567538, 567543}, - {567547, 567547}, {567549, 567550}, {567562, 567589}, - {567600, 567622}, {567648, 567676}, {567684, 567730}, - {567759, 567759}, {567776, 567780}, {567782, 567791}, - {567802, 567806}, {567808, 567848}, {567872, 567874}, - {567876, 567883}, {567904, 567926}, {567930, 567930}, - {567934, 567983}, {567985, 567985}, {567989, 567990}, - {567993, 567997}, {568000, 568000}, {568002, 568002}, - {568027, 568029}, {568032, 568042}, {568050, 568052}, - {568065, 568070}, {568073, 568078}, {568081, 568086}, - {568096, 568102}, {568104, 568110}, {568112, 568154}, - {568156, 568169}, {568176, 568290}, {568320, 579491}, - {579504, 579526}, {579531, 579579}, {588032, 588397}, - {588400, 588505}, {588544, 588550}, {588563, 588567}, - {588573, 588573}, {588575, 588584}, {588586, 588598}, - {588600, 588604}, {588606, 588606}, {588608, 588609}, - {588611, 588612}, {588614, 588721}, {588755, 589117}, - {589136, 589199}, {589202, 589255}, {589296, 589307}, - {589424, 589428}, {589430, 589564}, {589601, 589626}, - {589633, 589658}, {589670, 589758}, {589762, 589767}, - {589770, 589775}, {589778, 589783}, {589786, 589788}, - {589860, 589860}, {589889, 589914}, {589919, 589919}, - {589921, 589946}, {589994, 589994}, {590005, 590005}, - {590010, 590010}, {590016, 590038}, {590040, 590070}, - {590072, 590529}, {590534, 590545}, {590560, 590564}, - {590572, 590572}, {590574, 590574}, {590704, 590708}, - {590710, 590711}, {590714, 590717}, {590719, 590719}, - {590726, 590726}, {590728, 590730}, {590732, 590732}, - {590734, 590753}, {590755, 590837}, {590839, 590977}, - {590986, 591151}, {591153, 591190}, {591193, 591193}, - {591200, 591240}, {591312, 591338}, {591343, 591346}, - {591392, 591434}, {591470, 591471}, {591473, 591571}, - {591573, 591573}, {591589, 591590}, {591598, 591599}, - {591610, 591612}, {591615, 591615}, {591632, 591632}, - {591634, 591663}, {591693, 591781}, {591793, 591793}, - {591818, 591850}, {591860, 591861}, {591866, 591866}, - {591872, 591893}, {591898, 591898}, {591908, 591908}, - {591912, 591912}, {591936, 591960}, {591968, 591978}, - {591984, 592007}, {592009, 592014}, {592032, 592073}, - {592132, 592185}, {592189, 592189}, {592208, 592208}, - {592216, 592225}, {592241, 592256}, {592261, 592268}, - {592271, 592272}, {592275, 592296}, {592298, 592304}, - {592306, 592306}, {592310, 592313}, {592317, 592317}, - {592334, 592334}, {592348, 592349}, {592351, 592353}, - {592368, 592369}, {592380, 592380}, {592389, 592394}, - {592399, 592400}, {592403, 592424}, {592426, 592432}, - {592434, 592435}, {592437, 592438}, {592440, 592441}, - {592473, 592476}, {592478, 592478}, {592498, 592500}, - {592517, 592525}, {592527, 592529}, {592531, 592552}, - {592554, 592560}, {592562, 592563}, {592565, 592569}, - {592573, 592573}, {592592, 592592}, {592608, 592609}, - {592633, 592633}, {592645, 592652}, {592655, 592656}, - {592659, 592680}, {592682, 592688}, {592690, 592691}, - {592693, 592697}, {592701, 592701}, {592732, 592733}, - {592735, 592737}, {592753, 592753}, {592771, 592771}, - {592773, 592778}, {592782, 592784}, {592786, 592789}, - {592793, 592794}, {592796, 592796}, {592798, 592799}, - {592803, 592804}, {592808, 592810}, {592814, 592825}, - {592848, 592848}, {592901, 592908}, {592910, 592912}, - {592914, 592936}, {592938, 592953}, {592957, 592957}, - {592984, 592986}, {592989, 592989}, {592992, 592993}, - {593024, 593024}, {593029, 593036}, {593038, 593040}, - {593042, 593064}, {593066, 593075}, {593077, 593081}, - {593085, 593085}, {593117, 593118}, {593120, 593121}, - {593137, 593138}, {593156, 593164}, {593166, 593168}, - {593170, 593210}, {593213, 593213}, {593230, 593230}, - {593236, 593238}, {593247, 593249}, {593274, 593279}, - {593285, 593302}, {593306, 593329}, {593331, 593339}, - {593341, 593341}, {593344, 593350}, {593409, 593456}, - {593458, 593459}, {593472, 593478}, {593537, 593538}, - {593540, 593540}, {593542, 593546}, {593548, 593571}, - {593573, 593573}, {593575, 593584}, {593586, 593587}, - {593597, 593597}, {593600, 593604}, {593606, 593606}, - {593628, 593631}, {593664, 593664}, {593728, 593735}, - {593737, 593772}, {593800, 593804}, {593920, 593962}, - {593983, 593983}, {594000, 594005}, {594010, 594013}, - {594017, 594017}, {594021, 594022}, {594030, 594032}, - {594037, 594049}, {594062, 594062}, {594080, 594117}, - {594119, 594119}, {594125, 594125}, {594128, 594170}, - {594172, 594504}, {594506, 594509}, {594512, 594518}, - {594520, 594520}, {594522, 594525}, {594528, 594568}, - {594570, 594573}, {594576, 594608}, {594610, 594613}, - {594616, 594622}, {594624, 594624}, {594626, 594629}, - {594632, 594646}, {594648, 594704}, {594706, 594709}, - {594712, 594778}, {594816, 594831}, {594848, 594933}, - {594936, 594941}, {594945, 595564}, {595567, 595583}, - {595585, 595610}, {595616, 595690}, {595694, 595704}, - {595712, 595729}, {595743, 595761}, {595776, 595793}, - {595808, 595820}, {595822, 595824}, {595840, 595891}, - {595927, 595927}, {595932, 595932}, {596000, 596088}, - {596096, 596136}, {596138, 596138}, {596144, 596213}, - {596224, 596254}, {596304, 596333}, {596336, 596340}, - {596352, 596395}, {596400, 596425}, {596480, 596502}, - {596512, 596564}, {596647, 596647}, {596741, 596787}, - {596805, 596812}, {596867, 596896}, {596910, 596911}, - {596922, 596965}, {596992, 597027}, {597069, 597071}, - {597082, 597117}, {597120, 597128}, {597136, 597178}, - {597181, 597183}, {597225, 597228}, {597230, 597235}, - {597237, 597238}, {597242, 597242}, {597248, 597439}, - {597504, 597781}, {597784, 597789}, {597792, 597829}, - {597832, 597837}, {597840, 597847}, {597849, 597849}, - {597851, 597851}, {597853, 597853}, {597855, 597885}, - {597888, 597940}, {597942, 597948}, {597950, 597950}, - {597954, 597956}, {597958, 597964}, {597968, 597971}, - {597974, 597979}, {597984, 597996}, {598002, 598004}, - {598006, 598012}, {598129, 598129}, {598143, 598143}, - {598160, 598172}, {598274, 598274}, {598279, 598279}, - {598282, 598291}, {598293, 598293}, {598296, 598301}, - {598308, 598308}, {598310, 598310}, {598312, 598312}, - {598314, 598329}, {598332, 598335}, {598341, 598345}, - {598350, 598350}, {598368, 598408}, {601088, 601316}, - {601323, 601326}, {601330, 601331}, {601344, 601381}, - {601383, 601383}, {601389, 601389}, {601392, 601447}, - {601455, 601455}, {601472, 601494}, {601504, 601510}, - {601512, 601518}, {601520, 601526}, {601528, 601534}, - {601536, 601542}, {601544, 601550}, {601552, 601558}, - {601560, 601566}, {602117, 602119}, {602145, 602153}, - {602161, 602165}, {602168, 602172}, {602177, 602262}, - {602267, 602271}, {602273, 602362}, {602364, 602367}, - {602373, 602415}, {602417, 602510}, {602528, 602559}, - {602608, 602623}, {603136, 609727}, {609792, 631948}, - {632016, 632061}, {632064, 632332}, {632336, 632351}, - {632362, 632363}, {632384, 632430}, {632447, 632477}, - {632480, 632559}, {632599, 632607}, {632610, 632712}, - {632715, 632778}, {632784, 632785}, {632787, 632787}, - {632789, 632793}, {632818, 632833}, {632835, 632837}, - {632839, 632842}, {632844, 632866}, {632896, 632947}, - {632962, 633011}, {633074, 633079}, {633083, 633083}, - {633085, 633086}, {633098, 633125}, {633136, 633158}, - {633184, 633212}, {633220, 633266}, {633295, 633295}, - {633312, 633316}, {633318, 633327}, {633338, 633342}, - {633344, 633384}, {633408, 633410}, {633412, 633419}, - {633440, 633462}, {633466, 633466}, {633470, 633519}, - {633521, 633521}, {633525, 633526}, {633529, 633533}, - {633536, 633536}, {633538, 633538}, {633563, 633565}, - {633568, 633578}, {633586, 633588}, {633601, 633606}, - {633609, 633614}, {633617, 633622}, {633632, 633638}, - {633640, 633646}, {633648, 633690}, {633692, 633705}, - {633712, 633826}, {633856, 645027}, {645040, 645062}, - {645067, 645115}, {653568, 653933}, {653936, 654041}, - {654080, 654086}, {654099, 654103}, {654109, 654109}, - {654111, 654120}, {654122, 654134}, {654136, 654140}, - {654142, 654142}, {654144, 654145}, {654147, 654148}, - {654150, 654257}, {654291, 654653}, {654672, 654735}, - {654738, 654791}, {654832, 654843}, {654960, 654964}, - {654966, 655100}, {655137, 655162}, {655169, 655194}, - {655206, 655294}, {655298, 655303}, {655306, 655311}, - {655314, 655319}, {655322, 655324}, {655396, 655396}, - {655425, 655450}, {655455, 655455}, {655457, 655482}, - {655530, 655530}, {655541, 655541}, {655546, 655546}, - {655552, 655574}, {655576, 655606}, {655608, 656065}, - {656070, 656081}, {656096, 656100}, {656108, 656108}, - {656110, 656110}, {656240, 656244}, {656246, 656247}, - {656250, 656253}, {656255, 656255}, {656262, 656262}, - {656264, 656266}, {656268, 656268}, {656270, 656289}, - {656291, 656373}, {656375, 656513}, {656522, 656687}, - {656689, 656726}, {656729, 656729}, {656736, 656776}, - {656848, 656874}, {656879, 656882}, {656928, 656970}, - {657006, 657007}, {657009, 657107}, {657109, 657109}, - {657125, 657126}, {657134, 657135}, {657146, 657148}, - {657151, 657151}, {657168, 657168}, {657170, 657199}, - {657229, 657317}, {657329, 657329}, {657354, 657386}, - {657396, 657397}, {657402, 657402}, {657408, 657429}, - {657434, 657434}, {657444, 657444}, {657448, 657448}, - {657472, 657496}, {657504, 657514}, {657520, 657543}, - {657545, 657550}, {657568, 657609}, {657668, 657721}, - {657725, 657725}, {657744, 657744}, {657752, 657761}, - {657777, 657792}, {657797, 657804}, {657807, 657808}, - {657811, 657832}, {657834, 657840}, {657842, 657842}, - {657846, 657849}, {657853, 657853}, {657870, 657870}, - {657884, 657885}, {657887, 657889}, {657904, 657905}, - {657916, 657916}, {657925, 657930}, {657935, 657936}, - {657939, 657960}, {657962, 657968}, {657970, 657971}, - {657973, 657974}, {657976, 657977}, {658009, 658012}, - {658014, 658014}, {658034, 658036}, {658053, 658061}, - {658063, 658065}, {658067, 658088}, {658090, 658096}, - {658098, 658099}, {658101, 658105}, {658109, 658109}, - {658128, 658128}, {658144, 658145}, {658169, 658169}, - {658181, 658188}, {658191, 658192}, {658195, 658216}, - {658218, 658224}, {658226, 658227}, {658229, 658233}, - {658237, 658237}, {658268, 658269}, {658271, 658273}, - {658289, 658289}, {658307, 658307}, {658309, 658314}, - {658318, 658320}, {658322, 658325}, {658329, 658330}, - {658332, 658332}, {658334, 658335}, {658339, 658340}, - {658344, 658346}, {658350, 658361}, {658384, 658384}, - {658437, 658444}, {658446, 658448}, {658450, 658472}, - {658474, 658489}, {658493, 658493}, {658520, 658522}, - {658525, 658525}, {658528, 658529}, {658560, 658560}, - {658565, 658572}, {658574, 658576}, {658578, 658600}, - {658602, 658611}, {658613, 658617}, {658621, 658621}, - {658653, 658654}, {658656, 658657}, {658673, 658674}, - {658692, 658700}, {658702, 658704}, {658706, 658746}, - {658749, 658749}, {658766, 658766}, {658772, 658774}, - {658783, 658785}, {658810, 658815}, {658821, 658838}, - {658842, 658865}, {658867, 658875}, {658877, 658877}, - {658880, 658886}, {658945, 658992}, {658994, 658995}, - {659008, 659014}, {659073, 659074}, {659076, 659076}, - {659078, 659082}, {659084, 659107}, {659109, 659109}, - {659111, 659120}, {659122, 659123}, {659133, 659133}, - {659136, 659140}, {659142, 659142}, {659164, 659167}, - {659200, 659200}, {659264, 659271}, {659273, 659308}, - {659336, 659340}, {659456, 659498}, {659519, 659519}, - {659536, 659541}, {659546, 659549}, {659553, 659553}, - {659557, 659558}, {659566, 659568}, {659573, 659585}, - {659598, 659598}, {659616, 659653}, {659655, 659655}, - {659661, 659661}, {659664, 659706}, {659708, 660040}, - {660042, 660045}, {660048, 660054}, {660056, 660056}, - {660058, 660061}, {660064, 660104}, {660106, 660109}, - {660112, 660144}, {660146, 660149}, {660152, 660158}, - {660160, 660160}, {660162, 660165}, {660168, 660182}, - {660184, 660240}, {660242, 660245}, {660248, 660314}, - {660352, 660367}, {660384, 660469}, {660472, 660477}, - {660481, 661100}, {661103, 661119}, {661121, 661146}, - {661152, 661226}, {661230, 661240}, {661248, 661265}, - {661279, 661297}, {661312, 661329}, {661344, 661356}, - {661358, 661360}, {661376, 661427}, {661463, 661463}, - {661468, 661468}, {661536, 661624}, {661632, 661672}, - {661674, 661674}, {661680, 661749}, {661760, 661790}, - {661840, 661869}, {661872, 661876}, {661888, 661931}, - {661936, 661961}, {662016, 662038}, {662048, 662100}, - {662183, 662183}, {662277, 662323}, {662341, 662348}, - {662403, 662432}, {662446, 662447}, {662458, 662501}, - {662528, 662563}, {662605, 662607}, {662618, 662653}, - {662656, 662664}, {662672, 662714}, {662717, 662719}, - {662761, 662764}, {662766, 662771}, {662773, 662774}, - {662778, 662778}, {662784, 662975}, {663040, 663317}, - {663320, 663325}, {663328, 663365}, {663368, 663373}, - {663376, 663383}, {663385, 663385}, {663387, 663387}, - {663389, 663389}, {663391, 663421}, {663424, 663476}, - {663478, 663484}, {663486, 663486}, {663490, 663492}, - {663494, 663500}, {663504, 663507}, {663510, 663515}, - {663520, 663532}, {663538, 663540}, {663542, 663548}, - {663665, 663665}, {663679, 663679}, {663696, 663708}, - {663810, 663810}, {663815, 663815}, {663818, 663827}, - {663829, 663829}, {663832, 663837}, {663844, 663844}, - {663846, 663846}, {663848, 663848}, {663850, 663865}, - {663868, 663871}, {663877, 663881}, {663886, 663886}, - {663904, 663944}, {666624, 666852}, {666859, 666862}, - {666866, 666867}, {666880, 666917}, {666919, 666919}, - {666925, 666925}, {666928, 666983}, {666991, 666991}, - {667008, 667030}, {667040, 667046}, {667048, 667054}, - {667056, 667062}, {667064, 667070}, {667072, 667078}, - {667080, 667086}, {667088, 667094}, {667096, 667102}, - {667653, 667655}, {667681, 667689}, {667697, 667701}, - {667704, 667708}, {667713, 667798}, {667803, 667807}, - {667809, 667898}, {667900, 667903}, {667909, 667951}, - {667953, 668046}, {668064, 668095}, {668144, 668159}, - {668672, 675263}, {675328, 697484}, {697552, 697597}, - {697600, 697868}, {697872, 697887}, {697898, 697899}, - {697920, 697966}, {697983, 698013}, {698016, 698095}, - {698135, 698143}, {698146, 698248}, {698251, 698314}, - {698320, 698321}, {698323, 698323}, {698325, 698329}, - {698354, 698369}, {698371, 698373}, {698375, 698378}, - {698380, 698402}, {698432, 698483}, {698498, 698547}, - {698610, 698615}, {698619, 698619}, {698621, 698622}, - {698634, 698661}, {698672, 698694}, {698720, 698748}, - {698756, 698802}, {698831, 698831}, {698848, 698852}, - {698854, 698863}, {698874, 698878}, {698880, 698920}, - {698944, 698946}, {698948, 698955}, {698976, 698998}, - {699002, 699002}, {699006, 699055}, {699057, 699057}, - {699061, 699062}, {699065, 699069}, {699072, 699072}, - {699074, 699074}, {699099, 699101}, {699104, 699114}, - {699122, 699124}, {699137, 699142}, {699145, 699150}, - {699153, 699158}, {699168, 699174}, {699176, 699182}, - {699184, 699226}, {699228, 699241}, {699248, 699362}, - {699392, 710563}, {710576, 710598}, {710603, 710651}, - {719104, 719469}, {719472, 719577}, {719616, 719622}, - {719635, 719639}, {719645, 719645}, {719647, 719656}, - {719658, 719670}, {719672, 719676}, {719678, 719678}, - {719680, 719681}, {719683, 719684}, {719686, 719793}, - {719827, 720189}, {720208, 720271}, {720274, 720327}, - {720368, 720379}, {720496, 720500}, {720502, 720636}, - {720673, 720698}, {720705, 720730}, {720742, 720830}, - {720834, 720839}, {720842, 720847}, {720850, 720855}, - {720858, 720860}, {720932, 720932}, {720961, 720986}, - {720991, 720991}, {720993, 721018}, {721066, 721066}, - {721077, 721077}, {721082, 721082}, {721088, 721110}, - {721112, 721142}, {721144, 721601}, {721606, 721617}, - {721632, 721636}, {721644, 721644}, {721646, 721646}, - {721776, 721780}, {721782, 721783}, {721786, 721789}, - {721791, 721791}, {721798, 721798}, {721800, 721802}, - {721804, 721804}, {721806, 721825}, {721827, 721909}, - {721911, 722049}, {722058, 722223}, {722225, 722262}, - {722265, 722265}, {722272, 722312}, {722384, 722410}, - {722415, 722418}, {722464, 722506}, {722542, 722543}, - {722545, 722643}, {722645, 722645}, {722661, 722662}, - {722670, 722671}, {722682, 722684}, {722687, 722687}, - {722704, 722704}, {722706, 722735}, {722765, 722853}, - {722865, 722865}, {722890, 722922}, {722932, 722933}, - {722938, 722938}, {722944, 722965}, {722970, 722970}, - {722980, 722980}, {722984, 722984}, {723008, 723032}, - {723040, 723050}, {723056, 723079}, {723081, 723086}, - {723104, 723145}, {723204, 723257}, {723261, 723261}, - {723280, 723280}, {723288, 723297}, {723313, 723328}, - {723333, 723340}, {723343, 723344}, {723347, 723368}, - {723370, 723376}, {723378, 723378}, {723382, 723385}, - {723389, 723389}, {723406, 723406}, {723420, 723421}, - {723423, 723425}, {723440, 723441}, {723452, 723452}, - {723461, 723466}, {723471, 723472}, {723475, 723496}, - {723498, 723504}, {723506, 723507}, {723509, 723510}, - {723512, 723513}, {723545, 723548}, {723550, 723550}, - {723570, 723572}, {723589, 723597}, {723599, 723601}, - {723603, 723624}, {723626, 723632}, {723634, 723635}, - {723637, 723641}, {723645, 723645}, {723664, 723664}, - {723680, 723681}, {723705, 723705}, {723717, 723724}, - {723727, 723728}, {723731, 723752}, {723754, 723760}, - {723762, 723763}, {723765, 723769}, {723773, 723773}, - {723804, 723805}, {723807, 723809}, {723825, 723825}, - {723843, 723843}, {723845, 723850}, {723854, 723856}, - {723858, 723861}, {723865, 723866}, {723868, 723868}, - {723870, 723871}, {723875, 723876}, {723880, 723882}, - {723886, 723897}, {723920, 723920}, {723973, 723980}, - {723982, 723984}, {723986, 724008}, {724010, 724025}, - {724029, 724029}, {724056, 724058}, {724061, 724061}, - {724064, 724065}, {724096, 724096}, {724101, 724108}, - {724110, 724112}, {724114, 724136}, {724138, 724147}, - {724149, 724153}, {724157, 724157}, {724189, 724190}, - {724192, 724193}, {724209, 724210}, {724228, 724236}, - {724238, 724240}, {724242, 724282}, {724285, 724285}, - {724302, 724302}, {724308, 724310}, {724319, 724321}, - {724346, 724351}, {724357, 724374}, {724378, 724401}, - {724403, 724411}, {724413, 724413}, {724416, 724422}, - {724481, 724528}, {724530, 724531}, {724544, 724550}, - {724609, 724610}, {724612, 724612}, {724614, 724618}, - {724620, 724643}, {724645, 724645}, {724647, 724656}, - {724658, 724659}, {724669, 724669}, {724672, 724676}, - {724678, 724678}, {724700, 724703}, {724736, 724736}, - {724800, 724807}, {724809, 724844}, {724872, 724876}, - {724992, 725034}, {725055, 725055}, {725072, 725077}, - {725082, 725085}, {725089, 725089}, {725093, 725094}, - {725102, 725104}, {725109, 725121}, {725134, 725134}, - {725152, 725189}, {725191, 725191}, {725197, 725197}, - {725200, 725242}, {725244, 725576}, {725578, 725581}, - {725584, 725590}, {725592, 725592}, {725594, 725597}, - {725600, 725640}, {725642, 725645}, {725648, 725680}, - {725682, 725685}, {725688, 725694}, {725696, 725696}, - {725698, 725701}, {725704, 725718}, {725720, 725776}, - {725778, 725781}, {725784, 725850}, {725888, 725903}, - {725920, 726005}, {726008, 726013}, {726017, 726636}, - {726639, 726655}, {726657, 726682}, {726688, 726762}, - {726766, 726776}, {726784, 726801}, {726815, 726833}, - {726848, 726865}, {726880, 726892}, {726894, 726896}, - {726912, 726963}, {726999, 726999}, {727004, 727004}, - {727072, 727160}, {727168, 727208}, {727210, 727210}, - {727216, 727285}, {727296, 727326}, {727376, 727405}, - {727408, 727412}, {727424, 727467}, {727472, 727497}, - {727552, 727574}, {727584, 727636}, {727719, 727719}, - {727813, 727859}, {727877, 727884}, {727939, 727968}, - {727982, 727983}, {727994, 728037}, {728064, 728099}, - {728141, 728143}, {728154, 728189}, {728192, 728200}, - {728208, 728250}, {728253, 728255}, {728297, 728300}, - {728302, 728307}, {728309, 728310}, {728314, 728314}, - {728320, 728511}, {728576, 728853}, {728856, 728861}, - {728864, 728901}, {728904, 728909}, {728912, 728919}, - {728921, 728921}, {728923, 728923}, {728925, 728925}, - {728927, 728957}, {728960, 729012}, {729014, 729020}, - {729022, 729022}, {729026, 729028}, {729030, 729036}, - {729040, 729043}, {729046, 729051}, {729056, 729068}, - {729074, 729076}, {729078, 729084}, {729201, 729201}, - {729215, 729215}, {729232, 729244}, {729346, 729346}, - {729351, 729351}, {729354, 729363}, {729365, 729365}, - {729368, 729373}, {729380, 729380}, {729382, 729382}, - {729384, 729384}, {729386, 729401}, {729404, 729407}, - {729413, 729417}, {729422, 729422}, {729440, 729480}, - {732160, 732388}, {732395, 732398}, {732402, 732403}, - {732416, 732453}, {732455, 732455}, {732461, 732461}, - {732464, 732519}, {732527, 732527}, {732544, 732566}, - {732576, 732582}, {732584, 732590}, {732592, 732598}, - {732600, 732606}, {732608, 732614}, {732616, 732622}, - {732624, 732630}, {732632, 732638}, {733189, 733191}, - {733217, 733225}, {733233, 733237}, {733240, 733244}, - {733249, 733334}, {733339, 733343}, {733345, 733434}, - {733436, 733439}, {733445, 733487}, {733489, 733582}, - {733600, 733631}, {733680, 733695}, {734208, 740799}, - {740864, 763020}, {763088, 763133}, {763136, 763404}, - {763408, 763423}, {763434, 763435}, {763456, 763502}, - {763519, 763549}, {763552, 763631}, {763671, 763679}, - {763682, 763784}, {763787, 763850}, {763856, 763857}, - {763859, 763859}, {763861, 763865}, {763890, 763905}, - {763907, 763909}, {763911, 763914}, {763916, 763938}, - {763968, 764019}, {764034, 764083}, {764146, 764151}, - {764155, 764155}, {764157, 764158}, {764170, 764197}, - {764208, 764230}, {764256, 764284}, {764292, 764338}, - {764367, 764367}, {764384, 764388}, {764390, 764399}, - {764410, 764414}, {764416, 764456}, {764480, 764482}, - {764484, 764491}, {764512, 764534}, {764538, 764538}, - {764542, 764591}, {764593, 764593}, {764597, 764598}, - {764601, 764605}, {764608, 764608}, {764610, 764610}, - {764635, 764637}, {764640, 764650}, {764658, 764660}, - {764673, 764678}, {764681, 764686}, {764689, 764694}, - {764704, 764710}, {764712, 764718}, {764720, 764762}, - {764764, 764777}, {764784, 764898}, {764928, 776099}, - {776112, 776134}, {776139, 776187}, {784640, 785005}, - {785008, 785113}, {785152, 785158}, {785171, 785175}, - {785181, 785181}, {785183, 785192}, {785194, 785206}, - {785208, 785212}, {785214, 785214}, {785216, 785217}, - {785219, 785220}, {785222, 785329}, {785363, 785725}, - {785744, 785807}, {785810, 785863}, {785904, 785915}, - {786032, 786036}, {786038, 786172}, {786209, 786234}, - {786241, 786266}, {786278, 786366}, {786370, 786375}, - {786378, 786383}, {786386, 786391}, {786394, 786396}, - {786468, 786468}, {786497, 786522}, {786527, 786527}, - {786529, 786554}, {786602, 786602}, {786613, 786613}, - {786618, 786618}, {786624, 786646}, {786648, 786678}, - {786680, 787137}, {787142, 787153}, {787168, 787172}, - {787180, 787180}, {787182, 787182}, {787312, 787316}, - {787318, 787319}, {787322, 787325}, {787327, 787327}, - {787334, 787334}, {787336, 787338}, {787340, 787340}, - {787342, 787361}, {787363, 787445}, {787447, 787585}, - {787594, 787759}, {787761, 787798}, {787801, 787801}, - {787808, 787848}, {787920, 787946}, {787951, 787954}, - {788000, 788042}, {788078, 788079}, {788081, 788179}, - {788181, 788181}, {788197, 788198}, {788206, 788207}, - {788218, 788220}, {788223, 788223}, {788240, 788240}, - {788242, 788271}, {788301, 788389}, {788401, 788401}, - {788426, 788458}, {788468, 788469}, {788474, 788474}, - {788480, 788501}, {788506, 788506}, {788516, 788516}, - {788520, 788520}, {788544, 788568}, {788576, 788586}, - {788592, 788615}, {788617, 788622}, {788640, 788681}, - {788740, 788793}, {788797, 788797}, {788816, 788816}, - {788824, 788833}, {788849, 788864}, {788869, 788876}, - {788879, 788880}, {788883, 788904}, {788906, 788912}, - {788914, 788914}, {788918, 788921}, {788925, 788925}, - {788942, 788942}, {788956, 788957}, {788959, 788961}, - {788976, 788977}, {788988, 788988}, {788997, 789002}, - {789007, 789008}, {789011, 789032}, {789034, 789040}, - {789042, 789043}, {789045, 789046}, {789048, 789049}, - {789081, 789084}, {789086, 789086}, {789106, 789108}, - {789125, 789133}, {789135, 789137}, {789139, 789160}, - {789162, 789168}, {789170, 789171}, {789173, 789177}, - {789181, 789181}, {789200, 789200}, {789216, 789217}, - {789241, 789241}, {789253, 789260}, {789263, 789264}, - {789267, 789288}, {789290, 789296}, {789298, 789299}, - {789301, 789305}, {789309, 789309}, {789340, 789341}, - {789343, 789345}, {789361, 789361}, {789379, 789379}, - {789381, 789386}, {789390, 789392}, {789394, 789397}, - {789401, 789402}, {789404, 789404}, {789406, 789407}, - {789411, 789412}, {789416, 789418}, {789422, 789433}, - {789456, 789456}, {789509, 789516}, {789518, 789520}, - {789522, 789544}, {789546, 789561}, {789565, 789565}, - {789592, 789594}, {789597, 789597}, {789600, 789601}, - {789632, 789632}, {789637, 789644}, {789646, 789648}, - {789650, 789672}, {789674, 789683}, {789685, 789689}, - {789693, 789693}, {789725, 789726}, {789728, 789729}, - {789745, 789746}, {789764, 789772}, {789774, 789776}, - {789778, 789818}, {789821, 789821}, {789838, 789838}, - {789844, 789846}, {789855, 789857}, {789882, 789887}, - {789893, 789910}, {789914, 789937}, {789939, 789947}, - {789949, 789949}, {789952, 789958}, {790017, 790064}, - {790066, 790067}, {790080, 790086}, {790145, 790146}, - {790148, 790148}, {790150, 790154}, {790156, 790179}, - {790181, 790181}, {790183, 790192}, {790194, 790195}, - {790205, 790205}, {790208, 790212}, {790214, 790214}, - {790236, 790239}, {790272, 790272}, {790336, 790343}, - {790345, 790380}, {790408, 790412}, {790528, 790570}, - {790591, 790591}, {790608, 790613}, {790618, 790621}, - {790625, 790625}, {790629, 790630}, {790638, 790640}, - {790645, 790657}, {790670, 790670}, {790688, 790725}, - {790727, 790727}, {790733, 790733}, {790736, 790778}, - {790780, 791112}, {791114, 791117}, {791120, 791126}, - {791128, 791128}, {791130, 791133}, {791136, 791176}, - {791178, 791181}, {791184, 791216}, {791218, 791221}, - {791224, 791230}, {791232, 791232}, {791234, 791237}, - {791240, 791254}, {791256, 791312}, {791314, 791317}, - {791320, 791386}, {791424, 791439}, {791456, 791541}, - {791544, 791549}, {791553, 792172}, {792175, 792191}, - {792193, 792218}, {792224, 792298}, {792302, 792312}, - {792320, 792337}, {792351, 792369}, {792384, 792401}, - {792416, 792428}, {792430, 792432}, {792448, 792499}, - {792535, 792535}, {792540, 792540}, {792608, 792696}, - {792704, 792744}, {792746, 792746}, {792752, 792821}, - {792832, 792862}, {792912, 792941}, {792944, 792948}, - {792960, 793003}, {793008, 793033}, {793088, 793110}, - {793120, 793172}, {793255, 793255}, {793349, 793395}, - {793413, 793420}, {793475, 793504}, {793518, 793519}, - {793530, 793573}, {793600, 793635}, {793677, 793679}, - {793690, 793725}, {793728, 793736}, {793744, 793786}, - {793789, 793791}, {793833, 793836}, {793838, 793843}, - {793845, 793846}, {793850, 793850}, {793856, 794047}, - {794112, 794389}, {794392, 794397}, {794400, 794437}, - {794440, 794445}, {794448, 794455}, {794457, 794457}, - {794459, 794459}, {794461, 794461}, {794463, 794493}, - {794496, 794548}, {794550, 794556}, {794558, 794558}, - {794562, 794564}, {794566, 794572}, {794576, 794579}, - {794582, 794587}, {794592, 794604}, {794610, 794612}, - {794614, 794620}, {794737, 794737}, {794751, 794751}, - {794768, 794780}, {794882, 794882}, {794887, 794887}, - {794890, 794899}, {794901, 794901}, {794904, 794909}, - {794916, 794916}, {794918, 794918}, {794920, 794920}, - {794922, 794937}, {794940, 794943}, {794949, 794953}, - {794958, 794958}, {794976, 795016}, {797696, 797924}, - {797931, 797934}, {797938, 797939}, {797952, 797989}, - {797991, 797991}, {797997, 797997}, {798000, 798055}, - {798063, 798063}, {798080, 798102}, {798112, 798118}, - {798120, 798126}, {798128, 798134}, {798136, 798142}, - {798144, 798150}, {798152, 798158}, {798160, 798166}, - {798168, 798174}, {798725, 798727}, {798753, 798761}, - {798769, 798773}, {798776, 798780}, {798785, 798870}, - {798875, 798879}, {798881, 798970}, {798972, 798975}, - {798981, 799023}, {799025, 799118}, {799136, 799167}, - {799216, 799231}, {799744, 806335}, {806400, 828556}, - {828624, 828669}, {828672, 828940}, {828944, 828959}, - {828970, 828971}, {828992, 829038}, {829055, 829085}, - {829088, 829167}, {829207, 829215}, {829218, 829320}, - {829323, 829386}, {829392, 829393}, {829395, 829395}, - {829397, 829401}, {829426, 829441}, {829443, 829445}, - {829447, 829450}, {829452, 829474}, {829504, 829555}, - {829570, 829619}, {829682, 829687}, {829691, 829691}, - {829693, 829694}, {829706, 829733}, {829744, 829766}, - {829792, 829820}, {829828, 829874}, {829903, 829903}, - {829920, 829924}, {829926, 829935}, {829946, 829950}, - {829952, 829992}, {830016, 830018}, {830020, 830027}, - {830048, 830070}, {830074, 830074}, {830078, 830127}, - {830129, 830129}, {830133, 830134}, {830137, 830141}, - {830144, 830144}, {830146, 830146}, {830171, 830173}, - {830176, 830186}, {830194, 830196}, {830209, 830214}, - {830217, 830222}, {830225, 830230}, {830240, 830246}, - {830248, 830254}, {830256, 830298}, {830300, 830313}, - {830320, 830434}, {830464, 841635}, {841648, 841670}, - {841675, 841723}, {850176, 850541}, {850544, 850649}, - {850688, 850694}, {850707, 850711}, {850717, 850717}, - {850719, 850728}, {850730, 850742}, {850744, 850748}, - {850750, 850750}, {850752, 850753}, {850755, 850756}, - {850758, 850865}, {850899, 851261}, {851280, 851343}, - {851346, 851399}, {851440, 851451}, {851568, 851572}, - {851574, 851708}, {851745, 851770}, {851777, 851802}, - {851814, 851902}, {851906, 851911}, {851914, 851919}, - {851922, 851927}, {851930, 851932}, {852004, 852004}, - {852033, 852058}, {852063, 852063}, {852065, 852090}, - {852138, 852138}, {852149, 852149}, {852154, 852154}, - {852160, 852182}, {852184, 852214}, {852216, 852673}, - {852678, 852689}, {852704, 852708}, {852716, 852716}, - {852718, 852718}, {852848, 852852}, {852854, 852855}, - {852858, 852861}, {852863, 852863}, {852870, 852870}, - {852872, 852874}, {852876, 852876}, {852878, 852897}, - {852899, 852981}, {852983, 853121}, {853130, 853295}, - {853297, 853334}, {853337, 853337}, {853344, 853384}, - {853456, 853482}, {853487, 853490}, {853536, 853578}, - {853614, 853615}, {853617, 853715}, {853717, 853717}, - {853733, 853734}, {853742, 853743}, {853754, 853756}, - {853759, 853759}, {853776, 853776}, {853778, 853807}, - {853837, 853925}, {853937, 853937}, {853962, 853994}, - {854004, 854005}, {854010, 854010}, {854016, 854037}, - {854042, 854042}, {854052, 854052}, {854056, 854056}, - {854080, 854104}, {854112, 854122}, {854128, 854151}, - {854153, 854158}, {854176, 854217}, {854276, 854329}, - {854333, 854333}, {854352, 854352}, {854360, 854369}, - {854385, 854400}, {854405, 854412}, {854415, 854416}, - {854419, 854440}, {854442, 854448}, {854450, 854450}, - {854454, 854457}, {854461, 854461}, {854478, 854478}, - {854492, 854493}, {854495, 854497}, {854512, 854513}, - {854524, 854524}, {854533, 854538}, {854543, 854544}, - {854547, 854568}, {854570, 854576}, {854578, 854579}, - {854581, 854582}, {854584, 854585}, {854617, 854620}, - {854622, 854622}, {854642, 854644}, {854661, 854669}, - {854671, 854673}, {854675, 854696}, {854698, 854704}, - {854706, 854707}, {854709, 854713}, {854717, 854717}, - {854736, 854736}, {854752, 854753}, {854777, 854777}, - {854789, 854796}, {854799, 854800}, {854803, 854824}, - {854826, 854832}, {854834, 854835}, {854837, 854841}, - {854845, 854845}, {854876, 854877}, {854879, 854881}, - {854897, 854897}, {854915, 854915}, {854917, 854922}, - {854926, 854928}, {854930, 854933}, {854937, 854938}, - {854940, 854940}, {854942, 854943}, {854947, 854948}, - {854952, 854954}, {854958, 854969}, {854992, 854992}, - {855045, 855052}, {855054, 855056}, {855058, 855080}, - {855082, 855097}, {855101, 855101}, {855128, 855130}, - {855133, 855133}, {855136, 855137}, {855168, 855168}, - {855173, 855180}, {855182, 855184}, {855186, 855208}, - {855210, 855219}, {855221, 855225}, {855229, 855229}, - {855261, 855262}, {855264, 855265}, {855281, 855282}, - {855300, 855308}, {855310, 855312}, {855314, 855354}, - {855357, 855357}, {855374, 855374}, {855380, 855382}, - {855391, 855393}, {855418, 855423}, {855429, 855446}, - {855450, 855473}, {855475, 855483}, {855485, 855485}, - {855488, 855494}, {855553, 855600}, {855602, 855603}, - {855616, 855622}, {855681, 855682}, {855684, 855684}, - {855686, 855690}, {855692, 855715}, {855717, 855717}, - {855719, 855728}, {855730, 855731}, {855741, 855741}, - {855744, 855748}, {855750, 855750}, {855772, 855775}, - {855808, 855808}, {855872, 855879}, {855881, 855916}, - {855944, 855948}, {856064, 856106}, {856127, 856127}, - {856144, 856149}, {856154, 856157}, {856161, 856161}, - {856165, 856166}, {856174, 856176}, {856181, 856193}, - {856206, 856206}, {856224, 856261}, {856263, 856263}, - {856269, 856269}, {856272, 856314}, {856316, 856648}, - {856650, 856653}, {856656, 856662}, {856664, 856664}, - {856666, 856669}, {856672, 856712}, {856714, 856717}, - {856720, 856752}, {856754, 856757}, {856760, 856766}, - {856768, 856768}, {856770, 856773}, {856776, 856790}, - {856792, 856848}, {856850, 856853}, {856856, 856922}, - {856960, 856975}, {856992, 857077}, {857080, 857085}, - {857089, 857708}, {857711, 857727}, {857729, 857754}, - {857760, 857834}, {857838, 857848}, {857856, 857873}, - {857887, 857905}, {857920, 857937}, {857952, 857964}, - {857966, 857968}, {857984, 858035}, {858071, 858071}, - {858076, 858076}, {858144, 858232}, {858240, 858280}, - {858282, 858282}, {858288, 858357}, {858368, 858398}, - {858448, 858477}, {858480, 858484}, {858496, 858539}, - {858544, 858569}, {858624, 858646}, {858656, 858708}, - {858791, 858791}, {858885, 858931}, {858949, 858956}, - {859011, 859040}, {859054, 859055}, {859066, 859109}, - {859136, 859171}, {859213, 859215}, {859226, 859261}, - {859264, 859272}, {859280, 859322}, {859325, 859327}, - {859369, 859372}, {859374, 859379}, {859381, 859382}, - {859386, 859386}, {859392, 859583}, {859648, 859925}, - {859928, 859933}, {859936, 859973}, {859976, 859981}, - {859984, 859991}, {859993, 859993}, {859995, 859995}, - {859997, 859997}, {859999, 860029}, {860032, 860084}, - {860086, 860092}, {860094, 860094}, {860098, 860100}, - {860102, 860108}, {860112, 860115}, {860118, 860123}, - {860128, 860140}, {860146, 860148}, {860150, 860156}, - {860273, 860273}, {860287, 860287}, {860304, 860316}, - {860418, 860418}, {860423, 860423}, {860426, 860435}, - {860437, 860437}, {860440, 860445}, {860452, 860452}, - {860454, 860454}, {860456, 860456}, {860458, 860473}, - {860476, 860479}, {860485, 860489}, {860494, 860494}, - {860512, 860552}, {863232, 863460}, {863467, 863470}, - {863474, 863475}, {863488, 863525}, {863527, 863527}, - {863533, 863533}, {863536, 863591}, {863599, 863599}, - {863616, 863638}, {863648, 863654}, {863656, 863662}, - {863664, 863670}, {863672, 863678}, {863680, 863686}, - {863688, 863694}, {863696, 863702}, {863704, 863710}, - {864261, 864263}, {864289, 864297}, {864305, 864309}, - {864312, 864316}, {864321, 864406}, {864411, 864415}, - {864417, 864506}, {864508, 864511}, {864517, 864559}, - {864561, 864654}, {864672, 864703}, {864752, 864767}, - {865280, 871871}, {871936, 894092}, {894160, 894205}, - {894208, 894476}, {894480, 894495}, {894506, 894507}, - {894528, 894574}, {894591, 894621}, {894624, 894703}, - {894743, 894751}, {894754, 894856}, {894859, 894922}, - {894928, 894929}, {894931, 894931}, {894933, 894937}, - {894962, 894977}, {894979, 894981}, {894983, 894986}, - {894988, 895010}, {895040, 895091}, {895106, 895155}, - {895218, 895223}, {895227, 895227}, {895229, 895230}, - {895242, 895269}, {895280, 895302}, {895328, 895356}, - {895364, 895410}, {895439, 895439}, {895456, 895460}, - {895462, 895471}, {895482, 895486}, {895488, 895528}, - {895552, 895554}, {895556, 895563}, {895584, 895606}, - {895610, 895610}, {895614, 895663}, {895665, 895665}, - {895669, 895670}, {895673, 895677}, {895680, 895680}, - {895682, 895682}, {895707, 895709}, {895712, 895722}, - {895730, 895732}, {895745, 895750}, {895753, 895758}, - {895761, 895766}, {895776, 895782}, {895784, 895790}, - {895792, 895834}, {895836, 895849}, {895856, 895970}, - {896000, 907171}, {907184, 907206}, {907211, 907259}, - {915712, 916077}, {916080, 916185}, {916224, 916230}, - {916243, 916247}, {916253, 916253}, {916255, 916264}, - {916266, 916278}, {916280, 916284}, {916286, 916286}, - {916288, 916289}, {916291, 916292}, {916294, 916401}, - {916435, 916797}, {916816, 916879}, {916882, 916935}, - {916976, 916987}, {917104, 917108}, {917110, 917244}, - {917281, 917306}, {917313, 917338}, {917350, 917438}, - {917442, 917447}, {917450, 917455}, {917458, 917463}, - {917466, 917468}, {917540, 917540}, {917569, 917594}, - {917599, 917599}, {917601, 917626}, {917674, 917674}, - {917685, 917685}, {917690, 917690}, {917696, 917718}, - {917720, 917750}, {917752, 918209}, {918214, 918225}, - {918240, 918244}, {918252, 918252}, {918254, 918254}, - {918384, 918388}, {918390, 918391}, {918394, 918397}, - {918399, 918399}, {918406, 918406}, {918408, 918410}, - {918412, 918412}, {918414, 918433}, {918435, 918517}, - {918519, 918657}, {918666, 918831}, {918833, 918870}, - {918873, 918873}, {918880, 918920}, {918992, 919018}, - {919023, 919026}, {919072, 919114}, {919150, 919151}, - {919153, 919251}, {919253, 919253}, {919269, 919270}, - {919278, 919279}, {919290, 919292}, {919295, 919295}, - {919312, 919312}, {919314, 919343}, {919373, 919461}, - {919473, 919473}, {919498, 919530}, {919540, 919541}, - {919546, 919546}, {919552, 919573}, {919578, 919578}, - {919588, 919588}, {919592, 919592}, {919616, 919640}, - {919648, 919658}, {919664, 919687}, {919689, 919694}, - {919712, 919753}, {919812, 919865}, {919869, 919869}, - {919888, 919888}, {919896, 919905}, {919921, 919936}, - {919941, 919948}, {919951, 919952}, {919955, 919976}, - {919978, 919984}, {919986, 919986}, {919990, 919993}, - {919997, 919997}, {920014, 920014}, {920028, 920029}, - {920031, 920033}, {920048, 920049}, {920060, 920060}, - {920069, 920074}, {920079, 920080}, {920083, 920104}, - {920106, 920112}, {920114, 920115}, {920117, 920118}, - {920120, 920121}, {920153, 920156}, {920158, 920158}, - {920178, 920180}, {920197, 920205}, {920207, 920209}, - {920211, 920232}, {920234, 920240}, {920242, 920243}, - {920245, 920249}, {920253, 920253}, {920272, 920272}, - {920288, 920289}, {920313, 920313}, {920325, 920332}, - {920335, 920336}, {920339, 920360}, {920362, 920368}, - {920370, 920371}, {920373, 920377}, {920381, 920381}, - {920412, 920413}, {920415, 920417}, {920433, 920433}, - {920451, 920451}, {920453, 920458}, {920462, 920464}, - {920466, 920469}, {920473, 920474}, {920476, 920476}, - {920478, 920479}, {920483, 920484}, {920488, 920490}, - {920494, 920505}, {920528, 920528}, {920581, 920588}, - {920590, 920592}, {920594, 920616}, {920618, 920633}, - {920637, 920637}, {920664, 920666}, {920669, 920669}, - {920672, 920673}, {920704, 920704}, {920709, 920716}, - {920718, 920720}, {920722, 920744}, {920746, 920755}, - {920757, 920761}, {920765, 920765}, {920797, 920798}, - {920800, 920801}, {920817, 920818}, {920836, 920844}, - {920846, 920848}, {920850, 920890}, {920893, 920893}, - {920910, 920910}, {920916, 920918}, {920927, 920929}, - {920954, 920959}, {920965, 920982}, {920986, 921009}, - {921011, 921019}, {921021, 921021}, {921024, 921030}, - {921089, 921136}, {921138, 921139}, {921152, 921158}, - {921217, 921218}, {921220, 921220}, {921222, 921226}, - {921228, 921251}, {921253, 921253}, {921255, 921264}, - {921266, 921267}, {921277, 921277}, {921280, 921284}, - {921286, 921286}, {921308, 921311}, {921344, 921344}, - {921408, 921415}, {921417, 921452}, {921480, 921484}, - {921600, 921642}, {921663, 921663}, {921680, 921685}, - {921690, 921693}, {921697, 921697}, {921701, 921702}, - {921710, 921712}, {921717, 921729}, {921742, 921742}, - {921760, 921797}, {921799, 921799}, {921805, 921805}, - {921808, 921850}, {921852, 922184}, {922186, 922189}, - {922192, 922198}, {922200, 922200}, {922202, 922205}, - {922208, 922248}, {922250, 922253}, {922256, 922288}, - {922290, 922293}, {922296, 922302}, {922304, 922304}, - {922306, 922309}, {922312, 922326}, {922328, 922384}, - {922386, 922389}, {922392, 922458}, {922496, 922511}, - {922528, 922613}, {922616, 922621}, {922625, 923244}, - {923247, 923263}, {923265, 923290}, {923296, 923370}, - {923374, 923384}, {923392, 923409}, {923423, 923441}, - {923456, 923473}, {923488, 923500}, {923502, 923504}, - {923520, 923571}, {923607, 923607}, {923612, 923612}, - {923680, 923768}, {923776, 923816}, {923818, 923818}, - {923824, 923893}, {923904, 923934}, {923984, 924013}, - {924016, 924020}, {924032, 924075}, {924080, 924105}, - {924160, 924182}, {924192, 924244}, {924327, 924327}, - {924421, 924467}, {924485, 924492}, {924547, 924576}, - {924590, 924591}, {924602, 924645}, {924672, 924707}, - {924749, 924751}, {924762, 924797}, {924800, 924808}, - {924816, 924858}, {924861, 924863}, {924905, 924908}, - {924910, 924915}, {924917, 924918}, {924922, 924922}, - {924928, 925119}, {925184, 925461}, {925464, 925469}, - {925472, 925509}, {925512, 925517}, {925520, 925527}, - {925529, 925529}, {925531, 925531}, {925533, 925533}, - {925535, 925565}, {925568, 925620}, {925622, 925628}, - {925630, 925630}, {925634, 925636}, {925638, 925644}, - {925648, 925651}, {925654, 925659}, {925664, 925676}, - {925682, 925684}, {925686, 925692}, {925809, 925809}, - {925823, 925823}, {925840, 925852}, {925954, 925954}, - {925959, 925959}, {925962, 925971}, {925973, 925973}, - {925976, 925981}, {925988, 925988}, {925990, 925990}, - {925992, 925992}, {925994, 926009}, {926012, 926015}, - {926021, 926025}, {926030, 926030}, {926048, 926088}, - {928768, 928996}, {929003, 929006}, {929010, 929011}, - {929024, 929061}, {929063, 929063}, {929069, 929069}, - {929072, 929127}, {929135, 929135}, {929152, 929174}, - {929184, 929190}, {929192, 929198}, {929200, 929206}, - {929208, 929214}, {929216, 929222}, {929224, 929230}, - {929232, 929238}, {929240, 929246}, {929797, 929799}, - {929825, 929833}, {929841, 929845}, {929848, 929852}, - {929857, 929942}, {929947, 929951}, {929953, 930042}, - {930044, 930047}, {930053, 930095}, {930097, 930190}, - {930208, 930239}, {930288, 930303}, {930816, 937407}, - {937472, 959628}, {959696, 959741}, {959744, 960012}, - {960016, 960031}, {960042, 960043}, {960064, 960110}, - {960127, 960157}, {960160, 960239}, {960279, 960287}, - {960290, 960392}, {960395, 960458}, {960464, 960465}, - {960467, 960467}, {960469, 960473}, {960498, 960513}, - {960515, 960517}, {960519, 960522}, {960524, 960546}, - {960576, 960627}, {960642, 960691}, {960754, 960759}, - {960763, 960763}, {960765, 960766}, {960778, 960805}, - {960816, 960838}, {960864, 960892}, {960900, 960946}, - {960975, 960975}, {960992, 960996}, {960998, 961007}, - {961018, 961022}, {961024, 961064}, {961088, 961090}, - {961092, 961099}, {961120, 961142}, {961146, 961146}, - {961150, 961199}, {961201, 961201}, {961205, 961206}, - {961209, 961213}, {961216, 961216}, {961218, 961218}, - {961243, 961245}, {961248, 961258}, {961266, 961268}, - {961281, 961286}, {961289, 961294}, {961297, 961302}, - {961312, 961318}, {961320, 961326}, {961328, 961370}, - {961372, 961385}, {961392, 961506}, {961536, 972707}, - {972720, 972742}, {972747, 972795}, {981248, 981613}, - {981616, 981721}, {981760, 981766}, {981779, 981783}, - {981789, 981789}, {981791, 981800}, {981802, 981814}, - {981816, 981820}, {981822, 981822}, {981824, 981825}, - {981827, 981828}, {981830, 981937}, {981971, 982333}, - {982352, 982415}, {982418, 982471}, {982512, 982523}, - {982640, 982644}, {982646, 982780}, {982817, 982842}, - {982849, 982874}, {982886, 982974}, {982978, 982983}, - {982986, 982991}, {982994, 982999}, {983002, 983004}, - {983076, 983076}, {983105, 983130}, {983135, 983135}, - {983137, 983162}, {983210, 983210}, {983221, 983221}, - {983226, 983226}, {983232, 983254}, {983256, 983286}, - {983288, 983745}, {983750, 983761}, {983776, 983780}, - {983788, 983788}, {983790, 983790}, {983920, 983924}, - {983926, 983927}, {983930, 983933}, {983935, 983935}, - {983942, 983942}, {983944, 983946}, {983948, 983948}, - {983950, 983969}, {983971, 984053}, {984055, 984193}, - {984202, 984367}, {984369, 984406}, {984409, 984409}, - {984416, 984456}, {984528, 984554}, {984559, 984562}, - {984608, 984650}, {984686, 984687}, {984689, 984787}, - {984789, 984789}, {984805, 984806}, {984814, 984815}, - {984826, 984828}, {984831, 984831}, {984848, 984848}, - {984850, 984879}, {984909, 984997}, {985009, 985009}, - {985034, 985066}, {985076, 985077}, {985082, 985082}, - {985088, 985109}, {985114, 985114}, {985124, 985124}, - {985128, 985128}, {985152, 985176}, {985184, 985194}, - {985200, 985223}, {985225, 985230}, {985248, 985289}, - {985348, 985401}, {985405, 985405}, {985424, 985424}, - {985432, 985441}, {985457, 985472}, {985477, 985484}, - {985487, 985488}, {985491, 985512}, {985514, 985520}, - {985522, 985522}, {985526, 985529}, {985533, 985533}, - {985550, 985550}, {985564, 985565}, {985567, 985569}, - {985584, 985585}, {985596, 985596}, {985605, 985610}, - {985615, 985616}, {985619, 985640}, {985642, 985648}, - {985650, 985651}, {985653, 985654}, {985656, 985657}, - {985689, 985692}, {985694, 985694}, {985714, 985716}, - {985733, 985741}, {985743, 985745}, {985747, 985768}, - {985770, 985776}, {985778, 985779}, {985781, 985785}, - {985789, 985789}, {985808, 985808}, {985824, 985825}, - {985849, 985849}, {985861, 985868}, {985871, 985872}, - {985875, 985896}, {985898, 985904}, {985906, 985907}, - {985909, 985913}, {985917, 985917}, {985948, 985949}, - {985951, 985953}, {985969, 985969}, {985987, 985987}, - {985989, 985994}, {985998, 986000}, {986002, 986005}, - {986009, 986010}, {986012, 986012}, {986014, 986015}, - {986019, 986020}, {986024, 986026}, {986030, 986041}, - {986064, 986064}, {986117, 986124}, {986126, 986128}, - {986130, 986152}, {986154, 986169}, {986173, 986173}, - {986200, 986202}, {986205, 986205}, {986208, 986209}, - {986240, 986240}, {986245, 986252}, {986254, 986256}, - {986258, 986280}, {986282, 986291}, {986293, 986297}, - {986301, 986301}, {986333, 986334}, {986336, 986337}, - {986353, 986354}, {986372, 986380}, {986382, 986384}, - {986386, 986426}, {986429, 986429}, {986446, 986446}, - {986452, 986454}, {986463, 986465}, {986490, 986495}, - {986501, 986518}, {986522, 986545}, {986547, 986555}, - {986557, 986557}, {986560, 986566}, {986625, 986672}, - {986674, 986675}, {986688, 986694}, {986753, 986754}, - {986756, 986756}, {986758, 986762}, {986764, 986787}, - {986789, 986789}, {986791, 986800}, {986802, 986803}, - {986813, 986813}, {986816, 986820}, {986822, 986822}, - {986844, 986847}, {986880, 986880}, {986944, 986951}, - {986953, 986988}, {987016, 987020}, {987136, 987178}, - {987199, 987199}, {987216, 987221}, {987226, 987229}, - {987233, 987233}, {987237, 987238}, {987246, 987248}, - {987253, 987265}, {987278, 987278}, {987296, 987333}, - {987335, 987335}, {987341, 987341}, {987344, 987386}, - {987388, 987720}, {987722, 987725}, {987728, 987734}, - {987736, 987736}, {987738, 987741}, {987744, 987784}, - {987786, 987789}, {987792, 987824}, {987826, 987829}, - {987832, 987838}, {987840, 987840}, {987842, 987845}, - {987848, 987862}, {987864, 987920}, {987922, 987925}, - {987928, 987994}, {988032, 988047}, {988064, 988149}, - {988152, 988157}, {988161, 988780}, {988783, 988799}, - {988801, 988826}, {988832, 988906}, {988910, 988920}, - {988928, 988945}, {988959, 988977}, {988992, 989009}, - {989024, 989036}, {989038, 989040}, {989056, 989107}, - {989143, 989143}, {989148, 989148}, {989216, 989304}, - {989312, 989352}, {989354, 989354}, {989360, 989429}, - {989440, 989470}, {989520, 989549}, {989552, 989556}, - {989568, 989611}, {989616, 989641}, {989696, 989718}, - {989728, 989780}, {989863, 989863}, {989957, 990003}, - {990021, 990028}, {990083, 990112}, {990126, 990127}, - {990138, 990181}, {990208, 990243}, {990285, 990287}, - {990298, 990333}, {990336, 990344}, {990352, 990394}, - {990397, 990399}, {990441, 990444}, {990446, 990451}, - {990453, 990454}, {990458, 990458}, {990464, 990655}, - {990720, 990997}, {991000, 991005}, {991008, 991045}, - {991048, 991053}, {991056, 991063}, {991065, 991065}, - {991067, 991067}, {991069, 991069}, {991071, 991101}, - {991104, 991156}, {991158, 991164}, {991166, 991166}, - {991170, 991172}, {991174, 991180}, {991184, 991187}, - {991190, 991195}, {991200, 991212}, {991218, 991220}, - {991222, 991228}, {991345, 991345}, {991359, 991359}, - {991376, 991388}, {991490, 991490}, {991495, 991495}, - {991498, 991507}, {991509, 991509}, {991512, 991517}, - {991524, 991524}, {991526, 991526}, {991528, 991528}, - {991530, 991545}, {991548, 991551}, {991557, 991561}, - {991566, 991566}, {991584, 991624}, {994304, 994532}, - {994539, 994542}, {994546, 994547}, {994560, 994597}, - {994599, 994599}, {994605, 994605}, {994608, 994663}, - {994671, 994671}, {994688, 994710}, {994720, 994726}, - {994728, 994734}, {994736, 994742}, {994744, 994750}, - {994752, 994758}, {994760, 994766}, {994768, 994774}, - {994776, 994782}, {995333, 995335}, {995361, 995369}, - {995377, 995381}, {995384, 995388}, {995393, 995478}, - {995483, 995487}, {995489, 995578}, {995580, 995583}, - {995589, 995631}, {995633, 995726}, {995744, 995775}, - {995824, 995839}, {996352, 1002943}, {1003008, 1025164}, - {1025232, 1025277}, {1025280, 1025548}, {1025552, 1025567}, - {1025578, 1025579}, {1025600, 1025646}, {1025663, 1025693}, - {1025696, 1025775}, {1025815, 1025823}, {1025826, 1025928}, - {1025931, 1025994}, {1026000, 1026001}, {1026003, 1026003}, - {1026005, 1026009}, {1026034, 1026049}, {1026051, 1026053}, - {1026055, 1026058}, {1026060, 1026082}, {1026112, 1026163}, - {1026178, 1026227}, {1026290, 1026295}, {1026299, 1026299}, - {1026301, 1026302}, {1026314, 1026341}, {1026352, 1026374}, - {1026400, 1026428}, {1026436, 1026482}, {1026511, 1026511}, - {1026528, 1026532}, {1026534, 1026543}, {1026554, 1026558}, - {1026560, 1026600}, {1026624, 1026626}, {1026628, 1026635}, - {1026656, 1026678}, {1026682, 1026682}, {1026686, 1026735}, - {1026737, 1026737}, {1026741, 1026742}, {1026745, 1026749}, - {1026752, 1026752}, {1026754, 1026754}, {1026779, 1026781}, - {1026784, 1026794}, {1026802, 1026804}, {1026817, 1026822}, - {1026825, 1026830}, {1026833, 1026838}, {1026848, 1026854}, - {1026856, 1026862}, {1026864, 1026906}, {1026908, 1026921}, - {1026928, 1027042}, {1027072, 1038243}, {1038256, 1038278}, - {1038283, 1038331}, {1046784, 1047149}, {1047152, 1047257}, - {1047296, 1047302}, {1047315, 1047319}, {1047325, 1047325}, - {1047327, 1047336}, {1047338, 1047350}, {1047352, 1047356}, - {1047358, 1047358}, {1047360, 1047361}, {1047363, 1047364}, - {1047366, 1047473}, {1047507, 1047869}, {1047888, 1047951}, - {1047954, 1048007}, {1048048, 1048059}, {1048176, 1048180}, - {1048182, 1048316}, {1048353, 1048378}, {1048385, 1048410}, - {1048422, 1048510}, {1048514, 1048519}, {1048522, 1048527}, - {1048530, 1048535}, {1048538, 1048540}, {1048612, 1048612}, - {1048641, 1048666}, {1048671, 1048671}, {1048673, 1048698}, - {1048746, 1048746}, {1048757, 1048757}, {1048762, 1048762}, - {1048768, 1048790}, {1048792, 1048822}, {1048824, 1049281}, - {1049286, 1049297}, {1049312, 1049316}, {1049324, 1049324}, - {1049326, 1049326}, {1049456, 1049460}, {1049462, 1049463}, - {1049466, 1049469}, {1049471, 1049471}, {1049478, 1049478}, - {1049480, 1049482}, {1049484, 1049484}, {1049486, 1049505}, - {1049507, 1049589}, {1049591, 1049729}, {1049738, 1049903}, - {1049905, 1049942}, {1049945, 1049945}, {1049952, 1049992}, - {1050064, 1050090}, {1050095, 1050098}, {1050144, 1050186}, - {1050222, 1050223}, {1050225, 1050323}, {1050325, 1050325}, - {1050341, 1050342}, {1050350, 1050351}, {1050362, 1050364}, - {1050367, 1050367}, {1050384, 1050384}, {1050386, 1050415}, - {1050445, 1050533}, {1050545, 1050545}, {1050570, 1050602}, - {1050612, 1050613}, {1050618, 1050618}, {1050624, 1050645}, - {1050650, 1050650}, {1050660, 1050660}, {1050664, 1050664}, - {1050688, 1050712}, {1050720, 1050730}, {1050736, 1050759}, - {1050761, 1050766}, {1050784, 1050825}, {1050884, 1050937}, - {1050941, 1050941}, {1050960, 1050960}, {1050968, 1050977}, - {1050993, 1051008}, {1051013, 1051020}, {1051023, 1051024}, - {1051027, 1051048}, {1051050, 1051056}, {1051058, 1051058}, - {1051062, 1051065}, {1051069, 1051069}, {1051086, 1051086}, - {1051100, 1051101}, {1051103, 1051105}, {1051120, 1051121}, - {1051132, 1051132}, {1051141, 1051146}, {1051151, 1051152}, - {1051155, 1051176}, {1051178, 1051184}, {1051186, 1051187}, - {1051189, 1051190}, {1051192, 1051193}, {1051225, 1051228}, - {1051230, 1051230}, {1051250, 1051252}, {1051269, 1051277}, - {1051279, 1051281}, {1051283, 1051304}, {1051306, 1051312}, - {1051314, 1051315}, {1051317, 1051321}, {1051325, 1051325}, - {1051344, 1051344}, {1051360, 1051361}, {1051385, 1051385}, - {1051397, 1051404}, {1051407, 1051408}, {1051411, 1051432}, - {1051434, 1051440}, {1051442, 1051443}, {1051445, 1051449}, - {1051453, 1051453}, {1051484, 1051485}, {1051487, 1051489}, - {1051505, 1051505}, {1051523, 1051523}, {1051525, 1051530}, - {1051534, 1051536}, {1051538, 1051541}, {1051545, 1051546}, - {1051548, 1051548}, {1051550, 1051551}, {1051555, 1051556}, - {1051560, 1051562}, {1051566, 1051577}, {1051600, 1051600}, - {1051653, 1051660}, {1051662, 1051664}, {1051666, 1051688}, - {1051690, 1051705}, {1051709, 1051709}, {1051736, 1051738}, - {1051741, 1051741}, {1051744, 1051745}, {1051776, 1051776}, - {1051781, 1051788}, {1051790, 1051792}, {1051794, 1051816}, - {1051818, 1051827}, {1051829, 1051833}, {1051837, 1051837}, - {1051869, 1051870}, {1051872, 1051873}, {1051889, 1051890}, - {1051908, 1051916}, {1051918, 1051920}, {1051922, 1051962}, - {1051965, 1051965}, {1051982, 1051982}, {1051988, 1051990}, - {1051999, 1052001}, {1052026, 1052031}, {1052037, 1052054}, - {1052058, 1052081}, {1052083, 1052091}, {1052093, 1052093}, - {1052096, 1052102}, {1052161, 1052208}, {1052210, 1052211}, - {1052224, 1052230}, {1052289, 1052290}, {1052292, 1052292}, - {1052294, 1052298}, {1052300, 1052323}, {1052325, 1052325}, - {1052327, 1052336}, {1052338, 1052339}, {1052349, 1052349}, - {1052352, 1052356}, {1052358, 1052358}, {1052380, 1052383}, - {1052416, 1052416}, {1052480, 1052487}, {1052489, 1052524}, - {1052552, 1052556}, {1052672, 1052714}, {1052735, 1052735}, - {1052752, 1052757}, {1052762, 1052765}, {1052769, 1052769}, - {1052773, 1052774}, {1052782, 1052784}, {1052789, 1052801}, - {1052814, 1052814}, {1052832, 1052869}, {1052871, 1052871}, - {1052877, 1052877}, {1052880, 1052922}, {1052924, 1053256}, - {1053258, 1053261}, {1053264, 1053270}, {1053272, 1053272}, - {1053274, 1053277}, {1053280, 1053320}, {1053322, 1053325}, - {1053328, 1053360}, {1053362, 1053365}, {1053368, 1053374}, - {1053376, 1053376}, {1053378, 1053381}, {1053384, 1053398}, - {1053400, 1053456}, {1053458, 1053461}, {1053464, 1053530}, - {1053568, 1053583}, {1053600, 1053685}, {1053688, 1053693}, - {1053697, 1054316}, {1054319, 1054335}, {1054337, 1054362}, - {1054368, 1054442}, {1054446, 1054456}, {1054464, 1054481}, - {1054495, 1054513}, {1054528, 1054545}, {1054560, 1054572}, - {1054574, 1054576}, {1054592, 1054643}, {1054679, 1054679}, - {1054684, 1054684}, {1054752, 1054840}, {1054848, 1054888}, - {1054890, 1054890}, {1054896, 1054965}, {1054976, 1055006}, - {1055056, 1055085}, {1055088, 1055092}, {1055104, 1055147}, - {1055152, 1055177}, {1055232, 1055254}, {1055264, 1055316}, - {1055399, 1055399}, {1055493, 1055539}, {1055557, 1055564}, - {1055619, 1055648}, {1055662, 1055663}, {1055674, 1055717}, - {1055744, 1055779}, {1055821, 1055823}, {1055834, 1055869}, - {1055872, 1055880}, {1055888, 1055930}, {1055933, 1055935}, - {1055977, 1055980}, {1055982, 1055987}, {1055989, 1055990}, - {1055994, 1055994}, {1056000, 1056191}, {1056256, 1056533}, - {1056536, 1056541}, {1056544, 1056581}, {1056584, 1056589}, - {1056592, 1056599}, {1056601, 1056601}, {1056603, 1056603}, - {1056605, 1056605}, {1056607, 1056637}, {1056640, 1056692}, - {1056694, 1056700}, {1056702, 1056702}, {1056706, 1056708}, - {1056710, 1056716}, {1056720, 1056723}, {1056726, 1056731}, - {1056736, 1056748}, {1056754, 1056756}, {1056758, 1056764}, - {1056881, 1056881}, {1056895, 1056895}, {1056912, 1056924}, - {1057026, 1057026}, {1057031, 1057031}, {1057034, 1057043}, - {1057045, 1057045}, {1057048, 1057053}, {1057060, 1057060}, - {1057062, 1057062}, {1057064, 1057064}, {1057066, 1057081}, - {1057084, 1057087}, {1057093, 1057097}, {1057102, 1057102}, - {1057120, 1057160}, {1059840, 1060068}, {1060075, 1060078}, - {1060082, 1060083}, {1060096, 1060133}, {1060135, 1060135}, - {1060141, 1060141}, {1060144, 1060199}, {1060207, 1060207}, - {1060224, 1060246}, {1060256, 1060262}, {1060264, 1060270}, - {1060272, 1060278}, {1060280, 1060286}, {1060288, 1060294}, - {1060296, 1060302}, {1060304, 1060310}, {1060312, 1060318}, - {1060869, 1060871}, {1060897, 1060905}, {1060913, 1060917}, - {1060920, 1060924}, {1060929, 1061014}, {1061019, 1061023}, - {1061025, 1061114}, {1061116, 1061119}, {1061125, 1061167}, - {1061169, 1061262}, {1061280, 1061311}, {1061360, 1061375}, - {1061888, 1068479}, {1068544, 1090700}, {1090768, 1090813}, - {1090816, 1091084}, {1091088, 1091103}, {1091114, 1091115}, - {1091136, 1091182}, {1091199, 1091229}, {1091232, 1091311}, - {1091351, 1091359}, {1091362, 1091464}, {1091467, 1091530}, - {1091536, 1091537}, {1091539, 1091539}, {1091541, 1091545}, - {1091570, 1091585}, {1091587, 1091589}, {1091591, 1091594}, - {1091596, 1091618}, {1091648, 1091699}, {1091714, 1091763}, - {1091826, 1091831}, {1091835, 1091835}, {1091837, 1091838}, - {1091850, 1091877}, {1091888, 1091910}, {1091936, 1091964}, - {1091972, 1092018}, {1092047, 1092047}, {1092064, 1092068}, - {1092070, 1092079}, {1092090, 1092094}, {1092096, 1092136}, - {1092160, 1092162}, {1092164, 1092171}, {1092192, 1092214}, - {1092218, 1092218}, {1092222, 1092271}, {1092273, 1092273}, - {1092277, 1092278}, {1092281, 1092285}, {1092288, 1092288}, - {1092290, 1092290}, {1092315, 1092317}, {1092320, 1092330}, - {1092338, 1092340}, {1092353, 1092358}, {1092361, 1092366}, - {1092369, 1092374}, {1092384, 1092390}, {1092392, 1092398}, - {1092400, 1092442}, {1092444, 1092457}, {1092464, 1092578}, - {1092608, 1103779}, {1103792, 1103814}, {1103819, 1103867}, - {1112320, 1112685}, {1112688, 1112793}, {1112832, 1112838}, - {1112851, 1112855}, {1112861, 1112861}, {1112863, 1112872}, - {1112874, 1112886}, {1112888, 1112892}, {1112894, 1112894}, - {1112896, 1112897}, {1112899, 1112900}, {1112902, 1113009}, - {1113043, 1113405}, {1113424, 1113487}, {1113490, 1113543}, - {1113584, 1113595}, {1113712, 1113716}, {1113718, 1113852}, - {1113889, 1113914}, {1113921, 1113946}, {1113958, 1114046}, - {1114050, 1114055}, {1114058, 1114063}, {1114066, 1114071}, - {1114074, 1114076}}; +size_t valid_id_start_ranges_unicode[661][2] = { + {36, 36}, {65, 90}, {95, 95}, {97, 122}, + {170, 170}, {181, 181}, {186, 186}, {192, 214}, + {216, 246}, {248, 705}, {710, 721}, {736, 740}, + {748, 748}, {750, 750}, {880, 884}, {886, 887}, + {890, 893}, {895, 895}, {902, 902}, {904, 906}, + {908, 908}, {910, 929}, {931, 1013}, {1015, 1153}, + {1162, 1327}, {1329, 1366}, {1369, 1369}, {1376, 1416}, + {1488, 1514}, {1519, 1522}, {1568, 1610}, {1646, 1647}, + {1649, 1747}, {1749, 1749}, {1765, 1766}, {1774, 1775}, + {1786, 1788}, {1791, 1791}, {1808, 1808}, {1810, 1839}, + {1869, 1957}, {1969, 1969}, {1994, 2026}, {2036, 2037}, + {2042, 2042}, {2048, 2069}, {2074, 2074}, {2084, 2084}, + {2088, 2088}, {2112, 2136}, {2144, 2154}, {2160, 2183}, + {2185, 2190}, {2208, 2249}, {2308, 2361}, {2365, 2365}, + {2384, 2384}, {2392, 2401}, {2417, 2432}, {2437, 2444}, + {2447, 2448}, {2451, 2472}, {2474, 2480}, {2482, 2482}, + {2486, 2489}, {2493, 2493}, {2510, 2510}, {2524, 2525}, + {2527, 2529}, {2544, 2545}, {2556, 2556}, {2565, 2570}, + {2575, 2576}, {2579, 2600}, {2602, 2608}, {2610, 2611}, + {2613, 2614}, {2616, 2617}, {2649, 2652}, {2654, 2654}, + {2674, 2676}, {2693, 2701}, {2703, 2705}, {2707, 2728}, + {2730, 2736}, {2738, 2739}, {2741, 2745}, {2749, 2749}, + {2768, 2768}, {2784, 2785}, {2809, 2809}, {2821, 2828}, + {2831, 2832}, {2835, 2856}, {2858, 2864}, {2866, 2867}, + {2869, 2873}, {2877, 2877}, {2908, 2909}, {2911, 2913}, + {2929, 2929}, {2947, 2947}, {2949, 2954}, {2958, 2960}, + {2962, 2965}, {2969, 2970}, {2972, 2972}, {2974, 2975}, + {2979, 2980}, {2984, 2986}, {2990, 3001}, {3024, 3024}, + {3077, 3084}, {3086, 3088}, {3090, 3112}, {3114, 3129}, + {3133, 3133}, {3160, 3162}, {3165, 3165}, {3168, 3169}, + {3200, 3200}, {3205, 3212}, {3214, 3216}, {3218, 3240}, + {3242, 3251}, {3253, 3257}, {3261, 3261}, {3293, 3294}, + {3296, 3297}, {3313, 3314}, {3332, 3340}, {3342, 3344}, + {3346, 3386}, {3389, 3389}, {3406, 3406}, {3412, 3414}, + {3423, 3425}, {3450, 3455}, {3461, 3478}, {3482, 3505}, + {3507, 3515}, {3517, 3517}, {3520, 3526}, {3585, 3632}, + {3634, 3635}, {3648, 3654}, {3713, 3714}, {3716, 3716}, + {3718, 3722}, {3724, 3747}, {3749, 3749}, {3751, 3760}, + {3762, 3763}, {3773, 3773}, {3776, 3780}, {3782, 3782}, + {3804, 3807}, {3840, 3840}, {3904, 3911}, {3913, 3948}, + {3976, 3980}, {4096, 4138}, {4159, 4159}, {4176, 4181}, + {4186, 4189}, {4193, 4193}, {4197, 4198}, {4206, 4208}, + {4213, 4225}, {4238, 4238}, {4256, 4293}, {4295, 4295}, + {4301, 4301}, {4304, 4346}, {4348, 4680}, {4682, 4685}, + {4688, 4694}, {4696, 4696}, {4698, 4701}, {4704, 4744}, + {4746, 4749}, {4752, 4784}, {4786, 4789}, {4792, 4798}, + {4800, 4800}, {4802, 4805}, {4808, 4822}, {4824, 4880}, + {4882, 4885}, {4888, 4954}, {4992, 5007}, {5024, 5109}, + {5112, 5117}, {5121, 5740}, {5743, 5759}, {5761, 5786}, + {5792, 5866}, {5870, 5880}, {5888, 5905}, {5919, 5937}, + {5952, 5969}, {5984, 5996}, {5998, 6000}, {6016, 6067}, + {6103, 6103}, {6108, 6108}, {6176, 6264}, {6272, 6312}, + {6314, 6314}, {6320, 6389}, {6400, 6430}, {6480, 6509}, + {6512, 6516}, {6528, 6571}, {6576, 6601}, {6656, 6678}, + {6688, 6740}, {6823, 6823}, {6917, 6963}, {6981, 6988}, + {7043, 7072}, {7086, 7087}, {7098, 7141}, {7168, 7203}, + {7245, 7247}, {7258, 7293}, {7296, 7304}, {7312, 7354}, + {7357, 7359}, {7401, 7404}, {7406, 7411}, {7413, 7414}, + {7418, 7418}, {7424, 7615}, {7680, 7957}, {7960, 7965}, + {7968, 8005}, {8008, 8013}, {8016, 8023}, {8025, 8025}, + {8027, 8027}, {8029, 8029}, {8031, 8061}, {8064, 8116}, + {8118, 8124}, {8126, 8126}, {8130, 8132}, {8134, 8140}, + {8144, 8147}, {8150, 8155}, {8160, 8172}, {8178, 8180}, + {8182, 8188}, {8305, 8305}, {8319, 8319}, {8336, 8348}, + {8450, 8450}, {8455, 8455}, {8458, 8467}, {8469, 8469}, + {8472, 8477}, {8484, 8484}, {8486, 8486}, {8488, 8488}, + {8490, 8505}, {8508, 8511}, {8517, 8521}, {8526, 8526}, + {8544, 8584}, {11264, 11492}, {11499, 11502}, {11506, 11507}, + {11520, 11557}, {11559, 11559}, {11565, 11565}, {11568, 11623}, + {11631, 11631}, {11648, 11670}, {11680, 11686}, {11688, 11694}, + {11696, 11702}, {11704, 11710}, {11712, 11718}, {11720, 11726}, + {11728, 11734}, {11736, 11742}, {12293, 12295}, {12321, 12329}, + {12337, 12341}, {12344, 12348}, {12353, 12438}, {12443, 12447}, + {12449, 12538}, {12540, 12543}, {12549, 12591}, {12593, 12686}, + {12704, 12735}, {12784, 12799}, {13312, 19903}, {19968, 42124}, + {42192, 42237}, {42240, 42508}, {42512, 42527}, {42538, 42539}, + {42560, 42606}, {42623, 42653}, {42656, 42735}, {42775, 42783}, + {42786, 42888}, {42891, 42954}, {42960, 42961}, {42963, 42963}, + {42965, 42969}, {42994, 43009}, {43011, 43013}, {43015, 43018}, + {43020, 43042}, {43072, 43123}, {43138, 43187}, {43250, 43255}, + {43259, 43259}, {43261, 43262}, {43274, 43301}, {43312, 43334}, + {43360, 43388}, {43396, 43442}, {43471, 43471}, {43488, 43492}, + {43494, 43503}, {43514, 43518}, {43520, 43560}, {43584, 43586}, + {43588, 43595}, {43616, 43638}, {43642, 43642}, {43646, 43695}, + {43697, 43697}, {43701, 43702}, {43705, 43709}, {43712, 43712}, + {43714, 43714}, {43739, 43741}, {43744, 43754}, {43762, 43764}, + {43777, 43782}, {43785, 43790}, {43793, 43798}, {43808, 43814}, + {43816, 43822}, {43824, 43866}, {43868, 43881}, {43888, 44002}, + {44032, 55203}, {55216, 55238}, {55243, 55291}, {63744, 64109}, + {64112, 64217}, {64256, 64262}, {64275, 64279}, {64285, 64285}, + {64287, 64296}, {64298, 64310}, {64312, 64316}, {64318, 64318}, + {64320, 64321}, {64323, 64324}, {64326, 64433}, {64467, 64829}, + {64848, 64911}, {64914, 64967}, {65008, 65019}, {65136, 65140}, + {65142, 65276}, {65313, 65338}, {65345, 65370}, {65382, 65470}, + {65474, 65479}, {65482, 65487}, {65490, 65495}, {65498, 65500}, + {65536, 65547}, {65549, 65574}, {65576, 65594}, {65596, 65597}, + {65599, 65613}, {65616, 65629}, {65664, 65786}, {65856, 65908}, + {66176, 66204}, {66208, 66256}, {66304, 66335}, {66349, 66378}, + {66384, 66421}, {66432, 66461}, {66464, 66499}, {66504, 66511}, + {66513, 66517}, {66560, 66717}, {66736, 66771}, {66776, 66811}, + {66816, 66855}, {66864, 66915}, {66928, 66938}, {66940, 66954}, + {66956, 66962}, {66964, 66965}, {66967, 66977}, {66979, 66993}, + {66995, 67001}, {67003, 67004}, {67072, 67382}, {67392, 67413}, + {67424, 67431}, {67456, 67461}, {67463, 67504}, {67506, 67514}, + {67584, 67589}, {67592, 67592}, {67594, 67637}, {67639, 67640}, + {67644, 67644}, {67647, 67669}, {67680, 67702}, {67712, 67742}, + {67808, 67826}, {67828, 67829}, {67840, 67861}, {67872, 67897}, + {67968, 68023}, {68030, 68031}, {68096, 68096}, {68112, 68115}, + {68117, 68119}, {68121, 68149}, {68192, 68220}, {68224, 68252}, + {68288, 68295}, {68297, 68324}, {68352, 68405}, {68416, 68437}, + {68448, 68466}, {68480, 68497}, {68608, 68680}, {68736, 68786}, + {68800, 68850}, {68864, 68899}, {69248, 69289}, {69296, 69297}, + {69376, 69404}, {69415, 69415}, {69424, 69445}, {69488, 69505}, + {69552, 69572}, {69600, 69622}, {69635, 69687}, {69745, 69746}, + {69749, 69749}, {69763, 69807}, {69840, 69864}, {69891, 69926}, + {69956, 69956}, {69959, 69959}, {69968, 70002}, {70006, 70006}, + {70019, 70066}, {70081, 70084}, {70106, 70106}, {70108, 70108}, + {70144, 70161}, {70163, 70187}, {70207, 70208}, {70272, 70278}, + {70280, 70280}, {70282, 70285}, {70287, 70301}, {70303, 70312}, + {70320, 70366}, {70405, 70412}, {70415, 70416}, {70419, 70440}, + {70442, 70448}, {70450, 70451}, {70453, 70457}, {70461, 70461}, + {70480, 70480}, {70493, 70497}, {70656, 70708}, {70727, 70730}, + {70751, 70753}, {70784, 70831}, {70852, 70853}, {70855, 70855}, + {71040, 71086}, {71128, 71131}, {71168, 71215}, {71236, 71236}, + {71296, 71338}, {71352, 71352}, {71424, 71450}, {71488, 71494}, + {71680, 71723}, {71840, 71903}, {71935, 71942}, {71945, 71945}, + {71948, 71955}, {71957, 71958}, {71960, 71983}, {71999, 71999}, + {72001, 72001}, {72096, 72103}, {72106, 72144}, {72161, 72161}, + {72163, 72163}, {72192, 72192}, {72203, 72242}, {72250, 72250}, + {72272, 72272}, {72284, 72329}, {72349, 72349}, {72368, 72440}, + {72704, 72712}, {72714, 72750}, {72768, 72768}, {72818, 72847}, + {72960, 72966}, {72968, 72969}, {72971, 73008}, {73030, 73030}, + {73056, 73061}, {73063, 73064}, {73066, 73097}, {73112, 73112}, + {73440, 73458}, {73474, 73474}, {73476, 73488}, {73490, 73523}, + {73648, 73648}, {73728, 74649}, {74752, 74862}, {74880, 75075}, + {77712, 77808}, {77824, 78895}, {78913, 78918}, {82944, 83526}, + {92160, 92728}, {92736, 92766}, {92784, 92862}, {92880, 92909}, + {92928, 92975}, {92992, 92995}, {93027, 93047}, {93053, 93071}, + {93760, 93823}, {93952, 94026}, {94032, 94032}, {94099, 94111}, + {94176, 94177}, {94179, 94179}, {94208, 100343}, {100352, 101589}, + {101632, 101640}, {110576, 110579}, {110581, 110587}, {110589, 110590}, + {110592, 110882}, {110898, 110898}, {110928, 110930}, {110933, 110933}, + {110948, 110951}, {110960, 111355}, {113664, 113770}, {113776, 113788}, + {113792, 113800}, {113808, 113817}, {119808, 119892}, {119894, 119964}, + {119966, 119967}, {119970, 119970}, {119973, 119974}, {119977, 119980}, + {119982, 119993}, {119995, 119995}, {119997, 120003}, {120005, 120069}, + {120071, 120074}, {120077, 120084}, {120086, 120092}, {120094, 120121}, + {120123, 120126}, {120128, 120132}, {120134, 120134}, {120138, 120144}, + {120146, 120485}, {120488, 120512}, {120514, 120538}, {120540, 120570}, + {120572, 120596}, {120598, 120628}, {120630, 120654}, {120656, 120686}, + {120688, 120712}, {120714, 120744}, {120746, 120770}, {120772, 120779}, + {122624, 122654}, {122661, 122666}, {122928, 122989}, {123136, 123180}, + {123191, 123197}, {123214, 123214}, {123536, 123565}, {123584, 123627}, + {124112, 124139}, {124896, 124902}, {124904, 124907}, {124909, 124910}, + {124912, 124926}, {124928, 125124}, {125184, 125251}, {125259, 125259}, + {126464, 126467}, {126469, 126495}, {126497, 126498}, {126500, 126500}, + {126503, 126503}, {126505, 126514}, {126516, 126519}, {126521, 126521}, + {126523, 126523}, {126530, 126530}, {126535, 126535}, {126537, 126537}, + {126539, 126539}, {126541, 126543}, {126545, 126546}, {126548, 126548}, + {126551, 126551}, {126553, 126553}, {126555, 126555}, {126557, 126557}, + {126559, 126559}, {126561, 126562}, {126564, 126564}, {126567, 126570}, + {126572, 126578}, {126580, 126583}, {126585, 126588}, {126590, 126590}, + {126592, 126601}, {126603, 126619}, {126625, 126627}, {126629, 126633}, + {126635, 126651}, {131072, 173791}, {173824, 177977}, {177984, 178205}, + {178208, 183969}, {183984, 191456}, {194560, 195101}, {196608, 201546}, + {201552, 205743}}; ada_really_inline std::bitset<0x10FFFF> init_valid_id_start_mask_unicode() { std::bitset<0x10FFFF> id_start_mask{}; @@ -2483,2447 +498,211 @@ static std::bitset<0x10FFFF> valid_id_start_mask_unicode = // https://wicg.github.io/urlpattern/#is-a-valid-name-code-point ada_really_inline bool is_valid_identifier_start(const char32_t& c) noexcept { - return c < 256 ? /* extended ascii fast path */ valid_id_start_table_ascii[c] - : valid_id_start_mask_unicode[c]; + if (c == U'𐤀') { + std::cerr << "Hello!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; + } + return c < 256 + ? /* extended ascii fast path */ valid_id_start_table_ascii[c - 1] + : valid_id_start_mask_unicode[c]; } // Valid IdentifierPart unicods points 256+ // ranges with the regex [$_\u200C\u200D\p{ID_Continue}]/u // https://tc39.es/ecma262/#prod-IdentifierPart -size_t valid_id_part_ranges_unicode[7299][2] = { - {255, 705}, {710, 721}, {736, 740}, - {748, 748}, {750, 750}, {768, 884}, - {886, 887}, {890, 893}, {895, 895}, - {902, 906}, {908, 908}, {910, 929}, - {931, 1013}, {1015, 1153}, {1155, 1159}, - {1162, 1327}, {1329, 1366}, {1369, 1369}, - {1376, 1416}, {1425, 1469}, {1471, 1471}, - {1473, 1474}, {1476, 1477}, {1479, 1479}, - {1488, 1514}, {1519, 1522}, {1552, 1562}, - {1568, 1641}, {1646, 1747}, {1749, 1756}, - {1759, 1768}, {1770, 1788}, {1791, 1791}, - {1808, 1866}, {1869, 1969}, {1984, 2037}, - {2042, 2042}, {2045, 2045}, {2048, 2093}, - {2112, 2139}, {2144, 2154}, {2160, 2183}, - {2185, 2190}, {2200, 2273}, {2275, 2403}, - {2406, 2415}, {2417, 2435}, {2437, 2444}, - {2447, 2448}, {2451, 2472}, {2474, 2480}, - {2482, 2482}, {2486, 2489}, {2492, 2500}, - {2503, 2504}, {2507, 2510}, {2519, 2519}, - {2524, 2525}, {2527, 2531}, {2534, 2545}, - {2556, 2556}, {2558, 2558}, {2561, 2563}, - {2565, 2570}, {2575, 2576}, {2579, 2600}, - {2602, 2608}, {2610, 2611}, {2613, 2614}, - {2616, 2617}, {2620, 2620}, {2622, 2626}, - {2631, 2632}, {2635, 2637}, {2641, 2641}, - {2649, 2652}, {2654, 2654}, {2662, 2677}, - {2689, 2691}, {2693, 2701}, {2703, 2705}, - {2707, 2728}, {2730, 2736}, {2738, 2739}, - {2741, 2745}, {2748, 2757}, {2759, 2761}, - {2763, 2765}, {2768, 2768}, {2784, 2787}, - {2790, 2799}, {2809, 2815}, {2817, 2819}, - {2821, 2828}, {2831, 2832}, {2835, 2856}, - {2858, 2864}, {2866, 2867}, {2869, 2873}, - {2876, 2884}, {2887, 2888}, {2891, 2893}, - {2901, 2903}, {2908, 2909}, {2911, 2915}, - {2918, 2927}, {2929, 2929}, {2946, 2947}, - {2949, 2954}, {2958, 2960}, {2962, 2965}, - {2969, 2970}, {2972, 2972}, {2974, 2975}, - {2979, 2980}, {2984, 2986}, {2990, 3001}, - {3006, 3010}, {3014, 3016}, {3018, 3021}, - {3024, 3024}, {3031, 3031}, {3046, 3055}, - {3072, 3084}, {3086, 3088}, {3090, 3112}, - {3114, 3129}, {3132, 3140}, {3142, 3144}, - {3146, 3149}, {3157, 3158}, {3160, 3162}, - {3165, 3165}, {3168, 3171}, {3174, 3183}, - {3200, 3203}, {3205, 3212}, {3214, 3216}, - {3218, 3240}, {3242, 3251}, {3253, 3257}, - {3260, 3268}, {3270, 3272}, {3274, 3277}, - {3285, 3286}, {3293, 3294}, {3296, 3299}, - {3302, 3311}, {3313, 3315}, {3328, 3340}, - {3342, 3344}, {3346, 3396}, {3398, 3400}, - {3402, 3406}, {3412, 3415}, {3423, 3427}, - {3430, 3439}, {3450, 3455}, {3457, 3459}, - {3461, 3478}, {3482, 3505}, {3507, 3515}, - {3517, 3517}, {3520, 3526}, {3530, 3530}, - {3535, 3540}, {3542, 3542}, {3544, 3551}, - {3558, 3567}, {3570, 3571}, {3585, 3642}, - {3648, 3662}, {3664, 3673}, {3713, 3714}, - {3716, 3716}, {3718, 3722}, {3724, 3747}, - {3749, 3749}, {3751, 3773}, {3776, 3780}, - {3782, 3782}, {3784, 3790}, {3792, 3801}, - {3804, 3807}, {3840, 3840}, {3864, 3865}, - {3872, 3881}, {3893, 3893}, {3895, 3895}, - {3897, 3897}, {3902, 3911}, {3913, 3948}, - {3953, 3972}, {3974, 3991}, {3993, 4028}, - {4038, 4038}, {4096, 4169}, {4176, 4253}, - {4256, 4293}, {4295, 4295}, {4301, 4301}, - {4304, 4346}, {4348, 4680}, {4682, 4685}, - {4688, 4694}, {4696, 4696}, {4698, 4701}, - {4704, 4744}, {4746, 4749}, {4752, 4784}, - {4786, 4789}, {4792, 4798}, {4800, 4800}, - {4802, 4805}, {4808, 4822}, {4824, 4880}, - {4882, 4885}, {4888, 4954}, {4957, 4959}, - {4969, 4977}, {4992, 5007}, {5024, 5109}, - {5112, 5117}, {5121, 5740}, {5743, 5759}, - {5761, 5786}, {5792, 5866}, {5870, 5880}, - {5888, 5909}, {5919, 5940}, {5952, 5971}, - {5984, 5996}, {5998, 6000}, {6002, 6003}, - {6016, 6099}, {6103, 6103}, {6108, 6109}, - {6112, 6121}, {6155, 6157}, {6159, 6169}, - {6176, 6264}, {6272, 6314}, {6320, 6389}, - {6400, 6430}, {6432, 6443}, {6448, 6459}, - {6470, 6509}, {6512, 6516}, {6528, 6571}, - {6576, 6601}, {6608, 6618}, {6656, 6683}, - {6688, 6750}, {6752, 6780}, {6783, 6793}, - {6800, 6809}, {6823, 6823}, {6832, 6845}, - {6847, 6862}, {6912, 6988}, {6992, 7001}, - {7019, 7027}, {7040, 7155}, {7168, 7223}, - {7232, 7241}, {7245, 7293}, {7296, 7304}, - {7312, 7354}, {7357, 7359}, {7376, 7378}, - {7380, 7418}, {7424, 7957}, {7960, 7965}, - {7968, 8005}, {8008, 8013}, {8016, 8023}, - {8025, 8025}, {8027, 8027}, {8029, 8029}, - {8031, 8061}, {8064, 8116}, {8118, 8124}, - {8126, 8126}, {8130, 8132}, {8134, 8140}, - {8144, 8147}, {8150, 8155}, {8160, 8172}, - {8178, 8180}, {8182, 8188}, {8204, 8205}, - {8255, 8256}, {8276, 8276}, {8305, 8305}, - {8319, 8319}, {8336, 8348}, {8400, 8412}, - {8417, 8417}, {8421, 8432}, {8450, 8450}, - {8455, 8455}, {8458, 8467}, {8469, 8469}, - {8472, 8477}, {8484, 8484}, {8486, 8486}, - {8488, 8488}, {8490, 8505}, {8508, 8511}, - {8517, 8521}, {8526, 8526}, {8544, 8584}, - {11264, 11492}, {11499, 11507}, {11520, 11557}, - {11559, 11559}, {11565, 11565}, {11568, 11623}, - {11631, 11631}, {11647, 11670}, {11680, 11686}, - {11688, 11694}, {11696, 11702}, {11704, 11710}, - {11712, 11718}, {11720, 11726}, {11728, 11734}, - {11736, 11742}, {11744, 11775}, {12293, 12295}, - {12321, 12335}, {12337, 12341}, {12344, 12348}, - {12353, 12438}, {12441, 12447}, {12449, 12538}, - {12540, 12543}, {12549, 12591}, {12593, 12686}, - {12704, 12735}, {12784, 12799}, {13312, 19903}, - {19968, 42124}, {42192, 42237}, {42240, 42508}, - {42512, 42539}, {42560, 42607}, {42612, 42621}, - {42623, 42737}, {42775, 42783}, {42786, 42888}, - {42891, 42954}, {42960, 42961}, {42963, 42963}, - {42965, 42969}, {42994, 43047}, {43052, 43052}, - {43072, 43123}, {43136, 43205}, {43216, 43225}, - {43232, 43255}, {43259, 43259}, {43261, 43309}, - {43312, 43347}, {43360, 43388}, {43392, 43456}, - {43471, 43481}, {43488, 43518}, {43520, 43574}, - {43584, 43597}, {43600, 43609}, {43616, 43638}, - {43642, 43714}, {43739, 43741}, {43744, 43759}, - {43762, 43766}, {43777, 43782}, {43785, 43790}, - {43793, 43798}, {43808, 43814}, {43816, 43822}, - {43824, 43866}, {43868, 43881}, {43888, 44010}, - {44012, 44013}, {44016, 44025}, {44032, 55203}, - {55216, 55238}, {55243, 55291}, {63744, 64109}, - {64112, 64217}, {64256, 64262}, {64275, 64279}, - {64285, 64296}, {64298, 64310}, {64312, 64316}, - {64318, 64318}, {64320, 64321}, {64323, 64324}, - {64326, 64433}, {64467, 64829}, {64848, 64911}, - {64914, 64967}, {65008, 65019}, {65024, 65039}, - {65056, 65071}, {65075, 65076}, {65101, 65103}, - {65136, 65140}, {65142, 65276}, {65296, 65305}, - {65313, 65338}, {65343, 65343}, {65345, 65370}, - {65382, 65470}, {65474, 65479}, {65482, 65487}, - {65490, 65495}, {65498, 65500}, {65572, 65572}, - {65584, 65593}, {65601, 65626}, {65631, 65631}, - {65633, 65658}, {65706, 65706}, {65717, 65717}, - {65719, 65719}, {65722, 65722}, {65728, 65750}, - {65752, 65782}, {65784, 66241}, {66246, 66257}, - {66272, 66276}, {66284, 66284}, {66286, 66286}, - {66304, 66420}, {66422, 66423}, {66426, 66429}, - {66431, 66431}, {66438, 66442}, {66444, 66444}, - {66446, 66465}, {66467, 66549}, {66551, 66689}, - {66691, 66695}, {66698, 66863}, {66865, 66902}, - {66905, 66905}, {66912, 66952}, {66961, 67005}, - {67007, 67007}, {67009, 67010}, {67012, 67013}, - {67015, 67015}, {67024, 67050}, {67055, 67058}, - {67088, 67098}, {67104, 67177}, {67182, 67283}, - {67285, 67292}, {67295, 67304}, {67306, 67324}, - {67327, 67327}, {67344, 67402}, {67405, 67505}, - {67520, 67573}, {67578, 67578}, {67581, 67581}, - {67584, 67629}, {67648, 67675}, {67680, 67690}, - {67696, 67719}, {67721, 67726}, {67736, 67809}, - {67811, 67939}, {67942, 67951}, {67953, 67971}, - {67973, 67980}, {67983, 67984}, {67987, 68008}, - {68010, 68016}, {68018, 68018}, {68022, 68025}, - {68028, 68036}, {68039, 68040}, {68043, 68046}, - {68055, 68055}, {68060, 68061}, {68063, 68067}, - {68070, 68081}, {68092, 68092}, {68094, 68094}, - {68097, 68099}, {68101, 68106}, {68111, 68112}, - {68115, 68136}, {68138, 68144}, {68146, 68147}, - {68149, 68150}, {68152, 68153}, {68156, 68156}, - {68158, 68162}, {68167, 68168}, {68171, 68173}, - {68177, 68177}, {68185, 68188}, {68190, 68190}, - {68198, 68213}, {68225, 68227}, {68229, 68237}, - {68239, 68241}, {68243, 68264}, {68266, 68272}, - {68274, 68275}, {68277, 68281}, {68284, 68293}, - {68295, 68297}, {68299, 68301}, {68304, 68304}, - {68320, 68323}, {68326, 68335}, {68345, 68351}, - {68353, 68355}, {68357, 68364}, {68367, 68368}, - {68371, 68392}, {68394, 68400}, {68402, 68403}, - {68405, 68409}, {68412, 68420}, {68423, 68424}, - {68427, 68429}, {68437, 68439}, {68444, 68445}, - {68447, 68451}, {68454, 68463}, {68465, 68465}, - {68482, 68483}, {68485, 68490}, {68494, 68496}, - {68498, 68501}, {68505, 68506}, {68508, 68508}, - {68510, 68511}, {68515, 68516}, {68520, 68522}, - {68526, 68537}, {68542, 68546}, {68550, 68552}, - {68554, 68557}, {68560, 68560}, {68567, 68567}, - {68582, 68591}, {68608, 68620}, {68622, 68624}, - {68626, 68648}, {68650, 68665}, {68668, 68676}, - {68678, 68680}, {68682, 68685}, {68693, 68694}, - {68696, 68698}, {68701, 68701}, {68704, 68707}, - {68710, 68719}, {68736, 68739}, {68741, 68748}, - {68750, 68752}, {68754, 68776}, {68778, 68787}, - {68789, 68793}, {68796, 68804}, {68806, 68808}, - {68810, 68813}, {68821, 68822}, {68829, 68830}, - {68832, 68835}, {68838, 68847}, {68849, 68851}, - {68864, 68876}, {68878, 68880}, {68882, 68932}, - {68934, 68936}, {68938, 68942}, {68948, 68951}, - {68959, 68963}, {68966, 68975}, {68986, 68991}, - {68993, 68995}, {68997, 69014}, {69018, 69041}, - {69043, 69051}, {69053, 69053}, {69056, 69062}, - {69066, 69066}, {69071, 69076}, {69078, 69078}, - {69080, 69087}, {69094, 69103}, {69106, 69107}, - {69121, 69178}, {69184, 69198}, {69200, 69209}, - {69249, 69250}, {69252, 69252}, {69254, 69258}, - {69260, 69283}, {69285, 69285}, {69287, 69309}, - {69312, 69316}, {69318, 69318}, {69320, 69326}, - {69328, 69337}, {69340, 69343}, {69376, 69376}, - {69400, 69401}, {69408, 69417}, {69429, 69429}, - {69431, 69431}, {69433, 69433}, {69438, 69447}, - {69449, 69484}, {69489, 69508}, {69510, 69527}, - {69529, 69564}, {69574, 69574}, {69632, 69705}, - {69712, 69789}, {69792, 69829}, {69831, 69831}, - {69837, 69837}, {69840, 69882}, {69884, 70216}, - {70218, 70221}, {70224, 70230}, {70232, 70232}, - {70234, 70237}, {70240, 70280}, {70282, 70285}, - {70288, 70320}, {70322, 70325}, {70328, 70334}, - {70336, 70336}, {70338, 70341}, {70344, 70358}, - {70360, 70416}, {70418, 70421}, {70424, 70490}, - {70493, 70495}, {70505, 70513}, {70528, 70543}, - {70560, 70645}, {70648, 70653}, {70657, 71276}, - {71279, 71295}, {71297, 71322}, {71328, 71402}, - {71406, 71416}, {71424, 71445}, {71455, 71476}, - {71488, 71507}, {71520, 71532}, {71534, 71536}, - {71538, 71539}, {71552, 71635}, {71639, 71639}, - {71644, 71645}, {71648, 71657}, {71691, 71693}, - {71695, 71705}, {71712, 71800}, {71808, 71850}, - {71856, 71925}, {71936, 71966}, {71968, 71979}, - {71984, 71995}, {72006, 72045}, {72048, 72052}, - {72064, 72107}, {72112, 72137}, {72144, 72154}, - {72192, 72219}, {72224, 72286}, {72288, 72316}, - {72319, 72329}, {72336, 72345}, {72359, 72359}, - {72368, 72381}, {72383, 72398}, {72448, 72524}, - {72528, 72537}, {72555, 72563}, {72576, 72691}, - {72704, 72759}, {72768, 72777}, {72781, 72829}, - {72832, 72840}, {72848, 72890}, {72893, 72895}, - {72912, 72914}, {72916, 72954}, {72960, 73493}, - {73496, 73501}, {73504, 73541}, {73544, 73549}, - {73552, 73559}, {73561, 73561}, {73563, 73563}, - {73565, 73565}, {73567, 73597}, {73600, 73652}, - {73654, 73660}, {73662, 73662}, {73666, 73668}, - {73670, 73676}, {73680, 73683}, {73686, 73691}, - {73696, 73708}, {73714, 73716}, {73718, 73724}, - {73740, 73741}, {73791, 73792}, {73812, 73812}, - {73841, 73841}, {73855, 73855}, {73872, 73884}, - {73936, 73948}, {73953, 73953}, {73957, 73968}, - {73986, 73986}, {73991, 73991}, {73994, 74003}, - {74005, 74005}, {74008, 74013}, {74020, 74020}, - {74022, 74022}, {74024, 74024}, {74026, 74041}, - {74044, 74047}, {74053, 74057}, {74062, 74062}, - {74080, 74120}, {76800, 77028}, {77035, 77043}, - {77056, 77093}, {77095, 77095}, {77101, 77101}, - {77104, 77159}, {77167, 77167}, {77183, 77206}, - {77216, 77222}, {77224, 77230}, {77232, 77238}, - {77240, 77246}, {77248, 77254}, {77256, 77262}, - {77264, 77270}, {77272, 77278}, {77280, 77311}, - {77829, 77831}, {77857, 77871}, {77873, 77877}, - {77880, 77884}, {77889, 77974}, {77977, 77983}, - {77985, 78074}, {78076, 78079}, {78085, 78127}, - {78129, 78222}, {78240, 78271}, {78320, 78335}, - {78848, 85439}, {85504, 107660}, {107728, 107773}, - {107776, 108044}, {108048, 108075}, {108096, 108143}, - {108148, 108157}, {108159, 108273}, {108311, 108319}, - {108322, 108424}, {108427, 108490}, {108496, 108497}, - {108499, 108499}, {108501, 108505}, {108530, 108583}, - {108588, 108588}, {108608, 108659}, {108672, 108741}, - {108752, 108761}, {108768, 108791}, {108795, 108795}, - {108797, 108845}, {108848, 108883}, {108896, 108924}, - {108928, 108992}, {109007, 109017}, {109024, 109054}, - {109056, 109110}, {109120, 109133}, {109136, 109145}, - {109152, 109174}, {109178, 109250}, {109275, 109277}, - {109280, 109295}, {109298, 109302}, {109313, 109318}, - {109321, 109326}, {109329, 109334}, {109344, 109350}, - {109352, 109358}, {109360, 109402}, {109404, 109417}, - {109424, 109546}, {109548, 109549}, {109552, 109561}, - {109568, 120739}, {120752, 120774}, {120779, 120827}, - {129280, 129645}, {129648, 129753}, {129792, 129798}, - {129811, 129815}, {129821, 129832}, {129834, 129846}, - {129848, 129852}, {129854, 129854}, {129856, 129857}, - {129859, 129860}, {129862, 129969}, {130003, 130365}, - {130384, 130447}, {130450, 130503}, {130544, 130555}, - {130560, 130575}, {130592, 130607}, {130611, 130612}, - {130637, 130639}, {130672, 130676}, {130678, 130812}, - {130832, 130841}, {130849, 130874}, {130879, 130879}, - {130881, 130906}, {130918, 131006}, {131010, 131015}, - {131018, 131023}, {131026, 131031}, {131034, 131036}, - {131108, 131108}, {131120, 131129}, {131137, 131162}, - {131167, 131167}, {131169, 131194}, {131242, 131242}, - {131253, 131253}, {131255, 131255}, {131258, 131258}, - {131264, 131286}, {131288, 131318}, {131320, 131777}, - {131782, 131793}, {131808, 131812}, {131820, 131820}, - {131822, 131822}, {131840, 131956}, {131958, 131959}, - {131962, 131965}, {131967, 131967}, {131974, 131978}, - {131980, 131980}, {131982, 132001}, {132003, 132085}, - {132087, 132225}, {132227, 132231}, {132234, 132399}, - {132401, 132438}, {132441, 132441}, {132448, 132488}, - {132497, 132541}, {132543, 132543}, {132545, 132546}, - {132548, 132549}, {132551, 132551}, {132560, 132586}, - {132591, 132594}, {132624, 132634}, {132640, 132713}, - {132718, 132819}, {132821, 132828}, {132831, 132840}, - {132842, 132860}, {132863, 132863}, {132880, 132938}, - {132941, 133041}, {133056, 133109}, {133114, 133114}, - {133117, 133117}, {133120, 133165}, {133184, 133211}, - {133216, 133226}, {133232, 133255}, {133257, 133262}, - {133272, 133345}, {133347, 133475}, {133478, 133487}, - {133489, 133507}, {133509, 133516}, {133519, 133520}, - {133523, 133544}, {133546, 133552}, {133554, 133554}, - {133558, 133561}, {133564, 133572}, {133575, 133576}, - {133579, 133582}, {133591, 133591}, {133596, 133597}, - {133599, 133603}, {133606, 133617}, {133628, 133628}, - {133630, 133630}, {133633, 133635}, {133637, 133642}, - {133647, 133648}, {133651, 133672}, {133674, 133680}, - {133682, 133683}, {133685, 133686}, {133688, 133689}, - {133692, 133692}, {133694, 133698}, {133703, 133704}, - {133707, 133709}, {133713, 133713}, {133721, 133724}, - {133726, 133726}, {133734, 133749}, {133761, 133763}, - {133765, 133773}, {133775, 133777}, {133779, 133800}, - {133802, 133808}, {133810, 133811}, {133813, 133817}, - {133820, 133829}, {133831, 133833}, {133835, 133837}, - {133840, 133840}, {133856, 133859}, {133862, 133871}, - {133881, 133887}, {133889, 133891}, {133893, 133900}, - {133903, 133904}, {133907, 133928}, {133930, 133936}, - {133938, 133939}, {133941, 133945}, {133948, 133956}, - {133959, 133960}, {133963, 133965}, {133973, 133975}, - {133980, 133981}, {133983, 133987}, {133990, 133999}, - {134001, 134001}, {134018, 134019}, {134021, 134026}, - {134030, 134032}, {134034, 134037}, {134041, 134042}, - {134044, 134044}, {134046, 134047}, {134051, 134052}, - {134056, 134058}, {134062, 134073}, {134078, 134082}, - {134086, 134088}, {134090, 134093}, {134096, 134096}, - {134103, 134103}, {134118, 134127}, {134144, 134156}, - {134158, 134160}, {134162, 134184}, {134186, 134201}, - {134204, 134212}, {134214, 134216}, {134218, 134221}, - {134229, 134230}, {134232, 134234}, {134237, 134237}, - {134240, 134243}, {134246, 134255}, {134272, 134275}, - {134277, 134284}, {134286, 134288}, {134290, 134312}, - {134314, 134323}, {134325, 134329}, {134332, 134340}, - {134342, 134344}, {134346, 134349}, {134357, 134358}, - {134365, 134366}, {134368, 134371}, {134374, 134383}, - {134385, 134387}, {134400, 134412}, {134414, 134416}, - {134418, 134468}, {134470, 134472}, {134474, 134478}, - {134484, 134487}, {134495, 134499}, {134502, 134511}, - {134522, 134527}, {134529, 134531}, {134533, 134550}, - {134554, 134577}, {134579, 134587}, {134589, 134589}, - {134592, 134598}, {134602, 134602}, {134607, 134612}, - {134614, 134614}, {134616, 134623}, {134630, 134639}, - {134642, 134643}, {134657, 134714}, {134720, 134734}, - {134736, 134745}, {134785, 134786}, {134788, 134788}, - {134790, 134794}, {134796, 134819}, {134821, 134821}, - {134823, 134845}, {134848, 134852}, {134854, 134854}, - {134856, 134862}, {134864, 134873}, {134876, 134879}, - {134912, 134912}, {134936, 134937}, {134944, 134953}, - {134965, 134965}, {134967, 134967}, {134969, 134969}, - {134974, 134983}, {134985, 135020}, {135025, 135044}, - {135046, 135063}, {135065, 135100}, {135110, 135110}, - {135168, 135241}, {135248, 135325}, {135328, 135365}, - {135367, 135367}, {135373, 135373}, {135376, 135418}, - {135420, 135752}, {135754, 135757}, {135760, 135766}, - {135768, 135768}, {135770, 135773}, {135776, 135816}, - {135818, 135821}, {135824, 135856}, {135858, 135861}, - {135864, 135870}, {135872, 135872}, {135874, 135877}, - {135880, 135894}, {135896, 135952}, {135954, 135957}, - {135960, 136026}, {136029, 136031}, {136041, 136049}, - {136064, 136079}, {136096, 136181}, {136184, 136189}, - {136193, 136812}, {136815, 136831}, {136833, 136858}, - {136864, 136938}, {136942, 136952}, {136960, 136981}, - {136991, 137012}, {137024, 137043}, {137056, 137068}, - {137070, 137072}, {137074, 137075}, {137088, 137171}, - {137175, 137175}, {137180, 137181}, {137184, 137193}, - {137227, 137229}, {137231, 137241}, {137248, 137336}, - {137344, 137386}, {137392, 137461}, {137472, 137502}, - {137504, 137515}, {137520, 137531}, {137542, 137581}, - {137584, 137588}, {137600, 137643}, {137648, 137673}, - {137680, 137690}, {137728, 137755}, {137760, 137822}, - {137824, 137852}, {137855, 137865}, {137872, 137881}, - {137895, 137895}, {137904, 137917}, {137919, 137934}, - {137984, 138060}, {138064, 138073}, {138091, 138099}, - {138112, 138227}, {138240, 138295}, {138304, 138313}, - {138317, 138365}, {138368, 138376}, {138384, 138426}, - {138429, 138431}, {138448, 138450}, {138452, 138490}, - {138496, 139029}, {139032, 139037}, {139040, 139077}, - {139080, 139085}, {139088, 139095}, {139097, 139097}, - {139099, 139099}, {139101, 139101}, {139103, 139133}, - {139136, 139188}, {139190, 139196}, {139198, 139198}, - {139202, 139204}, {139206, 139212}, {139216, 139219}, - {139222, 139227}, {139232, 139244}, {139250, 139252}, - {139254, 139260}, {139276, 139277}, {139327, 139328}, - {139348, 139348}, {139377, 139377}, {139391, 139391}, - {139408, 139420}, {139472, 139484}, {139489, 139489}, - {139493, 139504}, {139522, 139522}, {139527, 139527}, - {139530, 139539}, {139541, 139541}, {139544, 139549}, - {139556, 139556}, {139558, 139558}, {139560, 139560}, - {139562, 139577}, {139580, 139583}, {139589, 139593}, - {139598, 139598}, {139616, 139656}, {142336, 142564}, - {142571, 142579}, {142592, 142629}, {142631, 142631}, - {142637, 142637}, {142640, 142695}, {142703, 142703}, - {142719, 142742}, {142752, 142758}, {142760, 142766}, - {142768, 142774}, {142776, 142782}, {142784, 142790}, - {142792, 142798}, {142800, 142806}, {142808, 142814}, - {142816, 142847}, {143365, 143367}, {143393, 143407}, - {143409, 143413}, {143416, 143420}, {143425, 143510}, - {143513, 143519}, {143521, 143610}, {143612, 143615}, - {143621, 143663}, {143665, 143758}, {143776, 143807}, - {143856, 143871}, {144384, 150975}, {151040, 173196}, - {173264, 173309}, {173312, 173580}, {173584, 173611}, - {173632, 173679}, {173684, 173693}, {173695, 173809}, - {173847, 173855}, {173858, 173960}, {173963, 174026}, - {174032, 174033}, {174035, 174035}, {174037, 174041}, - {174066, 174119}, {174124, 174124}, {174144, 174195}, - {174208, 174277}, {174288, 174297}, {174304, 174327}, - {174331, 174331}, {174333, 174381}, {174384, 174419}, - {174432, 174460}, {174464, 174528}, {174543, 174553}, - {174560, 174590}, {174592, 174646}, {174656, 174669}, - {174672, 174681}, {174688, 174710}, {174714, 174786}, - {174811, 174813}, {174816, 174831}, {174834, 174838}, - {174849, 174854}, {174857, 174862}, {174865, 174870}, - {174880, 174886}, {174888, 174894}, {174896, 174938}, - {174940, 174953}, {174960, 175082}, {175084, 175085}, - {175088, 175097}, {175104, 186275}, {186288, 186310}, - {186315, 186363}, {194816, 195181}, {195184, 195289}, - {195328, 195334}, {195347, 195351}, {195357, 195368}, - {195370, 195382}, {195384, 195388}, {195390, 195390}, - {195392, 195393}, {195395, 195396}, {195398, 195505}, - {195539, 195901}, {195920, 195983}, {195986, 196039}, - {196080, 196091}, {196096, 196111}, {196128, 196143}, - {196147, 196148}, {196173, 196175}, {196208, 196212}, - {196214, 196348}, {196368, 196377}, {196385, 196410}, - {196415, 196415}, {196417, 196442}, {196454, 196542}, - {196546, 196551}, {196554, 196559}, {196562, 196567}, - {196570, 196572}, {196644, 196644}, {196656, 196665}, - {196673, 196698}, {196703, 196703}, {196705, 196730}, - {196778, 196778}, {196789, 196789}, {196791, 196791}, - {196794, 196794}, {196800, 196822}, {196824, 196854}, - {196856, 197313}, {197318, 197329}, {197344, 197348}, - {197356, 197356}, {197358, 197358}, {197376, 197492}, - {197494, 197495}, {197498, 197501}, {197503, 197503}, - {197510, 197514}, {197516, 197516}, {197518, 197537}, - {197539, 197621}, {197623, 197761}, {197763, 197767}, - {197770, 197935}, {197937, 197974}, {197977, 197977}, - {197984, 198024}, {198033, 198077}, {198079, 198079}, - {198081, 198082}, {198084, 198085}, {198087, 198087}, - {198096, 198122}, {198127, 198130}, {198160, 198170}, - {198176, 198249}, {198254, 198355}, {198357, 198364}, - {198367, 198376}, {198378, 198396}, {198399, 198399}, - {198416, 198474}, {198477, 198577}, {198592, 198645}, - {198650, 198650}, {198653, 198653}, {198656, 198701}, - {198720, 198747}, {198752, 198762}, {198768, 198791}, - {198793, 198798}, {198808, 198881}, {198883, 199011}, - {199014, 199023}, {199025, 199043}, {199045, 199052}, - {199055, 199056}, {199059, 199080}, {199082, 199088}, - {199090, 199090}, {199094, 199097}, {199100, 199108}, - {199111, 199112}, {199115, 199118}, {199127, 199127}, - {199132, 199133}, {199135, 199139}, {199142, 199153}, - {199164, 199164}, {199166, 199166}, {199169, 199171}, - {199173, 199178}, {199183, 199184}, {199187, 199208}, - {199210, 199216}, {199218, 199219}, {199221, 199222}, - {199224, 199225}, {199228, 199228}, {199230, 199234}, - {199239, 199240}, {199243, 199245}, {199249, 199249}, - {199257, 199260}, {199262, 199262}, {199270, 199285}, - {199297, 199299}, {199301, 199309}, {199311, 199313}, - {199315, 199336}, {199338, 199344}, {199346, 199347}, - {199349, 199353}, {199356, 199365}, {199367, 199369}, - {199371, 199373}, {199376, 199376}, {199392, 199395}, - {199398, 199407}, {199417, 199423}, {199425, 199427}, - {199429, 199436}, {199439, 199440}, {199443, 199464}, - {199466, 199472}, {199474, 199475}, {199477, 199481}, - {199484, 199492}, {199495, 199496}, {199499, 199501}, - {199509, 199511}, {199516, 199517}, {199519, 199523}, - {199526, 199535}, {199537, 199537}, {199554, 199555}, - {199557, 199562}, {199566, 199568}, {199570, 199573}, - {199577, 199578}, {199580, 199580}, {199582, 199583}, - {199587, 199588}, {199592, 199594}, {199598, 199609}, - {199614, 199618}, {199622, 199624}, {199626, 199629}, - {199632, 199632}, {199639, 199639}, {199654, 199663}, - {199680, 199692}, {199694, 199696}, {199698, 199720}, - {199722, 199737}, {199740, 199748}, {199750, 199752}, - {199754, 199757}, {199765, 199766}, {199768, 199770}, - {199773, 199773}, {199776, 199779}, {199782, 199791}, - {199808, 199811}, {199813, 199820}, {199822, 199824}, - {199826, 199848}, {199850, 199859}, {199861, 199865}, - {199868, 199876}, {199878, 199880}, {199882, 199885}, - {199893, 199894}, {199901, 199902}, {199904, 199907}, - {199910, 199919}, {199921, 199923}, {199936, 199948}, - {199950, 199952}, {199954, 200004}, {200006, 200008}, - {200010, 200014}, {200020, 200023}, {200031, 200035}, - {200038, 200047}, {200058, 200063}, {200065, 200067}, - {200069, 200086}, {200090, 200113}, {200115, 200123}, - {200125, 200125}, {200128, 200134}, {200138, 200138}, - {200143, 200148}, {200150, 200150}, {200152, 200159}, - {200166, 200175}, {200178, 200179}, {200193, 200250}, - {200256, 200270}, {200272, 200281}, {200321, 200322}, - {200324, 200324}, {200326, 200330}, {200332, 200355}, - {200357, 200357}, {200359, 200381}, {200384, 200388}, - {200390, 200390}, {200392, 200398}, {200400, 200409}, - {200412, 200415}, {200448, 200448}, {200472, 200473}, - {200480, 200489}, {200501, 200501}, {200503, 200503}, - {200505, 200505}, {200510, 200519}, {200521, 200556}, - {200561, 200580}, {200582, 200599}, {200601, 200636}, - {200646, 200646}, {200704, 200777}, {200784, 200861}, - {200864, 200901}, {200903, 200903}, {200909, 200909}, - {200912, 200954}, {200956, 201288}, {201290, 201293}, - {201296, 201302}, {201304, 201304}, {201306, 201309}, - {201312, 201352}, {201354, 201357}, {201360, 201392}, - {201394, 201397}, {201400, 201406}, {201408, 201408}, - {201410, 201413}, {201416, 201430}, {201432, 201488}, - {201490, 201493}, {201496, 201562}, {201565, 201567}, - {201577, 201585}, {201600, 201615}, {201632, 201717}, - {201720, 201725}, {201729, 202348}, {202351, 202367}, - {202369, 202394}, {202400, 202474}, {202478, 202488}, - {202496, 202517}, {202527, 202548}, {202560, 202579}, - {202592, 202604}, {202606, 202608}, {202610, 202611}, - {202624, 202707}, {202711, 202711}, {202716, 202717}, - {202720, 202729}, {202763, 202765}, {202767, 202777}, - {202784, 202872}, {202880, 202922}, {202928, 202997}, - {203008, 203038}, {203040, 203051}, {203056, 203067}, - {203078, 203117}, {203120, 203124}, {203136, 203179}, - {203184, 203209}, {203216, 203226}, {203264, 203291}, - {203296, 203358}, {203360, 203388}, {203391, 203401}, - {203408, 203417}, {203431, 203431}, {203440, 203453}, - {203455, 203470}, {203520, 203596}, {203600, 203609}, - {203627, 203635}, {203648, 203763}, {203776, 203831}, - {203840, 203849}, {203853, 203901}, {203904, 203912}, - {203920, 203962}, {203965, 203967}, {203984, 203986}, - {203988, 204026}, {204032, 204565}, {204568, 204573}, - {204576, 204613}, {204616, 204621}, {204624, 204631}, - {204633, 204633}, {204635, 204635}, {204637, 204637}, - {204639, 204669}, {204672, 204724}, {204726, 204732}, - {204734, 204734}, {204738, 204740}, {204742, 204748}, - {204752, 204755}, {204758, 204763}, {204768, 204780}, - {204786, 204788}, {204790, 204796}, {204812, 204813}, - {204863, 204864}, {204884, 204884}, {204913, 204913}, - {204927, 204927}, {204944, 204956}, {205008, 205020}, - {205025, 205025}, {205029, 205040}, {205058, 205058}, - {205063, 205063}, {205066, 205075}, {205077, 205077}, - {205080, 205085}, {205092, 205092}, {205094, 205094}, - {205096, 205096}, {205098, 205113}, {205116, 205119}, - {205125, 205129}, {205134, 205134}, {205152, 205192}, - {207872, 208100}, {208107, 208115}, {208128, 208165}, - {208167, 208167}, {208173, 208173}, {208176, 208231}, - {208239, 208239}, {208255, 208278}, {208288, 208294}, - {208296, 208302}, {208304, 208310}, {208312, 208318}, - {208320, 208326}, {208328, 208334}, {208336, 208342}, - {208344, 208350}, {208352, 208383}, {208901, 208903}, - {208929, 208943}, {208945, 208949}, {208952, 208956}, - {208961, 209046}, {209049, 209055}, {209057, 209146}, - {209148, 209151}, {209157, 209199}, {209201, 209294}, - {209312, 209343}, {209392, 209407}, {209920, 216511}, - {216576, 238732}, {238800, 238845}, {238848, 239116}, - {239120, 239147}, {239168, 239215}, {239220, 239229}, - {239231, 239345}, {239383, 239391}, {239394, 239496}, - {239499, 239562}, {239568, 239569}, {239571, 239571}, - {239573, 239577}, {239602, 239655}, {239660, 239660}, - {239680, 239731}, {239744, 239813}, {239824, 239833}, - {239840, 239863}, {239867, 239867}, {239869, 239917}, - {239920, 239955}, {239968, 239996}, {240000, 240064}, - {240079, 240089}, {240096, 240126}, {240128, 240182}, - {240192, 240205}, {240208, 240217}, {240224, 240246}, - {240250, 240322}, {240347, 240349}, {240352, 240367}, - {240370, 240374}, {240385, 240390}, {240393, 240398}, - {240401, 240406}, {240416, 240422}, {240424, 240430}, - {240432, 240474}, {240476, 240489}, {240496, 240618}, - {240620, 240621}, {240624, 240633}, {240640, 251811}, - {251824, 251846}, {251851, 251899}, {260352, 260717}, - {260720, 260825}, {260864, 260870}, {260883, 260887}, - {260893, 260904}, {260906, 260918}, {260920, 260924}, - {260926, 260926}, {260928, 260929}, {260931, 260932}, - {260934, 261041}, {261075, 261437}, {261456, 261519}, - {261522, 261575}, {261616, 261627}, {261632, 261647}, - {261664, 261679}, {261683, 261684}, {261709, 261711}, - {261744, 261748}, {261750, 261884}, {261904, 261913}, - {261921, 261946}, {261951, 261951}, {261953, 261978}, - {261990, 262078}, {262082, 262087}, {262090, 262095}, - {262098, 262103}, {262106, 262108}, {262180, 262180}, - {262192, 262201}, {262209, 262234}, {262239, 262239}, - {262241, 262266}, {262314, 262314}, {262325, 262325}, - {262327, 262327}, {262330, 262330}, {262336, 262358}, - {262360, 262390}, {262392, 262849}, {262854, 262865}, - {262880, 262884}, {262892, 262892}, {262894, 262894}, - {262912, 263028}, {263030, 263031}, {263034, 263037}, - {263039, 263039}, {263046, 263050}, {263052, 263052}, - {263054, 263073}, {263075, 263157}, {263159, 263297}, - {263299, 263303}, {263306, 263471}, {263473, 263510}, - {263513, 263513}, {263520, 263560}, {263569, 263613}, - {263615, 263615}, {263617, 263618}, {263620, 263621}, - {263623, 263623}, {263632, 263658}, {263663, 263666}, - {263696, 263706}, {263712, 263785}, {263790, 263891}, - {263893, 263900}, {263903, 263912}, {263914, 263932}, - {263935, 263935}, {263952, 264010}, {264013, 264113}, - {264128, 264181}, {264186, 264186}, {264189, 264189}, - {264192, 264237}, {264256, 264283}, {264288, 264298}, - {264304, 264327}, {264329, 264334}, {264344, 264417}, - {264419, 264547}, {264550, 264559}, {264561, 264579}, - {264581, 264588}, {264591, 264592}, {264595, 264616}, - {264618, 264624}, {264626, 264626}, {264630, 264633}, - {264636, 264644}, {264647, 264648}, {264651, 264654}, - {264663, 264663}, {264668, 264669}, {264671, 264675}, - {264678, 264689}, {264700, 264700}, {264702, 264702}, - {264705, 264707}, {264709, 264714}, {264719, 264720}, - {264723, 264744}, {264746, 264752}, {264754, 264755}, - {264757, 264758}, {264760, 264761}, {264764, 264764}, - {264766, 264770}, {264775, 264776}, {264779, 264781}, - {264785, 264785}, {264793, 264796}, {264798, 264798}, - {264806, 264821}, {264833, 264835}, {264837, 264845}, - {264847, 264849}, {264851, 264872}, {264874, 264880}, - {264882, 264883}, {264885, 264889}, {264892, 264901}, - {264903, 264905}, {264907, 264909}, {264912, 264912}, - {264928, 264931}, {264934, 264943}, {264953, 264959}, - {264961, 264963}, {264965, 264972}, {264975, 264976}, - {264979, 265000}, {265002, 265008}, {265010, 265011}, - {265013, 265017}, {265020, 265028}, {265031, 265032}, - {265035, 265037}, {265045, 265047}, {265052, 265053}, - {265055, 265059}, {265062, 265071}, {265073, 265073}, - {265090, 265091}, {265093, 265098}, {265102, 265104}, - {265106, 265109}, {265113, 265114}, {265116, 265116}, - {265118, 265119}, {265123, 265124}, {265128, 265130}, - {265134, 265145}, {265150, 265154}, {265158, 265160}, - {265162, 265165}, {265168, 265168}, {265175, 265175}, - {265190, 265199}, {265216, 265228}, {265230, 265232}, - {265234, 265256}, {265258, 265273}, {265276, 265284}, - {265286, 265288}, {265290, 265293}, {265301, 265302}, - {265304, 265306}, {265309, 265309}, {265312, 265315}, - {265318, 265327}, {265344, 265347}, {265349, 265356}, - {265358, 265360}, {265362, 265384}, {265386, 265395}, - {265397, 265401}, {265404, 265412}, {265414, 265416}, - {265418, 265421}, {265429, 265430}, {265437, 265438}, - {265440, 265443}, {265446, 265455}, {265457, 265459}, - {265472, 265484}, {265486, 265488}, {265490, 265540}, - {265542, 265544}, {265546, 265550}, {265556, 265559}, - {265567, 265571}, {265574, 265583}, {265594, 265599}, - {265601, 265603}, {265605, 265622}, {265626, 265649}, - {265651, 265659}, {265661, 265661}, {265664, 265670}, - {265674, 265674}, {265679, 265684}, {265686, 265686}, - {265688, 265695}, {265702, 265711}, {265714, 265715}, - {265729, 265786}, {265792, 265806}, {265808, 265817}, - {265857, 265858}, {265860, 265860}, {265862, 265866}, - {265868, 265891}, {265893, 265893}, {265895, 265917}, - {265920, 265924}, {265926, 265926}, {265928, 265934}, - {265936, 265945}, {265948, 265951}, {265984, 265984}, - {266008, 266009}, {266016, 266025}, {266037, 266037}, - {266039, 266039}, {266041, 266041}, {266046, 266055}, - {266057, 266092}, {266097, 266116}, {266118, 266135}, - {266137, 266172}, {266182, 266182}, {266240, 266313}, - {266320, 266397}, {266400, 266437}, {266439, 266439}, - {266445, 266445}, {266448, 266490}, {266492, 266824}, - {266826, 266829}, {266832, 266838}, {266840, 266840}, - {266842, 266845}, {266848, 266888}, {266890, 266893}, - {266896, 266928}, {266930, 266933}, {266936, 266942}, - {266944, 266944}, {266946, 266949}, {266952, 266966}, - {266968, 267024}, {267026, 267029}, {267032, 267098}, - {267101, 267103}, {267113, 267121}, {267136, 267151}, - {267168, 267253}, {267256, 267261}, {267265, 267884}, - {267887, 267903}, {267905, 267930}, {267936, 268010}, - {268014, 268024}, {268032, 268053}, {268063, 268084}, - {268096, 268115}, {268128, 268140}, {268142, 268144}, - {268146, 268147}, {268160, 268243}, {268247, 268247}, - {268252, 268253}, {268256, 268265}, {268299, 268301}, - {268303, 268313}, {268320, 268408}, {268416, 268458}, - {268464, 268533}, {268544, 268574}, {268576, 268587}, - {268592, 268603}, {268614, 268653}, {268656, 268660}, - {268672, 268715}, {268720, 268745}, {268752, 268762}, - {268800, 268827}, {268832, 268894}, {268896, 268924}, - {268927, 268937}, {268944, 268953}, {268967, 268967}, - {268976, 268989}, {268991, 269006}, {269056, 269132}, - {269136, 269145}, {269163, 269171}, {269184, 269299}, - {269312, 269367}, {269376, 269385}, {269389, 269437}, - {269440, 269448}, {269456, 269498}, {269501, 269503}, - {269520, 269522}, {269524, 269562}, {269568, 270101}, - {270104, 270109}, {270112, 270149}, {270152, 270157}, - {270160, 270167}, {270169, 270169}, {270171, 270171}, - {270173, 270173}, {270175, 270205}, {270208, 270260}, - {270262, 270268}, {270270, 270270}, {270274, 270276}, - {270278, 270284}, {270288, 270291}, {270294, 270299}, - {270304, 270316}, {270322, 270324}, {270326, 270332}, - {270348, 270349}, {270399, 270400}, {270420, 270420}, - {270449, 270449}, {270463, 270463}, {270480, 270492}, - {270544, 270556}, {270561, 270561}, {270565, 270576}, - {270594, 270594}, {270599, 270599}, {270602, 270611}, - {270613, 270613}, {270616, 270621}, {270628, 270628}, - {270630, 270630}, {270632, 270632}, {270634, 270649}, - {270652, 270655}, {270661, 270665}, {270670, 270670}, - {270688, 270728}, {273408, 273636}, {273643, 273651}, - {273664, 273701}, {273703, 273703}, {273709, 273709}, - {273712, 273767}, {273775, 273775}, {273791, 273814}, - {273824, 273830}, {273832, 273838}, {273840, 273846}, - {273848, 273854}, {273856, 273862}, {273864, 273870}, - {273872, 273878}, {273880, 273886}, {273888, 273919}, - {274437, 274439}, {274465, 274479}, {274481, 274485}, - {274488, 274492}, {274497, 274582}, {274585, 274591}, - {274593, 274682}, {274684, 274687}, {274693, 274735}, - {274737, 274830}, {274848, 274879}, {274928, 274943}, - {275456, 282047}, {282112, 304268}, {304336, 304381}, - {304384, 304652}, {304656, 304683}, {304704, 304751}, - {304756, 304765}, {304767, 304881}, {304919, 304927}, - {304930, 305032}, {305035, 305098}, {305104, 305105}, - {305107, 305107}, {305109, 305113}, {305138, 305191}, - {305196, 305196}, {305216, 305267}, {305280, 305349}, - {305360, 305369}, {305376, 305399}, {305403, 305403}, - {305405, 305453}, {305456, 305491}, {305504, 305532}, - {305536, 305600}, {305615, 305625}, {305632, 305662}, - {305664, 305718}, {305728, 305741}, {305744, 305753}, - {305760, 305782}, {305786, 305858}, {305883, 305885}, - {305888, 305903}, {305906, 305910}, {305921, 305926}, - {305929, 305934}, {305937, 305942}, {305952, 305958}, - {305960, 305966}, {305968, 306010}, {306012, 306025}, - {306032, 306154}, {306156, 306157}, {306160, 306169}, - {306176, 317347}, {317360, 317382}, {317387, 317435}, - {325888, 326253}, {326256, 326361}, {326400, 326406}, - {326419, 326423}, {326429, 326440}, {326442, 326454}, - {326456, 326460}, {326462, 326462}, {326464, 326465}, - {326467, 326468}, {326470, 326577}, {326611, 326973}, - {326992, 327055}, {327058, 327111}, {327152, 327163}, - {327168, 327183}, {327200, 327215}, {327219, 327220}, - {327245, 327247}, {327280, 327284}, {327286, 327420}, - {327440, 327449}, {327457, 327482}, {327487, 327487}, - {327489, 327514}, {327526, 327614}, {327618, 327623}, - {327626, 327631}, {327634, 327639}, {327642, 327644}, - {327716, 327716}, {327728, 327737}, {327745, 327770}, - {327775, 327775}, {327777, 327802}, {327850, 327850}, - {327861, 327861}, {327863, 327863}, {327866, 327866}, - {327872, 327894}, {327896, 327926}, {327928, 328385}, - {328390, 328401}, {328416, 328420}, {328428, 328428}, - {328430, 328430}, {328448, 328564}, {328566, 328567}, - {328570, 328573}, {328575, 328575}, {328582, 328586}, - {328588, 328588}, {328590, 328609}, {328611, 328693}, - {328695, 328833}, {328835, 328839}, {328842, 329007}, - {329009, 329046}, {329049, 329049}, {329056, 329096}, - {329105, 329149}, {329151, 329151}, {329153, 329154}, - {329156, 329157}, {329159, 329159}, {329168, 329194}, - {329199, 329202}, {329232, 329242}, {329248, 329321}, - {329326, 329427}, {329429, 329436}, {329439, 329448}, - {329450, 329468}, {329471, 329471}, {329488, 329546}, - {329549, 329649}, {329664, 329717}, {329722, 329722}, - {329725, 329725}, {329728, 329773}, {329792, 329819}, - {329824, 329834}, {329840, 329863}, {329865, 329870}, - {329880, 329953}, {329955, 330083}, {330086, 330095}, - {330097, 330115}, {330117, 330124}, {330127, 330128}, - {330131, 330152}, {330154, 330160}, {330162, 330162}, - {330166, 330169}, {330172, 330180}, {330183, 330184}, - {330187, 330190}, {330199, 330199}, {330204, 330205}, - {330207, 330211}, {330214, 330225}, {330236, 330236}, - {330238, 330238}, {330241, 330243}, {330245, 330250}, - {330255, 330256}, {330259, 330280}, {330282, 330288}, - {330290, 330291}, {330293, 330294}, {330296, 330297}, - {330300, 330300}, {330302, 330306}, {330311, 330312}, - {330315, 330317}, {330321, 330321}, {330329, 330332}, - {330334, 330334}, {330342, 330357}, {330369, 330371}, - {330373, 330381}, {330383, 330385}, {330387, 330408}, - {330410, 330416}, {330418, 330419}, {330421, 330425}, - {330428, 330437}, {330439, 330441}, {330443, 330445}, - {330448, 330448}, {330464, 330467}, {330470, 330479}, - {330489, 330495}, {330497, 330499}, {330501, 330508}, - {330511, 330512}, {330515, 330536}, {330538, 330544}, - {330546, 330547}, {330549, 330553}, {330556, 330564}, - {330567, 330568}, {330571, 330573}, {330581, 330583}, - {330588, 330589}, {330591, 330595}, {330598, 330607}, - {330609, 330609}, {330626, 330627}, {330629, 330634}, - {330638, 330640}, {330642, 330645}, {330649, 330650}, - {330652, 330652}, {330654, 330655}, {330659, 330660}, - {330664, 330666}, {330670, 330681}, {330686, 330690}, - {330694, 330696}, {330698, 330701}, {330704, 330704}, - {330711, 330711}, {330726, 330735}, {330752, 330764}, - {330766, 330768}, {330770, 330792}, {330794, 330809}, - {330812, 330820}, {330822, 330824}, {330826, 330829}, - {330837, 330838}, {330840, 330842}, {330845, 330845}, - {330848, 330851}, {330854, 330863}, {330880, 330883}, - {330885, 330892}, {330894, 330896}, {330898, 330920}, - {330922, 330931}, {330933, 330937}, {330940, 330948}, - {330950, 330952}, {330954, 330957}, {330965, 330966}, - {330973, 330974}, {330976, 330979}, {330982, 330991}, - {330993, 330995}, {331008, 331020}, {331022, 331024}, - {331026, 331076}, {331078, 331080}, {331082, 331086}, - {331092, 331095}, {331103, 331107}, {331110, 331119}, - {331130, 331135}, {331137, 331139}, {331141, 331158}, - {331162, 331185}, {331187, 331195}, {331197, 331197}, - {331200, 331206}, {331210, 331210}, {331215, 331220}, - {331222, 331222}, {331224, 331231}, {331238, 331247}, - {331250, 331251}, {331265, 331322}, {331328, 331342}, - {331344, 331353}, {331393, 331394}, {331396, 331396}, - {331398, 331402}, {331404, 331427}, {331429, 331429}, - {331431, 331453}, {331456, 331460}, {331462, 331462}, - {331464, 331470}, {331472, 331481}, {331484, 331487}, - {331520, 331520}, {331544, 331545}, {331552, 331561}, - {331573, 331573}, {331575, 331575}, {331577, 331577}, - {331582, 331591}, {331593, 331628}, {331633, 331652}, - {331654, 331671}, {331673, 331708}, {331718, 331718}, - {331776, 331849}, {331856, 331933}, {331936, 331973}, - {331975, 331975}, {331981, 331981}, {331984, 332026}, - {332028, 332360}, {332362, 332365}, {332368, 332374}, - {332376, 332376}, {332378, 332381}, {332384, 332424}, - {332426, 332429}, {332432, 332464}, {332466, 332469}, - {332472, 332478}, {332480, 332480}, {332482, 332485}, - {332488, 332502}, {332504, 332560}, {332562, 332565}, - {332568, 332634}, {332637, 332639}, {332649, 332657}, - {332672, 332687}, {332704, 332789}, {332792, 332797}, - {332801, 333420}, {333423, 333439}, {333441, 333466}, - {333472, 333546}, {333550, 333560}, {333568, 333589}, - {333599, 333620}, {333632, 333651}, {333664, 333676}, - {333678, 333680}, {333682, 333683}, {333696, 333779}, - {333783, 333783}, {333788, 333789}, {333792, 333801}, - {333835, 333837}, {333839, 333849}, {333856, 333944}, - {333952, 333994}, {334000, 334069}, {334080, 334110}, - {334112, 334123}, {334128, 334139}, {334150, 334189}, - {334192, 334196}, {334208, 334251}, {334256, 334281}, - {334288, 334298}, {334336, 334363}, {334368, 334430}, - {334432, 334460}, {334463, 334473}, {334480, 334489}, - {334503, 334503}, {334512, 334525}, {334527, 334542}, - {334592, 334668}, {334672, 334681}, {334699, 334707}, - {334720, 334835}, {334848, 334903}, {334912, 334921}, - {334925, 334973}, {334976, 334984}, {334992, 335034}, - {335037, 335039}, {335056, 335058}, {335060, 335098}, - {335104, 335637}, {335640, 335645}, {335648, 335685}, - {335688, 335693}, {335696, 335703}, {335705, 335705}, - {335707, 335707}, {335709, 335709}, {335711, 335741}, - {335744, 335796}, {335798, 335804}, {335806, 335806}, - {335810, 335812}, {335814, 335820}, {335824, 335827}, - {335830, 335835}, {335840, 335852}, {335858, 335860}, - {335862, 335868}, {335884, 335885}, {335935, 335936}, - {335956, 335956}, {335985, 335985}, {335999, 335999}, - {336016, 336028}, {336080, 336092}, {336097, 336097}, - {336101, 336112}, {336130, 336130}, {336135, 336135}, - {336138, 336147}, {336149, 336149}, {336152, 336157}, - {336164, 336164}, {336166, 336166}, {336168, 336168}, - {336170, 336185}, {336188, 336191}, {336197, 336201}, - {336206, 336206}, {336224, 336264}, {338944, 339172}, - {339179, 339187}, {339200, 339237}, {339239, 339239}, - {339245, 339245}, {339248, 339303}, {339311, 339311}, - {339327, 339350}, {339360, 339366}, {339368, 339374}, - {339376, 339382}, {339384, 339390}, {339392, 339398}, - {339400, 339406}, {339408, 339414}, {339416, 339422}, - {339424, 339455}, {339973, 339975}, {340001, 340015}, - {340017, 340021}, {340024, 340028}, {340033, 340118}, - {340121, 340127}, {340129, 340218}, {340220, 340223}, - {340229, 340271}, {340273, 340366}, {340384, 340415}, - {340464, 340479}, {340992, 347583}, {347648, 369804}, - {369872, 369917}, {369920, 370188}, {370192, 370219}, - {370240, 370287}, {370292, 370301}, {370303, 370417}, - {370455, 370463}, {370466, 370568}, {370571, 370634}, - {370640, 370641}, {370643, 370643}, {370645, 370649}, - {370674, 370727}, {370732, 370732}, {370752, 370803}, - {370816, 370885}, {370896, 370905}, {370912, 370935}, - {370939, 370939}, {370941, 370989}, {370992, 371027}, - {371040, 371068}, {371072, 371136}, {371151, 371161}, - {371168, 371198}, {371200, 371254}, {371264, 371277}, - {371280, 371289}, {371296, 371318}, {371322, 371394}, - {371419, 371421}, {371424, 371439}, {371442, 371446}, - {371457, 371462}, {371465, 371470}, {371473, 371478}, - {371488, 371494}, {371496, 371502}, {371504, 371546}, - {371548, 371561}, {371568, 371690}, {371692, 371693}, - {371696, 371705}, {371712, 382883}, {382896, 382918}, - {382923, 382971}, {391424, 391789}, {391792, 391897}, - {391936, 391942}, {391955, 391959}, {391965, 391976}, - {391978, 391990}, {391992, 391996}, {391998, 391998}, - {392000, 392001}, {392003, 392004}, {392006, 392113}, - {392147, 392509}, {392528, 392591}, {392594, 392647}, - {392688, 392699}, {392704, 392719}, {392736, 392751}, - {392755, 392756}, {392781, 392783}, {392816, 392820}, - {392822, 392956}, {392976, 392985}, {392993, 393018}, - {393023, 393023}, {393025, 393050}, {393062, 393150}, - {393154, 393159}, {393162, 393167}, {393170, 393175}, - {393178, 393180}, {393252, 393252}, {393264, 393273}, - {393281, 393306}, {393311, 393311}, {393313, 393338}, - {393386, 393386}, {393397, 393397}, {393399, 393399}, - {393402, 393402}, {393408, 393430}, {393432, 393462}, - {393464, 393921}, {393926, 393937}, {393952, 393956}, - {393964, 393964}, {393966, 393966}, {393984, 394100}, - {394102, 394103}, {394106, 394109}, {394111, 394111}, - {394118, 394122}, {394124, 394124}, {394126, 394145}, - {394147, 394229}, {394231, 394369}, {394371, 394375}, - {394378, 394543}, {394545, 394582}, {394585, 394585}, - {394592, 394632}, {394641, 394685}, {394687, 394687}, - {394689, 394690}, {394692, 394693}, {394695, 394695}, - {394704, 394730}, {394735, 394738}, {394768, 394778}, - {394784, 394857}, {394862, 394963}, {394965, 394972}, - {394975, 394984}, {394986, 395004}, {395007, 395007}, - {395024, 395082}, {395085, 395185}, {395200, 395253}, - {395258, 395258}, {395261, 395261}, {395264, 395309}, - {395328, 395355}, {395360, 395370}, {395376, 395399}, - {395401, 395406}, {395416, 395489}, {395491, 395619}, - {395622, 395631}, {395633, 395651}, {395653, 395660}, - {395663, 395664}, {395667, 395688}, {395690, 395696}, - {395698, 395698}, {395702, 395705}, {395708, 395716}, - {395719, 395720}, {395723, 395726}, {395735, 395735}, - {395740, 395741}, {395743, 395747}, {395750, 395761}, - {395772, 395772}, {395774, 395774}, {395777, 395779}, - {395781, 395786}, {395791, 395792}, {395795, 395816}, - {395818, 395824}, {395826, 395827}, {395829, 395830}, - {395832, 395833}, {395836, 395836}, {395838, 395842}, - {395847, 395848}, {395851, 395853}, {395857, 395857}, - {395865, 395868}, {395870, 395870}, {395878, 395893}, - {395905, 395907}, {395909, 395917}, {395919, 395921}, - {395923, 395944}, {395946, 395952}, {395954, 395955}, - {395957, 395961}, {395964, 395973}, {395975, 395977}, - {395979, 395981}, {395984, 395984}, {396000, 396003}, - {396006, 396015}, {396025, 396031}, {396033, 396035}, - {396037, 396044}, {396047, 396048}, {396051, 396072}, - {396074, 396080}, {396082, 396083}, {396085, 396089}, - {396092, 396100}, {396103, 396104}, {396107, 396109}, - {396117, 396119}, {396124, 396125}, {396127, 396131}, - {396134, 396143}, {396145, 396145}, {396162, 396163}, - {396165, 396170}, {396174, 396176}, {396178, 396181}, - {396185, 396186}, {396188, 396188}, {396190, 396191}, - {396195, 396196}, {396200, 396202}, {396206, 396217}, - {396222, 396226}, {396230, 396232}, {396234, 396237}, - {396240, 396240}, {396247, 396247}, {396262, 396271}, - {396288, 396300}, {396302, 396304}, {396306, 396328}, - {396330, 396345}, {396348, 396356}, {396358, 396360}, - {396362, 396365}, {396373, 396374}, {396376, 396378}, - {396381, 396381}, {396384, 396387}, {396390, 396399}, - {396416, 396419}, {396421, 396428}, {396430, 396432}, - {396434, 396456}, {396458, 396467}, {396469, 396473}, - {396476, 396484}, {396486, 396488}, {396490, 396493}, - {396501, 396502}, {396509, 396510}, {396512, 396515}, - {396518, 396527}, {396529, 396531}, {396544, 396556}, - {396558, 396560}, {396562, 396612}, {396614, 396616}, - {396618, 396622}, {396628, 396631}, {396639, 396643}, - {396646, 396655}, {396666, 396671}, {396673, 396675}, - {396677, 396694}, {396698, 396721}, {396723, 396731}, - {396733, 396733}, {396736, 396742}, {396746, 396746}, - {396751, 396756}, {396758, 396758}, {396760, 396767}, - {396774, 396783}, {396786, 396787}, {396801, 396858}, - {396864, 396878}, {396880, 396889}, {396929, 396930}, - {396932, 396932}, {396934, 396938}, {396940, 396963}, - {396965, 396965}, {396967, 396989}, {396992, 396996}, - {396998, 396998}, {397000, 397006}, {397008, 397017}, - {397020, 397023}, {397056, 397056}, {397080, 397081}, - {397088, 397097}, {397109, 397109}, {397111, 397111}, - {397113, 397113}, {397118, 397127}, {397129, 397164}, - {397169, 397188}, {397190, 397207}, {397209, 397244}, - {397254, 397254}, {397312, 397385}, {397392, 397469}, - {397472, 397509}, {397511, 397511}, {397517, 397517}, - {397520, 397562}, {397564, 397896}, {397898, 397901}, - {397904, 397910}, {397912, 397912}, {397914, 397917}, - {397920, 397960}, {397962, 397965}, {397968, 398000}, - {398002, 398005}, {398008, 398014}, {398016, 398016}, - {398018, 398021}, {398024, 398038}, {398040, 398096}, - {398098, 398101}, {398104, 398170}, {398173, 398175}, - {398185, 398193}, {398208, 398223}, {398240, 398325}, - {398328, 398333}, {398337, 398956}, {398959, 398975}, - {398977, 399002}, {399008, 399082}, {399086, 399096}, - {399104, 399125}, {399135, 399156}, {399168, 399187}, - {399200, 399212}, {399214, 399216}, {399218, 399219}, - {399232, 399315}, {399319, 399319}, {399324, 399325}, - {399328, 399337}, {399371, 399373}, {399375, 399385}, - {399392, 399480}, {399488, 399530}, {399536, 399605}, - {399616, 399646}, {399648, 399659}, {399664, 399675}, - {399686, 399725}, {399728, 399732}, {399744, 399787}, - {399792, 399817}, {399824, 399834}, {399872, 399899}, - {399904, 399966}, {399968, 399996}, {399999, 400009}, - {400016, 400025}, {400039, 400039}, {400048, 400061}, - {400063, 400078}, {400128, 400204}, {400208, 400217}, - {400235, 400243}, {400256, 400371}, {400384, 400439}, - {400448, 400457}, {400461, 400509}, {400512, 400520}, - {400528, 400570}, {400573, 400575}, {400592, 400594}, - {400596, 400634}, {400640, 401173}, {401176, 401181}, - {401184, 401221}, {401224, 401229}, {401232, 401239}, - {401241, 401241}, {401243, 401243}, {401245, 401245}, - {401247, 401277}, {401280, 401332}, {401334, 401340}, - {401342, 401342}, {401346, 401348}, {401350, 401356}, - {401360, 401363}, {401366, 401371}, {401376, 401388}, - {401394, 401396}, {401398, 401404}, {401420, 401421}, - {401471, 401472}, {401492, 401492}, {401521, 401521}, - {401535, 401535}, {401552, 401564}, {401616, 401628}, - {401633, 401633}, {401637, 401648}, {401666, 401666}, - {401671, 401671}, {401674, 401683}, {401685, 401685}, - {401688, 401693}, {401700, 401700}, {401702, 401702}, - {401704, 401704}, {401706, 401721}, {401724, 401727}, - {401733, 401737}, {401742, 401742}, {401760, 401800}, - {404480, 404708}, {404715, 404723}, {404736, 404773}, - {404775, 404775}, {404781, 404781}, {404784, 404839}, - {404847, 404847}, {404863, 404886}, {404896, 404902}, - {404904, 404910}, {404912, 404918}, {404920, 404926}, - {404928, 404934}, {404936, 404942}, {404944, 404950}, - {404952, 404958}, {404960, 404991}, {405509, 405511}, - {405537, 405551}, {405553, 405557}, {405560, 405564}, - {405569, 405654}, {405657, 405663}, {405665, 405754}, - {405756, 405759}, {405765, 405807}, {405809, 405902}, - {405920, 405951}, {406000, 406015}, {406528, 413119}, - {413184, 435340}, {435408, 435453}, {435456, 435724}, - {435728, 435755}, {435776, 435823}, {435828, 435837}, - {435839, 435953}, {435991, 435999}, {436002, 436104}, - {436107, 436170}, {436176, 436177}, {436179, 436179}, - {436181, 436185}, {436210, 436263}, {436268, 436268}, - {436288, 436339}, {436352, 436421}, {436432, 436441}, - {436448, 436471}, {436475, 436475}, {436477, 436525}, - {436528, 436563}, {436576, 436604}, {436608, 436672}, - {436687, 436697}, {436704, 436734}, {436736, 436790}, - {436800, 436813}, {436816, 436825}, {436832, 436854}, - {436858, 436930}, {436955, 436957}, {436960, 436975}, - {436978, 436982}, {436993, 436998}, {437001, 437006}, - {437009, 437014}, {437024, 437030}, {437032, 437038}, - {437040, 437082}, {437084, 437097}, {437104, 437226}, - {437228, 437229}, {437232, 437241}, {437248, 448419}, - {448432, 448454}, {448459, 448507}, {456960, 457325}, - {457328, 457433}, {457472, 457478}, {457491, 457495}, - {457501, 457512}, {457514, 457526}, {457528, 457532}, - {457534, 457534}, {457536, 457537}, {457539, 457540}, - {457542, 457649}, {457683, 458045}, {458064, 458127}, - {458130, 458183}, {458224, 458235}, {458240, 458255}, - {458272, 458287}, {458291, 458292}, {458317, 458319}, - {458352, 458356}, {458358, 458492}, {458512, 458521}, - {458529, 458554}, {458559, 458559}, {458561, 458586}, - {458598, 458686}, {458690, 458695}, {458698, 458703}, - {458706, 458711}, {458714, 458716}, {458788, 458788}, - {458800, 458809}, {458817, 458842}, {458847, 458847}, - {458849, 458874}, {458922, 458922}, {458933, 458933}, - {458935, 458935}, {458938, 458938}, {458944, 458966}, - {458968, 458998}, {459000, 459457}, {459462, 459473}, - {459488, 459492}, {459500, 459500}, {459502, 459502}, - {459520, 459636}, {459638, 459639}, {459642, 459645}, - {459647, 459647}, {459654, 459658}, {459660, 459660}, - {459662, 459681}, {459683, 459765}, {459767, 459905}, - {459907, 459911}, {459914, 460079}, {460081, 460118}, - {460121, 460121}, {460128, 460168}, {460177, 460221}, - {460223, 460223}, {460225, 460226}, {460228, 460229}, - {460231, 460231}, {460240, 460266}, {460271, 460274}, - {460304, 460314}, {460320, 460393}, {460398, 460499}, - {460501, 460508}, {460511, 460520}, {460522, 460540}, - {460543, 460543}, {460560, 460618}, {460621, 460721}, - {460736, 460789}, {460794, 460794}, {460797, 460797}, - {460800, 460845}, {460864, 460891}, {460896, 460906}, - {460912, 460935}, {460937, 460942}, {460952, 461025}, - {461027, 461155}, {461158, 461167}, {461169, 461187}, - {461189, 461196}, {461199, 461200}, {461203, 461224}, - {461226, 461232}, {461234, 461234}, {461238, 461241}, - {461244, 461252}, {461255, 461256}, {461259, 461262}, - {461271, 461271}, {461276, 461277}, {461279, 461283}, - {461286, 461297}, {461308, 461308}, {461310, 461310}, - {461313, 461315}, {461317, 461322}, {461327, 461328}, - {461331, 461352}, {461354, 461360}, {461362, 461363}, - {461365, 461366}, {461368, 461369}, {461372, 461372}, - {461374, 461378}, {461383, 461384}, {461387, 461389}, - {461393, 461393}, {461401, 461404}, {461406, 461406}, - {461414, 461429}, {461441, 461443}, {461445, 461453}, - {461455, 461457}, {461459, 461480}, {461482, 461488}, - {461490, 461491}, {461493, 461497}, {461500, 461509}, - {461511, 461513}, {461515, 461517}, {461520, 461520}, - {461536, 461539}, {461542, 461551}, {461561, 461567}, - {461569, 461571}, {461573, 461580}, {461583, 461584}, - {461587, 461608}, {461610, 461616}, {461618, 461619}, - {461621, 461625}, {461628, 461636}, {461639, 461640}, - {461643, 461645}, {461653, 461655}, {461660, 461661}, - {461663, 461667}, {461670, 461679}, {461681, 461681}, - {461698, 461699}, {461701, 461706}, {461710, 461712}, - {461714, 461717}, {461721, 461722}, {461724, 461724}, - {461726, 461727}, {461731, 461732}, {461736, 461738}, - {461742, 461753}, {461758, 461762}, {461766, 461768}, - {461770, 461773}, {461776, 461776}, {461783, 461783}, - {461798, 461807}, {461824, 461836}, {461838, 461840}, - {461842, 461864}, {461866, 461881}, {461884, 461892}, - {461894, 461896}, {461898, 461901}, {461909, 461910}, - {461912, 461914}, {461917, 461917}, {461920, 461923}, - {461926, 461935}, {461952, 461955}, {461957, 461964}, - {461966, 461968}, {461970, 461992}, {461994, 462003}, - {462005, 462009}, {462012, 462020}, {462022, 462024}, - {462026, 462029}, {462037, 462038}, {462045, 462046}, - {462048, 462051}, {462054, 462063}, {462065, 462067}, - {462080, 462092}, {462094, 462096}, {462098, 462148}, - {462150, 462152}, {462154, 462158}, {462164, 462167}, - {462175, 462179}, {462182, 462191}, {462202, 462207}, - {462209, 462211}, {462213, 462230}, {462234, 462257}, - {462259, 462267}, {462269, 462269}, {462272, 462278}, - {462282, 462282}, {462287, 462292}, {462294, 462294}, - {462296, 462303}, {462310, 462319}, {462322, 462323}, - {462337, 462394}, {462400, 462414}, {462416, 462425}, - {462465, 462466}, {462468, 462468}, {462470, 462474}, - {462476, 462499}, {462501, 462501}, {462503, 462525}, - {462528, 462532}, {462534, 462534}, {462536, 462542}, - {462544, 462553}, {462556, 462559}, {462592, 462592}, - {462616, 462617}, {462624, 462633}, {462645, 462645}, - {462647, 462647}, {462649, 462649}, {462654, 462663}, - {462665, 462700}, {462705, 462724}, {462726, 462743}, - {462745, 462780}, {462790, 462790}, {462848, 462921}, - {462928, 463005}, {463008, 463045}, {463047, 463047}, - {463053, 463053}, {463056, 463098}, {463100, 463432}, - {463434, 463437}, {463440, 463446}, {463448, 463448}, - {463450, 463453}, {463456, 463496}, {463498, 463501}, - {463504, 463536}, {463538, 463541}, {463544, 463550}, - {463552, 463552}, {463554, 463557}, {463560, 463574}, - {463576, 463632}, {463634, 463637}, {463640, 463706}, - {463709, 463711}, {463721, 463729}, {463744, 463759}, - {463776, 463861}, {463864, 463869}, {463873, 464492}, - {464495, 464511}, {464513, 464538}, {464544, 464618}, - {464622, 464632}, {464640, 464661}, {464671, 464692}, - {464704, 464723}, {464736, 464748}, {464750, 464752}, - {464754, 464755}, {464768, 464851}, {464855, 464855}, - {464860, 464861}, {464864, 464873}, {464907, 464909}, - {464911, 464921}, {464928, 465016}, {465024, 465066}, - {465072, 465141}, {465152, 465182}, {465184, 465195}, - {465200, 465211}, {465222, 465261}, {465264, 465268}, - {465280, 465323}, {465328, 465353}, {465360, 465370}, - {465408, 465435}, {465440, 465502}, {465504, 465532}, - {465535, 465545}, {465552, 465561}, {465575, 465575}, - {465584, 465597}, {465599, 465614}, {465664, 465740}, - {465744, 465753}, {465771, 465779}, {465792, 465907}, - {465920, 465975}, {465984, 465993}, {465997, 466045}, - {466048, 466056}, {466064, 466106}, {466109, 466111}, - {466128, 466130}, {466132, 466170}, {466176, 466709}, - {466712, 466717}, {466720, 466757}, {466760, 466765}, - {466768, 466775}, {466777, 466777}, {466779, 466779}, - {466781, 466781}, {466783, 466813}, {466816, 466868}, - {466870, 466876}, {466878, 466878}, {466882, 466884}, - {466886, 466892}, {466896, 466899}, {466902, 466907}, - {466912, 466924}, {466930, 466932}, {466934, 466940}, - {466956, 466957}, {467007, 467008}, {467028, 467028}, - {467057, 467057}, {467071, 467071}, {467088, 467100}, - {467152, 467164}, {467169, 467169}, {467173, 467184}, - {467202, 467202}, {467207, 467207}, {467210, 467219}, - {467221, 467221}, {467224, 467229}, {467236, 467236}, - {467238, 467238}, {467240, 467240}, {467242, 467257}, - {467260, 467263}, {467269, 467273}, {467278, 467278}, - {467296, 467336}, {470016, 470244}, {470251, 470259}, - {470272, 470309}, {470311, 470311}, {470317, 470317}, - {470320, 470375}, {470383, 470383}, {470399, 470422}, - {470432, 470438}, {470440, 470446}, {470448, 470454}, - {470456, 470462}, {470464, 470470}, {470472, 470478}, - {470480, 470486}, {470488, 470494}, {470496, 470527}, - {471045, 471047}, {471073, 471087}, {471089, 471093}, - {471096, 471100}, {471105, 471190}, {471193, 471199}, - {471201, 471290}, {471292, 471295}, {471301, 471343}, - {471345, 471438}, {471456, 471487}, {471536, 471551}, - {472064, 478655}, {478720, 500876}, {500944, 500989}, - {500992, 501260}, {501264, 501291}, {501312, 501359}, - {501364, 501373}, {501375, 501489}, {501527, 501535}, - {501538, 501640}, {501643, 501706}, {501712, 501713}, - {501715, 501715}, {501717, 501721}, {501746, 501799}, - {501804, 501804}, {501824, 501875}, {501888, 501957}, - {501968, 501977}, {501984, 502007}, {502011, 502011}, - {502013, 502061}, {502064, 502099}, {502112, 502140}, - {502144, 502208}, {502223, 502233}, {502240, 502270}, - {502272, 502326}, {502336, 502349}, {502352, 502361}, - {502368, 502390}, {502394, 502466}, {502491, 502493}, - {502496, 502511}, {502514, 502518}, {502529, 502534}, - {502537, 502542}, {502545, 502550}, {502560, 502566}, - {502568, 502574}, {502576, 502618}, {502620, 502633}, - {502640, 502762}, {502764, 502765}, {502768, 502777}, - {502784, 513955}, {513968, 513990}, {513995, 514043}, - {522496, 522861}, {522864, 522969}, {523008, 523014}, - {523027, 523031}, {523037, 523048}, {523050, 523062}, - {523064, 523068}, {523070, 523070}, {523072, 523073}, - {523075, 523076}, {523078, 523185}, {523219, 523581}, - {523600, 523663}, {523666, 523719}, {523760, 523771}, - {523776, 523791}, {523808, 523823}, {523827, 523828}, - {523853, 523855}, {523888, 523892}, {523894, 524028}, - {524048, 524057}, {524065, 524090}, {524095, 524095}, - {524097, 524122}, {524134, 524222}, {524226, 524231}, - {524234, 524239}, {524242, 524247}, {524250, 524252}, - {524324, 524324}, {524336, 524345}, {524353, 524378}, - {524383, 524383}, {524385, 524410}, {524458, 524458}, - {524469, 524469}, {524471, 524471}, {524474, 524474}, - {524480, 524502}, {524504, 524534}, {524536, 524993}, - {524998, 525009}, {525024, 525028}, {525036, 525036}, - {525038, 525038}, {525056, 525172}, {525174, 525175}, - {525178, 525181}, {525183, 525183}, {525190, 525194}, - {525196, 525196}, {525198, 525217}, {525219, 525301}, - {525303, 525441}, {525443, 525447}, {525450, 525615}, - {525617, 525654}, {525657, 525657}, {525664, 525704}, - {525713, 525757}, {525759, 525759}, {525761, 525762}, - {525764, 525765}, {525767, 525767}, {525776, 525802}, - {525807, 525810}, {525840, 525850}, {525856, 525929}, - {525934, 526035}, {526037, 526044}, {526047, 526056}, - {526058, 526076}, {526079, 526079}, {526096, 526154}, - {526157, 526257}, {526272, 526325}, {526330, 526330}, - {526333, 526333}, {526336, 526381}, {526400, 526427}, - {526432, 526442}, {526448, 526471}, {526473, 526478}, - {526488, 526561}, {526563, 526691}, {526694, 526703}, - {526705, 526723}, {526725, 526732}, {526735, 526736}, - {526739, 526760}, {526762, 526768}, {526770, 526770}, - {526774, 526777}, {526780, 526788}, {526791, 526792}, - {526795, 526798}, {526807, 526807}, {526812, 526813}, - {526815, 526819}, {526822, 526833}, {526844, 526844}, - {526846, 526846}, {526849, 526851}, {526853, 526858}, - {526863, 526864}, {526867, 526888}, {526890, 526896}, - {526898, 526899}, {526901, 526902}, {526904, 526905}, - {526908, 526908}, {526910, 526914}, {526919, 526920}, - {526923, 526925}, {526929, 526929}, {526937, 526940}, - {526942, 526942}, {526950, 526965}, {526977, 526979}, - {526981, 526989}, {526991, 526993}, {526995, 527016}, - {527018, 527024}, {527026, 527027}, {527029, 527033}, - {527036, 527045}, {527047, 527049}, {527051, 527053}, - {527056, 527056}, {527072, 527075}, {527078, 527087}, - {527097, 527103}, {527105, 527107}, {527109, 527116}, - {527119, 527120}, {527123, 527144}, {527146, 527152}, - {527154, 527155}, {527157, 527161}, {527164, 527172}, - {527175, 527176}, {527179, 527181}, {527189, 527191}, - {527196, 527197}, {527199, 527203}, {527206, 527215}, - {527217, 527217}, {527234, 527235}, {527237, 527242}, - {527246, 527248}, {527250, 527253}, {527257, 527258}, - {527260, 527260}, {527262, 527263}, {527267, 527268}, - {527272, 527274}, {527278, 527289}, {527294, 527298}, - {527302, 527304}, {527306, 527309}, {527312, 527312}, - {527319, 527319}, {527334, 527343}, {527360, 527372}, - {527374, 527376}, {527378, 527400}, {527402, 527417}, - {527420, 527428}, {527430, 527432}, {527434, 527437}, - {527445, 527446}, {527448, 527450}, {527453, 527453}, - {527456, 527459}, {527462, 527471}, {527488, 527491}, - {527493, 527500}, {527502, 527504}, {527506, 527528}, - {527530, 527539}, {527541, 527545}, {527548, 527556}, - {527558, 527560}, {527562, 527565}, {527573, 527574}, - {527581, 527582}, {527584, 527587}, {527590, 527599}, - {527601, 527603}, {527616, 527628}, {527630, 527632}, - {527634, 527684}, {527686, 527688}, {527690, 527694}, - {527700, 527703}, {527711, 527715}, {527718, 527727}, - {527738, 527743}, {527745, 527747}, {527749, 527766}, - {527770, 527793}, {527795, 527803}, {527805, 527805}, - {527808, 527814}, {527818, 527818}, {527823, 527828}, - {527830, 527830}, {527832, 527839}, {527846, 527855}, - {527858, 527859}, {527873, 527930}, {527936, 527950}, - {527952, 527961}, {528001, 528002}, {528004, 528004}, - {528006, 528010}, {528012, 528035}, {528037, 528037}, - {528039, 528061}, {528064, 528068}, {528070, 528070}, - {528072, 528078}, {528080, 528089}, {528092, 528095}, - {528128, 528128}, {528152, 528153}, {528160, 528169}, - {528181, 528181}, {528183, 528183}, {528185, 528185}, - {528190, 528199}, {528201, 528236}, {528241, 528260}, - {528262, 528279}, {528281, 528316}, {528326, 528326}, - {528384, 528457}, {528464, 528541}, {528544, 528581}, - {528583, 528583}, {528589, 528589}, {528592, 528634}, - {528636, 528968}, {528970, 528973}, {528976, 528982}, - {528984, 528984}, {528986, 528989}, {528992, 529032}, - {529034, 529037}, {529040, 529072}, {529074, 529077}, - {529080, 529086}, {529088, 529088}, {529090, 529093}, - {529096, 529110}, {529112, 529168}, {529170, 529173}, - {529176, 529242}, {529245, 529247}, {529257, 529265}, - {529280, 529295}, {529312, 529397}, {529400, 529405}, - {529409, 530028}, {530031, 530047}, {530049, 530074}, - {530080, 530154}, {530158, 530168}, {530176, 530197}, - {530207, 530228}, {530240, 530259}, {530272, 530284}, - {530286, 530288}, {530290, 530291}, {530304, 530387}, - {530391, 530391}, {530396, 530397}, {530400, 530409}, - {530443, 530445}, {530447, 530457}, {530464, 530552}, - {530560, 530602}, {530608, 530677}, {530688, 530718}, - {530720, 530731}, {530736, 530747}, {530758, 530797}, - {530800, 530804}, {530816, 530859}, {530864, 530889}, - {530896, 530906}, {530944, 530971}, {530976, 531038}, - {531040, 531068}, {531071, 531081}, {531088, 531097}, - {531111, 531111}, {531120, 531133}, {531135, 531150}, - {531200, 531276}, {531280, 531289}, {531307, 531315}, - {531328, 531443}, {531456, 531511}, {531520, 531529}, - {531533, 531581}, {531584, 531592}, {531600, 531642}, - {531645, 531647}, {531664, 531666}, {531668, 531706}, - {531712, 532245}, {532248, 532253}, {532256, 532293}, - {532296, 532301}, {532304, 532311}, {532313, 532313}, - {532315, 532315}, {532317, 532317}, {532319, 532349}, - {532352, 532404}, {532406, 532412}, {532414, 532414}, - {532418, 532420}, {532422, 532428}, {532432, 532435}, - {532438, 532443}, {532448, 532460}, {532466, 532468}, - {532470, 532476}, {532492, 532493}, {532543, 532544}, - {532564, 532564}, {532593, 532593}, {532607, 532607}, - {532624, 532636}, {532688, 532700}, {532705, 532705}, - {532709, 532720}, {532738, 532738}, {532743, 532743}, - {532746, 532755}, {532757, 532757}, {532760, 532765}, - {532772, 532772}, {532774, 532774}, {532776, 532776}, - {532778, 532793}, {532796, 532799}, {532805, 532809}, - {532814, 532814}, {532832, 532872}, {535552, 535780}, - {535787, 535795}, {535808, 535845}, {535847, 535847}, - {535853, 535853}, {535856, 535911}, {535919, 535919}, - {535935, 535958}, {535968, 535974}, {535976, 535982}, - {535984, 535990}, {535992, 535998}, {536000, 536006}, - {536008, 536014}, {536016, 536022}, {536024, 536030}, - {536032, 536063}, {536581, 536583}, {536609, 536623}, - {536625, 536629}, {536632, 536636}, {536641, 536726}, - {536729, 536735}, {536737, 536826}, {536828, 536831}, - {536837, 536879}, {536881, 536974}, {536992, 537023}, - {537072, 537087}, {537600, 544191}, {544256, 566412}, - {566480, 566525}, {566528, 566796}, {566800, 566827}, - {566848, 566895}, {566900, 566909}, {566911, 567025}, - {567063, 567071}, {567074, 567176}, {567179, 567242}, - {567248, 567249}, {567251, 567251}, {567253, 567257}, - {567282, 567335}, {567340, 567340}, {567360, 567411}, - {567424, 567493}, {567504, 567513}, {567520, 567543}, - {567547, 567547}, {567549, 567597}, {567600, 567635}, - {567648, 567676}, {567680, 567744}, {567759, 567769}, - {567776, 567806}, {567808, 567862}, {567872, 567885}, - {567888, 567897}, {567904, 567926}, {567930, 568002}, - {568027, 568029}, {568032, 568047}, {568050, 568054}, - {568065, 568070}, {568073, 568078}, {568081, 568086}, - {568096, 568102}, {568104, 568110}, {568112, 568154}, - {568156, 568169}, {568176, 568298}, {568300, 568301}, - {568304, 568313}, {568320, 579491}, {579504, 579526}, - {579531, 579579}, {588032, 588397}, {588400, 588505}, - {588544, 588550}, {588563, 588567}, {588573, 588584}, - {588586, 588598}, {588600, 588604}, {588606, 588606}, - {588608, 588609}, {588611, 588612}, {588614, 588721}, - {588755, 589117}, {589136, 589199}, {589202, 589255}, - {589296, 589307}, {589312, 589327}, {589344, 589359}, - {589363, 589364}, {589389, 589391}, {589424, 589428}, - {589430, 589564}, {589584, 589593}, {589601, 589626}, - {589631, 589631}, {589633, 589658}, {589670, 589758}, - {589762, 589767}, {589770, 589775}, {589778, 589783}, - {589786, 589788}, {589860, 589860}, {589872, 589881}, - {589889, 589914}, {589919, 589919}, {589921, 589946}, - {589994, 589994}, {590005, 590005}, {590007, 590007}, - {590010, 590010}, {590016, 590038}, {590040, 590070}, - {590072, 590529}, {590534, 590545}, {590560, 590564}, - {590572, 590572}, {590574, 590574}, {590592, 590708}, - {590710, 590711}, {590714, 590717}, {590719, 590719}, - {590726, 590730}, {590732, 590732}, {590734, 590753}, - {590755, 590837}, {590839, 590977}, {590979, 590983}, - {590986, 591151}, {591153, 591190}, {591193, 591193}, - {591200, 591240}, {591249, 591293}, {591295, 591295}, - {591297, 591298}, {591300, 591301}, {591303, 591303}, - {591312, 591338}, {591343, 591346}, {591376, 591386}, - {591392, 591465}, {591470, 591571}, {591573, 591580}, - {591583, 591592}, {591594, 591612}, {591615, 591615}, - {591632, 591690}, {591693, 591793}, {591808, 591861}, - {591866, 591866}, {591869, 591869}, {591872, 591917}, - {591936, 591963}, {591968, 591978}, {591984, 592007}, - {592009, 592014}, {592024, 592097}, {592099, 592227}, - {592230, 592239}, {592241, 592259}, {592261, 592268}, - {592271, 592272}, {592275, 592296}, {592298, 592304}, - {592306, 592306}, {592310, 592313}, {592316, 592324}, - {592327, 592328}, {592331, 592334}, {592343, 592343}, - {592348, 592349}, {592351, 592355}, {592358, 592369}, - {592380, 592380}, {592382, 592382}, {592385, 592387}, - {592389, 592394}, {592399, 592400}, {592403, 592424}, - {592426, 592432}, {592434, 592435}, {592437, 592438}, - {592440, 592441}, {592444, 592444}, {592446, 592450}, - {592455, 592456}, {592459, 592461}, {592465, 592465}, - {592473, 592476}, {592478, 592478}, {592486, 592501}, - {592513, 592515}, {592517, 592525}, {592527, 592529}, - {592531, 592552}, {592554, 592560}, {592562, 592563}, - {592565, 592569}, {592572, 592581}, {592583, 592585}, - {592587, 592589}, {592592, 592592}, {592608, 592611}, - {592614, 592623}, {592633, 592639}, {592641, 592643}, - {592645, 592652}, {592655, 592656}, {592659, 592680}, - {592682, 592688}, {592690, 592691}, {592693, 592697}, - {592700, 592708}, {592711, 592712}, {592715, 592717}, - {592725, 592727}, {592732, 592733}, {592735, 592739}, - {592742, 592751}, {592753, 592753}, {592770, 592771}, - {592773, 592778}, {592782, 592784}, {592786, 592789}, - {592793, 592794}, {592796, 592796}, {592798, 592799}, - {592803, 592804}, {592808, 592810}, {592814, 592825}, - {592830, 592834}, {592838, 592840}, {592842, 592845}, - {592848, 592848}, {592855, 592855}, {592870, 592879}, - {592896, 592908}, {592910, 592912}, {592914, 592936}, - {592938, 592953}, {592956, 592964}, {592966, 592968}, - {592970, 592973}, {592981, 592982}, {592984, 592986}, - {592989, 592989}, {592992, 592995}, {592998, 593007}, - {593024, 593027}, {593029, 593036}, {593038, 593040}, - {593042, 593064}, {593066, 593075}, {593077, 593081}, - {593084, 593092}, {593094, 593096}, {593098, 593101}, - {593109, 593110}, {593117, 593118}, {593120, 593123}, - {593126, 593135}, {593137, 593139}, {593152, 593164}, - {593166, 593168}, {593170, 593220}, {593222, 593224}, - {593226, 593230}, {593236, 593239}, {593247, 593251}, - {593254, 593263}, {593274, 593279}, {593281, 593283}, - {593285, 593302}, {593306, 593329}, {593331, 593339}, - {593341, 593341}, {593344, 593350}, {593354, 593354}, - {593359, 593364}, {593366, 593366}, {593368, 593375}, - {593382, 593391}, {593394, 593395}, {593409, 593466}, - {593472, 593486}, {593488, 593497}, {593537, 593538}, - {593540, 593540}, {593542, 593546}, {593548, 593571}, - {593573, 593573}, {593575, 593597}, {593600, 593604}, - {593606, 593606}, {593608, 593614}, {593616, 593625}, - {593628, 593631}, {593664, 593664}, {593688, 593689}, - {593696, 593705}, {593717, 593717}, {593719, 593719}, - {593721, 593721}, {593726, 593735}, {593737, 593772}, - {593777, 593796}, {593798, 593815}, {593817, 593852}, - {593862, 593862}, {593920, 593993}, {594000, 594077}, - {594080, 594117}, {594119, 594119}, {594125, 594125}, - {594128, 594170}, {594172, 594504}, {594506, 594509}, - {594512, 594518}, {594520, 594520}, {594522, 594525}, - {594528, 594568}, {594570, 594573}, {594576, 594608}, - {594610, 594613}, {594616, 594622}, {594624, 594624}, - {594626, 594629}, {594632, 594646}, {594648, 594704}, - {594706, 594709}, {594712, 594778}, {594781, 594783}, - {594793, 594801}, {594816, 594831}, {594848, 594933}, - {594936, 594941}, {594945, 595564}, {595567, 595583}, - {595585, 595610}, {595616, 595690}, {595694, 595704}, - {595712, 595733}, {595743, 595764}, {595776, 595795}, - {595808, 595820}, {595822, 595824}, {595826, 595827}, - {595840, 595923}, {595927, 595927}, {595932, 595933}, - {595936, 595945}, {595979, 595981}, {595983, 595993}, - {596000, 596088}, {596096, 596138}, {596144, 596213}, - {596224, 596254}, {596256, 596267}, {596272, 596283}, - {596294, 596333}, {596336, 596340}, {596352, 596395}, - {596400, 596425}, {596432, 596442}, {596480, 596507}, - {596512, 596574}, {596576, 596604}, {596607, 596617}, - {596624, 596633}, {596647, 596647}, {596656, 596669}, - {596671, 596686}, {596736, 596812}, {596816, 596825}, - {596843, 596851}, {596864, 596979}, {596992, 597047}, - {597056, 597065}, {597069, 597117}, {597120, 597128}, - {597136, 597178}, {597181, 597183}, {597200, 597202}, - {597204, 597242}, {597248, 597781}, {597784, 597789}, - {597792, 597829}, {597832, 597837}, {597840, 597847}, - {597849, 597849}, {597851, 597851}, {597853, 597853}, - {597855, 597885}, {597888, 597940}, {597942, 597948}, - {597950, 597950}, {597954, 597956}, {597958, 597964}, - {597968, 597971}, {597974, 597979}, {597984, 597996}, - {598002, 598004}, {598006, 598012}, {598028, 598029}, - {598079, 598080}, {598100, 598100}, {598129, 598129}, - {598143, 598143}, {598160, 598172}, {598224, 598236}, - {598241, 598241}, {598245, 598256}, {598274, 598274}, - {598279, 598279}, {598282, 598291}, {598293, 598293}, - {598296, 598301}, {598308, 598308}, {598310, 598310}, - {598312, 598312}, {598314, 598329}, {598332, 598335}, - {598341, 598345}, {598350, 598350}, {598368, 598408}, - {601088, 601316}, {601323, 601331}, {601344, 601381}, - {601383, 601383}, {601389, 601389}, {601392, 601447}, - {601455, 601455}, {601471, 601494}, {601504, 601510}, - {601512, 601518}, {601520, 601526}, {601528, 601534}, - {601536, 601542}, {601544, 601550}, {601552, 601558}, - {601560, 601566}, {601568, 601599}, {602117, 602119}, - {602145, 602159}, {602161, 602165}, {602168, 602172}, - {602177, 602262}, {602265, 602271}, {602273, 602362}, - {602364, 602367}, {602373, 602415}, {602417, 602510}, - {602528, 602559}, {602608, 602623}, {603136, 609727}, - {609792, 631948}, {632016, 632061}, {632064, 632332}, - {632336, 632363}, {632384, 632431}, {632436, 632445}, - {632447, 632561}, {632599, 632607}, {632610, 632712}, - {632715, 632778}, {632784, 632785}, {632787, 632787}, - {632789, 632793}, {632818, 632871}, {632876, 632876}, - {632896, 632947}, {632960, 633029}, {633040, 633049}, - {633056, 633079}, {633083, 633083}, {633085, 633133}, - {633136, 633171}, {633184, 633212}, {633216, 633280}, - {633295, 633305}, {633312, 633342}, {633344, 633398}, - {633408, 633421}, {633424, 633433}, {633440, 633462}, - {633466, 633538}, {633563, 633565}, {633568, 633583}, - {633586, 633590}, {633601, 633606}, {633609, 633614}, - {633617, 633622}, {633632, 633638}, {633640, 633646}, - {633648, 633690}, {633692, 633705}, {633712, 633834}, - {633836, 633837}, {633840, 633849}, {633856, 645027}, - {645040, 645062}, {645067, 645115}, {653568, 653933}, - {653936, 654041}, {654080, 654086}, {654099, 654103}, - {654109, 654120}, {654122, 654134}, {654136, 654140}, - {654142, 654142}, {654144, 654145}, {654147, 654148}, - {654150, 654257}, {654291, 654653}, {654672, 654735}, - {654738, 654791}, {654832, 654843}, {654848, 654863}, - {654880, 654895}, {654899, 654900}, {654925, 654927}, - {654960, 654964}, {654966, 655100}, {655120, 655129}, - {655137, 655162}, {655167, 655167}, {655169, 655194}, - {655206, 655294}, {655298, 655303}, {655306, 655311}, - {655314, 655319}, {655322, 655324}, {655396, 655396}, - {655408, 655417}, {655425, 655450}, {655455, 655455}, - {655457, 655482}, {655530, 655530}, {655541, 655541}, - {655543, 655543}, {655546, 655546}, {655552, 655574}, - {655576, 655606}, {655608, 656065}, {656070, 656081}, - {656096, 656100}, {656108, 656108}, {656110, 656110}, - {656128, 656244}, {656246, 656247}, {656250, 656253}, - {656255, 656255}, {656262, 656266}, {656268, 656268}, - {656270, 656289}, {656291, 656373}, {656375, 656513}, - {656515, 656519}, {656522, 656687}, {656689, 656726}, - {656729, 656729}, {656736, 656776}, {656785, 656829}, - {656831, 656831}, {656833, 656834}, {656836, 656837}, - {656839, 656839}, {656848, 656874}, {656879, 656882}, - {656912, 656922}, {656928, 657001}, {657006, 657107}, - {657109, 657116}, {657119, 657128}, {657130, 657148}, - {657151, 657151}, {657168, 657226}, {657229, 657329}, - {657344, 657397}, {657402, 657402}, {657405, 657405}, - {657408, 657453}, {657472, 657499}, {657504, 657514}, - {657520, 657543}, {657545, 657550}, {657560, 657633}, - {657635, 657763}, {657766, 657775}, {657777, 657795}, - {657797, 657804}, {657807, 657808}, {657811, 657832}, - {657834, 657840}, {657842, 657842}, {657846, 657849}, - {657852, 657860}, {657863, 657864}, {657867, 657870}, - {657879, 657879}, {657884, 657885}, {657887, 657891}, - {657894, 657905}, {657916, 657916}, {657918, 657918}, - {657921, 657923}, {657925, 657930}, {657935, 657936}, - {657939, 657960}, {657962, 657968}, {657970, 657971}, - {657973, 657974}, {657976, 657977}, {657980, 657980}, - {657982, 657986}, {657991, 657992}, {657995, 657997}, - {658001, 658001}, {658009, 658012}, {658014, 658014}, - {658022, 658037}, {658049, 658051}, {658053, 658061}, - {658063, 658065}, {658067, 658088}, {658090, 658096}, - {658098, 658099}, {658101, 658105}, {658108, 658117}, - {658119, 658121}, {658123, 658125}, {658128, 658128}, - {658144, 658147}, {658150, 658159}, {658169, 658175}, - {658177, 658179}, {658181, 658188}, {658191, 658192}, - {658195, 658216}, {658218, 658224}, {658226, 658227}, - {658229, 658233}, {658236, 658244}, {658247, 658248}, - {658251, 658253}, {658261, 658263}, {658268, 658269}, - {658271, 658275}, {658278, 658287}, {658289, 658289}, - {658306, 658307}, {658309, 658314}, {658318, 658320}, - {658322, 658325}, {658329, 658330}, {658332, 658332}, - {658334, 658335}, {658339, 658340}, {658344, 658346}, - {658350, 658361}, {658366, 658370}, {658374, 658376}, - {658378, 658381}, {658384, 658384}, {658391, 658391}, - {658406, 658415}, {658432, 658444}, {658446, 658448}, - {658450, 658472}, {658474, 658489}, {658492, 658500}, - {658502, 658504}, {658506, 658509}, {658517, 658518}, - {658520, 658522}, {658525, 658525}, {658528, 658531}, - {658534, 658543}, {658560, 658563}, {658565, 658572}, - {658574, 658576}, {658578, 658600}, {658602, 658611}, - {658613, 658617}, {658620, 658628}, {658630, 658632}, - {658634, 658637}, {658645, 658646}, {658653, 658654}, - {658656, 658659}, {658662, 658671}, {658673, 658675}, - {658688, 658700}, {658702, 658704}, {658706, 658756}, - {658758, 658760}, {658762, 658766}, {658772, 658775}, - {658783, 658787}, {658790, 658799}, {658810, 658815}, - {658817, 658819}, {658821, 658838}, {658842, 658865}, - {658867, 658875}, {658877, 658877}, {658880, 658886}, - {658890, 658890}, {658895, 658900}, {658902, 658902}, - {658904, 658911}, {658918, 658927}, {658930, 658931}, - {658945, 659002}, {659008, 659022}, {659024, 659033}, - {659073, 659074}, {659076, 659076}, {659078, 659082}, - {659084, 659107}, {659109, 659109}, {659111, 659133}, - {659136, 659140}, {659142, 659142}, {659144, 659150}, - {659152, 659161}, {659164, 659167}, {659200, 659200}, - {659224, 659225}, {659232, 659241}, {659253, 659253}, - {659255, 659255}, {659257, 659257}, {659262, 659271}, - {659273, 659308}, {659313, 659332}, {659334, 659351}, - {659353, 659388}, {659398, 659398}, {659456, 659529}, - {659536, 659613}, {659616, 659653}, {659655, 659655}, - {659661, 659661}, {659664, 659706}, {659708, 660040}, - {660042, 660045}, {660048, 660054}, {660056, 660056}, - {660058, 660061}, {660064, 660104}, {660106, 660109}, - {660112, 660144}, {660146, 660149}, {660152, 660158}, - {660160, 660160}, {660162, 660165}, {660168, 660182}, - {660184, 660240}, {660242, 660245}, {660248, 660314}, - {660317, 660319}, {660329, 660337}, {660352, 660367}, - {660384, 660469}, {660472, 660477}, {660481, 661100}, - {661103, 661119}, {661121, 661146}, {661152, 661226}, - {661230, 661240}, {661248, 661269}, {661279, 661300}, - {661312, 661331}, {661344, 661356}, {661358, 661360}, - {661362, 661363}, {661376, 661459}, {661463, 661463}, - {661468, 661469}, {661472, 661481}, {661515, 661517}, - {661519, 661529}, {661536, 661624}, {661632, 661674}, - {661680, 661749}, {661760, 661790}, {661792, 661803}, - {661808, 661819}, {661830, 661869}, {661872, 661876}, - {661888, 661931}, {661936, 661961}, {661968, 661978}, - {662016, 662043}, {662048, 662110}, {662112, 662140}, - {662143, 662153}, {662160, 662169}, {662183, 662183}, - {662192, 662205}, {662207, 662222}, {662272, 662348}, - {662352, 662361}, {662379, 662387}, {662400, 662515}, - {662528, 662583}, {662592, 662601}, {662605, 662653}, - {662656, 662664}, {662672, 662714}, {662717, 662719}, - {662736, 662738}, {662740, 662778}, {662784, 663317}, - {663320, 663325}, {663328, 663365}, {663368, 663373}, - {663376, 663383}, {663385, 663385}, {663387, 663387}, - {663389, 663389}, {663391, 663421}, {663424, 663476}, - {663478, 663484}, {663486, 663486}, {663490, 663492}, - {663494, 663500}, {663504, 663507}, {663510, 663515}, - {663520, 663532}, {663538, 663540}, {663542, 663548}, - {663564, 663565}, {663615, 663616}, {663636, 663636}, - {663665, 663665}, {663679, 663679}, {663696, 663708}, - {663760, 663772}, {663777, 663777}, {663781, 663792}, - {663810, 663810}, {663815, 663815}, {663818, 663827}, - {663829, 663829}, {663832, 663837}, {663844, 663844}, - {663846, 663846}, {663848, 663848}, {663850, 663865}, - {663868, 663871}, {663877, 663881}, {663886, 663886}, - {663904, 663944}, {666624, 666852}, {666859, 666867}, - {666880, 666917}, {666919, 666919}, {666925, 666925}, - {666928, 666983}, {666991, 666991}, {667007, 667030}, - {667040, 667046}, {667048, 667054}, {667056, 667062}, - {667064, 667070}, {667072, 667078}, {667080, 667086}, - {667088, 667094}, {667096, 667102}, {667104, 667135}, - {667653, 667655}, {667681, 667695}, {667697, 667701}, - {667704, 667708}, {667713, 667798}, {667801, 667807}, - {667809, 667898}, {667900, 667903}, {667909, 667951}, - {667953, 668046}, {668064, 668095}, {668144, 668159}, - {668672, 675263}, {675328, 697484}, {697552, 697597}, - {697600, 697868}, {697872, 697899}, {697920, 697967}, - {697972, 697981}, {697983, 698097}, {698135, 698143}, - {698146, 698248}, {698251, 698314}, {698320, 698321}, - {698323, 698323}, {698325, 698329}, {698354, 698407}, - {698412, 698412}, {698432, 698483}, {698496, 698565}, - {698576, 698585}, {698592, 698615}, {698619, 698619}, - {698621, 698669}, {698672, 698707}, {698720, 698748}, - {698752, 698816}, {698831, 698841}, {698848, 698878}, - {698880, 698934}, {698944, 698957}, {698960, 698969}, - {698976, 698998}, {699002, 699074}, {699099, 699101}, - {699104, 699119}, {699122, 699126}, {699137, 699142}, - {699145, 699150}, {699153, 699158}, {699168, 699174}, - {699176, 699182}, {699184, 699226}, {699228, 699241}, - {699248, 699370}, {699372, 699373}, {699376, 699385}, - {699392, 710563}, {710576, 710598}, {710603, 710651}, - {719104, 719469}, {719472, 719577}, {719616, 719622}, - {719635, 719639}, {719645, 719656}, {719658, 719670}, - {719672, 719676}, {719678, 719678}, {719680, 719681}, - {719683, 719684}, {719686, 719793}, {719827, 720189}, - {720208, 720271}, {720274, 720327}, {720368, 720379}, - {720384, 720399}, {720416, 720431}, {720435, 720436}, - {720461, 720463}, {720496, 720500}, {720502, 720636}, - {720656, 720665}, {720673, 720698}, {720703, 720703}, - {720705, 720730}, {720742, 720830}, {720834, 720839}, - {720842, 720847}, {720850, 720855}, {720858, 720860}, - {720932, 720932}, {720944, 720953}, {720961, 720986}, - {720991, 720991}, {720993, 721018}, {721066, 721066}, - {721077, 721077}, {721079, 721079}, {721082, 721082}, - {721088, 721110}, {721112, 721142}, {721144, 721601}, - {721606, 721617}, {721632, 721636}, {721644, 721644}, - {721646, 721646}, {721664, 721780}, {721782, 721783}, - {721786, 721789}, {721791, 721791}, {721798, 721802}, - {721804, 721804}, {721806, 721825}, {721827, 721909}, - {721911, 722049}, {722051, 722055}, {722058, 722223}, - {722225, 722262}, {722265, 722265}, {722272, 722312}, - {722321, 722365}, {722367, 722367}, {722369, 722370}, - {722372, 722373}, {722375, 722375}, {722384, 722410}, - {722415, 722418}, {722448, 722458}, {722464, 722537}, - {722542, 722643}, {722645, 722652}, {722655, 722664}, - {722666, 722684}, {722687, 722687}, {722704, 722762}, - {722765, 722865}, {722880, 722933}, {722938, 722938}, - {722941, 722941}, {722944, 722989}, {723008, 723035}, - {723040, 723050}, {723056, 723079}, {723081, 723086}, - {723096, 723169}, {723171, 723299}, {723302, 723311}, - {723313, 723331}, {723333, 723340}, {723343, 723344}, - {723347, 723368}, {723370, 723376}, {723378, 723378}, - {723382, 723385}, {723388, 723396}, {723399, 723400}, - {723403, 723406}, {723415, 723415}, {723420, 723421}, - {723423, 723427}, {723430, 723441}, {723452, 723452}, - {723454, 723454}, {723457, 723459}, {723461, 723466}, - {723471, 723472}, {723475, 723496}, {723498, 723504}, - {723506, 723507}, {723509, 723510}, {723512, 723513}, - {723516, 723516}, {723518, 723522}, {723527, 723528}, - {723531, 723533}, {723537, 723537}, {723545, 723548}, - {723550, 723550}, {723558, 723573}, {723585, 723587}, - {723589, 723597}, {723599, 723601}, {723603, 723624}, - {723626, 723632}, {723634, 723635}, {723637, 723641}, - {723644, 723653}, {723655, 723657}, {723659, 723661}, - {723664, 723664}, {723680, 723683}, {723686, 723695}, - {723705, 723711}, {723713, 723715}, {723717, 723724}, - {723727, 723728}, {723731, 723752}, {723754, 723760}, - {723762, 723763}, {723765, 723769}, {723772, 723780}, - {723783, 723784}, {723787, 723789}, {723797, 723799}, - {723804, 723805}, {723807, 723811}, {723814, 723823}, - {723825, 723825}, {723842, 723843}, {723845, 723850}, - {723854, 723856}, {723858, 723861}, {723865, 723866}, - {723868, 723868}, {723870, 723871}, {723875, 723876}, - {723880, 723882}, {723886, 723897}, {723902, 723906}, - {723910, 723912}, {723914, 723917}, {723920, 723920}, - {723927, 723927}, {723942, 723951}, {723968, 723980}, - {723982, 723984}, {723986, 724008}, {724010, 724025}, - {724028, 724036}, {724038, 724040}, {724042, 724045}, - {724053, 724054}, {724056, 724058}, {724061, 724061}, - {724064, 724067}, {724070, 724079}, {724096, 724099}, - {724101, 724108}, {724110, 724112}, {724114, 724136}, - {724138, 724147}, {724149, 724153}, {724156, 724164}, - {724166, 724168}, {724170, 724173}, {724181, 724182}, - {724189, 724190}, {724192, 724195}, {724198, 724207}, - {724209, 724211}, {724224, 724236}, {724238, 724240}, - {724242, 724292}, {724294, 724296}, {724298, 724302}, - {724308, 724311}, {724319, 724323}, {724326, 724335}, - {724346, 724351}, {724353, 724355}, {724357, 724374}, - {724378, 724401}, {724403, 724411}, {724413, 724413}, - {724416, 724422}, {724426, 724426}, {724431, 724436}, - {724438, 724438}, {724440, 724447}, {724454, 724463}, - {724466, 724467}, {724481, 724538}, {724544, 724558}, - {724560, 724569}, {724609, 724610}, {724612, 724612}, - {724614, 724618}, {724620, 724643}, {724645, 724645}, - {724647, 724669}, {724672, 724676}, {724678, 724678}, - {724680, 724686}, {724688, 724697}, {724700, 724703}, - {724736, 724736}, {724760, 724761}, {724768, 724777}, - {724789, 724789}, {724791, 724791}, {724793, 724793}, - {724798, 724807}, {724809, 724844}, {724849, 724868}, - {724870, 724887}, {724889, 724924}, {724934, 724934}, - {724992, 725065}, {725072, 725149}, {725152, 725189}, - {725191, 725191}, {725197, 725197}, {725200, 725242}, - {725244, 725576}, {725578, 725581}, {725584, 725590}, - {725592, 725592}, {725594, 725597}, {725600, 725640}, - {725642, 725645}, {725648, 725680}, {725682, 725685}, - {725688, 725694}, {725696, 725696}, {725698, 725701}, - {725704, 725718}, {725720, 725776}, {725778, 725781}, - {725784, 725850}, {725853, 725855}, {725865, 725873}, - {725888, 725903}, {725920, 726005}, {726008, 726013}, - {726017, 726636}, {726639, 726655}, {726657, 726682}, - {726688, 726762}, {726766, 726776}, {726784, 726805}, - {726815, 726836}, {726848, 726867}, {726880, 726892}, - {726894, 726896}, {726898, 726899}, {726912, 726995}, - {726999, 726999}, {727004, 727005}, {727008, 727017}, - {727051, 727053}, {727055, 727065}, {727072, 727160}, - {727168, 727210}, {727216, 727285}, {727296, 727326}, - {727328, 727339}, {727344, 727355}, {727366, 727405}, - {727408, 727412}, {727424, 727467}, {727472, 727497}, - {727504, 727514}, {727552, 727579}, {727584, 727646}, - {727648, 727676}, {727679, 727689}, {727696, 727705}, - {727719, 727719}, {727728, 727741}, {727743, 727758}, - {727808, 727884}, {727888, 727897}, {727915, 727923}, - {727936, 728051}, {728064, 728119}, {728128, 728137}, - {728141, 728189}, {728192, 728200}, {728208, 728250}, - {728253, 728255}, {728272, 728274}, {728276, 728314}, - {728320, 728853}, {728856, 728861}, {728864, 728901}, - {728904, 728909}, {728912, 728919}, {728921, 728921}, - {728923, 728923}, {728925, 728925}, {728927, 728957}, - {728960, 729012}, {729014, 729020}, {729022, 729022}, - {729026, 729028}, {729030, 729036}, {729040, 729043}, - {729046, 729051}, {729056, 729068}, {729074, 729076}, - {729078, 729084}, {729100, 729101}, {729151, 729152}, - {729172, 729172}, {729201, 729201}, {729215, 729215}, - {729232, 729244}, {729296, 729308}, {729313, 729313}, - {729317, 729328}, {729346, 729346}, {729351, 729351}, - {729354, 729363}, {729365, 729365}, {729368, 729373}, - {729380, 729380}, {729382, 729382}, {729384, 729384}, - {729386, 729401}, {729404, 729407}, {729413, 729417}, - {729422, 729422}, {729440, 729480}, {732160, 732388}, - {732395, 732403}, {732416, 732453}, {732455, 732455}, - {732461, 732461}, {732464, 732519}, {732527, 732527}, - {732543, 732566}, {732576, 732582}, {732584, 732590}, - {732592, 732598}, {732600, 732606}, {732608, 732614}, - {732616, 732622}, {732624, 732630}, {732632, 732638}, - {732640, 732671}, {733189, 733191}, {733217, 733231}, - {733233, 733237}, {733240, 733244}, {733249, 733334}, - {733337, 733343}, {733345, 733434}, {733436, 733439}, - {733445, 733487}, {733489, 733582}, {733600, 733631}, - {733680, 733695}, {734208, 740799}, {740864, 763020}, - {763088, 763133}, {763136, 763404}, {763408, 763435}, - {763456, 763503}, {763508, 763517}, {763519, 763633}, - {763671, 763679}, {763682, 763784}, {763787, 763850}, - {763856, 763857}, {763859, 763859}, {763861, 763865}, - {763890, 763943}, {763948, 763948}, {763968, 764019}, - {764032, 764101}, {764112, 764121}, {764128, 764151}, - {764155, 764155}, {764157, 764205}, {764208, 764243}, - {764256, 764284}, {764288, 764352}, {764367, 764377}, - {764384, 764414}, {764416, 764470}, {764480, 764493}, - {764496, 764505}, {764512, 764534}, {764538, 764610}, - {764635, 764637}, {764640, 764655}, {764658, 764662}, - {764673, 764678}, {764681, 764686}, {764689, 764694}, - {764704, 764710}, {764712, 764718}, {764720, 764762}, - {764764, 764777}, {764784, 764906}, {764908, 764909}, - {764912, 764921}, {764928, 776099}, {776112, 776134}, - {776139, 776187}, {784640, 785005}, {785008, 785113}, - {785152, 785158}, {785171, 785175}, {785181, 785192}, - {785194, 785206}, {785208, 785212}, {785214, 785214}, - {785216, 785217}, {785219, 785220}, {785222, 785329}, - {785363, 785725}, {785744, 785807}, {785810, 785863}, - {785904, 785915}, {785920, 785935}, {785952, 785967}, - {785971, 785972}, {785997, 785999}, {786032, 786036}, - {786038, 786172}, {786192, 786201}, {786209, 786234}, - {786239, 786239}, {786241, 786266}, {786278, 786366}, - {786370, 786375}, {786378, 786383}, {786386, 786391}, - {786394, 786396}, {786468, 786468}, {786480, 786489}, - {786497, 786522}, {786527, 786527}, {786529, 786554}, - {786602, 786602}, {786613, 786613}, {786615, 786615}, - {786618, 786618}, {786624, 786646}, {786648, 786678}, - {786680, 787137}, {787142, 787153}, {787168, 787172}, - {787180, 787180}, {787182, 787182}, {787200, 787316}, - {787318, 787319}, {787322, 787325}, {787327, 787327}, - {787334, 787338}, {787340, 787340}, {787342, 787361}, - {787363, 787445}, {787447, 787585}, {787587, 787591}, - {787594, 787759}, {787761, 787798}, {787801, 787801}, - {787808, 787848}, {787857, 787901}, {787903, 787903}, - {787905, 787906}, {787908, 787909}, {787911, 787911}, - {787920, 787946}, {787951, 787954}, {787984, 787994}, - {788000, 788073}, {788078, 788179}, {788181, 788188}, - {788191, 788200}, {788202, 788220}, {788223, 788223}, - {788240, 788298}, {788301, 788401}, {788416, 788469}, - {788474, 788474}, {788477, 788477}, {788480, 788525}, - {788544, 788571}, {788576, 788586}, {788592, 788615}, - {788617, 788622}, {788632, 788705}, {788707, 788835}, - {788838, 788847}, {788849, 788867}, {788869, 788876}, - {788879, 788880}, {788883, 788904}, {788906, 788912}, - {788914, 788914}, {788918, 788921}, {788924, 788932}, - {788935, 788936}, {788939, 788942}, {788951, 788951}, - {788956, 788957}, {788959, 788963}, {788966, 788977}, - {788988, 788988}, {788990, 788990}, {788993, 788995}, - {788997, 789002}, {789007, 789008}, {789011, 789032}, - {789034, 789040}, {789042, 789043}, {789045, 789046}, - {789048, 789049}, {789052, 789052}, {789054, 789058}, - {789063, 789064}, {789067, 789069}, {789073, 789073}, - {789081, 789084}, {789086, 789086}, {789094, 789109}, - {789121, 789123}, {789125, 789133}, {789135, 789137}, - {789139, 789160}, {789162, 789168}, {789170, 789171}, - {789173, 789177}, {789180, 789189}, {789191, 789193}, - {789195, 789197}, {789200, 789200}, {789216, 789219}, - {789222, 789231}, {789241, 789247}, {789249, 789251}, - {789253, 789260}, {789263, 789264}, {789267, 789288}, - {789290, 789296}, {789298, 789299}, {789301, 789305}, - {789308, 789316}, {789319, 789320}, {789323, 789325}, - {789333, 789335}, {789340, 789341}, {789343, 789347}, - {789350, 789359}, {789361, 789361}, {789378, 789379}, - {789381, 789386}, {789390, 789392}, {789394, 789397}, - {789401, 789402}, {789404, 789404}, {789406, 789407}, - {789411, 789412}, {789416, 789418}, {789422, 789433}, - {789438, 789442}, {789446, 789448}, {789450, 789453}, - {789456, 789456}, {789463, 789463}, {789478, 789487}, - {789504, 789516}, {789518, 789520}, {789522, 789544}, - {789546, 789561}, {789564, 789572}, {789574, 789576}, - {789578, 789581}, {789589, 789590}, {789592, 789594}, - {789597, 789597}, {789600, 789603}, {789606, 789615}, - {789632, 789635}, {789637, 789644}, {789646, 789648}, - {789650, 789672}, {789674, 789683}, {789685, 789689}, - {789692, 789700}, {789702, 789704}, {789706, 789709}, - {789717, 789718}, {789725, 789726}, {789728, 789731}, - {789734, 789743}, {789745, 789747}, {789760, 789772}, - {789774, 789776}, {789778, 789828}, {789830, 789832}, - {789834, 789838}, {789844, 789847}, {789855, 789859}, - {789862, 789871}, {789882, 789887}, {789889, 789891}, - {789893, 789910}, {789914, 789937}, {789939, 789947}, - {789949, 789949}, {789952, 789958}, {789962, 789962}, - {789967, 789972}, {789974, 789974}, {789976, 789983}, - {789990, 789999}, {790002, 790003}, {790017, 790074}, - {790080, 790094}, {790096, 790105}, {790145, 790146}, - {790148, 790148}, {790150, 790154}, {790156, 790179}, - {790181, 790181}, {790183, 790205}, {790208, 790212}, - {790214, 790214}, {790216, 790222}, {790224, 790233}, - {790236, 790239}, {790272, 790272}, {790296, 790297}, - {790304, 790313}, {790325, 790325}, {790327, 790327}, - {790329, 790329}, {790334, 790343}, {790345, 790380}, - {790385, 790404}, {790406, 790423}, {790425, 790460}, - {790470, 790470}, {790528, 790601}, {790608, 790685}, - {790688, 790725}, {790727, 790727}, {790733, 790733}, - {790736, 790778}, {790780, 791112}, {791114, 791117}, - {791120, 791126}, {791128, 791128}, {791130, 791133}, - {791136, 791176}, {791178, 791181}, {791184, 791216}, - {791218, 791221}, {791224, 791230}, {791232, 791232}, - {791234, 791237}, {791240, 791254}, {791256, 791312}, - {791314, 791317}, {791320, 791386}, {791389, 791391}, - {791401, 791409}, {791424, 791439}, {791456, 791541}, - {791544, 791549}, {791553, 792172}, {792175, 792191}, - {792193, 792218}, {792224, 792298}, {792302, 792312}, - {792320, 792341}, {792351, 792372}, {792384, 792403}, - {792416, 792428}, {792430, 792432}, {792434, 792435}, - {792448, 792531}, {792535, 792535}, {792540, 792541}, - {792544, 792553}, {792587, 792589}, {792591, 792601}, - {792608, 792696}, {792704, 792746}, {792752, 792821}, - {792832, 792862}, {792864, 792875}, {792880, 792891}, - {792902, 792941}, {792944, 792948}, {792960, 793003}, - {793008, 793033}, {793040, 793050}, {793088, 793115}, - {793120, 793182}, {793184, 793212}, {793215, 793225}, - {793232, 793241}, {793255, 793255}, {793264, 793277}, - {793279, 793294}, {793344, 793420}, {793424, 793433}, - {793451, 793459}, {793472, 793587}, {793600, 793655}, - {793664, 793673}, {793677, 793725}, {793728, 793736}, - {793744, 793786}, {793789, 793791}, {793808, 793810}, - {793812, 793850}, {793856, 794389}, {794392, 794397}, - {794400, 794437}, {794440, 794445}, {794448, 794455}, - {794457, 794457}, {794459, 794459}, {794461, 794461}, - {794463, 794493}, {794496, 794548}, {794550, 794556}, - {794558, 794558}, {794562, 794564}, {794566, 794572}, - {794576, 794579}, {794582, 794587}, {794592, 794604}, - {794610, 794612}, {794614, 794620}, {794636, 794637}, - {794687, 794688}, {794708, 794708}, {794737, 794737}, - {794751, 794751}, {794768, 794780}, {794832, 794844}, - {794849, 794849}, {794853, 794864}, {794882, 794882}, - {794887, 794887}, {794890, 794899}, {794901, 794901}, - {794904, 794909}, {794916, 794916}, {794918, 794918}, - {794920, 794920}, {794922, 794937}, {794940, 794943}, - {794949, 794953}, {794958, 794958}, {794976, 795016}, - {797696, 797924}, {797931, 797939}, {797952, 797989}, - {797991, 797991}, {797997, 797997}, {798000, 798055}, - {798063, 798063}, {798079, 798102}, {798112, 798118}, - {798120, 798126}, {798128, 798134}, {798136, 798142}, - {798144, 798150}, {798152, 798158}, {798160, 798166}, - {798168, 798174}, {798176, 798207}, {798725, 798727}, - {798753, 798767}, {798769, 798773}, {798776, 798780}, - {798785, 798870}, {798873, 798879}, {798881, 798970}, - {798972, 798975}, {798981, 799023}, {799025, 799118}, - {799136, 799167}, {799216, 799231}, {799744, 806335}, - {806400, 828556}, {828624, 828669}, {828672, 828940}, - {828944, 828971}, {828992, 829039}, {829044, 829053}, - {829055, 829169}, {829207, 829215}, {829218, 829320}, - {829323, 829386}, {829392, 829393}, {829395, 829395}, - {829397, 829401}, {829426, 829479}, {829484, 829484}, - {829504, 829555}, {829568, 829637}, {829648, 829657}, - {829664, 829687}, {829691, 829691}, {829693, 829741}, - {829744, 829779}, {829792, 829820}, {829824, 829888}, - {829903, 829913}, {829920, 829950}, {829952, 830006}, - {830016, 830029}, {830032, 830041}, {830048, 830070}, - {830074, 830146}, {830171, 830173}, {830176, 830191}, - {830194, 830198}, {830209, 830214}, {830217, 830222}, - {830225, 830230}, {830240, 830246}, {830248, 830254}, - {830256, 830298}, {830300, 830313}, {830320, 830442}, - {830444, 830445}, {830448, 830457}, {830464, 841635}, - {841648, 841670}, {841675, 841723}, {850176, 850541}, - {850544, 850649}, {850688, 850694}, {850707, 850711}, - {850717, 850728}, {850730, 850742}, {850744, 850748}, - {850750, 850750}, {850752, 850753}, {850755, 850756}, - {850758, 850865}, {850899, 851261}, {851280, 851343}, - {851346, 851399}, {851440, 851451}, {851456, 851471}, - {851488, 851503}, {851507, 851508}, {851533, 851535}, - {851568, 851572}, {851574, 851708}, {851728, 851737}, - {851745, 851770}, {851775, 851775}, {851777, 851802}, - {851814, 851902}, {851906, 851911}, {851914, 851919}, - {851922, 851927}, {851930, 851932}, {852004, 852004}, - {852016, 852025}, {852033, 852058}, {852063, 852063}, - {852065, 852090}, {852138, 852138}, {852149, 852149}, - {852151, 852151}, {852154, 852154}, {852160, 852182}, - {852184, 852214}, {852216, 852673}, {852678, 852689}, - {852704, 852708}, {852716, 852716}, {852718, 852718}, - {852736, 852852}, {852854, 852855}, {852858, 852861}, - {852863, 852863}, {852870, 852874}, {852876, 852876}, - {852878, 852897}, {852899, 852981}, {852983, 853121}, - {853123, 853127}, {853130, 853295}, {853297, 853334}, - {853337, 853337}, {853344, 853384}, {853393, 853437}, - {853439, 853439}, {853441, 853442}, {853444, 853445}, - {853447, 853447}, {853456, 853482}, {853487, 853490}, - {853520, 853530}, {853536, 853609}, {853614, 853715}, - {853717, 853724}, {853727, 853736}, {853738, 853756}, - {853759, 853759}, {853776, 853834}, {853837, 853937}, - {853952, 854005}, {854010, 854010}, {854013, 854013}, - {854016, 854061}, {854080, 854107}, {854112, 854122}, - {854128, 854151}, {854153, 854158}, {854168, 854241}, - {854243, 854371}, {854374, 854383}, {854385, 854403}, - {854405, 854412}, {854415, 854416}, {854419, 854440}, - {854442, 854448}, {854450, 854450}, {854454, 854457}, - {854460, 854468}, {854471, 854472}, {854475, 854478}, - {854487, 854487}, {854492, 854493}, {854495, 854499}, - {854502, 854513}, {854524, 854524}, {854526, 854526}, - {854529, 854531}, {854533, 854538}, {854543, 854544}, - {854547, 854568}, {854570, 854576}, {854578, 854579}, - {854581, 854582}, {854584, 854585}, {854588, 854588}, - {854590, 854594}, {854599, 854600}, {854603, 854605}, - {854609, 854609}, {854617, 854620}, {854622, 854622}, - {854630, 854645}, {854657, 854659}, {854661, 854669}, - {854671, 854673}, {854675, 854696}, {854698, 854704}, - {854706, 854707}, {854709, 854713}, {854716, 854725}, - {854727, 854729}, {854731, 854733}, {854736, 854736}, - {854752, 854755}, {854758, 854767}, {854777, 854783}, - {854785, 854787}, {854789, 854796}, {854799, 854800}, - {854803, 854824}, {854826, 854832}, {854834, 854835}, - {854837, 854841}, {854844, 854852}, {854855, 854856}, - {854859, 854861}, {854869, 854871}, {854876, 854877}, - {854879, 854883}, {854886, 854895}, {854897, 854897}, - {854914, 854915}, {854917, 854922}, {854926, 854928}, - {854930, 854933}, {854937, 854938}, {854940, 854940}, - {854942, 854943}, {854947, 854948}, {854952, 854954}, - {854958, 854969}, {854974, 854978}, {854982, 854984}, - {854986, 854989}, {854992, 854992}, {854999, 854999}, - {855014, 855023}, {855040, 855052}, {855054, 855056}, - {855058, 855080}, {855082, 855097}, {855100, 855108}, - {855110, 855112}, {855114, 855117}, {855125, 855126}, - {855128, 855130}, {855133, 855133}, {855136, 855139}, - {855142, 855151}, {855168, 855171}, {855173, 855180}, - {855182, 855184}, {855186, 855208}, {855210, 855219}, - {855221, 855225}, {855228, 855236}, {855238, 855240}, - {855242, 855245}, {855253, 855254}, {855261, 855262}, - {855264, 855267}, {855270, 855279}, {855281, 855283}, - {855296, 855308}, {855310, 855312}, {855314, 855364}, - {855366, 855368}, {855370, 855374}, {855380, 855383}, - {855391, 855395}, {855398, 855407}, {855418, 855423}, - {855425, 855427}, {855429, 855446}, {855450, 855473}, - {855475, 855483}, {855485, 855485}, {855488, 855494}, - {855498, 855498}, {855503, 855508}, {855510, 855510}, - {855512, 855519}, {855526, 855535}, {855538, 855539}, - {855553, 855610}, {855616, 855630}, {855632, 855641}, - {855681, 855682}, {855684, 855684}, {855686, 855690}, - {855692, 855715}, {855717, 855717}, {855719, 855741}, - {855744, 855748}, {855750, 855750}, {855752, 855758}, - {855760, 855769}, {855772, 855775}, {855808, 855808}, - {855832, 855833}, {855840, 855849}, {855861, 855861}, - {855863, 855863}, {855865, 855865}, {855870, 855879}, - {855881, 855916}, {855921, 855940}, {855942, 855959}, - {855961, 855996}, {856006, 856006}, {856064, 856137}, - {856144, 856221}, {856224, 856261}, {856263, 856263}, - {856269, 856269}, {856272, 856314}, {856316, 856648}, - {856650, 856653}, {856656, 856662}, {856664, 856664}, - {856666, 856669}, {856672, 856712}, {856714, 856717}, - {856720, 856752}, {856754, 856757}, {856760, 856766}, - {856768, 856768}, {856770, 856773}, {856776, 856790}, - {856792, 856848}, {856850, 856853}, {856856, 856922}, - {856925, 856927}, {856937, 856945}, {856960, 856975}, - {856992, 857077}, {857080, 857085}, {857089, 857708}, - {857711, 857727}, {857729, 857754}, {857760, 857834}, - {857838, 857848}, {857856, 857877}, {857887, 857908}, - {857920, 857939}, {857952, 857964}, {857966, 857968}, - {857970, 857971}, {857984, 858067}, {858071, 858071}, - {858076, 858077}, {858080, 858089}, {858123, 858125}, - {858127, 858137}, {858144, 858232}, {858240, 858282}, - {858288, 858357}, {858368, 858398}, {858400, 858411}, - {858416, 858427}, {858438, 858477}, {858480, 858484}, - {858496, 858539}, {858544, 858569}, {858576, 858586}, - {858624, 858651}, {858656, 858718}, {858720, 858748}, - {858751, 858761}, {858768, 858777}, {858791, 858791}, - {858800, 858813}, {858815, 858830}, {858880, 858956}, - {858960, 858969}, {858987, 858995}, {859008, 859123}, - {859136, 859191}, {859200, 859209}, {859213, 859261}, - {859264, 859272}, {859280, 859322}, {859325, 859327}, - {859344, 859346}, {859348, 859386}, {859392, 859925}, - {859928, 859933}, {859936, 859973}, {859976, 859981}, - {859984, 859991}, {859993, 859993}, {859995, 859995}, - {859997, 859997}, {859999, 860029}, {860032, 860084}, - {860086, 860092}, {860094, 860094}, {860098, 860100}, - {860102, 860108}, {860112, 860115}, {860118, 860123}, - {860128, 860140}, {860146, 860148}, {860150, 860156}, - {860172, 860173}, {860223, 860224}, {860244, 860244}, - {860273, 860273}, {860287, 860287}, {860304, 860316}, - {860368, 860380}, {860385, 860385}, {860389, 860400}, - {860418, 860418}, {860423, 860423}, {860426, 860435}, - {860437, 860437}, {860440, 860445}, {860452, 860452}, - {860454, 860454}, {860456, 860456}, {860458, 860473}, - {860476, 860479}, {860485, 860489}, {860494, 860494}, - {860512, 860552}, {863232, 863460}, {863467, 863475}, - {863488, 863525}, {863527, 863527}, {863533, 863533}, - {863536, 863591}, {863599, 863599}, {863615, 863638}, - {863648, 863654}, {863656, 863662}, {863664, 863670}, - {863672, 863678}, {863680, 863686}, {863688, 863694}, - {863696, 863702}, {863704, 863710}, {863712, 863743}, - {864261, 864263}, {864289, 864303}, {864305, 864309}, - {864312, 864316}, {864321, 864406}, {864409, 864415}, - {864417, 864506}, {864508, 864511}, {864517, 864559}, - {864561, 864654}, {864672, 864703}, {864752, 864767}, - {865280, 871871}, {871936, 894092}, {894160, 894205}, - {894208, 894476}, {894480, 894507}, {894528, 894575}, - {894580, 894589}, {894591, 894705}, {894743, 894751}, - {894754, 894856}, {894859, 894922}, {894928, 894929}, - {894931, 894931}, {894933, 894937}, {894962, 895015}, - {895020, 895020}, {895040, 895091}, {895104, 895173}, - {895184, 895193}, {895200, 895223}, {895227, 895227}, - {895229, 895277}, {895280, 895315}, {895328, 895356}, - {895360, 895424}, {895439, 895449}, {895456, 895486}, - {895488, 895542}, {895552, 895565}, {895568, 895577}, - {895584, 895606}, {895610, 895682}, {895707, 895709}, - {895712, 895727}, {895730, 895734}, {895745, 895750}, - {895753, 895758}, {895761, 895766}, {895776, 895782}, - {895784, 895790}, {895792, 895834}, {895836, 895849}, - {895856, 895978}, {895980, 895981}, {895984, 895993}, - {896000, 907171}, {907184, 907206}, {907211, 907259}, - {915712, 916077}, {916080, 916185}, {916224, 916230}, - {916243, 916247}, {916253, 916264}, {916266, 916278}, - {916280, 916284}, {916286, 916286}, {916288, 916289}, - {916291, 916292}, {916294, 916401}, {916435, 916797}, - {916816, 916879}, {916882, 916935}, {916976, 916987}, - {916992, 917007}, {917024, 917039}, {917043, 917044}, - {917069, 917071}, {917104, 917108}, {917110, 917244}, - {917264, 917273}, {917281, 917306}, {917311, 917311}, - {917313, 917338}, {917350, 917438}, {917442, 917447}, - {917450, 917455}, {917458, 917463}, {917466, 917468}, - {917540, 917540}, {917552, 917561}, {917569, 917594}, - {917599, 917599}, {917601, 917626}, {917674, 917674}, - {917685, 917685}, {917687, 917687}, {917690, 917690}, - {917696, 917718}, {917720, 917750}, {917752, 918209}, - {918214, 918225}, {918240, 918244}, {918252, 918252}, - {918254, 918254}, {918272, 918388}, {918390, 918391}, - {918394, 918397}, {918399, 918399}, {918406, 918410}, - {918412, 918412}, {918414, 918433}, {918435, 918517}, - {918519, 918657}, {918659, 918663}, {918666, 918831}, - {918833, 918870}, {918873, 918873}, {918880, 918920}, - {918929, 918973}, {918975, 918975}, {918977, 918978}, - {918980, 918981}, {918983, 918983}, {918992, 919018}, - {919023, 919026}, {919056, 919066}, {919072, 919145}, - {919150, 919251}, {919253, 919260}, {919263, 919272}, - {919274, 919292}, {919295, 919295}, {919312, 919370}, - {919373, 919473}, {919488, 919541}, {919546, 919546}, - {919549, 919549}, {919552, 919597}, {919616, 919643}, - {919648, 919658}, {919664, 919687}, {919689, 919694}, - {919704, 919777}, {919779, 919907}, {919910, 919919}, - {919921, 919939}, {919941, 919948}, {919951, 919952}, - {919955, 919976}, {919978, 919984}, {919986, 919986}, - {919990, 919993}, {919996, 920004}, {920007, 920008}, - {920011, 920014}, {920023, 920023}, {920028, 920029}, - {920031, 920035}, {920038, 920049}, {920060, 920060}, - {920062, 920062}, {920065, 920067}, {920069, 920074}, - {920079, 920080}, {920083, 920104}, {920106, 920112}, - {920114, 920115}, {920117, 920118}, {920120, 920121}, - {920124, 920124}, {920126, 920130}, {920135, 920136}, - {920139, 920141}, {920145, 920145}, {920153, 920156}, - {920158, 920158}, {920166, 920181}, {920193, 920195}, - {920197, 920205}, {920207, 920209}, {920211, 920232}, - {920234, 920240}, {920242, 920243}, {920245, 920249}, - {920252, 920261}, {920263, 920265}, {920267, 920269}, - {920272, 920272}, {920288, 920291}, {920294, 920303}, - {920313, 920319}, {920321, 920323}, {920325, 920332}, - {920335, 920336}, {920339, 920360}, {920362, 920368}, - {920370, 920371}, {920373, 920377}, {920380, 920388}, - {920391, 920392}, {920395, 920397}, {920405, 920407}, - {920412, 920413}, {920415, 920419}, {920422, 920431}, - {920433, 920433}, {920450, 920451}, {920453, 920458}, - {920462, 920464}, {920466, 920469}, {920473, 920474}, - {920476, 920476}, {920478, 920479}, {920483, 920484}, - {920488, 920490}, {920494, 920505}, {920510, 920514}, - {920518, 920520}, {920522, 920525}, {920528, 920528}, - {920535, 920535}, {920550, 920559}, {920576, 920588}, - {920590, 920592}, {920594, 920616}, {920618, 920633}, - {920636, 920644}, {920646, 920648}, {920650, 920653}, - {920661, 920662}, {920664, 920666}, {920669, 920669}, - {920672, 920675}, {920678, 920687}, {920704, 920707}, - {920709, 920716}, {920718, 920720}, {920722, 920744}, - {920746, 920755}, {920757, 920761}, {920764, 920772}, - {920774, 920776}, {920778, 920781}, {920789, 920790}, - {920797, 920798}, {920800, 920803}, {920806, 920815}, - {920817, 920819}, {920832, 920844}, {920846, 920848}, - {920850, 920900}, {920902, 920904}, {920906, 920910}, - {920916, 920919}, {920927, 920931}, {920934, 920943}, - {920954, 920959}, {920961, 920963}, {920965, 920982}, - {920986, 921009}, {921011, 921019}, {921021, 921021}, - {921024, 921030}, {921034, 921034}, {921039, 921044}, - {921046, 921046}, {921048, 921055}, {921062, 921071}, - {921074, 921075}, {921089, 921146}, {921152, 921166}, - {921168, 921177}, {921217, 921218}, {921220, 921220}, - {921222, 921226}, {921228, 921251}, {921253, 921253}, - {921255, 921277}, {921280, 921284}, {921286, 921286}, - {921288, 921294}, {921296, 921305}, {921308, 921311}, - {921344, 921344}, {921368, 921369}, {921376, 921385}, - {921397, 921397}, {921399, 921399}, {921401, 921401}, - {921406, 921415}, {921417, 921452}, {921457, 921476}, - {921478, 921495}, {921497, 921532}, {921542, 921542}, - {921600, 921673}, {921680, 921757}, {921760, 921797}, - {921799, 921799}, {921805, 921805}, {921808, 921850}, - {921852, 922184}, {922186, 922189}, {922192, 922198}, - {922200, 922200}, {922202, 922205}, {922208, 922248}, - {922250, 922253}, {922256, 922288}, {922290, 922293}, - {922296, 922302}, {922304, 922304}, {922306, 922309}, - {922312, 922326}, {922328, 922384}, {922386, 922389}, - {922392, 922458}, {922461, 922463}, {922473, 922481}, - {922496, 922511}, {922528, 922613}, {922616, 922621}, - {922625, 923244}, {923247, 923263}, {923265, 923290}, - {923296, 923370}, {923374, 923384}, {923392, 923413}, - {923423, 923444}, {923456, 923475}, {923488, 923500}, - {923502, 923504}, {923506, 923507}, {923520, 923603}, - {923607, 923607}, {923612, 923613}, {923616, 923625}, - {923659, 923661}, {923663, 923673}, {923680, 923768}, - {923776, 923818}, {923824, 923893}, {923904, 923934}, - {923936, 923947}, {923952, 923963}, {923974, 924013}, - {924016, 924020}, {924032, 924075}, {924080, 924105}, - {924112, 924122}, {924160, 924187}, {924192, 924254}, - {924256, 924284}, {924287, 924297}, {924304, 924313}, - {924327, 924327}, {924336, 924349}, {924351, 924366}, - {924416, 924492}, {924496, 924505}, {924523, 924531}, - {924544, 924659}, {924672, 924727}, {924736, 924745}, - {924749, 924797}, {924800, 924808}, {924816, 924858}, - {924861, 924863}, {924880, 924882}, {924884, 924922}, - {924928, 925461}, {925464, 925469}, {925472, 925509}, - {925512, 925517}, {925520, 925527}, {925529, 925529}, - {925531, 925531}, {925533, 925533}, {925535, 925565}, - {925568, 925620}, {925622, 925628}, {925630, 925630}, - {925634, 925636}, {925638, 925644}, {925648, 925651}, - {925654, 925659}, {925664, 925676}, {925682, 925684}, - {925686, 925692}, {925708, 925709}, {925759, 925760}, - {925780, 925780}, {925809, 925809}, {925823, 925823}, - {925840, 925852}, {925904, 925916}, {925921, 925921}, - {925925, 925936}, {925954, 925954}, {925959, 925959}, - {925962, 925971}, {925973, 925973}, {925976, 925981}, - {925988, 925988}, {925990, 925990}, {925992, 925992}, - {925994, 926009}, {926012, 926015}, {926021, 926025}, - {926030, 926030}, {926048, 926088}, {928768, 928996}, - {929003, 929011}, {929024, 929061}, {929063, 929063}, - {929069, 929069}, {929072, 929127}, {929135, 929135}, - {929151, 929174}, {929184, 929190}, {929192, 929198}, - {929200, 929206}, {929208, 929214}, {929216, 929222}, - {929224, 929230}, {929232, 929238}, {929240, 929246}, - {929248, 929279}, {929797, 929799}, {929825, 929839}, - {929841, 929845}, {929848, 929852}, {929857, 929942}, - {929945, 929951}, {929953, 930042}, {930044, 930047}, - {930053, 930095}, {930097, 930190}, {930208, 930239}, - {930288, 930303}, {930816, 937407}, {937472, 959628}, - {959696, 959741}, {959744, 960012}, {960016, 960043}, - {960064, 960111}, {960116, 960125}, {960127, 960241}, - {960279, 960287}, {960290, 960392}, {960395, 960458}, - {960464, 960465}, {960467, 960467}, {960469, 960473}, - {960498, 960551}, {960556, 960556}, {960576, 960627}, - {960640, 960709}, {960720, 960729}, {960736, 960759}, - {960763, 960763}, {960765, 960813}, {960816, 960851}, - {960864, 960892}, {960896, 960960}, {960975, 960985}, - {960992, 961022}, {961024, 961078}, {961088, 961101}, - {961104, 961113}, {961120, 961142}, {961146, 961218}, - {961243, 961245}, {961248, 961263}, {961266, 961270}, - {961281, 961286}, {961289, 961294}, {961297, 961302}, - {961312, 961318}, {961320, 961326}, {961328, 961370}, - {961372, 961385}, {961392, 961514}, {961516, 961517}, - {961520, 961529}, {961536, 972707}, {972720, 972742}, - {972747, 972795}, {981248, 981613}, {981616, 981721}, - {981760, 981766}, {981779, 981783}, {981789, 981800}, - {981802, 981814}, {981816, 981820}, {981822, 981822}, - {981824, 981825}, {981827, 981828}, {981830, 981937}, - {981971, 982333}, {982352, 982415}, {982418, 982471}, - {982512, 982523}, {982528, 982543}, {982560, 982575}, - {982579, 982580}, {982605, 982607}, {982640, 982644}, - {982646, 982780}, {982800, 982809}, {982817, 982842}, - {982847, 982847}, {982849, 982874}, {982886, 982974}, - {982978, 982983}, {982986, 982991}, {982994, 982999}, - {983002, 983004}, {983076, 983076}, {983088, 983097}, - {983105, 983130}, {983135, 983135}, {983137, 983162}, - {983210, 983210}, {983221, 983221}, {983223, 983223}, - {983226, 983226}, {983232, 983254}, {983256, 983286}, - {983288, 983745}, {983750, 983761}, {983776, 983780}, - {983788, 983788}, {983790, 983790}, {983808, 983924}, - {983926, 983927}, {983930, 983933}, {983935, 983935}, - {983942, 983946}, {983948, 983948}, {983950, 983969}, - {983971, 984053}, {984055, 984193}, {984195, 984199}, - {984202, 984367}, {984369, 984406}, {984409, 984409}, - {984416, 984456}, {984465, 984509}, {984511, 984511}, - {984513, 984514}, {984516, 984517}, {984519, 984519}, - {984528, 984554}, {984559, 984562}, {984592, 984602}, - {984608, 984681}, {984686, 984787}, {984789, 984796}, - {984799, 984808}, {984810, 984828}, {984831, 984831}, - {984848, 984906}, {984909, 985009}, {985024, 985077}, - {985082, 985082}, {985085, 985085}, {985088, 985133}, - {985152, 985179}, {985184, 985194}, {985200, 985223}, - {985225, 985230}, {985240, 985313}, {985315, 985443}, - {985446, 985455}, {985457, 985475}, {985477, 985484}, - {985487, 985488}, {985491, 985512}, {985514, 985520}, - {985522, 985522}, {985526, 985529}, {985532, 985540}, - {985543, 985544}, {985547, 985550}, {985559, 985559}, - {985564, 985565}, {985567, 985571}, {985574, 985585}, - {985596, 985596}, {985598, 985598}, {985601, 985603}, - {985605, 985610}, {985615, 985616}, {985619, 985640}, - {985642, 985648}, {985650, 985651}, {985653, 985654}, - {985656, 985657}, {985660, 985660}, {985662, 985666}, - {985671, 985672}, {985675, 985677}, {985681, 985681}, - {985689, 985692}, {985694, 985694}, {985702, 985717}, - {985729, 985731}, {985733, 985741}, {985743, 985745}, - {985747, 985768}, {985770, 985776}, {985778, 985779}, - {985781, 985785}, {985788, 985797}, {985799, 985801}, - {985803, 985805}, {985808, 985808}, {985824, 985827}, - {985830, 985839}, {985849, 985855}, {985857, 985859}, - {985861, 985868}, {985871, 985872}, {985875, 985896}, - {985898, 985904}, {985906, 985907}, {985909, 985913}, - {985916, 985924}, {985927, 985928}, {985931, 985933}, - {985941, 985943}, {985948, 985949}, {985951, 985955}, - {985958, 985967}, {985969, 985969}, {985986, 985987}, - {985989, 985994}, {985998, 986000}, {986002, 986005}, - {986009, 986010}, {986012, 986012}, {986014, 986015}, - {986019, 986020}, {986024, 986026}, {986030, 986041}, - {986046, 986050}, {986054, 986056}, {986058, 986061}, - {986064, 986064}, {986071, 986071}, {986086, 986095}, - {986112, 986124}, {986126, 986128}, {986130, 986152}, - {986154, 986169}, {986172, 986180}, {986182, 986184}, - {986186, 986189}, {986197, 986198}, {986200, 986202}, - {986205, 986205}, {986208, 986211}, {986214, 986223}, - {986240, 986243}, {986245, 986252}, {986254, 986256}, - {986258, 986280}, {986282, 986291}, {986293, 986297}, - {986300, 986308}, {986310, 986312}, {986314, 986317}, - {986325, 986326}, {986333, 986334}, {986336, 986339}, - {986342, 986351}, {986353, 986355}, {986368, 986380}, - {986382, 986384}, {986386, 986436}, {986438, 986440}, - {986442, 986446}, {986452, 986455}, {986463, 986467}, - {986470, 986479}, {986490, 986495}, {986497, 986499}, - {986501, 986518}, {986522, 986545}, {986547, 986555}, - {986557, 986557}, {986560, 986566}, {986570, 986570}, - {986575, 986580}, {986582, 986582}, {986584, 986591}, - {986598, 986607}, {986610, 986611}, {986625, 986682}, - {986688, 986702}, {986704, 986713}, {986753, 986754}, - {986756, 986756}, {986758, 986762}, {986764, 986787}, - {986789, 986789}, {986791, 986813}, {986816, 986820}, - {986822, 986822}, {986824, 986830}, {986832, 986841}, - {986844, 986847}, {986880, 986880}, {986904, 986905}, - {986912, 986921}, {986933, 986933}, {986935, 986935}, - {986937, 986937}, {986942, 986951}, {986953, 986988}, - {986993, 987012}, {987014, 987031}, {987033, 987068}, - {987078, 987078}, {987136, 987209}, {987216, 987293}, - {987296, 987333}, {987335, 987335}, {987341, 987341}, - {987344, 987386}, {987388, 987720}, {987722, 987725}, - {987728, 987734}, {987736, 987736}, {987738, 987741}, - {987744, 987784}, {987786, 987789}, {987792, 987824}, - {987826, 987829}, {987832, 987838}, {987840, 987840}, - {987842, 987845}, {987848, 987862}, {987864, 987920}, - {987922, 987925}, {987928, 987994}, {987997, 987999}, - {988009, 988017}, {988032, 988047}, {988064, 988149}, - {988152, 988157}, {988161, 988780}, {988783, 988799}, - {988801, 988826}, {988832, 988906}, {988910, 988920}, - {988928, 988949}, {988959, 988980}, {988992, 989011}, - {989024, 989036}, {989038, 989040}, {989042, 989043}, - {989056, 989139}, {989143, 989143}, {989148, 989149}, - {989152, 989161}, {989195, 989197}, {989199, 989209}, - {989216, 989304}, {989312, 989354}, {989360, 989429}, - {989440, 989470}, {989472, 989483}, {989488, 989499}, - {989510, 989549}, {989552, 989556}, {989568, 989611}, - {989616, 989641}, {989648, 989658}, {989696, 989723}, - {989728, 989790}, {989792, 989820}, {989823, 989833}, - {989840, 989849}, {989863, 989863}, {989872, 989885}, - {989887, 989902}, {989952, 990028}, {990032, 990041}, - {990059, 990067}, {990080, 990195}, {990208, 990263}, - {990272, 990281}, {990285, 990333}, {990336, 990344}, - {990352, 990394}, {990397, 990399}, {990416, 990418}, - {990420, 990458}, {990464, 990997}, {991000, 991005}, - {991008, 991045}, {991048, 991053}, {991056, 991063}, - {991065, 991065}, {991067, 991067}, {991069, 991069}, - {991071, 991101}, {991104, 991156}, {991158, 991164}, - {991166, 991166}, {991170, 991172}, {991174, 991180}, - {991184, 991187}, {991190, 991195}, {991200, 991212}, - {991218, 991220}, {991222, 991228}, {991244, 991245}, - {991295, 991296}, {991316, 991316}, {991345, 991345}, - {991359, 991359}, {991376, 991388}, {991440, 991452}, - {991457, 991457}, {991461, 991472}, {991490, 991490}, - {991495, 991495}, {991498, 991507}, {991509, 991509}, - {991512, 991517}, {991524, 991524}, {991526, 991526}, - {991528, 991528}, {991530, 991545}, {991548, 991551}, - {991557, 991561}, {991566, 991566}, {991584, 991624}, - {994304, 994532}, {994539, 994547}, {994560, 994597}, - {994599, 994599}, {994605, 994605}, {994608, 994663}, - {994671, 994671}, {994687, 994710}, {994720, 994726}, - {994728, 994734}, {994736, 994742}, {994744, 994750}, - {994752, 994758}, {994760, 994766}, {994768, 994774}, - {994776, 994782}, {994784, 994815}, {995333, 995335}, - {995361, 995375}, {995377, 995381}, {995384, 995388}, - {995393, 995478}, {995481, 995487}, {995489, 995578}, - {995580, 995583}, {995589, 995631}, {995633, 995726}, - {995744, 995775}, {995824, 995839}, {996352, 1002943}, - {1003008, 1025164}, {1025232, 1025277}, {1025280, 1025548}, - {1025552, 1025579}, {1025600, 1025647}, {1025652, 1025661}, - {1025663, 1025777}, {1025815, 1025823}, {1025826, 1025928}, - {1025931, 1025994}, {1026000, 1026001}, {1026003, 1026003}, - {1026005, 1026009}, {1026034, 1026087}, {1026092, 1026092}, - {1026112, 1026163}, {1026176, 1026245}, {1026256, 1026265}, - {1026272, 1026295}, {1026299, 1026299}, {1026301, 1026349}, - {1026352, 1026387}, {1026400, 1026428}, {1026432, 1026496}, - {1026511, 1026521}, {1026528, 1026558}, {1026560, 1026614}, - {1026624, 1026637}, {1026640, 1026649}, {1026656, 1026678}, - {1026682, 1026754}, {1026779, 1026781}, {1026784, 1026799}, - {1026802, 1026806}, {1026817, 1026822}, {1026825, 1026830}, - {1026833, 1026838}, {1026848, 1026854}, {1026856, 1026862}, - {1026864, 1026906}, {1026908, 1026921}, {1026928, 1027050}, - {1027052, 1027053}, {1027056, 1027065}, {1027072, 1038243}, - {1038256, 1038278}, {1038283, 1038331}, {1046784, 1047149}, - {1047152, 1047257}, {1047296, 1047302}, {1047315, 1047319}, - {1047325, 1047336}, {1047338, 1047350}, {1047352, 1047356}, - {1047358, 1047358}, {1047360, 1047361}, {1047363, 1047364}, - {1047366, 1047473}, {1047507, 1047869}, {1047888, 1047951}, - {1047954, 1048007}, {1048048, 1048059}, {1048064, 1048079}, - {1048096, 1048111}, {1048115, 1048116}, {1048141, 1048143}, - {1048176, 1048180}, {1048182, 1048316}, {1048336, 1048345}, - {1048353, 1048378}, {1048383, 1048383}, {1048385, 1048410}, - {1048422, 1048510}, {1048514, 1048519}, {1048522, 1048527}, - {1048530, 1048535}, {1048538, 1048540}, {1048612, 1048612}, - {1048624, 1048633}, {1048641, 1048666}, {1048671, 1048671}, - {1048673, 1048698}, {1048746, 1048746}, {1048757, 1048757}, - {1048759, 1048759}, {1048762, 1048762}, {1048768, 1048790}, - {1048792, 1048822}, {1048824, 1049281}, {1049286, 1049297}, - {1049312, 1049316}, {1049324, 1049324}, {1049326, 1049326}, - {1049344, 1049460}, {1049462, 1049463}, {1049466, 1049469}, - {1049471, 1049471}, {1049478, 1049482}, {1049484, 1049484}, - {1049486, 1049505}, {1049507, 1049589}, {1049591, 1049729}, - {1049731, 1049735}, {1049738, 1049903}, {1049905, 1049942}, - {1049945, 1049945}, {1049952, 1049992}, {1050001, 1050045}, - {1050047, 1050047}, {1050049, 1050050}, {1050052, 1050053}, - {1050055, 1050055}, {1050064, 1050090}, {1050095, 1050098}, - {1050128, 1050138}, {1050144, 1050217}, {1050222, 1050323}, - {1050325, 1050332}, {1050335, 1050344}, {1050346, 1050364}, - {1050367, 1050367}, {1050384, 1050442}, {1050445, 1050545}, - {1050560, 1050613}, {1050618, 1050618}, {1050621, 1050621}, - {1050624, 1050669}, {1050688, 1050715}, {1050720, 1050730}, - {1050736, 1050759}, {1050761, 1050766}, {1050776, 1050849}, - {1050851, 1050979}, {1050982, 1050991}, {1050993, 1051011}, - {1051013, 1051020}, {1051023, 1051024}, {1051027, 1051048}, - {1051050, 1051056}, {1051058, 1051058}, {1051062, 1051065}, - {1051068, 1051076}, {1051079, 1051080}, {1051083, 1051086}, - {1051095, 1051095}, {1051100, 1051101}, {1051103, 1051107}, - {1051110, 1051121}, {1051132, 1051132}, {1051134, 1051134}, - {1051137, 1051139}, {1051141, 1051146}, {1051151, 1051152}, - {1051155, 1051176}, {1051178, 1051184}, {1051186, 1051187}, - {1051189, 1051190}, {1051192, 1051193}, {1051196, 1051196}, - {1051198, 1051202}, {1051207, 1051208}, {1051211, 1051213}, - {1051217, 1051217}, {1051225, 1051228}, {1051230, 1051230}, - {1051238, 1051253}, {1051265, 1051267}, {1051269, 1051277}, - {1051279, 1051281}, {1051283, 1051304}, {1051306, 1051312}, - {1051314, 1051315}, {1051317, 1051321}, {1051324, 1051333}, - {1051335, 1051337}, {1051339, 1051341}, {1051344, 1051344}, - {1051360, 1051363}, {1051366, 1051375}, {1051385, 1051391}, - {1051393, 1051395}, {1051397, 1051404}, {1051407, 1051408}, - {1051411, 1051432}, {1051434, 1051440}, {1051442, 1051443}, - {1051445, 1051449}, {1051452, 1051460}, {1051463, 1051464}, - {1051467, 1051469}, {1051477, 1051479}, {1051484, 1051485}, - {1051487, 1051491}, {1051494, 1051503}, {1051505, 1051505}, - {1051522, 1051523}, {1051525, 1051530}, {1051534, 1051536}, - {1051538, 1051541}, {1051545, 1051546}, {1051548, 1051548}, - {1051550, 1051551}, {1051555, 1051556}, {1051560, 1051562}, - {1051566, 1051577}, {1051582, 1051586}, {1051590, 1051592}, - {1051594, 1051597}, {1051600, 1051600}, {1051607, 1051607}, - {1051622, 1051631}, {1051648, 1051660}, {1051662, 1051664}, - {1051666, 1051688}, {1051690, 1051705}, {1051708, 1051716}, - {1051718, 1051720}, {1051722, 1051725}, {1051733, 1051734}, - {1051736, 1051738}, {1051741, 1051741}, {1051744, 1051747}, - {1051750, 1051759}, {1051776, 1051779}, {1051781, 1051788}, - {1051790, 1051792}, {1051794, 1051816}, {1051818, 1051827}, - {1051829, 1051833}, {1051836, 1051844}, {1051846, 1051848}, - {1051850, 1051853}, {1051861, 1051862}, {1051869, 1051870}, - {1051872, 1051875}, {1051878, 1051887}, {1051889, 1051891}, - {1051904, 1051916}, {1051918, 1051920}, {1051922, 1051972}, - {1051974, 1051976}, {1051978, 1051982}, {1051988, 1051991}, - {1051999, 1052003}, {1052006, 1052015}, {1052026, 1052031}, - {1052033, 1052035}, {1052037, 1052054}, {1052058, 1052081}, - {1052083, 1052091}, {1052093, 1052093}, {1052096, 1052102}, - {1052106, 1052106}, {1052111, 1052116}, {1052118, 1052118}, - {1052120, 1052127}, {1052134, 1052143}, {1052146, 1052147}, - {1052161, 1052218}, {1052224, 1052238}, {1052240, 1052249}, - {1052289, 1052290}, {1052292, 1052292}, {1052294, 1052298}, - {1052300, 1052323}, {1052325, 1052325}, {1052327, 1052349}, - {1052352, 1052356}, {1052358, 1052358}, {1052360, 1052366}, - {1052368, 1052377}, {1052380, 1052383}, {1052416, 1052416}, - {1052440, 1052441}, {1052448, 1052457}, {1052469, 1052469}, - {1052471, 1052471}, {1052473, 1052473}, {1052478, 1052487}, - {1052489, 1052524}, {1052529, 1052548}, {1052550, 1052567}, - {1052569, 1052604}, {1052614, 1052614}, {1052672, 1052745}, - {1052752, 1052829}, {1052832, 1052869}, {1052871, 1052871}, - {1052877, 1052877}, {1052880, 1052922}, {1052924, 1053256}, - {1053258, 1053261}, {1053264, 1053270}, {1053272, 1053272}, - {1053274, 1053277}, {1053280, 1053320}, {1053322, 1053325}, - {1053328, 1053360}, {1053362, 1053365}, {1053368, 1053374}, - {1053376, 1053376}, {1053378, 1053381}, {1053384, 1053398}, - {1053400, 1053456}, {1053458, 1053461}, {1053464, 1053530}, - {1053533, 1053535}, {1053545, 1053553}, {1053568, 1053583}, - {1053600, 1053685}, {1053688, 1053693}, {1053697, 1054316}, - {1054319, 1054335}, {1054337, 1054362}, {1054368, 1054442}, - {1054446, 1054456}, {1054464, 1054485}, {1054495, 1054516}, - {1054528, 1054547}, {1054560, 1054572}, {1054574, 1054576}, - {1054578, 1054579}, {1054592, 1054675}, {1054679, 1054679}, - {1054684, 1054685}, {1054688, 1054697}, {1054731, 1054733}, - {1054735, 1054745}, {1054752, 1054840}, {1054848, 1054890}, - {1054896, 1054965}, {1054976, 1055006}, {1055008, 1055019}, - {1055024, 1055035}, {1055046, 1055085}, {1055088, 1055092}, - {1055104, 1055147}, {1055152, 1055177}, {1055184, 1055194}, - {1055232, 1055259}, {1055264, 1055326}, {1055328, 1055356}, - {1055359, 1055369}, {1055376, 1055385}, {1055399, 1055399}, - {1055408, 1055421}, {1055423, 1055438}, {1055488, 1055564}, - {1055568, 1055577}, {1055595, 1055603}, {1055616, 1055731}, - {1055744, 1055799}, {1055808, 1055817}, {1055821, 1055869}, - {1055872, 1055880}, {1055888, 1055930}, {1055933, 1055935}, - {1055952, 1055954}, {1055956, 1055994}, {1056000, 1056533}, - {1056536, 1056541}, {1056544, 1056581}, {1056584, 1056589}, - {1056592, 1056599}, {1056601, 1056601}, {1056603, 1056603}, - {1056605, 1056605}, {1056607, 1056637}, {1056640, 1056692}, - {1056694, 1056700}, {1056702, 1056702}, {1056706, 1056708}, - {1056710, 1056716}, {1056720, 1056723}, {1056726, 1056731}, - {1056736, 1056748}, {1056754, 1056756}, {1056758, 1056764}, - {1056780, 1056781}, {1056831, 1056832}, {1056852, 1056852}, - {1056881, 1056881}, {1056895, 1056895}, {1056912, 1056924}, - {1056976, 1056988}, {1056993, 1056993}, {1056997, 1057008}, - {1057026, 1057026}, {1057031, 1057031}, {1057034, 1057043}, - {1057045, 1057045}, {1057048, 1057053}, {1057060, 1057060}, - {1057062, 1057062}, {1057064, 1057064}, {1057066, 1057081}, - {1057084, 1057087}, {1057093, 1057097}, {1057102, 1057102}, - {1057120, 1057160}, {1059840, 1060068}, {1060075, 1060083}, - {1060096, 1060133}, {1060135, 1060135}, {1060141, 1060141}, - {1060144, 1060199}, {1060207, 1060207}, {1060223, 1060246}, - {1060256, 1060262}, {1060264, 1060270}, {1060272, 1060278}, - {1060280, 1060286}, {1060288, 1060294}, {1060296, 1060302}, - {1060304, 1060310}, {1060312, 1060318}, {1060320, 1060351}, - {1060869, 1060871}, {1060897, 1060911}, {1060913, 1060917}, - {1060920, 1060924}, {1060929, 1061014}, {1061017, 1061023}, - {1061025, 1061114}, {1061116, 1061119}, {1061125, 1061167}, - {1061169, 1061262}, {1061280, 1061311}, {1061360, 1061375}, - {1061888, 1068479}, {1068544, 1090700}, {1090768, 1090813}, - {1090816, 1091084}, {1091088, 1091115}, {1091136, 1091183}, - {1091188, 1091197}, {1091199, 1091313}, {1091351, 1091359}, - {1091362, 1091464}, {1091467, 1091530}, {1091536, 1091537}, - {1091539, 1091539}, {1091541, 1091545}, {1091570, 1091623}, - {1091628, 1091628}, {1091648, 1091699}, {1091712, 1091781}, - {1091792, 1091801}, {1091808, 1091831}, {1091835, 1091835}, - {1091837, 1091885}, {1091888, 1091923}, {1091936, 1091964}, - {1091968, 1092032}, {1092047, 1092057}, {1092064, 1092094}, - {1092096, 1092150}, {1092160, 1092173}, {1092176, 1092185}, - {1092192, 1092214}, {1092218, 1092290}, {1092315, 1092317}, - {1092320, 1092335}, {1092338, 1092342}, {1092353, 1092358}, - {1092361, 1092366}, {1092369, 1092374}, {1092384, 1092390}, - {1092392, 1092398}, {1092400, 1092442}, {1092444, 1092457}, - {1092464, 1092586}, {1092588, 1092589}, {1092592, 1092601}, - {1092608, 1103779}, {1103792, 1103814}, {1103819, 1103867}, - {1112320, 1112685}, {1112688, 1112793}, {1112832, 1112838}, - {1112851, 1112855}, {1112861, 1112872}, {1112874, 1112886}, - {1112888, 1112892}, {1112894, 1112894}, {1112896, 1112897}, - {1112899, 1112900}, {1112902, 1113009}, {1113043, 1113405}, - {1113424, 1113487}, {1113490, 1113543}, {1113584, 1113595}, - {1113600, 1113615}, {1113632, 1113647}, {1113651, 1113652}, - {1113677, 1113679}, {1113712, 1113716}, {1113718, 1113852}, - {1113872, 1113881}, {1113889, 1113914}, {1113919, 1113919}, - {1113921, 1113946}, {1113958, 1114046}, {1114050, 1114055}, - {1114058, 1114063}, {1114066, 1114071}, {1114074, 1114076}}; +size_t valid_id_part_ranges_unicode[770][2] = { + {36, 36}, {48, 57}, {65, 90}, {95, 95}, + {97, 122}, {170, 170}, {181, 181}, {183, 183}, + {186, 186}, {192, 214}, {216, 246}, {248, 705}, + {710, 721}, {736, 740}, {748, 748}, {750, 750}, + {768, 884}, {886, 887}, {890, 893}, {895, 895}, + {902, 906}, {908, 908}, {910, 929}, {931, 1013}, + {1015, 1153}, {1155, 1159}, {1162, 1327}, {1329, 1366}, + {1369, 1369}, {1376, 1416}, {1425, 1469}, {1471, 1471}, + {1473, 1474}, {1476, 1477}, {1479, 1479}, {1488, 1514}, + {1519, 1522}, {1552, 1562}, {1568, 1641}, {1646, 1747}, + {1749, 1756}, {1759, 1768}, {1770, 1788}, {1791, 1791}, + {1808, 1866}, {1869, 1969}, {1984, 2037}, {2042, 2042}, + {2045, 2045}, {2048, 2093}, {2112, 2139}, {2144, 2154}, + {2160, 2183}, {2185, 2190}, {2200, 2273}, {2275, 2403}, + {2406, 2415}, {2417, 2435}, {2437, 2444}, {2447, 2448}, + {2451, 2472}, {2474, 2480}, {2482, 2482}, {2486, 2489}, + {2492, 2500}, {2503, 2504}, {2507, 2510}, {2519, 2519}, + {2524, 2525}, {2527, 2531}, {2534, 2545}, {2556, 2556}, + {2558, 2558}, {2561, 2563}, {2565, 2570}, {2575, 2576}, + {2579, 2600}, {2602, 2608}, {2610, 2611}, {2613, 2614}, + {2616, 2617}, {2620, 2620}, {2622, 2626}, {2631, 2632}, + {2635, 2637}, {2641, 2641}, {2649, 2652}, {2654, 2654}, + {2662, 2677}, {2689, 2691}, {2693, 2701}, {2703, 2705}, + {2707, 2728}, {2730, 2736}, {2738, 2739}, {2741, 2745}, + {2748, 2757}, {2759, 2761}, {2763, 2765}, {2768, 2768}, + {2784, 2787}, {2790, 2799}, {2809, 2815}, {2817, 2819}, + {2821, 2828}, {2831, 2832}, {2835, 2856}, {2858, 2864}, + {2866, 2867}, {2869, 2873}, {2876, 2884}, {2887, 2888}, + {2891, 2893}, {2901, 2903}, {2908, 2909}, {2911, 2915}, + {2918, 2927}, {2929, 2929}, {2946, 2947}, {2949, 2954}, + {2958, 2960}, {2962, 2965}, {2969, 2970}, {2972, 2972}, + {2974, 2975}, {2979, 2980}, {2984, 2986}, {2990, 3001}, + {3006, 3010}, {3014, 3016}, {3018, 3021}, {3024, 3024}, + {3031, 3031}, {3046, 3055}, {3072, 3084}, {3086, 3088}, + {3090, 3112}, {3114, 3129}, {3132, 3140}, {3142, 3144}, + {3146, 3149}, {3157, 3158}, {3160, 3162}, {3165, 3165}, + {3168, 3171}, {3174, 3183}, {3200, 3203}, {3205, 3212}, + {3214, 3216}, {3218, 3240}, {3242, 3251}, {3253, 3257}, + {3260, 3268}, {3270, 3272}, {3274, 3277}, {3285, 3286}, + {3293, 3294}, {3296, 3299}, {3302, 3311}, {3313, 3315}, + {3328, 3340}, {3342, 3344}, {3346, 3396}, {3398, 3400}, + {3402, 3406}, {3412, 3415}, {3423, 3427}, {3430, 3439}, + {3450, 3455}, {3457, 3459}, {3461, 3478}, {3482, 3505}, + {3507, 3515}, {3517, 3517}, {3520, 3526}, {3530, 3530}, + {3535, 3540}, {3542, 3542}, {3544, 3551}, {3558, 3567}, + {3570, 3571}, {3585, 3642}, {3648, 3662}, {3664, 3673}, + {3713, 3714}, {3716, 3716}, {3718, 3722}, {3724, 3747}, + {3749, 3749}, {3751, 3773}, {3776, 3780}, {3782, 3782}, + {3784, 3790}, {3792, 3801}, {3804, 3807}, {3840, 3840}, + {3864, 3865}, {3872, 3881}, {3893, 3893}, {3895, 3895}, + {3897, 3897}, {3902, 3911}, {3913, 3948}, {3953, 3972}, + {3974, 3991}, {3993, 4028}, {4038, 4038}, {4096, 4169}, + {4176, 4253}, {4256, 4293}, {4295, 4295}, {4301, 4301}, + {4304, 4346}, {4348, 4680}, {4682, 4685}, {4688, 4694}, + {4696, 4696}, {4698, 4701}, {4704, 4744}, {4746, 4749}, + {4752, 4784}, {4786, 4789}, {4792, 4798}, {4800, 4800}, + {4802, 4805}, {4808, 4822}, {4824, 4880}, {4882, 4885}, + {4888, 4954}, {4957, 4959}, {4969, 4977}, {4992, 5007}, + {5024, 5109}, {5112, 5117}, {5121, 5740}, {5743, 5759}, + {5761, 5786}, {5792, 5866}, {5870, 5880}, {5888, 5909}, + {5919, 5940}, {5952, 5971}, {5984, 5996}, {5998, 6000}, + {6002, 6003}, {6016, 6099}, {6103, 6103}, {6108, 6109}, + {6112, 6121}, {6155, 6157}, {6159, 6169}, {6176, 6264}, + {6272, 6314}, {6320, 6389}, {6400, 6430}, {6432, 6443}, + {6448, 6459}, {6470, 6509}, {6512, 6516}, {6528, 6571}, + {6576, 6601}, {6608, 6618}, {6656, 6683}, {6688, 6750}, + {6752, 6780}, {6783, 6793}, {6800, 6809}, {6823, 6823}, + {6832, 6845}, {6847, 6862}, {6912, 6988}, {6992, 7001}, + {7019, 7027}, {7040, 7155}, {7168, 7223}, {7232, 7241}, + {7245, 7293}, {7296, 7304}, {7312, 7354}, {7357, 7359}, + {7376, 7378}, {7380, 7418}, {7424, 7957}, {7960, 7965}, + {7968, 8005}, {8008, 8013}, {8016, 8023}, {8025, 8025}, + {8027, 8027}, {8029, 8029}, {8031, 8061}, {8064, 8116}, + {8118, 8124}, {8126, 8126}, {8130, 8132}, {8134, 8140}, + {8144, 8147}, {8150, 8155}, {8160, 8172}, {8178, 8180}, + {8182, 8188}, {8204, 8205}, {8255, 8256}, {8276, 8276}, + {8305, 8305}, {8319, 8319}, {8336, 8348}, {8400, 8412}, + {8417, 8417}, {8421, 8432}, {8450, 8450}, {8455, 8455}, + {8458, 8467}, {8469, 8469}, {8472, 8477}, {8484, 8484}, + {8486, 8486}, {8488, 8488}, {8490, 8505}, {8508, 8511}, + {8517, 8521}, {8526, 8526}, {8544, 8584}, {11264, 11492}, + {11499, 11507}, {11520, 11557}, {11559, 11559}, {11565, 11565}, + {11568, 11623}, {11631, 11631}, {11647, 11670}, {11680, 11686}, + {11688, 11694}, {11696, 11702}, {11704, 11710}, {11712, 11718}, + {11720, 11726}, {11728, 11734}, {11736, 11742}, {11744, 11775}, + {12293, 12295}, {12321, 12335}, {12337, 12341}, {12344, 12348}, + {12353, 12438}, {12441, 12447}, {12449, 12538}, {12540, 12543}, + {12549, 12591}, {12593, 12686}, {12704, 12735}, {12784, 12799}, + {13312, 19903}, {19968, 42124}, {42192, 42237}, {42240, 42508}, + {42512, 42539}, {42560, 42607}, {42612, 42621}, {42623, 42737}, + {42775, 42783}, {42786, 42888}, {42891, 42954}, {42960, 42961}, + {42963, 42963}, {42965, 42969}, {42994, 43047}, {43052, 43052}, + {43072, 43123}, {43136, 43205}, {43216, 43225}, {43232, 43255}, + {43259, 43259}, {43261, 43309}, {43312, 43347}, {43360, 43388}, + {43392, 43456}, {43471, 43481}, {43488, 43518}, {43520, 43574}, + {43584, 43597}, {43600, 43609}, {43616, 43638}, {43642, 43714}, + {43739, 43741}, {43744, 43759}, {43762, 43766}, {43777, 43782}, + {43785, 43790}, {43793, 43798}, {43808, 43814}, {43816, 43822}, + {43824, 43866}, {43868, 43881}, {43888, 44010}, {44012, 44013}, + {44016, 44025}, {44032, 55203}, {55216, 55238}, {55243, 55291}, + {63744, 64109}, {64112, 64217}, {64256, 64262}, {64275, 64279}, + {64285, 64296}, {64298, 64310}, {64312, 64316}, {64318, 64318}, + {64320, 64321}, {64323, 64324}, {64326, 64433}, {64467, 64829}, + {64848, 64911}, {64914, 64967}, {65008, 65019}, {65024, 65039}, + {65056, 65071}, {65075, 65076}, {65101, 65103}, {65136, 65140}, + {65142, 65276}, {65296, 65305}, {65313, 65338}, {65343, 65343}, + {65345, 65370}, {65382, 65470}, {65474, 65479}, {65482, 65487}, + {65490, 65495}, {65498, 65500}, {65536, 65547}, {65549, 65574}, + {65576, 65594}, {65596, 65597}, {65599, 65613}, {65616, 65629}, + {65664, 65786}, {65856, 65908}, {66045, 66045}, {66176, 66204}, + {66208, 66256}, {66272, 66272}, {66304, 66335}, {66349, 66378}, + {66384, 66426}, {66432, 66461}, {66464, 66499}, {66504, 66511}, + {66513, 66517}, {66560, 66717}, {66720, 66729}, {66736, 66771}, + {66776, 66811}, {66816, 66855}, {66864, 66915}, {66928, 66938}, + {66940, 66954}, {66956, 66962}, {66964, 66965}, {66967, 66977}, + {66979, 66993}, {66995, 67001}, {67003, 67004}, {67072, 67382}, + {67392, 67413}, {67424, 67431}, {67456, 67461}, {67463, 67504}, + {67506, 67514}, {67584, 67589}, {67592, 67592}, {67594, 67637}, + {67639, 67640}, {67644, 67644}, {67647, 67669}, {67680, 67702}, + {67712, 67742}, {67808, 67826}, {67828, 67829}, {67840, 67861}, + {67872, 67897}, {67968, 68023}, {68030, 68031}, {68096, 68099}, + {68101, 68102}, {68108, 68115}, {68117, 68119}, {68121, 68149}, + {68152, 68154}, {68159, 68159}, {68192, 68220}, {68224, 68252}, + {68288, 68295}, {68297, 68326}, {68352, 68405}, {68416, 68437}, + {68448, 68466}, {68480, 68497}, {68608, 68680}, {68736, 68786}, + {68800, 68850}, {68864, 68903}, {68912, 68921}, {69248, 69289}, + {69291, 69292}, {69296, 69297}, {69373, 69404}, {69415, 69415}, + {69424, 69456}, {69488, 69509}, {69552, 69572}, {69600, 69622}, + {69632, 69702}, {69734, 69749}, {69759, 69818}, {69826, 69826}, + {69840, 69864}, {69872, 69881}, {69888, 69940}, {69942, 69951}, + {69956, 69959}, {69968, 70003}, {70006, 70006}, {70016, 70084}, + {70089, 70092}, {70094, 70106}, {70108, 70108}, {70144, 70161}, + {70163, 70199}, {70206, 70209}, {70272, 70278}, {70280, 70280}, + {70282, 70285}, {70287, 70301}, {70303, 70312}, {70320, 70378}, + {70384, 70393}, {70400, 70403}, {70405, 70412}, {70415, 70416}, + {70419, 70440}, {70442, 70448}, {70450, 70451}, {70453, 70457}, + {70459, 70468}, {70471, 70472}, {70475, 70477}, {70480, 70480}, + {70487, 70487}, {70493, 70499}, {70502, 70508}, {70512, 70516}, + {70656, 70730}, {70736, 70745}, {70750, 70753}, {70784, 70853}, + {70855, 70855}, {70864, 70873}, {71040, 71093}, {71096, 71104}, + {71128, 71133}, {71168, 71232}, {71236, 71236}, {71248, 71257}, + {71296, 71352}, {71360, 71369}, {71424, 71450}, {71453, 71467}, + {71472, 71481}, {71488, 71494}, {71680, 71738}, {71840, 71913}, + {71935, 71942}, {71945, 71945}, {71948, 71955}, {71957, 71958}, + {71960, 71989}, {71991, 71992}, {71995, 72003}, {72016, 72025}, + {72096, 72103}, {72106, 72151}, {72154, 72161}, {72163, 72164}, + {72192, 72254}, {72263, 72263}, {72272, 72345}, {72349, 72349}, + {72368, 72440}, {72704, 72712}, {72714, 72758}, {72760, 72768}, + {72784, 72793}, {72818, 72847}, {72850, 72871}, {72873, 72886}, + {72960, 72966}, {72968, 72969}, {72971, 73014}, {73018, 73018}, + {73020, 73021}, {73023, 73031}, {73040, 73049}, {73056, 73061}, + {73063, 73064}, {73066, 73102}, {73104, 73105}, {73107, 73112}, + {73120, 73129}, {73440, 73462}, {73472, 73488}, {73490, 73530}, + {73534, 73538}, {73552, 73561}, {73648, 73648}, {73728, 74649}, + {74752, 74862}, {74880, 75075}, {77712, 77808}, {77824, 78895}, + {78912, 78933}, {82944, 83526}, {92160, 92728}, {92736, 92766}, + {92768, 92777}, {92784, 92862}, {92864, 92873}, {92880, 92909}, + {92912, 92916}, {92928, 92982}, {92992, 92995}, {93008, 93017}, + {93027, 93047}, {93053, 93071}, {93760, 93823}, {93952, 94026}, + {94031, 94087}, {94095, 94111}, {94176, 94177}, {94179, 94180}, + {94192, 94193}, {94208, 100343}, {100352, 101589}, {101632, 101640}, + {110576, 110579}, {110581, 110587}, {110589, 110590}, {110592, 110882}, + {110898, 110898}, {110928, 110930}, {110933, 110933}, {110948, 110951}, + {110960, 111355}, {113664, 113770}, {113776, 113788}, {113792, 113800}, + {113808, 113817}, {113821, 113822}, {118528, 118573}, {118576, 118598}, + {119141, 119145}, {119149, 119154}, {119163, 119170}, {119173, 119179}, + {119210, 119213}, {119362, 119364}, {119808, 119892}, {119894, 119964}, + {119966, 119967}, {119970, 119970}, {119973, 119974}, {119977, 119980}, + {119982, 119993}, {119995, 119995}, {119997, 120003}, {120005, 120069}, + {120071, 120074}, {120077, 120084}, {120086, 120092}, {120094, 120121}, + {120123, 120126}, {120128, 120132}, {120134, 120134}, {120138, 120144}, + {120146, 120485}, {120488, 120512}, {120514, 120538}, {120540, 120570}, + {120572, 120596}, {120598, 120628}, {120630, 120654}, {120656, 120686}, + {120688, 120712}, {120714, 120744}, {120746, 120770}, {120772, 120779}, + {120782, 120831}, {121344, 121398}, {121403, 121452}, {121461, 121461}, + {121476, 121476}, {121499, 121503}, {121505, 121519}, {122624, 122654}, + {122661, 122666}, {122880, 122886}, {122888, 122904}, {122907, 122913}, + {122915, 122916}, {122918, 122922}, {122928, 122989}, {123023, 123023}, + {123136, 123180}, {123184, 123197}, {123200, 123209}, {123214, 123214}, + {123536, 123566}, {123584, 123641}, {124112, 124153}, {124896, 124902}, + {124904, 124907}, {124909, 124910}, {124912, 124926}, {124928, 125124}, + {125136, 125142}, {125184, 125259}, {125264, 125273}, {126464, 126467}, + {126469, 126495}, {126497, 126498}, {126500, 126500}, {126503, 126503}, + {126505, 126514}, {126516, 126519}, {126521, 126521}, {126523, 126523}, + {126530, 126530}, {126535, 126535}, {126537, 126537}, {126539, 126539}, + {126541, 126543}, {126545, 126546}, {126548, 126548}, {126551, 126551}, + {126553, 126553}, {126555, 126555}, {126557, 126557}, {126559, 126559}, + {126561, 126562}, {126564, 126564}, {126567, 126570}, {126572, 126578}, + {126580, 126583}, {126585, 126588}, {126590, 126590}, {126592, 126601}, + {126603, 126619}, {126625, 126627}, {126629, 126633}, {126635, 126651}, + {130032, 130041}, {131072, 173791}, {173824, 177977}, {177984, 178205}, + {178208, 183969}, {183984, 191456}, {194560, 195101}, {196608, 201546}, + {201552, 205743}, {917760, 917999}}; ada_really_inline std::bitset<0x10FFFF> init_valid_id_part_mask_unicode() { std::bitset<0x10FFFF> id_part_mask{}; @@ -4955,6 +734,9 @@ static_assert(sizeof(valid_id_part_table_ascii) == 256); // https://wicg.github.io/urlpattern/#is-a-valid-name-code-point ada_really_inline bool is_valid_identifier_part(const char32_t& c) noexcept { + if (c == U'𐤀') { + std::cerr << "PART Hello!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; + } return c < 256 ? /* extended ascii fast-path*/ valid_id_part_table_ascii[c] : valid_id_part_mask_unicode[c]; } From 824725d16bf2c27a2a6b935ce14c7b31b4ec82fd Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 6 Jun 2023 23:47:35 -0300 Subject: [PATCH 18/23] urlpattern: WIP fix tokenizer --- src/urlpattern_tokenizer.cpp | 213 +++++++++++++++++++++++++---------- 1 file changed, 152 insertions(+), 61 deletions(-) diff --git a/src/urlpattern_tokenizer.cpp b/src/urlpattern_tokenizer.cpp index 7ee6f2ca4..39c6712a6 100644 --- a/src/urlpattern_tokenizer.cpp +++ b/src/urlpattern_tokenizer.cpp @@ -3,6 +3,7 @@ #include "ada/urlpattern.h" #include +#include namespace ada::urlpattern { @@ -15,9 +16,9 @@ ada_really_inline bool is_valid_name_code_point(const char32_t &c, ada_really_inline bool is_ascii(char32_t &c) { return c < 0x80; } // https://wicg.github.io/urlpattern/#seek-and-get-the-next-code-point -ada_really_inline void tokenizer::seek_and_get_next_code_point() { +ada_really_inline void tokenizer::seek_and_get_next_code_point(size_t &_index) { // Set tokenizer’s next index to index. - index = next_index; + next_index = _index; // Run get the next code point given tokenizer. get_next_code_point(); @@ -27,24 +28,43 @@ ada_really_inline void tokenizer::seek_and_get_next_code_point() { ada_really_inline void tokenizer::get_next_code_point() { // Set tokenizer’s code point to the Unicode code point in tokenizer’s input // at the position indicated by tokenizer’s next index. - code_point = input[index]; + code_point = input[next_index]; // Increment tokenizer’s next index by 1. ++next_index; } // https://wicg.github.io/urlpattern/#add-a-token -ada_really_inline void tokenizer::add_token(TOKEN_TYPE type, size_t next_pos, - size_t value_start, +ada_really_inline void tokenizer::add_token(TOKEN_TYPE type, size_t value_start, size_t value_end) { - // Let token be a new token. token new_token = token(); new_token.type = type; new_token.value_start = value_start; new_token.value_end = value_end; token_list.push_back(new_token); - index = next_pos; + index = value_end; +} + +// https://wicg.github.io/urlpattern/#add-a-token +ada_really_inline void tokenizer::add_token(TOKEN_TYPE type) { + // 1. Let token be a new token. + token new_token = token(); + + // 2. Set token’s type to type. + new_token.type = type; + + // 3. Set token’s index to tokenizer’s index. + // 4. Set token’s value to the code point substring from value position with + // length value length within tokenizer’s input. + new_token.value_start = index; + new_token.value_end = index; + + // 5. Append token to the back of tokenizer’s token list. + token_list.push_back(new_token); + + // Set tokenizer’s index to next position. + index = next_index; } void tokenizer::process_tokenizing_error(std::string_view msg, @@ -53,82 +73,93 @@ void tokenizer::process_tokenizing_error(std::string_view msg, throw std::invalid_argument(std::string(msg)); } - token_list.push_back({TOKEN_TYPE::INVALID_CHAR, value_start, value_end}); + add_token(TOKEN_TYPE::INVALID_CHAR, value_start, value_end); } -std::vector tokenize(std::u32string_view _input, - ada::urlpattern::POLICY _policy) { +std::vector tokenize(std::u32string_view input, + ada::urlpattern::POLICY policy) { // Let tokenizer be a new tokenizer. auto t = tokenizer(); // Set tokenizer’s input to input. - t.input = _input; + t.input = input; // Set tokenizer’s policy to policy. - t.policy = _policy; + t.policy = policy; // While tokenizer’s index is less than tokenizer’s input's code point length: while (t.index < t.input.size()) { - std::cout << t.code_point << std::endl; // Run seek and get the next code point given tokenizer and tokenizer’s // index. - t.seek_and_get_next_code_point(); + t.seek_and_get_next_code_point(t.index); switch (t.code_point) { case '*': { + std::cerr << "'*'" << std::endl; // Run add a token with default position and length given tokenizer and // "asterisk". - t.add_token(TOKEN_TYPE::ASTERISK, t.next_index, t.index, t.index); - continue; + t.add_token(TOKEN_TYPE::ASTERISK); + break; } case '+': case '?': { - t.add_token(TOKEN_TYPE::OTHER_MODIFIER, t.next_index, t.index, t.index); - continue; + std::cerr << "'?''+'" << std::endl; + t.add_token(TOKEN_TYPE::OTHER_MODIFIER); + break; } case '\\': { - // If tokenizer’s index is equal to tokenizer’s input's code point + std::cerr << "'\\'" << std::endl; + // 1. If tokenizer’s index is equal to tokenizer’s input's code point // length − 1: if (t.index == t.input.size() - 1) { // Run process a tokenizing error given tokenizer, tokenizer’s next // index, and tokenizer’s index. t.process_tokenizing_error("should scape something", /*value_start*/ t.index, - /*value_end*/ t.index); + /*value_end*/ t.next_index); continue; } + // 2.Let escaped index be tokenizer’s next index. + size_t escaped_index = t.next_index; - // Run get the next code point given tokenizer. + // 3. Run get the next code point given tokenizer. t.get_next_code_point(); // Run add a token with default length given tokenizer, "escaped-char", // tokenizer’s next index, and escaped index. - t.add_token(TOKEN_TYPE::ESCAPED_CHAR, t.next_index, t.index, t.index); - continue; + t.add_token(TOKEN_TYPE::ESCAPED_CHAR, escaped_index, escaped_index); + break; } case '{': { - t.add_token(TOKEN_TYPE::OPEN, t.next_index, t.index, t.index); - continue; + std::cerr << "'{'" << std::endl; + t.add_token(TOKEN_TYPE::OPEN); + break; } case '}': { - t.add_token(TOKEN_TYPE::CLOSE, t.next_index, t.index, t.index); - continue; + std::cerr << "'}'" << std::endl; + t.add_token(TOKEN_TYPE::CLOSE); + break; } case ':': { - // Let name position be tokenizer’s next index. + std::cerr << "':'" << std::endl; + // 1. Let name position be tokenizer’s next index. size_t name_start, name_position; name_position = t.next_index; - // Let name start be name position. + // 2. Let name start be name position. name_start = name_position; - // While name position is less than tokenizer’s input's code point + // 3. While name position is less than tokenizer’s input's code point // length: while (name_position < t.input.size()) { + std::cerr << name_position << std::endl; + if (t.code_point == U'𐤀') { + std::cerr << "HELLOOOOOOOO" << std::endl; + } + // Run seek and get the next code point given tokenizer and name // position. - std::cout << "NEXT INDEX" << t.next_index << std::endl; - t.seek_and_get_next_code_point(); + t.seek_and_get_next_code_point(name_position); // Let first code point be true if name position equals name start and // false otherwise. @@ -136,56 +167,102 @@ std::vector tokenize(std::u32string_view _input, // Let valid code point be the result of running is a valid name code // point given tokenizer’s code point and first code point. + // std::cerr << "IS FIRST " << first_code_point << std::endl; bool valid_code_point = - is_valid_name_code_point(t.input[t.code_point], + is_valid_name_code_point(t.input[name_position], /*is_first=*/first_code_point); // If valid code point is false break. - if (!valid_code_point) break; + if (!valid_code_point) { + std::cerr << "NOT VALID CODE POOINT" << t.code_point << std::endl; + break; + } // Set name position to tokenizer’s next index. name_position = t.next_index; + std::cerr << "final: " << name_position << std::endl; } + std::cerr << "after loop: " << name_position << std::endl; + + // If name position is less than or equal to name start: if (name_position <= name_start) { - t.process_tokenizing_error("missing pattern name", name_start, - t.index); - continue; + std::cerr << "ERROR " << name_position << std::endl; + t.process_tokenizing_error("missing pattern name", t.index, + name_start); + break; } - t.add_token(TOKEN_TYPE::NAME, t.next_index, name_start, name_position); - continue; + t.add_token(TOKEN_TYPE::NAME, name_start, name_position); + break; } case '(': { - size_t regexp_start, regexp_position, depth; + std::cerr << "'('" << std::endl; + // 1. Let depth be 1. + size_t depth = 1; + + size_t regexp_start, regexp_position; + + // 2. Let regexp position be tokenizer’s next index. regexp_position = t.next_index; + + // 3. Let regexp start be regexp position. regexp_start = regexp_position; - depth = 1; + // 4. Let error be false. bool error = false; while (regexp_position < t.input.size()) { - t.seek_and_get_next_code_point(); + // 1. Run seek and get the next code point given tokenizer and regexp + // position. + t.seek_and_get_next_code_point(regexp_position); + + // 2. If the result of running is ASCII given tokenizer’s code point + // is false: if (!is_ascii(t.code_point)) { + // Run process a tokenizing error given tokenizer, regexp start, + // and tokenizer’s index. + // Set error to true. + // Break. t.process_tokenizing_error("invalid char for regex", regexp_start, - regexp_position); + t.index); error = true; break; } + + // 3. If regexp position equals regexp start and tokenizer’s code + // point is U+003F (?): if (t.code_point == '?' && (regexp_position == regexp_start)) { + // Run process a tokenizing error given tokenizer, regexp start, + // and tokenizer’s index. + // Set error to true. + // Break. t.process_tokenizing_error("malformed regex", regexp_start, t.index); error = true; break; } + + // 4. If tokenizer’s code point is U+005C (\): if (t.code_point == '\\') { + // 1. If regexp position equals tokenizer’s input's code point + // length − 1: if (regexp_position == t.input.size() - 1) { + // Run process a tokenizing error given tokenizer, regexp start, + // and tokenizer’s index. + // Set error to true. + // Break. t.process_tokenizing_error("malformed regex", regexp_start, t.index); error = true; break; } + + // 2. Run get the next code point given tokenizer. t.get_next_code_point(); + + // 3. If the result of running is ASCII given tokenizer’s code point + // is false if (!is_ascii(t.code_point)) { t.process_tokenizing_error("invalid char for regex", regexp_start, t.index); @@ -193,17 +270,26 @@ std::vector tokenize(std::u32string_view _input, error = true; break; } + + // 4. Set regexp position to tokenizer’s next index. regexp_position = t.next_index; continue; } + // 5. If tokenizer’s code point is U+0029 ()): if (t.code_point == ')') { --depth; if (depth == 0) { + // Set regexp position to tokenizer’s next index. regexp_position = t.next_index; + break; } - } else if (t.code_point == '(') { + } + // 6. Else if tokenizer’s code point is U+0028 ((): + else if (t.code_point == '(') { ++depth; + // 2. If regexp position equals tokenizer’s input's code point + // length − 1: if (regexp_position == t.input.size() - 1) { t.process_tokenizing_error("malformed regex", regexp_start, t.index); @@ -211,7 +297,10 @@ std::vector tokenize(std::u32string_view _input, error = true; break; } + // Let temporary position be tokenizer’s next index. size_t tmp_pos = t.next_index; + + // Run get the next code point given tokenizer. t.get_next_code_point(); if (t.code_point != '?') { @@ -223,33 +312,35 @@ std::vector tokenize(std::u32string_view _input, } t.next_index = tmp_pos; } + // 7. Set regexp position to tokenizer’s next index. + regexp_position = t.next_index; + } - if (error) continue; - - if (depth) { - t.process_tokenizing_error("malformed regex", regexp_start, - t.index); - continue; - } + // If error is true continue. + if (error) break; - if ((regexp_position - regexp_start) == 0) { - t.process_tokenizing_error("malformed regex", regexp_start, - t.index); - continue; - } + if (depth) { + t.process_tokenizing_error("malformed regex", regexp_start, t.index); + break; + } - t.add_token(TOKEN_TYPE::REGEXP, /*next_pos=*/regexp_position, - regexp_start, regexp_position); - continue; + // 8. Let regexp length be regexp position − regexp start − 1. + if ((regexp_position - regexp_start - 1) == 0) { + t.process_tokenizing_error("malformed regex", regexp_start, t.index); + break; } + + t.add_token(TOKEN_TYPE::REGEXP, regexp_start, regexp_position); + break; } default: { // TODO: maybe group the TOKEN_TYPE::CHARs to make tokens cheaper - t.add_token(TOKEN_TYPE::CHAR, t.next_index, t.index, t.index); + t.add_token(TOKEN_TYPE::CHAR); + break; } } } - t.add_token(TOKEN_TYPE::END, t.next_index, t.index, t.index); + t.add_token(TOKEN_TYPE::END); return t.token_list; } From 88453a5033394090f0fa12faf40a2ab410f37922 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 6 Jun 2023 23:48:46 -0300 Subject: [PATCH 19/23] urlpattern: update tokenizer --- include/ada/urlpattern_tokenizer.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/ada/urlpattern_tokenizer.h b/include/ada/urlpattern_tokenizer.h index 318f6d231..5c6035e25 100644 --- a/include/ada/urlpattern_tokenizer.h +++ b/include/ada/urlpattern_tokenizer.h @@ -40,14 +40,15 @@ struct tokenizer { char32_t code_point; // https://wicg.github.io/urlpattern/#seek-and-get-the-next-code-point - ada_really_inline void seek_and_get_next_code_point(); + ada_really_inline void seek_and_get_next_code_point(size_t &_index); // https://wicg.github.io/urlpattern/#get-the-next-code-point ada_really_inline void get_next_code_point(); // https://wicg.github.io/urlpattern/#add-a-token - ada_really_inline void add_token(TOKEN_TYPE type, size_t next_pos, - size_t value_start, size_t value_end); + ada_really_inline void add_token(TOKEN_TYPE type, size_t value_start, + size_t value_end); + ada_really_inline void add_token(TOKEN_TYPE type); // https://wicg.github.io/urlpattern/#process-a-tokenizing-error ada_really_inline void process_tokenizing_error(std::string_view msg, From 6e14684ed0a9125c8fdcb1fcb3760cfbd4a01955 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Tue, 6 Jun 2023 23:49:13 -0300 Subject: [PATCH 20/23] urlpattern: updates tokenizer's test --- tests/urlpattern_tokenizer_tests.cpp | 149 +++++++++++++++++++-------- 1 file changed, 105 insertions(+), 44 deletions(-) diff --git a/tests/urlpattern_tokenizer_tests.cpp b/tests/urlpattern_tokenizer_tests.cpp index ba7098408..55d45aa88 100644 --- a/tests/urlpattern_tokenizer_tests.cpp +++ b/tests/urlpattern_tokenizer_tests.cpp @@ -10,29 +10,82 @@ using namespace simdjson; using namespace ada; -bool operator!=(const urlpattern::token& lhs, const urlpattern::token& rhs) { - return !(lhs.type == rhs.type && lhs.value_end == rhs.value_end && - lhs.value_start == rhs.value_start); -} - bool is_token_list_equal(std::vector& first, - std::vector& second) { - if (first.size() != second.size()) return false; - for (size_t i = 0; i < first.size(); i++) { - if (first[i] != second[i]) { - return false; + std::vector& second); + +std::string to_utf8(std::u32string_view utf32); +std::u32string to_utf32(std::string_view utf8); + +bool operator!=(const urlpattern::token& lhs, const urlpattern::token& rhs); + +std::vector arr_token_from_json( + ondemand::array& raw_token_arr); + +std::string_view TOKENIZER_TESTDATA = "urlpattern/tokenizer.json"; + +TEST(urlpattern_tests, tokenize) { + ondemand::parser parser; + padded_string json = padded_string::load(TOKENIZER_TESTDATA); + + auto token_type_to_string = [](urlpattern::TOKEN_TYPE type) { + switch (type) { + case (urlpattern::TOKEN_TYPE::OPEN): + return "OPEN"; + case (urlpattern::TOKEN_TYPE::CLOSE): + return "CLOSE"; + case (urlpattern::TOKEN_TYPE::ASTERISK): + return "ASTERISK"; + case (ada::urlpattern::TOKEN_TYPE::END): + return "END"; + case (urlpattern::TOKEN_TYPE::REGEXP): + return "REGEXP"; + case (urlpattern::TOKEN_TYPE::NAME): + return "NAME"; + case (ada::urlpattern::TOKEN_TYPE::ESCAPED_CHAR): + return "ESCAPED_CHAR"; + case (urlpattern::TOKEN_TYPE::OTHER_MODIFIER): + return "OTHER_MODIFIER"; + case (urlpattern::TOKEN_TYPE::INVALID_CHAR): + return "INVALID_CHAR"; + case (urlpattern::TOKEN_TYPE::CHAR): + return "CHAR"; } - } - return true; -} + }; -std::u32string to_utf32(std::string_view utf8) { - size_t utf32_length = - ada::idna::utf32_length_from_utf8(utf8.data(), utf8.size()); - std::u32string utf32(utf32_length, '\0'); - idna::utf8_to_utf32(utf8.data(), utf8.size(), utf32.data()); + ondemand::document doc = parser.iterate(json); + try { + for (auto test_case : doc.get_array()) { + ondemand::object object = test_case.get_object(); - return utf32; + std::string_view utf8_input = object["input"].get_string(); + auto utf32_input = to_utf32(utf8_input); + + ondemand::array raw_expected_output = object["output"].get_array(); + auto expected_output = arr_token_from_json(raw_expected_output); + + auto tokens = + urlpattern::tokenize(utf32_input, urlpattern::POLICY::LENIENT); + + for (size_t i = 0; i < tokens.size(); i++) { + std::cerr << token_type_to_string(tokens[i].type) << ": "; + std::cerr << to_utf8(utf32_input.substr( + tokens[i].value_start, + tokens[i].value_end - tokens[i].value_start + 1)) + << std::endl; + } + // if (!is_token_list_equal(expected_output, tokens)) { + // std::cerr << "expected size: " << expected_output.size() + // << " actual: " << tokens.size() << std::endl; + // } + // ASSERT_TRUE(is_token_list_equal(expected_output, tokens)); + } + } catch (simdjson::simdjson_error& error) { + std::cerr << "JSON error: " << error.what() << " near " + << doc.current_location() << " in " << TOKENIZER_TESTDATA + << std::endl; + FAIL(); + } + SUCCEED(); } std::vector arr_token_from_json( @@ -64,33 +117,41 @@ std::vector arr_token_from_json( return arr_token; } -std::string_view TOKENIZER_TESTDATA = "urlpattern/tokenizer.json"; - -TEST(urlpattern_tests, tokenize) { - ondemand::parser parser; - padded_string json = padded_string::load(TOKENIZER_TESTDATA); +bool is_token_list_equal(std::vector& first, + std::vector& second) { + // if (first.size() != second.size()) { + // return false; + // } + for (size_t i = 0; i < first.size(); i++) { + if (first[i] != second[i]) { + std::cerr << "first: AAA " << first[i].value_end << " " + << first[i].value_start << std::endl; + std::cerr << "second: AAA " << second[i].value_end << " " + << second[i].value_start << std::endl; + } + } + return true; +} - ondemand::document doc = parser.iterate(json); - try { - for (auto test_case : doc.get_array()) { - ondemand::object object = test_case.get_object(); +bool operator!=(const urlpattern::token& lhs, const urlpattern::token& rhs) { + return !(lhs.type == rhs.type && lhs.value_end == rhs.value_end && + lhs.value_start == rhs.value_start); +} - std::string_view utf8_input = object["input"].get_string(); - auto utf32_input = to_utf32(utf8_input); +std::u32string to_utf32(std::string_view utf8) { + size_t utf32_length = + ada::idna::utf32_length_from_utf8(utf8.data(), utf8.size()); + std::u32string utf32(utf32_length, '\0'); + idna::utf8_to_utf32(utf8.data(), utf8.size(), utf32.data()); - ondemand::array raw_expected_output = object["output"].get_array(); - auto expected_output = arr_token_from_json(raw_expected_output); + return utf32; +} - auto tokens = - urlpattern::tokenize(utf32_input, urlpattern::POLICY::LENIENT); +std::string to_utf8(std::u32string_view utf32) { + auto utf8_size = + ada::idna::utf8_length_from_utf32(utf32.data(), utf32.size()); + std::string utf8(utf8_size, '\0'); + ada::idna::utf32_to_utf8(utf32.data(), utf32.size(), utf8.data()); - ASSERT_TRUE(is_token_list_equal(expected_output, tokens)); - } - } catch (simdjson::simdjson_error& error) { - std::cerr << "JSON error: " << error.what() << " near " - << doc.current_location() << " in " << TOKENIZER_TESTDATA - << std::endl; - FAIL(); - } - SUCCEED(); -} \ No newline at end of file + return utf8; +} From 81fa16d30b16e22bf55639297ca47e7e2161fc81 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Thu, 8 Jun 2023 18:00:35 -0300 Subject: [PATCH 21/23] urlpattern: make tokenizer pass the tests --- include/ada/urlpattern_tokenizer.h | 23 +- src/unicode.cpp | 11 +- src/urlpattern_constructor_string_parser.cpp | 35 +- src/urlpattern_pattern_parser.cpp | 8 +- src/urlpattern_tokenizer.cpp | 139 +- tests/urlpattern/tokenizer.json | 1376 +++++++++--------- tests/urlpattern_tokenizer_tests.cpp | 114 +- 7 files changed, 833 insertions(+), 873 deletions(-) diff --git a/include/ada/urlpattern_tokenizer.h b/include/ada/urlpattern_tokenizer.h index 5c6035e25..955382ea6 100644 --- a/include/ada/urlpattern_tokenizer.h +++ b/include/ada/urlpattern_tokenizer.h @@ -24,8 +24,8 @@ enum class TOKEN_TYPE : uint8_t { struct token { TOKEN_TYPE type; - size_t value_start; - size_t value_end; + size_t index; + std::u32string_view value; }; enum class POLICY : uint8_t { STRICT, LENIENT }; @@ -46,14 +46,21 @@ struct tokenizer { ada_really_inline void get_next_code_point(); // https://wicg.github.io/urlpattern/#add-a-token - ada_really_inline void add_token(TOKEN_TYPE type, size_t value_start, - size_t value_end); - ada_really_inline void add_token(TOKEN_TYPE type); + ada_really_inline void add_token(TOKEN_TYPE type, size_t next_pos, + size_t value_pos, size_t value_length); + + // https://wicg.github.io/urlpattern/#add-a-token-with-default-length + ada_really_inline void add_token_with_default_length(TOKEN_TYPE type, + size_t next_pos, + size_t value_pos); + + // https://wicg.github.io/urlpattern/#add-a-token-with-default-position-and-length + ada_really_inline void add_token_with_default_position_and_length( + TOKEN_TYPE type); // https://wicg.github.io/urlpattern/#process-a-tokenizing-error - ada_really_inline void process_tokenizing_error(std::string_view msg, - size_t value_start, - size_t value_end); + ada_really_inline void process_tokenizing_error(size_t next_pos, + size_t value_position); }; /** diff --git a/src/unicode.cpp b/src/unicode.cpp index 23912b638..8596d0e01 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -498,12 +498,8 @@ static std::bitset<0x10FFFF> valid_id_start_mask_unicode = // https://wicg.github.io/urlpattern/#is-a-valid-name-code-point ada_really_inline bool is_valid_identifier_start(const char32_t& c) noexcept { - if (c == U'𐤀') { - std::cerr << "Hello!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; - } - return c < 256 - ? /* extended ascii fast path */ valid_id_start_table_ascii[c - 1] - : valid_id_start_mask_unicode[c]; + return c < 256 ? /* extended ascii fast path */ valid_id_start_table_ascii[c] + : valid_id_start_mask_unicode[c]; } // Valid IdentifierPart unicods points 256+ @@ -734,9 +730,6 @@ static_assert(sizeof(valid_id_part_table_ascii) == 256); // https://wicg.github.io/urlpattern/#is-a-valid-name-code-point ada_really_inline bool is_valid_identifier_part(const char32_t& c) noexcept { - if (c == U'𐤀') { - std::cerr << "PART Hello!!!!!!!!!!!!!!!!!!!!!!!" << std::endl; - } return c < 256 ? /* extended ascii fast-path*/ valid_id_part_table_ascii[c] : valid_id_part_mask_unicode[c]; } diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp index fb218e9ed..2668c9c20 100644 --- a/src/urlpattern_constructor_string_parser.cpp +++ b/src/urlpattern_constructor_string_parser.cpp @@ -212,12 +212,13 @@ ada_really_inline bool constructor_string_parser::is_search_prefix() { // TODO: improve this: - if (curr_token->value_end - curr_token->value_start != 0) return false; - - const char32_t c = '?'; - if (input.find(&c, curr_token->value_start, 1) == std::u32string_view::npos) { - return false; - } + // if (curr_token->value_end - curr_token->value_start != 0) return false; + // + // const char32_t c = '?'; + // if (input.find(&c, curr_token->value_start, 1) == + // std::u32string_view::npos) { + // return false; + // } // Let previous index be parser’s token index − 1. size_t prev_index = token_index - 1; @@ -254,11 +255,12 @@ ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( // // TODO: improve this: - if (safe_token->value_end - safe_token->value_start != 0) return false; - - if (input.find(&c, safe_token->value_start, 1) == std::u32string_view::npos) { - return false; - } + // if (safe_token->value_end - safe_token->value_start != 0) return false; + // + // if (input.find(&c, safe_token->value_start, 1) == + // std::u32string_view::npos) { + // return false; + // } // 3. If any of the following are true : // token’s type is "char"; @@ -334,14 +336,15 @@ constructor_string_parser::make_component_string() { token *safe_token = get_safe_token(component_start); // Let component start input index be component start token’s index. - size_t component_start_index = safe_token->value_start; - - // Let end index be token’s index. - size_t end = token_list[token_index].value_start; + // size_t component_start_index = safe_token->value_start; + // + // // Let end index be token’s index. + // size_t end = token_list[token_index].value_start; // Return the code point substring from component start input index to end // index within parser’s input. - return input.substr(component_start_index, end); + // return input.substr(component_start_index, end); + return U""; } } // namespace ada::urlpattern diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp index cb06dfb4e..b9077939d 100644 --- a/src/urlpattern_pattern_parser.cpp +++ b/src/urlpattern_pattern_parser.cpp @@ -152,10 +152,10 @@ std::vector parse_pattern_string( // Let prefix be the empty string. // If char token is not null then set prefix to char token’s value. std::u32string prefix{}; - if (char_token.has_value()) { - prefix.append(input.substr(char_token.value()->value_start, - char_token.value()->value_end + 1)); - } + // if (char_token.has_value()) { + // prefix.append(input.substr(char_token.value()->value_start, + // char_token.value()->value_end + 1)); + // } // If prefix is not the empty string and not options’s prefix code point: if (!prefix.empty() && prefix != options.prefix) { diff --git a/src/urlpattern_tokenizer.cpp b/src/urlpattern_tokenizer.cpp index 39c6712a6..3941ac6d4 100644 --- a/src/urlpattern_tokenizer.cpp +++ b/src/urlpattern_tokenizer.cpp @@ -3,7 +3,9 @@ #include "ada/urlpattern.h" #include -#include +#include +#include +#include namespace ada::urlpattern { @@ -35,19 +37,9 @@ ada_really_inline void tokenizer::get_next_code_point() { } // https://wicg.github.io/urlpattern/#add-a-token -ada_really_inline void tokenizer::add_token(TOKEN_TYPE type, size_t value_start, - size_t value_end) { - token new_token = token(); - new_token.type = type; - new_token.value_start = value_start; - new_token.value_end = value_end; - - token_list.push_back(new_token); - index = value_end; -} - -// https://wicg.github.io/urlpattern/#add-a-token -ada_really_inline void tokenizer::add_token(TOKEN_TYPE type) { +ada_really_inline void tokenizer::add_token(TOKEN_TYPE type, size_t next_pos, + size_t value_pos, + size_t value_length) { // 1. Let token be a new token. token new_token = token(); @@ -55,25 +47,48 @@ ada_really_inline void tokenizer::add_token(TOKEN_TYPE type) { new_token.type = type; // 3. Set token’s index to tokenizer’s index. + new_token.index = index; + // 4. Set token’s value to the code point substring from value position with // length value length within tokenizer’s input. - new_token.value_start = index; - new_token.value_end = index; + new_token.value = input.substr(value_pos, value_length); // 5. Append token to the back of tokenizer’s token list. token_list.push_back(new_token); - // Set tokenizer’s index to next position. - index = next_index; + // 6. Set tokenizer’s index to next position. + index = next_pos; +} + +// https://wicg.github.io/urlpattern/#add-a-token-with-default-length +ada_really_inline void tokenizer::add_token_with_default_length( + TOKEN_TYPE type, size_t next_pos, size_t value_pos) { + // 1. Let computed length be next position − value position. + size_t computed_length = next_pos - value_pos; + + // 2. Run add a token given tokenizer, type, next position, value position, + // and computed length + add_token(type, next_pos, value_pos, computed_length); } -void tokenizer::process_tokenizing_error(std::string_view msg, - size_t value_start, size_t value_end) { +ada_really_inline void tokenizer::add_token_with_default_position_and_length( + TOKEN_TYPE type) { + // 1. Run add a token with default length given tokenizer, type, tokenizer’s + // next index, and tokenizer’s index. + add_token_with_default_length(type, next_index, index); +} + +ada_really_inline void tokenizer::process_tokenizing_error( + size_t next_pos, size_t value_position) { + // 1. If tokenizer’s policy is "strict", then throw a TypeError. if (policy != POLICY::LENIENT) { - throw std::invalid_argument(std::string(msg)); + throw std::bad_typeid(); } - add_token(TOKEN_TYPE::INVALID_CHAR, value_start, value_end); + // Run add a token with default length given tokenizer, "invalid-char", next + // position, and value position. + add_token_with_default_length(TOKEN_TYPE::INVALID_CHAR, next_pos, + value_position); } std::vector tokenize(std::u32string_view input, @@ -95,28 +110,24 @@ std::vector tokenize(std::u32string_view input, switch (t.code_point) { case '*': { - std::cerr << "'*'" << std::endl; // Run add a token with default position and length given tokenizer and // "asterisk". - t.add_token(TOKEN_TYPE::ASTERISK); + t.add_token_with_default_position_and_length(TOKEN_TYPE::ASTERISK); break; } case '+': case '?': { - std::cerr << "'?''+'" << std::endl; - t.add_token(TOKEN_TYPE::OTHER_MODIFIER); + t.add_token_with_default_position_and_length( + TOKEN_TYPE::OTHER_MODIFIER); break; } case '\\': { - std::cerr << "'\\'" << std::endl; // 1. If tokenizer’s index is equal to tokenizer’s input's code point // length − 1: if (t.index == t.input.size() - 1) { // Run process a tokenizing error given tokenizer, tokenizer’s next // index, and tokenizer’s index. - t.process_tokenizing_error("should scape something", - /*value_start*/ t.index, - /*value_end*/ t.next_index); + t.process_tokenizing_error(t.next_index, t.index); continue; } // 2.Let escaped index be tokenizer’s next index. @@ -127,21 +138,19 @@ std::vector tokenize(std::u32string_view input, // Run add a token with default length given tokenizer, "escaped-char", // tokenizer’s next index, and escaped index. - t.add_token(TOKEN_TYPE::ESCAPED_CHAR, escaped_index, escaped_index); + t.add_token_with_default_length(TOKEN_TYPE::ESCAPED_CHAR, t.next_index, + escaped_index); break; } case '{': { - std::cerr << "'{'" << std::endl; - t.add_token(TOKEN_TYPE::OPEN); + t.add_token_with_default_position_and_length(TOKEN_TYPE::OPEN); break; } case '}': { - std::cerr << "'}'" << std::endl; - t.add_token(TOKEN_TYPE::CLOSE); + t.add_token_with_default_position_and_length(TOKEN_TYPE::CLOSE); break; } case ':': { - std::cerr << "':'" << std::endl; // 1. Let name position be tokenizer’s next index. size_t name_start, name_position; name_position = t.next_index; @@ -152,11 +161,6 @@ std::vector tokenize(std::u32string_view input, // 3. While name position is less than tokenizer’s input's code point // length: while (name_position < t.input.size()) { - std::cerr << name_position << std::endl; - if (t.code_point == U'𐤀') { - std::cerr << "HELLOOOOOOOO" << std::endl; - } - // Run seek and get the next code point given tokenizer and name // position. t.seek_and_get_next_code_point(name_position); @@ -167,35 +171,31 @@ std::vector tokenize(std::u32string_view input, // Let valid code point be the result of running is a valid name code // point given tokenizer’s code point and first code point. - // std::cerr << "IS FIRST " << first_code_point << std::endl; bool valid_code_point = is_valid_name_code_point(t.input[name_position], /*is_first=*/first_code_point); // If valid code point is false break. if (!valid_code_point) { - std::cerr << "NOT VALID CODE POOINT" << t.code_point << std::endl; break; } // Set name position to tokenizer’s next index. name_position = t.next_index; - std::cerr << "final: " << name_position << std::endl; } - std::cerr << "after loop: " << name_position << std::endl; // If name position is less than or equal to name start: if (name_position <= name_start) { - std::cerr << "ERROR " << name_position << std::endl; - t.process_tokenizing_error("missing pattern name", t.index, - name_start); + // Run process a tokenizing error given tokenizer, name start, and + // tokenizer’s index. + t.process_tokenizing_error(name_start, t.index); break; } - t.add_token(TOKEN_TYPE::NAME, name_start, name_position); + t.add_token_with_default_length(TOKEN_TYPE::NAME, name_position, + name_start); break; } case '(': { - std::cerr << "'('" << std::endl; // 1. Let depth be 1. size_t depth = 1; @@ -221,8 +221,7 @@ std::vector tokenize(std::u32string_view input, // and tokenizer’s index. // Set error to true. // Break. - t.process_tokenizing_error("invalid char for regex", regexp_start, - t.index); + t.process_tokenizing_error(regexp_start, t.index); error = true; break; @@ -235,8 +234,7 @@ std::vector tokenize(std::u32string_view input, // and tokenizer’s index. // Set error to true. // Break. - t.process_tokenizing_error("malformed regex", regexp_start, - t.index); + t.process_tokenizing_error(regexp_start, t.index); error = true; break; @@ -251,8 +249,7 @@ std::vector tokenize(std::u32string_view input, // and tokenizer’s index. // Set error to true. // Break. - t.process_tokenizing_error("malformed regex", regexp_start, - t.index); + t.process_tokenizing_error(regexp_start, t.index); error = true; break; @@ -264,8 +261,7 @@ std::vector tokenize(std::u32string_view input, // 3. If the result of running is ASCII given tokenizer’s code point // is false if (!is_ascii(t.code_point)) { - t.process_tokenizing_error("invalid char for regex", regexp_start, - t.index); + t.process_tokenizing_error(regexp_start, t.index); error = true; break; @@ -291,8 +287,7 @@ std::vector tokenize(std::u32string_view input, // 2. If regexp position equals tokenizer’s input's code point // length − 1: if (regexp_position == t.input.size() - 1) { - t.process_tokenizing_error("malformed regex", regexp_start, - t.index); + t.process_tokenizing_error(regexp_start, t.index); error = true; break; @@ -304,8 +299,7 @@ std::vector tokenize(std::u32string_view input, t.get_next_code_point(); if (t.code_point != '?') { - t.process_tokenizing_error("malformed regex", regexp_start, - t.index); + t.process_tokenizing_error(regexp_start, t.index); error = true; break; @@ -320,27 +314,34 @@ std::vector tokenize(std::u32string_view input, if (error) break; if (depth) { - t.process_tokenizing_error("malformed regex", regexp_start, t.index); + t.process_tokenizing_error(regexp_start, t.index); break; } - // 8. Let regexp length be regexp position − regexp start − 1. - if ((regexp_position - regexp_start - 1) == 0) { - t.process_tokenizing_error("malformed regex", regexp_start, t.index); + // Let regexp length be regexp position − regexp start − 1. + size_t regexp_length = regexp_position - regexp_start - 1; + + if (regexp_length == 0) { + t.process_tokenizing_error(regexp_start, t.index); break; } - t.add_token(TOKEN_TYPE::REGEXP, regexp_start, regexp_position); + // Run add a token given tokenizer, "regexp", regexp position, regexp + // start, and regexp length. + t.add_token(TOKEN_TYPE::REGEXP, regexp_position, regexp_start, + regexp_length); + break; } default: { // TODO: maybe group the TOKEN_TYPE::CHARs to make tokens cheaper - t.add_token(TOKEN_TYPE::CHAR); + t.add_token_with_default_position_and_length(TOKEN_TYPE::CHAR); break; } } } - t.add_token(TOKEN_TYPE::END); + + t.add_token_with_default_length(TOKEN_TYPE::END, t.index, t.index); return t.token_list; } diff --git a/tests/urlpattern/tokenizer.json b/tests/urlpattern/tokenizer.json index 98bdd7064..68ab38f91 100644 --- a/tests/urlpattern/tokenizer.json +++ b/tests/urlpattern/tokenizer.json @@ -4,143 +4,143 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "f" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "/" }, { "type": "NAME", - "value_start": 24, - "value_end": 27 + "index": 24, + "value": "bar" }, { "type": "REGEX", - "value_start": 28, - "value_end": 33 + "index": 28, + "value": "[^/]*" }, { "type": "OTHER_MODIFIER", - "value_start": 35, - "value_end": 36 + "index": 35, + "value": "?" }, { "type": "END", - "value_start": 36, - "value_end": 36 + "index": 36, + "value": "" } ] }, @@ -149,168 +149,168 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "OPEN", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "{" }, { "type": "CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": "s" }, { "type": "CLOSE", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "}" }, { "type": "OTHER_MODIFIER", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "?" }, { "type": "INVALID_CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": ":" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "/" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "/" }, { "type": "ASTERISK", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "*" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "." }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "e" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "x" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "a" }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "m" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "p" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "l" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "e" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "." }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "c" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "m" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "/" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "b" }, { "type": "CHAR", - "value_start": 26, - "value_end": 27 + "index": 26, + "value": "o" }, { "type": "CHAR", - "value_start": 27, - "value_end": 28 + "index": 27, + "value": "o" }, { "type": "CHAR", - "value_start": 28, - "value_end": 29 + "index": 28, + "value": "k" }, { "type": "CHAR", - "value_start": 29, - "value_end": 30 + "index": 29, + "value": "s" }, { "type": "CHAR", - "value_start": 30, - "value_end": 31 + "index": 30, + "value": "/" }, { "type": "NAME", - "value_start": 31, - "value_end": 33 + "index": 31, + "value": "id" }, { "type": "END", - "value_start": 34, - "value_end": 34 + "index": 34, + "value": "" } ] }, @@ -319,158 +319,158 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "2" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "0" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "2" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "3" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "/" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "m" }, { "type": "CHAR", - "value_start": 26, - "value_end": 27 + "index": 26, + "value": "a" }, { "type": "CHAR", - "value_start": 27, - "value_end": 28 + "index": 27, + "value": "y" }, { "type": "CHAR", - "value_start": 28, - "value_end": 29 + "index": 28, + "value": "/" }, { "type": "ASTERISK", - "value_start": 29, - "value_end": 30 + "index": 29, + "value": "*" }, { "type": "END", - "value_start": 30, - "value_end": 30 + "index": 30, + "value": "" } ] }, @@ -479,143 +479,143 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { "type": "NAME", - "value_start": 26, - "value_end": 28 + "index": 26, + "value": "id" }, { "type": "END", - "value_start": 29, - "value_end": 29 + "index": 29, + "value": "" } ] }, @@ -624,113 +624,113 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "INVALID_CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": ":" }, { "type": "CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": "/" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "e" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "x" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "a" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "m" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "p" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "l" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "e" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "." }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "c" }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "o" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "m" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "/" }, { "type": "NAME", - "value_start": 19, - "value_end": 23 + "index": 19, + "value": "name" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "/" }, { "type": "END", - "value_start": 25, - "value_end": 25 + "index": 25, + "value": "" } ] }, @@ -739,143 +739,143 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { "type": "NAME", - "value_start": 26, - "value_end": 28 + "index": 26, + "value": "你好" }, { "type": "END", - "value_start": 29, - "value_end": 29 + "index": 29, + "value": "" } ] }, @@ -884,153 +884,153 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { "type": "NAME", - "value_start": 26, - "value_end": 28 + "index": 26, + "value": "你好" }, { "type": "CHAR", - "value_start": 29, - "value_end": 30 + "index": 29, + "value": "/" }, { "type": "NAME", - "value_start": 30, - "value_end": 33 + "index": 30, + "value": "日本語" }, { "type": "END", - "value_start": 34, - "value_end": 34 + "index": 34, + "value": "" } ] }, @@ -1039,163 +1039,153 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { "type": "NAME", - "value_start": 26, - "value_end": 28 + "index": 26, + "value": "你好" }, { "type": "CHAR", - "value_start": 29, - "value_end": 30 + "index": 29, + "value": "/" }, { - "type": "INVALID_CHAR", - "value_start": 30, - "value_end": 31 - }, - { - "type": "CHAR", - "value_start": 31, - "value_end": 32 - }, - { - "type": "CHAR", - "value_start": 32, - "value_end": 33 + "type": "NAME", + "index": 30, + "value": "𝒳" }, { "type": "END", - "value_start": 33, - "value_end": 33 + "index": 32, + "value": "" } ] }, @@ -1204,143 +1194,143 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { "type": "NAME", - "value_start": 26, - "value_end": 32 + "index": 26, + "value": "футбол" }, { "type": "END", - "value_start": 33, - "value_end": 33 + "index": 33, + "value": "" } ] }, @@ -1349,143 +1339,143 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { "type": "NAME", - "value_start": 26, - "value_end": 32 + "index": 26, + "value": "नमस्ते" }, { "type": "END", - "value_start": 33, - "value_end": 33 + "index": 33, + "value": "" } ] }, @@ -1494,153 +1484,143 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": "s" }, { "type": "INVALID_CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": ":" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "/" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "e" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "x" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "a" }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "m" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "p" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "l" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "e" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "." }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "c" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "o" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "m" }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "/" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "b" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "o" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "o" }, { "type": "CHAR", - "value_start": 23, - "value_end": 24 + "index": 23, + "value": "k" }, { "type": "CHAR", - "value_start": 24, - "value_end": 25 + "index": 24, + "value": "s" }, { "type": "CHAR", - "value_start": 25, - "value_end": 26 + "index": 25, + "value": "/" }, { - "type": "INVALID_CHAR", - "value_start": 26, - "value_end": 27 - }, - { - "type": "CHAR", - "value_start": 27, - "value_end": 28 - }, - { - "type": "CHAR", - "value_start": 28, - "value_end": 29 + "type": "NAME", + "index": 26, + "value": "𐤀" }, { "type": "END", - "value_start": 29, - "value_end": 29 + "index": 28, + "value": "" } ] }, @@ -1649,123 +1629,123 @@ "output": [ { "type": "CHAR", - "value_start": 0, - "value_end": 1 + "index": 0, + "value": "h" }, { "type": "CHAR", - "value_start": 1, - "value_end": 2 + "index": 1, + "value": "t" }, { "type": "CHAR", - "value_start": 2, - "value_end": 3 + "index": 2, + "value": "t" }, { "type": "CHAR", - "value_start": 3, - "value_end": 4 + "index": 3, + "value": "p" }, { "type": "INVALID_CHAR", - "value_start": 4, - "value_end": 5 + "index": 4, + "value": ":" }, { "type": "CHAR", - "value_start": 5, - "value_end": 6 + "index": 5, + "value": "/" }, { "type": "CHAR", - "value_start": 6, - "value_end": 7 + "index": 6, + "value": "/" }, { "type": "CHAR", - "value_start": 7, - "value_end": 8 + "index": 7, + "value": "w" }, { "type": "CHAR", - "value_start": 8, - "value_end": 9 + "index": 8, + "value": "w" }, { "type": "CHAR", - "value_start": 9, - "value_end": 10 + "index": 9, + "value": "w" }, { "type": "CHAR", - "value_start": 10, - "value_end": 11 + "index": 10, + "value": "." }, { "type": "CHAR", - "value_start": 11, - "value_end": 12 + "index": 11, + "value": "e" }, { "type": "CHAR", - "value_start": 12, - "value_end": 13 + "index": 12, + "value": "x" }, { "type": "CHAR", - "value_start": 13, - "value_end": 14 + "index": 13, + "value": "a" }, { "type": "CHAR", - "value_start": 14, - "value_end": 15 + "index": 14, + "value": "m" }, { "type": "CHAR", - "value_start": 15, - "value_end": 16 + "index": 15, + "value": "p" }, { "type": "CHAR", - "value_start": 16, - "value_end": 17 + "index": 16, + "value": "l" }, { "type": "CHAR", - "value_start": 17, - "value_end": 18 + "index": 17, + "value": "e" }, { "type": "CHAR", - "value_start": 18, - "value_end": 19 + "index": 18, + "value": "." }, { "type": "CHAR", - "value_start": 19, - "value_end": 20 + "index": 19, + "value": "c" }, { "type": "CHAR", - "value_start": 20, - "value_end": 21 + "index": 20, + "value": "o" }, { "type": "CHAR", - "value_start": 21, - "value_end": 22 + "index": 21, + "value": "m" }, { "type": "CHAR", - "value_start": 22, - "value_end": 23 + "index": 22, + "value": "/" }, { "type": "END", - "value_start": 23, - "value_end": 23 + "index": 23, + "value": "" } ] } diff --git a/tests/urlpattern_tokenizer_tests.cpp b/tests/urlpattern_tokenizer_tests.cpp index 55d45aa88..ac467aee2 100644 --- a/tests/urlpattern_tokenizer_tests.cpp +++ b/tests/urlpattern_tokenizer_tests.cpp @@ -1,6 +1,10 @@ +#include +#include +#include #include #include #include +#include #include "ada.h" #include "ada/urlpattern_tokenizer.h" @@ -10,17 +14,9 @@ using namespace simdjson; using namespace ada; -bool is_token_list_equal(std::vector& first, - std::vector& second); - std::string to_utf8(std::u32string_view utf32); std::u32string to_utf32(std::string_view utf8); -bool operator!=(const urlpattern::token& lhs, const urlpattern::token& rhs); - -std::vector arr_token_from_json( - ondemand::array& raw_token_arr); - std::string_view TOKENIZER_TESTDATA = "urlpattern/tokenizer.json"; TEST(urlpattern_tests, tokenize) { @@ -52,6 +48,21 @@ TEST(urlpattern_tests, tokenize) { } }; + auto token_type_from_string = [](std::string_view type) { + if (type == "OPEN") return urlpattern::TOKEN_TYPE::OPEN; + if (type == "CLOSE") return urlpattern::TOKEN_TYPE::CLOSE; + if (type == "REGEX") return urlpattern::TOKEN_TYPE::REGEXP; + if (type == "NAME") return urlpattern::TOKEN_TYPE::NAME; + if (type == "CHAR") return urlpattern::TOKEN_TYPE::CHAR; + if (type == "ESCAPED_CHAR") return urlpattern::TOKEN_TYPE::ESCAPED_CHAR; + if (type == "OTHER_MODIFIER") return urlpattern::TOKEN_TYPE::OTHER_MODIFIER; + if (type == "ASTERISK") return urlpattern::TOKEN_TYPE::ASTERISK; + if (type == "END") return urlpattern::TOKEN_TYPE::END; + if (type == "INVALID_CHAR") return urlpattern::TOKEN_TYPE::INVALID_CHAR; + + unreachable(); + }; + ondemand::document doc = parser.iterate(json); try { for (auto test_case : doc.get_array()) { @@ -61,23 +72,38 @@ TEST(urlpattern_tests, tokenize) { auto utf32_input = to_utf32(utf8_input); ondemand::array raw_expected_output = object["output"].get_array(); - auto expected_output = arr_token_from_json(raw_expected_output); + std::vector expected_tokens{}; + std::vector expected_token_values{}; + for (auto raw_t : raw_expected_output) { + urlpattern::token expected_t = urlpattern::token(); + + expected_t.index = raw_t["index"].get_uint64(); + expected_t.type = token_type_from_string(raw_t["type"].get_string()); + + std::string_view u8_value = raw_t["value"].get_string(); + std::u32string u32_value = to_utf32(u8_value); + + // TODO: this is terrible.. + expected_token_values.push_back(u32_value); + + expected_tokens.push_back(expected_t); + } auto tokens = urlpattern::tokenize(utf32_input, urlpattern::POLICY::LENIENT); + if (expected_tokens.size() != tokens.size()) { + for (auto t : expected_tokens) { + std::cerr << token_type_to_string(t.type) << std::endl; + } + FAIL(); + } + for (size_t i = 0; i < tokens.size(); i++) { - std::cerr << token_type_to_string(tokens[i].type) << ": "; - std::cerr << to_utf8(utf32_input.substr( - tokens[i].value_start, - tokens[i].value_end - tokens[i].value_start + 1)) - << std::endl; + ASSERT_TRUE(tokens[i].index == expected_tokens[i].index); + ASSERT_TRUE(tokens[i].type == expected_tokens[i].type); + ASSERT_TRUE(tokens[i].value.compare(expected_token_values[i]) == 0); } - // if (!is_token_list_equal(expected_output, tokens)) { - // std::cerr << "expected size: " << expected_output.size() - // << " actual: " << tokens.size() << std::endl; - // } - // ASSERT_TRUE(is_token_list_equal(expected_output, tokens)); } } catch (simdjson::simdjson_error& error) { std::cerr << "JSON error: " << error.what() << " near " @@ -88,56 +114,6 @@ TEST(urlpattern_tests, tokenize) { SUCCEED(); } -std::vector arr_token_from_json( - ondemand::array& raw_token_arr) { - auto token_type_from_string = [](std::string_view type) { - if (type == "OPEN") return urlpattern::TOKEN_TYPE::OPEN; - if (type == "CLOSE") return urlpattern::TOKEN_TYPE::CLOSE; - if (type == "REGEXP") return urlpattern::TOKEN_TYPE::REGEXP; - if (type == "NAME") return urlpattern::TOKEN_TYPE::NAME; - if (type == "CHAR") return urlpattern::TOKEN_TYPE::CHAR; - if (type == "ESCAPED_CHAR") return urlpattern::TOKEN_TYPE::ESCAPED_CHAR; - if (type == "OTHER_MODIFIER") return urlpattern::TOKEN_TYPE::OTHER_MODIFIER; - if (type == "ASTERISK") return urlpattern::TOKEN_TYPE::ASTERISK; - if (type == "END") return urlpattern::TOKEN_TYPE::END; - if (type == "INVALID_CHAR") return urlpattern::TOKEN_TYPE::INVALID_CHAR; - - unreachable(); - }; - - std::vector arr_token{}; - for (auto raw_token : raw_token_arr) { - auto t = urlpattern::token(); - t.value_start = raw_token["value_start"].get_int64(); - t.value_end = raw_token["value_end"].get_int64(); - t.type = token_type_from_string(raw_token["type"].get_string()); - arr_token.push_back(t); - } - - return arr_token; -} - -bool is_token_list_equal(std::vector& first, - std::vector& second) { - // if (first.size() != second.size()) { - // return false; - // } - for (size_t i = 0; i < first.size(); i++) { - if (first[i] != second[i]) { - std::cerr << "first: AAA " << first[i].value_end << " " - << first[i].value_start << std::endl; - std::cerr << "second: AAA " << second[i].value_end << " " - << second[i].value_start << std::endl; - } - } - return true; -} - -bool operator!=(const urlpattern::token& lhs, const urlpattern::token& rhs) { - return !(lhs.type == rhs.type && lhs.value_end == rhs.value_end && - lhs.value_start == rhs.value_start); -} - std::u32string to_utf32(std::string_view utf8) { size_t utf32_length = ada::idna::utf32_length_from_utf8(utf8.data(), utf8.size()); From 50167862d0566160ebe44833bf800f41e18af691 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Thu, 8 Jun 2023 22:55:20 -0300 Subject: [PATCH 22/23] urlpattern: WIP compile a component --- include/ada/urlpattern.h | 2 - .../urlpattern_constructor_string_parser.h | 29 +- include/ada/urlpattern_internals.h | 12 +- include/ada/urlpattern_tokenizer.h | 3 + src/urlpattern_constructor_string_parser.cpp | 471 +++++++++++++----- src/urlpattern_pattern_parser.cpp | 11 +- 6 files changed, 393 insertions(+), 135 deletions(-) diff --git a/include/ada/urlpattern.h b/include/ada/urlpattern.h index 25437e963..5a5ba6bf7 100644 --- a/include/ada/urlpattern.h +++ b/include/ada/urlpattern.h @@ -10,8 +10,6 @@ #include namespace ada::urlpattern { -// https://wicg.github.io/urlpattern/#options - struct urlpattern_component_result { std::string_view input; std::unordered_map> groups; diff --git a/include/ada/urlpattern_constructor_string_parser.h b/include/ada/urlpattern_constructor_string_parser.h index 4dd0226ae..ba2c97535 100644 --- a/include/ada/urlpattern_constructor_string_parser.h +++ b/include/ada/urlpattern_constructor_string_parser.h @@ -1,6 +1,7 @@ #ifndef ADA_URLPATTERN_CONSTRUCTOR_STRING_PARSER_H #define ADA_URLPATTERN_CONSTRUCTOR_STRING_PARSER_H +#include #include "ada/helpers.h" #include "ada/urlpattern_base.h" @@ -42,7 +43,17 @@ struct constructor_string_parser { ada_really_inline bool is_search_prefix(); // https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char - ada_really_inline bool is_nonspecial_pattern_char(const char32_t &c); + ada_really_inline bool is_nonspecial_pattern_char(size_t index, + const char32_t *value); + + // https://wicg.github.io/urlpattern/#is-an-identity-terminator + ada_really_inline bool is_identity_terminator(); + + // https://wicg.github.io/urlpattern/#is-a-pathname-start + ada_really_inline bool is_pathname_start(); + + // https://wicg.github.io/urlpattern/#is-a-password-prefix + ada_really_inline bool is_password_prefix(); // https://wicg.github.io/urlpattern/#get-a-safe-token ada_really_inline token *get_safe_token(size_t &index); @@ -50,6 +61,15 @@ struct constructor_string_parser { // https://wicg.github.io/urlpattern/#is-a-group-open ada_really_inline bool is_group_open(); + // https://wicg.github.io/urlpattern/#is-an-ipv6-open + ada_really_inline bool is_ipv6_open(); + + // https://wicg.github.io/urlpattern/#is-an-ipv6-close + ada_really_inline bool is_ipv6_close(); + + // https://wicg.github.io/urlpattern/#is-a-port-prefix + ada_really_inline bool is_port_prefix(); + // https://wicg.github.io/urlpattern/#is-a-group-close ada_really_inline bool is_group_close(); @@ -62,6 +82,9 @@ struct constructor_string_parser { // https://wicg.github.io/urlpattern/#make-a-component-string ada_really_inline std::u32string_view make_component_string(); + /// https://wicg.github.io/urlpattern/#next-is-authority-slashes + ada_really_inline bool next_is_authority_slashes(); + std::u32string_view input; std::vector token_list; size_t component_start = 0; @@ -69,13 +92,13 @@ struct constructor_string_parser { size_t token_increment = 0; size_t group_depth = 0; size_t hostname_ipv6_bracket_depth = 0; - bool protocol_matches_special_scheme = false; + bool protocol_matches_special_scheme_flag = false; urlpattern_init result = urlpattern_init(); PARSER_STATE state = PARSER_STATE::INIT; }; // https://wicg.github.io/urlpattern/#parse-a-constructor-string -void parse_contructor_string(std::u32string_view input); +urlpattern_init parse_contructor_string(std::u32string_view input); } // namespace ada::urlpattern diff --git a/include/ada/urlpattern_internals.h b/include/ada/urlpattern_internals.h index ce12757f8..fc8fc90ec 100644 --- a/include/ada/urlpattern_internals.h +++ b/include/ada/urlpattern_internals.h @@ -3,13 +3,23 @@ #include "ada/urlpattern_base.h" #include +#include "regex" +#include "vector" namespace ada::urlpattern { +// https://wicg.github.io/urlpattern/#component +struct urlpattern_component { + std::u32string_view pattern_string; + // TODO: use a more performant lib, eg RE2 + std::regex regular_expression; + std::vector group_name_list; +}; +// https://wicg.github.io/urlpattern/#component std::string_view compile_component(std::u32string_view input, std::function &callback, u32urlpattern_options &options); -} +} // namespace ada::urlpattern #endif \ No newline at end of file diff --git a/include/ada/urlpattern_tokenizer.h b/include/ada/urlpattern_tokenizer.h index 955382ea6..72c69f7cf 100644 --- a/include/ada/urlpattern_tokenizer.h +++ b/include/ada/urlpattern_tokenizer.h @@ -9,6 +9,7 @@ namespace ada::urlpattern { +// https://wicg.github.io/urlpattern/#token-type enum class TOKEN_TYPE : uint8_t { OPEN, CLOSE, @@ -22,12 +23,14 @@ enum class TOKEN_TYPE : uint8_t { INVALID_CHAR }; +// https://wicg.github.io/urlpattern/#token struct token { TOKEN_TYPE type; size_t index; std::u32string_view value; }; +// https://wicg.github.io/urlpattern/#tokenize-policy enum class POLICY : uint8_t { STRICT, LENIENT }; // https://wicg.github.io/urlpattern/#tokenizer diff --git a/src/urlpattern_constructor_string_parser.cpp b/src/urlpattern_constructor_string_parser.cpp index 2668c9c20..d1ef321eb 100644 --- a/src/urlpattern_constructor_string_parser.cpp +++ b/src/urlpattern_constructor_string_parser.cpp @@ -1,6 +1,6 @@ #include "ada/implementation.h" - #include +#include #include "ada/urlpattern_tokenizer.h" #include "ada/urlpattern_constructor_string_parser.h" @@ -15,115 +15,289 @@ ada_really_inline constructor_string_parser::constructor_string_parser( } // https://wicg.github.io/urlpattern/#parse-a-constructor-string -void parse_contructor_string(std::u32string_view input) { - // Let parser be a new constructor string parser whose input is input and +urlpattern_init parse_contructor_string(std::u32string_view input) { + // 1. Let parser be a new constructor string parser whose input is input and // token list is the result of running tokenize given input and "lenient". - auto p = constructor_string_parser(input); + auto parser = constructor_string_parser(input); // 2. While parser’s token index is less than parser’s token list size: - while (p.token_index < p.token_list.size()) { - // Set parser’s token increment to 1. - p.token_increment = 1; - // If parser’s token list[parser’s token index]'s type is "end" then: + while (parser.token_index < parser.token_list.size()) { + // 1. Set parser’s token increment to 1. + parser.token_increment = 1; - if (p.token_list[p.token_index].type == TOKEN_TYPE::END) { - if (p.state == PARSER_STATE::INIT) { - // If parser’s state is "init": - // Run rewind given parser. - p.rewind(); + // 2. If parser’s token list[parser’s token index]'s type is "end" then: + if (parser.token_list[parser.token_index].type == TOKEN_TYPE::END) { + // 1. If parser’s state is "init": + if (parser.state == PARSER_STATE::INIT) { + // 1. Run rewind given parser. + parser.rewind(); // We next determine at which component the relative pattern begins. // Relative pathnames are most common, but URLs and URLPattern // constructor strings can begin with the search or hash components as // well. - // If the result of running is a hash prefix given parser is true, then - // run change state given parser, "hash" and 1. - if (p.is_hash_prefix()) { - p.change_state(PARSER_STATE::HASH, 1); - } else if (p.is_search_prefix()) { - // Else if the result of running is a search prefix given parser is - // true + // 2. If the result of running is a hash prefix given parser is true, + // then run change state given parser, "hash" and 1. + if (parser.is_hash_prefix()) { + parser.change_state(PARSER_STATE::HASH, 1); + } + // Else if the result of running is a search prefix given parser is + // true: + else if (parser.is_search_prefix()) { // Run change state given parser, "search" and 1 // Set parser’s result["hash"] to the empty string. - p.change_state(PARSER_STATE::SEARCH, 1); - p.result.hash = ""; + parser.change_state(PARSER_STATE::SEARCH, 1); + parser.result.hash = ""; } else { // Run change state given parser, "pathname" and 0. - p.change_state(PARSER_STATE::PATHNAME, 0); + parser.change_state(PARSER_STATE::PATHNAME, 0); // Set parser’s result["search"] to the empty string. - p.result.search = ""; - p.result.hash = ""; + parser.result.search = ""; + // Set parser’s result["hash"] to the empty string. + parser.result.hash = ""; } // Increment parser’s token index by parser’s token increment. - p.token_index += p.token_increment; + parser.token_index += parser.token_increment; continue; } - if (p.state == PARSER_STATE::AUTHORITY) { - // If we reached the end of the string in the "authority" state, then we - // failed to find an "@". Therefore there is no username or password. + // If parser’s state is "authority": + if (parser.state == PARSER_STATE::AUTHORITY) { + // If we reached the end of the string in the "authority" state, then + // we failed to find an "@". Therefore there is no username or + // password. - // Run rewind and set state given parser, and "hostname". - p.rewind_and_set_state(PARSER_STATE::HOSTNAME); - // Increment parser’s token index by parser’s token increment. - p.token_index += p.token_increment; + // 1. Run rewind and set state given parser, and "hostname". + parser.rewind_and_set_state(PARSER_STATE::HOSTNAME); + // Increment parser’s token index by parser’s token increment. + parser.token_index += parser.token_increment; continue; } - // Run change state given parser, "done" and 0. - p.change_state(PARSER_STATE::DONE, 0); + // 3. Run change state given parser, "done" and 0. + parser.change_state(PARSER_STATE::DONE, 0); break; } - if (p.is_group_open()) { - // Increment parser’s group depth by 1. - ++p.group_depth; - // Increment parser’s token index by parser’s token increment. - p.token_index += p.token_increment; + // 3. If the result of running is a group open given parser is true: + if (parser.is_group_open()) { + // 1. Increment parser’s group depth by 1. + ++parser.group_depth; + // 2. Increment parser’s token index by parser’s token increment. + parser.token_index += parser.token_increment; continue; } - // If parser’s group depth is greater than 0: - if (p.group_depth > 0) { - // If the result of running is a group close given parser is true, then - // decrement parser’s group depth by 1. - if (p.is_group_close()) { - --p.group_depth; + // 4. If parser’s group depth is greater than 0: + if (parser.group_depth > 0) { + // 1. If the result of running is a group close given parser is true, + // then decrement parser’s group depth by 1. + if (parser.is_group_close()) { + --parser.group_depth; } else { - // Increment parser’s token index by parser’s token increment. - p.token_index += p.token_increment; + // 1. Increment parser’s token index by parser’s token increment. + parser.token_index += parser.token_increment; continue; } } - // Switch on parser’s state and run the associated steps: - switch (p.state) { + // 5. Switch on parser’s state and run the associated steps: + switch (parser.state) { case PARSER_STATE::INIT: { - if (p.is_protocol_suffix()) { - // We found a protocol suffix, so this must be an absolute URLPattern - // constructor string. Therefore initialize all component to the empty - // string. - p.result.username = ""; - p.result.password = ""; - p.result.hostname = ""; - p.result.port = ""; - p.result.pathname = ""; - p.result.search = ""; - p.result.hash = ""; + // If the result of running is a protocol suffix given parser is true: + if (parser.is_protocol_suffix()) { + // We found a protocol suffix, so this must be an absolute + // URLPattern constructor string. Therefore initialize all component + // to the empty string. + + parser.result.username = ""; + parser.result.password = ""; + parser.result.hostname = ""; + parser.result.port = ""; + parser.result.pathname = ""; + parser.result.search = ""; + parser.result.hash = ""; // Run rewind and set state given parser and "protocol". - p.rewind_and_set_state(PARSER_STATE::PROTOCOL); + parser.rewind_and_set_state(PARSER_STATE::PROTOCOL); } break; } case PARSER_STATE::PROTOCOL: { - if (p.is_protocol_suffix()) { + // 1. If the result of running is a protocol suffix given parser is + // true:s + if (parser.is_protocol_suffix()) { + // 1. Run compute protocol matches a special scheme flag given + // parser. + parser.compute_protocol_matches_special_scheme_flag(); + // We need to eagerly compile the protocol component to + // determine if it matches any special schemes. If it + // does then certain special rules apply. It determines + // if the pathname defaults to a "/" and also whether we + // will look for the username, password, hostname, and + // port components. Authority slashes can also cause us + // to look for these components as well. Otherwise we + // treat this as an "opaque path URL" and go straight to + // the pathname component. + + // 2. If parser’s protocol matches a special scheme flag is true, + // then set parser’s result["pathname"] to "/". + if (parser.protocol_matches_special_scheme_flag) { + parser.result.pathname = "/"; + } + // 3. Let next state be "pathname". + PARSER_STATE next_state = PARSER_STATE::PATHNAME; + + // 4. Let skip be 1. + uint8_t skip = 1; + // 5. If the result of running next is authority slashes given + // parser is true. + if (parser.next_is_authority_slashes()) { + // Set next state to "authority". + next_state = PARSER_STATE::AUTHORITY; + + // Set skip to 3. + skip = 3; + } + // Else if parser’s protocol matches a special scheme flag is true, + // then set next state to "authority". + else if (parser.protocol_matches_special_scheme_flag) { + next_state = PARSER_STATE::AUTHORITY; + } + // 7. Run change state given parser, next state, and skip. + parser.change_state(next_state, skip); } + break; + } + case PARSER_STATE::AUTHORITY: { + // 1. If the result of running is an identity terminator given parser + // is true, then run rewind and set state given parser and "username". + if (parser.is_identity_terminator()) { + parser.rewind_and_set_state(PARSER_STATE::USERNAME); + } + // Else if any of the following are true: + // the result of running is a pathname start given parser; + // the result of running is a search prefix given parser; or + // the result of running is a hash prefix given parser, + // then run rewind and set state given parser and "hostname". + else if (parser.is_pathname_start() || parser.is_search_prefix() || + parser.is_hash_prefix()) { + parser.rewind_and_set_state(PARSER_STATE::HOSTNAME); + } + break; + } + case PARSER_STATE::USERNAME: { + // 1. If the result of running is a password prefix given parser is + // true, then run change state given parser, "password", and 1. + if (parser.is_password_prefix()) { + parser.change_state(PARSER_STATE::PASSWORD, 1); + } + // 2. Else if the result of running is an identity terminator given + // parser is true, then run change state given parser, "hostname", + // and 1. + else if (parser.is_identity_terminator()) { + parser.change_state(PARSER_STATE::HOSTNAME, 1); + } + break; + } + case PARSER_STATE::PASSWORD: { + // 1. If the result of running is an identity terminator given parser + // is true, then run change state given parser, "hostname", and 1. + if (parser.is_identity_terminator()) { + parser.change_state(PARSER_STATE::HOSTNAME, 1); + } + break; + } + case PARSER_STATE::HOSTNAME: { + // 1. If the the result of running is an IPv6 open given parser is + // true, then increment parser’s hostname IPv6 bracket depth by 1. + if (parser.is_ipv6_open()) { + ++parser.hostname_ipv6_bracket_depth; + } + // 2. Else if the the result of running is an IPv6 close given parser + // is true, then decrement parser’s hostname IPv6 bracket depth by 1. + else if (parser.is_ipv6_close()) { + --parser.hostname_ipv6_bracket_depth; + } + // 3. Else if the result of running is a port prefix given parser is + // true and parser’s hostname IPv6 bracket depth is zero, then run + // change state given parser, "port", and 1. + else if (parser.is_port_prefix() && + parser.hostname_ipv6_bracket_depth == 0) { + parser.change_state(PARSER_STATE::PORT, 1); + } + // 4. Else if the result of running is a pathname start given parser + // is true, then run change state given parser, "pathname", and 0. + if (parser.is_pathname_start()) { + parser.change_state(PARSER_STATE::PATHNAME, 0); + } + // 5. Else if the result of running is a search prefix given parser is + // true, then run change state given parser, "search", and 1. + if (parser.is_search_prefix()) { + parser.change_state(PARSER_STATE::SEARCH, 1); + } + // 6. Else if the result of running is a hash prefix given parser is + // true, then run change state given parser, "hash", and 1. + if (parser.is_hash_prefix()) { + parser.change_state(PARSER_STATE::HASH, 1); + } + break; + } + case PARSER_STATE::PORT: { + // 1. If the result of running is a pathname start given parser is + // true, then run change state given parser, "pathname", and 0. + if (parser.is_pathname_start()) { + parser.change_state(PARSER_STATE::PATHNAME, 0); + } + // 2. Else if the result of running is a search prefix given parser is + // true, then run change state given parser, "search", and 1. + else if (parser.is_search_prefix()) { + parser.change_state(PARSER_STATE::SEARCH, 1); + } + // 3. Else if the result of running is a hash prefix given parser is + // true, then run change state given parser, "hash", and 1. + if (parser.is_hash_prefix()) { + parser.change_state(PARSER_STATE::HASH, 1); + } + } + case PARSER_STATE::PATHNAME: { + // 1. If the result of running is a search prefix given parser is + // true, then run change state given parser, "search", and 1. + if (parser.is_search_prefix()) { + parser.change_state(PARSER_STATE::SEARCH, 1); + } + // 2. Else if the result of running is a hash prefix given parser is + // true, then run change state given parser, "hash", and 1. + else if (parser.is_hash_prefix()) { + parser.change_state(PARSER_STATE::HASH, 1); + } + break; + } + case PARSER_STATE::SEARCH: { + // 1. If the result of running is a hash prefix given parser is true, + // then run change state given parser, "hash", and 1. + if (parser.is_hash_prefix()) { + parser.change_state(PARSER_STATE::HASH, 1); + } + break; + } + case PARSER_STATE::HASH: { + // do nothing; + break; + } + case PARSER_STATE::DONE: { + // 1. Assert: This step is never reached. + assert(false); } } + // 6. Increment parser’s token index by parser’s token increment. + parser.token_index += parser.token_increment; } + + // Return parser’s result. + return parser.result; } // https://wicg.github.io/urlpattern/#change-state @@ -174,6 +348,27 @@ ada_really_inline void constructor_string_parser::change_state( token_increment = 0; }; +// https://wicg.github.io/urlpattern/#is-a-pathname-start +ada_really_inline bool constructor_string_parser::is_pathname_start() { + // 1. Return the result of running is a non-special pattern char given + // parser, parser’s token index, and "/". + return is_nonspecial_pattern_char(token_index, U"/"); +} + +// https://wicg.github.io/urlpattern/#is-an-ipv6-open +ada_really_inline bool constructor_string_parser::is_ipv6_open() { + // 1, Return the result of running is a non-special pattern char given + // parser, parser’s token index, and "[". + return is_nonspecial_pattern_char(token_index, U"["); +} + +// https://wicg.github.io/urlpattern/#is-an-ipv6-close +ada_really_inline bool constructor_string_parser::is_ipv6_close() { + // 1. Return the result of running is a non-special pattern char given + // parser, parser’s token index, and "]". + return is_nonspecial_pattern_char(token_index, U"]"); +} + // https://wicg.github.io/urlpattern/#rewind ada_really_inline void constructor_string_parser::rewind() { token_index = component_start; @@ -190,54 +385,77 @@ ada_really_inline void constructor_string_parser::rewind_and_set_state( state = new_state; } +// https://wicg.github.io/urlpattern/#is-a-password-prefix +ada_really_inline bool constructor_string_parser::is_password_prefix() { + // 1. Return the result of running is a non-special pattern char given + // parser, parser’s token index, and ":". + return is_nonspecial_pattern_char(token_index, U":"); +} + +// https://wicg.github.io/urlpattern/#is-an-identity-terminator +ada_really_inline bool constructor_string_parser::is_identity_terminator() { + // 1. Return the result of running is a non-special pattern char given + // parser, parser’s token index, and "@". + return is_nonspecial_pattern_char(token_index, U"@"); +} + // https://wicg.github.io/urlpattern/#is-a-hash-prefix ada_really_inline bool constructor_string_parser::is_hash_prefix() { // Return the result of running is a non-special pattern char given parser, // parser’s token index and "#". - return is_nonspecial_pattern_char('#'); + return is_nonspecial_pattern_char(token_index, U"#"); } // https://wicg.github.io/urlpattern/#is-a-search-prefix ada_really_inline bool constructor_string_parser::is_search_prefix() { - // If result of running is a non-special pattern char given parser, parser’s - // token index and "?" is true, then return true. - if (is_nonspecial_pattern_char('?')) { + // 1. If result of running is a non-special pattern char given parser, + // parser’s token index and "?" is true, then return true. + if (is_nonspecial_pattern_char(token_index, U"?")) { return true; } - // If parser’s token list[parser’s token index]'s value is not "?", then + // 2. If parser’s token list[parser’s token index]'s value is not "?", then // return false. + if (token_list[token_index].value.compare(U"?") != 0) { + return false; + } - token *curr_token = &token_list[token_index]; - - // TODO: improve this: - - // if (curr_token->value_end - curr_token->value_start != 0) return false; - // - // const char32_t c = '?'; - // if (input.find(&c, curr_token->value_start, 1) == - // std::u32string_view::npos) { - // return false; - // } - - // Let previous index be parser’s token index − 1. + // 3. Let previous index be parser’s token index − 1. size_t prev_index = token_index - 1; + // 4. If previous index is less than 0, then return true. if (prev_index < 0) return true; - // Let previous token be the result of running get a safe token given parser - // and previous index. - token *prev_safe_token = get_safe_token(prev_index); + // 5. Let previous token be the result of running get a safe token given + // parser and previous index. + token *prev_token = get_safe_token(prev_index); - // If any of the following are true, then return false: - // + // 6. If any of the following are true, then return false: // previous token’s type is "name". // previous token’s type is "regexp". // previous token’s type is "close". // previous token’s type is "asterisk". - if (prev_safe_token->type == TOKEN_TYPE::NAME || - prev_safe_token->type == TOKEN_TYPE::REGEXP || - prev_safe_token->type == TOKEN_TYPE::CLOSE || - prev_safe_token->type == TOKEN_TYPE::ASTERISK) { + + if (prev_token->type == TOKEN_TYPE::NAME || + prev_token->type == TOKEN_TYPE::REGEXP || + prev_token->type == TOKEN_TYPE::CLOSE || + prev_token->type == TOKEN_TYPE::ASTERISK) { + return false; + } + + return true; +} + +// https://wicg.github.io/urlpattern/#next-is-authority-slashes +ada_really_inline bool constructor_string_parser::next_is_authority_slashes() { + // 1. If the result of running is a non-special pattern char given parser, + // parser’s token index + 1, and "/" is false, then return false. + if (!is_nonspecial_pattern_char(token_index + 1, U"/")) { + return false; + } + + // 2. If the result of running is a non-special pattern char given parser, + // parser’s token index + 2, and "/" is false, then return false. + if (!is_nonspecial_pattern_char(token_index + 2, U"/")) { return false; } @@ -246,32 +464,30 @@ ada_really_inline bool constructor_string_parser::is_search_prefix() { // https://wicg.github.io/urlpattern/#is-a-non-special-pattern-char ada_really_inline bool constructor_string_parser::is_nonspecial_pattern_char( - const char32_t &c) { + size_t index, const char32_t *value) { // 1. Let token be the result of running get a safe token given parser and // index. - token *safe_token = get_safe_token(token_index); + token *safe_token = get_safe_token(index); // 2. If token’s value is not value, then return false. - // + if (safe_token->value.compare(std::u32string_view(value)) != 0) { + return false; + } - // TODO: improve this: - // if (safe_token->value_end - safe_token->value_start != 0) return false; + // If any of the following are true: + // + // token’s type is "char"; + // token’s type is "escaped-char"; or + // token’s type is "invalid-char", // - // if (input.find(&c, safe_token->value_start, 1) == - // std::u32string_view::npos) { - // return false; - // } - - // 3. If any of the following are true : - // token’s type is "char"; - // token’s type is "escaped-char"; - // or token’s type is "invalid-char", // then return true. + if (safe_token->type == TOKEN_TYPE::CHAR || safe_token->type == TOKEN_TYPE::ESCAPED_CHAR || safe_token->type == TOKEN_TYPE::INVALID_CHAR) { return true; } + return false; } @@ -311,40 +527,53 @@ ada_really_inline bool constructor_string_parser::is_group_close() { ada_really_inline bool constructor_string_parser::is_protocol_suffix() { // Return the result of running is a non-special pattern char given parser, // parser’s token index, and ":". - return is_nonspecial_pattern_char(':'); + return is_nonspecial_pattern_char(token_index, U":"); +} + +// https://wicg.github.io/urlpattern/#is-a-port-prefix +ada_really_inline bool constructor_string_parser::is_port_prefix() { + // 1. Return the result of running is a non-special pattern char given + // parser, parser’s token index, and ":". + return is_nonspecial_pattern_char(token_index, U":"); } // https://wicg.github.io/urlpattern/#compute-protocol-matches-a-special-scheme-flag ada_really_inline void constructor_string_parser::compute_protocol_matches_special_scheme_flag() { - std::u32string_view protocol = make_component_string(); - // Let protocol component be the result of compiling a component given + // 1. Let protocol string be the result of running make a component string + // given parser. + std::u32string_view protocol_string = make_component_string(); + + // 2. Let protocol component be the result of compiling a component given + // protocol string, canonicalize a protocol, and default options. + + + // 1. Let protocol component be the result of compiling a component given // protocol string, canonicalize a protocol, and default options. } // https://wicg.github.io/urlpattern/#make-a-component-string ada_really_inline std::u32string_view constructor_string_parser::make_component_string() { - // Assert: parser’s token index is less than parser’s token list's size. + // 1. Assert: parser’s token index is less than parser’s token list's size. assert(token_index < token_list.size()); - // Let token be parser’s token list[parser’s token index]. - // TOKEN *token = &token_list[token_index]; + // 2. Let token be parser’s token list[parser’s token index]. + auto *t = &token_list[token_index]; - // Let component start token be the result of running get a safe token given - // parser and parser’s component start. - token *safe_token = get_safe_token(component_start); + // 3. Let component start token be the result of running get a safe token + // given parser and parser’s component start. + auto component_start_token = get_safe_token(component_start); - // Let component start input index be component start token’s index. - // size_t component_start_index = safe_token->value_start; - // - // // Let end index be token’s index. - // size_t end = token_list[token_index].value_start; + // 4. Let component start input index be component start token’s index. + size_t component_start_input_index = component_start_token->index; + + // 5. Let end index be token’s index. + size_t end_index = t->index; - // Return the code point substring from component start input index to end + // 6. Return the code point substring from component start input index to end // index within parser’s input. - // return input.substr(component_start_index, end); - return U""; + return input.substr(component_start_input_index, end_index); } } // namespace ada::urlpattern diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp index b9077939d..ffb6f6431 100644 --- a/src/urlpattern_pattern_parser.cpp +++ b/src/urlpattern_pattern_parser.cpp @@ -2,6 +2,7 @@ #include "ada/urlpattern_pattern_parser.h" #include +#include namespace ada::urlpattern { @@ -16,21 +17,15 @@ ada_really_inline pattern_parser::pattern_parser( // https://wicg.github.io/urlpattern/#escape-a-regexp-string ada_really_inline std::u32string escape_regexp_string( std::u32string_view input) { + // 1. Assert: input is an ASCII string. assert(ada::idna::is_ascii(input)); - // // TODO: make it cheaper - // size_t u8input_size = - // ada::idna::utf8_length_from_utf32(input.data(), input.size()); - // std::string final_u8input(u8input_size, '\0'); - // ada::idna::utf32_to_utf8(input.data(), input.size(), - // final_u8input.data()); - std::u32string result = U""; size_t index = 0; while (index < input.size()) { size_t pos = input.find_first_of(U".+*?^${}()[]|/\\)"); if (pos == std::string_view::npos) { - result += input.substr(index, input.size()); + result = result += input.substr(index, input.size()); break; } result.append(input.substr(index, pos)).append(U"\\"); From 8c8942a4fe4ac90f699067229a2c32dbce640529 Mon Sep 17 00:00:00 2001 From: Miguel Teixeira Date: Sat, 10 Jun 2023 11:11:23 -0300 Subject: [PATCH 23/23] urlpattern: WIP pattern parser --- include/ada/urlpattern_base.h | 2 + include/ada/urlpattern_canonicalization.h | 1 + include/ada/urlpattern_pattern_parser.h | 26 ++- src/urlpattern_internals.cpp | 6 +- src/urlpattern_pattern_parser.cpp | 214 +++++++++++++++++++--- 5 files changed, 219 insertions(+), 30 deletions(-) diff --git a/include/ada/urlpattern_base.h b/include/ada/urlpattern_base.h index be7cb5808..9a8de880d 100644 --- a/include/ada/urlpattern_base.h +++ b/include/ada/urlpattern_base.h @@ -1,6 +1,8 @@ #ifndef ADA_URLPATTERN_BASE_H #define ADA_URLPATTERN_BASE_H +#include "ada/helpers.h" + #include namespace ada::urlpattern { diff --git a/include/ada/urlpattern_canonicalization.h b/include/ada/urlpattern_canonicalization.h index 512c8c53b..ff1e27946 100644 --- a/include/ada/urlpattern_canonicalization.h +++ b/include/ada/urlpattern_canonicalization.h @@ -1,6 +1,7 @@ #ifndef ADA_URLPATTERN_CANONICALIZATION_H #define ADA_URLPATTERN_CANONICALIZATION_H +#include "ada/helpers.h" #include namespace ada::urlpattern { diff --git a/include/ada/urlpattern_pattern_parser.h b/include/ada/urlpattern_pattern_parser.h index ef16f8863..40765450d 100644 --- a/include/ada/urlpattern_pattern_parser.h +++ b/include/ada/urlpattern_pattern_parser.h @@ -6,6 +6,7 @@ #include "ada/urlpattern_base.h" #include "ada/urlpattern_tokenizer.h" +#include #include namespace ada::urlpattern { @@ -27,22 +28,25 @@ enum class PART_MODIFIER : uint8_t { struct part { PART_TYPE type; PART_MODIFIER modifier; - std::string_view value; - std::string_view name{}; - std::string_view prefix{}; - std::string_view suffix{}; + std::u32string_view value; + std::u32string_view name{}; + std::u32string_view prefix{}; + std::u32string_view suffix{}; }; // https://wicg.github.io/urlpattern/#pattern-parser struct pattern_parser { ada_really_inline pattern_parser( - std::function &encoding, + std::function &encoding, std::u32string_view wildcard_regexp); // https://wicg.github.io/urlpattern/#try-to-consume-a-token ada_really_inline std::optional try_to_consume_token( TOKEN_TYPE type); + // https://wicg.github.io/urlpattern/#try-to-consume-a-modifier-tokenssss + ada_really_inline std::optional try_to_consume_modifier_token(); + // https://wicg.github.io/urlpattern/#try-to-consume-a-regexp-or-wildcard-token ada_really_inline std::optional try_to_consume_regexp_or_wildcard_token(std::optional &name_token); @@ -50,10 +54,20 @@ struct pattern_parser { // https://wicg.github.io/urlpattern/#maybe-add-a-part-from-the-pending-fixed-value ada_really_inline void maybe_add_part_from_pendind_fixed_value(); + // https://wicg.github.io/urlpattern/#add-a-part + ada_really_inline void add_part( + std::u32string_view prefix, std::optional &name_token, + std::optional ®exp_or_wildcard_token, + std::u32string_view suffix, std::optional &modifier_token); + + // https://wicg.github.io/urlpattern/#is-a-duplicate-name + ada_really_inline bool is_duplicate_name(std::u32string_view name); + std::vector token_list; - std::function encoding_callback; + std::function encoding_callback; std::u32string segment_wildcard_regexp; std::u32string pending_fixed_value{}; + std::u32string full_wildcard_regexp_value = U".*"; size_t index = 0; size_t next_numeric_name = 0; std::vector part_list{}; diff --git a/src/urlpattern_internals.cpp b/src/urlpattern_internals.cpp index 84a2a95cc..1fd88f614 100644 --- a/src/urlpattern_internals.cpp +++ b/src/urlpattern_internals.cpp @@ -6,8 +6,12 @@ namespace ada::urlpattern { std::string_view compile_component(std::u32string_view input, std::function &callback, u32urlpattern_options &options) { - // If input is null, then set input to "*". + // 1. If input is null, then set input to "*". if (input.empty()) input = U"*"; + + // 2. Let part list be the result of running parse a pattern string given + // input, options, and encoding callback. + } } // namespace ada::urlpattern \ No newline at end of file diff --git a/src/urlpattern_pattern_parser.cpp b/src/urlpattern_pattern_parser.cpp index ffb6f6431..e09962129 100644 --- a/src/urlpattern_pattern_parser.cpp +++ b/src/urlpattern_pattern_parser.cpp @@ -2,12 +2,14 @@ #include "ada/urlpattern_pattern_parser.h" #include +#include +#include #include namespace ada::urlpattern { ada_really_inline pattern_parser::pattern_parser( - std::function &encoding, + std::function &encoding, std::u32string_view wildcard_regexp) { encoding_callback = encoding; @@ -45,7 +47,7 @@ pattern_parser::maybe_add_part_from_pendind_fixed_value() { // Let encoded value be the result of running parser’s encoding callback given // parser’s pending fixed value. - std::string_view encoded_value = encoding_callback(pending_fixed_value); + std::u32string_view encoded_value = encoding_callback(pending_fixed_value); // Set parser’s pending fixed value to the empty strin pending_fixed_value.clear(); @@ -91,6 +93,162 @@ ada_really_inline std::optional pattern_parser::try_to_consume_token( return next_token; } +// https://wicg.github.io/urlpattern/#is-a-duplicate-name +ada_really_inline bool pattern_parser::is_duplicate_name( + std::u32string_view name) { + // 1. For each part of parser’s part list: + // 2. If part’s name is name, then return true. + // 3. Return false. + return std::any_of(part_list.begin(), part_list.end(), + [&name](part p) { return p.name.compare(name) == 0; }); +} + +// https://wicg.github.io/urlpattern/#add-a-part +ada_really_inline void pattern_parser::add_part( + std::u32string_view prefix, std::optional &name_token, + std::optional ®exp_or_wildcard_token, + std::u32string_view suffix, std::optional &modifier_token) { + // 1. Let modifier be "none". + PART_MODIFIER modifier = PART_MODIFIER::NONE; + + // 2. If modifier token is not null: + if (modifier_token.has_value()) { + // 1. If modifier token’s value is "?" then set modifier to "optional". + if (modifier_token.value()->value == U"?") { + modifier = PART_MODIFIER::OPTIONAL; + } + // 2. Else if modifier token’s value is "*" then set modifier to + // "zero-or-more". + else if (modifier_token.value()->value == U"*") { + modifier = PART_MODIFIER::ZERO_OR_MORE; + } + // 3. Else if modifier token’s value is "+" then set modifier to + // "one-or-more". + else if (modifier_token.value()->value == U"+") { + modifier = PART_MODIFIER::ONE_OR_MORE; + } + } + // 3. If name token is null and regexp or wildcard token is null and modifier + // is "none": + if (!name_token.has_value() && !regexp_or_wildcard_token.has_value() && + modifier == PART_MODIFIER::NONE) { + // This was a "{foo}" grouping. We add this to the pending fixed value so + // that it will be combined with any previous or subsequent text. + // 1. Append prefix to the end of parser’s pending fixed value. + pending_fixed_value.append(prefix); + return; + } + // 4. Run maybe add a part from the pending fixed value given parser. + maybe_add_part_from_pendind_fixed_value(); + // 5. If name token is null and regexp or wildcard token is null: + if (!name_token.has_value() && !regexp_or_wildcard_token.has_value()) { + // This was a "{foo}?" grouping. The modifier means we cannot combine it + // with other text. Therefore we add it as a part immediately. + // 1. Assert: suffix is the empty string. + assert(suffix.empty()); + // 2. If prefix is the empty string, then return. + if (prefix.empty()) return; + // 3.Let encoded value be the result of running parser’s encoding callback + // given prefix. + auto encoded_value = encoding_callback(prefix); + + // 4. Let part be a new part whose type is "fixed-text", value is encoded + // value, and modifier is modifier. + auto p = part(); + p.type = PART_TYPE::FIXED_TEXT; + p.value = encoded_value; + p.modifier = modifier; + + // 5. Append part to parser’s part list. + part_list.push_back(p); + return; + } + + // 6. Let regexp value be the empty string. + std::u32string regexp_value{}; + + // Next, we convert the regexp or wildcard token into a regular expression. + + // 7. If regexp or wildcard token is null, then set regexp value to parser’s + // segment wildcard regexp. + if (!regexp_or_wildcard_token.has_value()) { + regexp_value = segment_wildcard_regexp; + } + // 8. Else if regexp or wildcard token’s type is "asterisk", then set regexp + // value to the full wildcard regexp value. + else if (regexp_or_wildcard_token.value()->type == TOKEN_TYPE::ASTERISK) { + regexp_value = full_wildcard_regexp_value; + } + // 9. Else set regexp value to regexp or wildcard token’s value. + else { + regexp_value = regexp_or_wildcard_token.value()->value; + } + // 10. Let type be "regexp". + auto type = PART_TYPE::REGEXP; + // Next, we convert regexp value into a part type. We make sure to go to a + // regular expression first so that an equivalent "regexp" token will be + // treated the same as a "name" or "asterisk" token. + + // 11. If regexp value is parser’s segment wildcard regexp: + if (regexp_value == segment_wildcard_regexp) { + // 1. Set type to "segment-wildcard". + type = PART_TYPE::SEGMENT_WILDCARD; + // 2. Set regexp value to the empty string. + regexp_value.clear(); + } + // 12. Else if regexp value is the full wildcard regexp value: + else if (regexp_value == full_wildcard_regexp_value) { + // 1. Set type to "full-wildcard". + type = PART_TYPE::FULL_WILDCARD; + // 2. Set regexp value to the empty string. + regexp_value.clear(); + } + // 13. Let name be the empty string. + std::u32string name{}; + // Next, we determine the part name. This can be explicitly provided by a + // "name" token or be automatically assigned. + + // 14. If name token is not null, then set name to name token’s value. + if (name_token.has_value()) { + name = name_token.value()->value; + } + // 15. Else if regexp or wildcard token is not null: + else if (regexp_or_wildcard_token.has_value()) { + // 1. Set name to parser’s next numeric name. + // TODO: Needs a huge improvement + std::stringstream ss{}; + ss << next_numeric_name; + for (char c : ss.str()) { + name += c; + } + // 2. Increment parser’s next numeric name by 1. + ++next_numeric_name; + } + // 16 If the result of running is a duplicate name given parser and name is + // true, then throw a TypeError. + if (is_duplicate_name(name)) { + throw std::bad_typeid(); + } +} + +// https://wicg.github.io/urlpattern/#try-to-consume-a-modifier-tokenssss +ada_really_inline std::optional +pattern_parser::try_to_consume_modifier_token() { + // 1. Let token be the result of running try to consume a token given parser + // and "other-modifier". + std::optional t = try_to_consume_token(TOKEN_TYPE::OTHER_MODIFIER); + + // 2. If token is not null, then return token. + if (t.has_value()) { + return t; + } + + // 3. Set token to the result of running try to consume a token given parser + // and "asterisk". + t = try_to_consume_token(TOKEN_TYPE::ASTERISK); + return t; +} + ada_really_inline std::optional pattern_parser::try_to_consume_regexp_or_wildcard_token( std::optional &name_token) { @@ -111,57 +269,67 @@ pattern_parser::try_to_consume_regexp_or_wildcard_token( // https://wicg.github.io/urlpattern/#parse-a-pattern-string std::vector parse_pattern_string( std::u32string_view input, u32urlpattern_options &options, - std::function &encoding) { - // Let parser be a new pattern parser whose encoding callback is encoding + std::function + &encoding_callback) { + // 1. Let parser be a new pattern parser whose encoding callback is encoding // callback and segment wildcard regexp is the result of running generate a // segment wildcard regexp given options. - std::u32string seg_wildcard_regexp = generate_segment_wildcard_regexp(options); - auto p = pattern_parser(encoding, seg_wildcard_regexp); + auto p = pattern_parser(encoding_callback, seg_wildcard_regexp); - // Set parser’s token list to the result of running tokenize given input and - // "strict". + // 1. Set parser’s token list to the result of running tokenize given input + // and "strict". p.token_list = tokenize(input, POLICY::STRICT); - // While parser’s index is less than parser’s token list's size: + // 3. While parser’s index is less than parser’s token list's size: while (p.index < p.token_list.size()) { - // Let char token be the result of running try to consume a token given + // 1. Let char token be the result of running try to consume a token given // parser and "char". std::optional char_token = p.try_to_consume_token(TOKEN_TYPE::CHAR); - // Let name token be the result of running try to consume a token given + // 2. Let name token be the result of running try to consume a token given // parser and "name". std::optional name_token = p.try_to_consume_token(TOKEN_TYPE::NAME); - // Let regexp or wildcard token be the result of running try to consume a + // 2. Let regexp or wildcard token be the result of running try to consume a // regexp or wildcard token given parser and name token. std::optional regexp_or_wildcard = p.try_to_consume_regexp_or_wildcard_token(name_token); - // If name token is not null or regexp or wildcard token is not null: + // 3. If name token is not null or regexp or wildcard token is not null: if (name_token.has_value() || regexp_or_wildcard.has_value()) { // If there is a matching group, we need to add the part immediately. - // Let prefix be the empty string. - // If char token is not null then set prefix to char token’s value. + + // 1. Let prefix be the empty string. std::u32string prefix{}; - // if (char_token.has_value()) { - // prefix.append(input.substr(char_token.value()->value_start, - // char_token.value()->value_end + 1)); - // } - // If prefix is not the empty string and not options’s prefix code point: + // 2. If char token is not null then set prefix to char token’s value. + if (char_token.has_value()) { + prefix = char_token.value()->value; + } + + // 3. If prefix is not the empty string and not options’s prefix code + // point: if (!prefix.empty() && prefix != options.prefix) { - // Append prefix to the end of parser’s pending fixed value. + // 1. Append prefix to the end of parser’s pending fixed value. p.pending_fixed_value.append(prefix); - // Set prefix to the empty string. + // 2. Set prefix to the empty string. prefix.clear(); } - // Run maybe add a part from the pending fixed value given parser. + // 4. Run maybe add a part from the pending fixed value given parser. p.maybe_add_part_from_pendind_fixed_value(); + + // 5. Let modifier token be the result of running try to consume a + // modifier token given parser. + std::optional modifier_token = p.try_to_consume_modifier_token(); + + // 6. Run add a part given parser, prefix, name token, regexp or wildcard + // token, the empty string, and modifier token. + p.ad } }