dnomd343
/
klotski
mirror of https://github.com/dnomd343/klotski.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

update: apply new fast short codec

legacy
Dnomd343 2 years ago
parent
c530c3f65c
commit
8d82ee362c
8 changed files with 247 additions and 202 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 38
      src/main.cc
  2. 185
      src/short_code/convert.cc
  3. 100
      src/short_code/data_loader.cc
  4. 2
      src/short_code/offset/all_cases_offset.h
  5. 2
      src/short_code/offset/basic_ranges_offset.h
  6. 2
      src/short_code/offset/range_prefix_offset.h
  7. 22
      src/short_code/short_code.h
  8. 96
      src/short_code/short_code_mark.h

38
src/main.cc
View File

@ -174,8 +174,15 @@ int main() {
// } // }
// } // }
// ShortCode::speed_up(ShortCode::FAST); ShortCode::speed_up(ShortCode::FAST);
// AllCases::build(); AllCases::build();
std::vector<uint64_t> all_cases;
for (uint64_t head = 0; head < 16; ++head) {
for (const auto &range : BasicRanges::fetch()) {
all_cases.emplace_back(head << 32 | range);
}
}
// std::cout << "start benchmark" << std::endl; // std::cout << "start benchmark" << std::endl;
auto start_time = clock(); auto start_time = clock();
@ -254,21 +261,24 @@ int main() {
// printf("%08X\n", range); // printf("%08X\n", range);
// } // }
AllCases::build(); // AllCases::build();
for (auto head = 0; head < 16; ++head) { // for (auto head = 0; head < 16; ++head) {
uint64_t prefix = (uint64_t)head << 32; // uint64_t prefix = (uint64_t)head << 32;
for (const auto &range : AllCases::fetch()[head]) { // for (const auto &range : AllCases::fetch()[head]) {
printf("%09lX\n", prefix | range); // printf("%09lX\n", prefix | range);
} // }
} // }
// for (uint32_t i = 0; i < 29334498; ++i) { for (uint32_t i = 0; i < 29334498; ++i) {
// if (ShortCode::fast_encode(ShortCode::fast_decode(i)) != i) { // if (ShortCode::fast_encode(ShortCode::fast_decode(i)) != i) {
// std::cout << "error" << std::endl; // std::cout << "error" << std::endl;
// } // }
// } // ShortCode::fast_encode_legacy(i);
// ShortCode::fast_decode(i);
ShortCode::fast_encode(all_cases[i]);
}
// printf("%09lX\n", ShortCode::tiny_decode_demo(14323231)); // printf("%09lX\n", ShortCode::tiny_decode(14323231));
// std::cout << ShortCode::tiny_encode_demo(0x6EC0F8800) << std::endl; // std::cout << ShortCode::tiny_encode_demo(0x6EC0F8800) << std::endl;
// auto br = BasicRanges::fetch(); // auto br = BasicRanges::fetch();
@ -302,8 +312,8 @@ int main() {
// printf("%09lX\n", ShortCode::fast_decode(14323231)); // printf("%09lX\n", ShortCode::fast_decode(14323231));
// std::cout << ShortCode::fast_encode(0x6EC0F8800) << std::endl; // std::cout << ShortCode::fast_encode(0x6EC0F8800) << std::endl;
std::cerr << (clock() - start_time) * 1000 / CLOCKS_PER_SEC << "ms" << std::endl; // std::cerr << (clock() - start_time) * 1000 / CLOCKS_PER_SEC << "ms" << std::endl;
// std::cerr << (clock() - start_time) * 1000000 / CLOCKS_PER_SEC << "us" << std::endl; std::cerr << (clock() - start_time) * 1000000 / CLOCKS_PER_SEC << "us" << std::endl;
// std::cout << "complete benchmark" << std::endl; // std::cout << "complete benchmark" << std::endl;
// pause(); // pause();

185
src/short_code/convert.cc
View File

@ -1,67 +1,174 @@
#include <algorithm>
#include "common.h" #include "common.h"
#include "short_code.h" #include "short_code.h"
#include "basic_ranges.h" #include "basic_ranges.h"
#include "short_code_mark.h"
//#include "short_code_mark.h"
CommonCode ShortCode::to_common_code() const { // convert to common code CommonCode ShortCode::to_common_code() const { // convert to common code
if (ShortCode::check_mode() == ShortCode::NORMAL) { if (ShortCode::check_mode() == ShortCode::NORMAL) {
return CommonCode::unsafe_create(tiny_decode(code)); // using normal mode return CommonCode::unsafe_create(tiny_decode(code)); // normal mode
} }
return CommonCode::unsafe_create(all_cases_list[code]); // using fast mode return CommonCode::unsafe_create(fast_decode(code)); // fast mode
} }
ShortCode::ShortCode(const CommonCode &common_code) { // convert from common code ShortCode::ShortCode(const CommonCode &common_code) { // convert from common code
if (ShortCode::check_mode() == ShortCode::NORMAL) { if (ShortCode::check_mode() == ShortCode::NORMAL) {
code = tiny_encode(common_code.unwrap()); // using normal mode code = tiny_encode(common_code.unwrap()); // normal mode
} else { } else {
code = all_cases_dict[common_code.unwrap()]; // using fast mode code = fast_encode(common_code.unwrap()); // fast mode
} }
} }
/// ensure that input common code is valid #include "all_cases.h"
uint32_t ShortCode::tiny_encode(uint64_t common_code) { // common_code --low-memory--> short_code #include "all_cases_offset.h"
uint32_t offset = 0; #include "basic_ranges_offset.h"
uint32_t head = common_code >> 32; // common code head #include "range_prefix_offset.h"
uint32_t prefix = (common_code >> 24) & 0xFF; // common code range prefix
auto target = Common::range_reverse((uint32_t)common_code); // target range
for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges uint64_t ShortCode::fast_decode(uint32_t short_code) { // short code => common code
uint32_t range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]]; auto offset = std::upper_bound( // using binary search
if (range == target) { ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
break; // found target range ) - 1;
} uint64_t head = offset - ALL_CASES_OFFSET; // head index
if (Common::check_case(head, range)) { // search for valid cases return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code
++offset; // record sub offset
}
}
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
} }
uint32_t ShortCode::fast_encode(uint64_t common_code) { // common code => short code
auto head = common_code >> 32; // head index
const auto &ranges = AllCases::fetch()[head]; // available ranges
auto offset = std::lower_bound(ranges.begin(), ranges.end(), (uint32_t)common_code) - ranges.begin();
return ALL_CASES_OFFSET[head] + offset; // release short code
}
/// ensure that input common code is valid
//uint32_t ShortCode::tiny_encode(uint64_t common_code) { // common_code --low-memory--> short_code
// uint32_t offset = 0;
// uint32_t head = common_code >> 32; // common code head
// uint32_t prefix = (common_code >> 24) & 0xFF; // common code range prefix
// auto target = Common::range_reverse((uint32_t)common_code); // target range
//
// for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges
// uint32_t range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]];
// if (range == target) {
// break; // found target range
// }
// if (Common::check_case(head, range)) { // search for valid cases
// ++offset; // record sub offset
// }
// }
// return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
//}
/// ensure that input short code is valid /// ensure that input short code is valid
uint64_t ShortCode::tiny_decode(uint32_t short_code) { // short_code --low-memory--> common_code //uint64_t ShortCode::tiny_decode(uint32_t short_code) { // short_code --low-memory--> common_code
uint32_t head = 0, prefix = 0; // uint32_t head = 0, prefix = 0;
for (; head < 16; ++head) { // for (; head < 16; ++head) {
if (short_code < ALL_CASES_INDEX[head]) { // match head // if (short_code < ALL_CASES_INDEX[head]) { // match head
break; // break;
} // }
short_code -= ALL_CASES_INDEX[head]; // short code approximate // short_code -= ALL_CASES_INDEX[head]; // short code approximate
// }
// for (; prefix < 256; ++prefix) {
// if (short_code < RANGE_PREFIX_INDEX[head][prefix]) { // match range prefix
// break;
// }
// short_code -= RANGE_PREFIX_INDEX[head][prefix]; // short code approximate
// }
//
// uint32_t range;
// for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges
// range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]];
// if (Common::check_case(head, range)) { // search for valid cases
// if (short_code == 0) {
// break; // found target range
// }
// --short_code; // short code approximate
// }
// }
// return (uint64_t)head << 32 | Common::range_reverse(range); // release common code
//}
// TODO: try to using 10-bits range prefix -> less static data
uint64_t ShortCode::tiny_decode(uint32_t short_code) {
/// match head index
auto offset = std::upper_bound( // binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
) - 1;
uint64_t head = offset - ALL_CASES_OFFSET; // head index
short_code -= *offset;
/// match range prefix
offset = std::upper_bound( // binary search
RANGE_PREFIX_OFFSET[head], RANGE_PREFIX_OFFSET[head] + 4096, short_code
) - 1;
uint32_t prefix = offset - RANGE_PREFIX_OFFSET[head]; // range prefix
short_code -= *offset;
/// search target range
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) {
uint32_t range = basic_ranges[index]; // traverse basic ranges
uint32_t broken = Common::check_range(head, basic_ranges[index]); // check and get broken address
auto range_rev = Common::range_reverse(basic_ranges[index]); // reversed range
if (broken) { // invalid case
auto delta = (uint32_t)1 << (32 - broken * 2); // this --delta--> next possible range
auto next_min = (range_rev & ~(delta - 1)) + delta;
while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
--index;
} else {
if (!short_code--) { // short code approximate
/// found target range
return head << 32 | range_rev;
} }
for (; prefix < 256; ++prefix) {
if (short_code < RANGE_PREFIX_INDEX[head][prefix]) { // match range prefix
break;
} }
short_code -= RANGE_PREFIX_INDEX[head][prefix]; // short code approximate
} }
uint32_t range; return 0; // never reach when input valid
for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges }
range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]];
uint32_t ShortCode::tiny_encode(uint64_t common_code) {
// printf("%09lX\n", common_code);
uint32_t head = common_code >> 32;
uint32_t prefix = (common_code >> 20) & 0xFFF;
// printf("head = %d\n", head);
// printf("prefix = %X\n", prefix);
uint32_t offset = 0;
auto target = Common::range_reverse((uint32_t)common_code); // target range
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) { // traverse basic ranges
uint32_t range = basic_ranges[index];
if (Common::check_case(head, range)) { // search for valid cases if (Common::check_case(head, range)) { // search for valid cases
if (short_code == 0) {
break; // found target range if (range == target) { // found target range
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
} }
--short_code; // short code approximate
++offset; // record sub offset
} }
} }
return (uint64_t)head << 32 | Common::range_reverse(range); // release common code
return 0;
} }

100
src/short_code/data_loader.cc
View File

@ -16,6 +16,10 @@ void ShortCode::speed_up(ShortCode::Mode mode) {
} }
if (mode == ShortCode::FAST) { // build fast mode data if (mode == ShortCode::FAST) { // build fast mode data
build_mappings(); build_mappings();
// TODO: confirm AllCases data available
AllCases::build();
} else if (mode == ShortCode::NORMAL && !normal_mode_available) { // build normal mode data } else if (mode == ShortCode::NORMAL && !normal_mode_available) { // build normal mode data
BasicRanges::build(); // blocking function BasicRanges::build(); // blocking function
normal_mode_available = true; normal_mode_available = true;
@ -52,20 +56,11 @@ void ShortCode::build_mappings() { // build fast search mappings
map_building.unlock(); map_building.unlock();
} }
#include <algorithm> uint32_t ShortCode::fast_encode_legacy(uint64_t common_code) {
return all_cases_dict[common_code];
uint64_t ShortCode::fast_decode(uint32_t short_code) {
auto offset = std::upper_bound(ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code) - 1; // binary search
uint64_t head = offset - ALL_CASES_OFFSET; // head index
return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code
} }
uint32_t ShortCode::fast_encode(uint64_t common_code) { #include <algorithm>
auto head = common_code >> 32; // head index
const auto &ranges = AllCases::fetch()[head]; // available ranges
auto offset = std::lower_bound(ranges.begin(), ranges.end(), (uint32_t)common_code) - ranges.begin();
return ALL_CASES_OFFSET[head] + offset; // release short code
}
#include "basic_ranges_offset.h" #include "basic_ranges_offset.h"
#include "range_prefix_offset.h" #include "range_prefix_offset.h"
@ -73,84 +68,3 @@ uint32_t ShortCode::fast_encode(uint64_t common_code) {
#include <iostream> #include <iostream>
#include "common.h" #include "common.h"
uint64_t ShortCode::tiny_decode_demo(uint32_t short_code) {
/// match head index
auto offset = std::upper_bound( // binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
) - 1;
uint64_t head = offset - ALL_CASES_OFFSET; // head index
short_code -= *offset;
/// match range prefix
offset = std::upper_bound( // binary search
RANGE_PREFIX_OFFSET_[head], RANGE_PREFIX_OFFSET_[head] + 4096, short_code
) - 1;
uint32_t prefix = offset - RANGE_PREFIX_OFFSET_[head]; // range prefix
short_code -= *offset;
/// search target range
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET_[prefix]; index < basic_ranges.size(); ++index) {
uint32_t range = basic_ranges[index]; // traverse basic ranges
uint32_t broken = Common::check_range(head, basic_ranges[index]); // check and get broken address
auto range_rev = Common::range_reverse(basic_ranges[index]); // reversed range
if (broken) { // invalid case
auto delta = (uint32_t)1 << (32 - broken * 2); // this --delta--> next possible range
auto next_min = (range_rev & ~(delta - 1)) + delta;
while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
--index;
} else {
if (!short_code--) { // short code approximate
/// found target range
return head << 32 | range_rev;
}
}
}
return 0; // never reach when input valid
}
uint32_t ShortCode::tiny_encode_demo(uint64_t common_code) {
// printf("%09lX\n", common_code);
uint32_t head = common_code >> 32;
uint32_t prefix = (common_code >> 20) & 0xFFF;
// printf("head = %d\n", head);
// printf("prefix = %X\n", prefix);
uint32_t offset = 0;
auto target = Common::range_reverse((uint32_t)common_code); // target range
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET_[prefix]; index < basic_ranges.size(); ++index) { // traverse basic ranges
uint32_t range = basic_ranges[index];
if (Common::check_case(head, range)) { // search for valid cases
if (range == target) { // found target range
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET_[head][prefix] + offset;
}
++offset; // record sub offset
}
}
return 0;
}

2
src/short_code/offset/all_cases_offset.h
View File

@ -2,7 +2,7 @@
#include <cstdint> #include <cstdint>
const uint32_t ALL_CASES_OFFSET_[16] = { const uint32_t ALL_CASES_OFFSET[16] = {
0, 2942906, 5203298, 8146204, 0, 2942906, 5203298, 8146204,
8146204, 10468254, 12345199, 14667249, 8146204, 10468254, 12345199, 14667249,
14667249, 16989299, 18866244, 21188294, 14667249, 16989299, 18866244, 21188294,

2
src/short_code/offset/basic_ranges_offset.h
View File

@ -2,7 +2,7 @@
#include <cstdint> #include <cstdint>
const uint32_t BASIC_RANGES_OFFSET_[4096] = { const uint32_t BASIC_RANGES_OFFSET[4096] = {
0, 18272, 24960, 31648, 49920, 56608, 59056, 61504, 0, 18272, 24960, 31648, 49920, 56608, 59056, 61504,
68192, 74880, 77328, 79776, 86464, 104736, 111424, 118112, 68192, 74880, 77328, 79776, 86464, 104736, 111424, 118112,
136384, 143072, 145520, 147968, 154656, 157104, 158000, 158896, 136384, 143072, 145520, 147968, 154656, 157104, 158000, 158896,

2
src/short_code/offset/range_prefix_offset.h
View File

@ -2,7 +2,7 @@
#include <cstdint> #include <cstdint>
const uint32_t RANGE_PREFIX_OFFSET_[16][4096] = { const uint32_t RANGE_PREFIX_OFFSET[16][4096] = {
/// --------------------------------- 0x0 --------------------------------- /// --------------------------------- 0x0 ---------------------------------
0, 9527, 12991, 16067, 25594, 29058, 30527, 31657, 0, 9527, 12991, 16067, 25594, 29058, 30527, 31657,
35121, 38525, 39766, 41041, 44445, 53972, 57436, 60512, 35121, 38525, 39766, 41041, 44445, 53972, 57436, 60512,

22
src/short_code/short_code.h
View File

@ -21,6 +21,8 @@ public:
CommonCode to_common_code() const; CommonCode to_common_code() const;
static bool check(uint32_t short_code); static bool check(uint32_t short_code);
// TODO: std::cout << ShortCode(...) << std::endl;
explicit ShortCode(uint32_t short_code); explicit ShortCode(uint32_t short_code);
explicit ShortCode(const CommonCode &common_code); explicit ShortCode(const CommonCode &common_code);
explicit ShortCode(const std::string &short_code_str); explicit ShortCode(const std::string &short_code_str);
@ -34,22 +36,34 @@ public:
speed_up(mode); speed_up(mode);
} }
// TODO: mark as private after inner test
static uint64_t fast_decode(uint32_t short_code); static uint64_t fast_decode(uint32_t short_code);
static uint32_t fast_encode(uint64_t common_code); static uint32_t fast_encode(uint64_t common_code);
static uint64_t tiny_decode_demo(uint32_t short_code); static uint64_t tiny_decode(uint32_t short_code);
static uint32_t tiny_encode_demo(uint64_t common_code); static uint32_t tiny_encode(uint64_t common_code);
// TODO: ShortCode::create() / ShortCode::from_str(...) / ShortCode::from_common_code(...)
static uint32_t fast_encode_legacy(uint64_t common_code);
private: private:
uint32_t code; uint32_t code;
static std::mutex map_building; static std::mutex map_building;
static bool fast_mode_available; static bool fast_mode_available;
static bool normal_mode_available; static bool normal_mode_available;
static const uint32_t SHORT_CODE_LIMIT = 29334498; static const uint32_t SHORT_CODE_LIMIT = 29334498;
/// NOTE: using binary search instead of global vector and unordered_map
/// for some test, the new function only using < 170MB memory, while the legacy using > 1.5GB
/// but the legacy one is more easy and a little fast.
/// BTW, the new one init less than 1.2s, legacy one need about 15s
static std::vector<uint64_t> all_cases_list; // short_code -> common_code static std::vector<uint64_t> all_cases_list; // short_code -> common_code
static std::unordered_map<uint64_t, uint32_t> all_cases_dict; // common_code -> short_code static std::unordered_map<uint64_t, uint32_t> all_cases_dict; // common_code -> short_code
static void build_mappings(); static void build_mappings();
static uint64_t tiny_decode(uint32_t short_code); // static uint64_t tiny_decode(uint32_t short_code);
static uint32_t tiny_encode(uint64_t common_code); // static uint32_t tiny_encode(uint64_t common_code);
}; };

96
src/short_code/short_code_mark.h
View File

@ -2,56 +2,56 @@
#include <cstdint> #include <cstdint>
const uint32_t ALL_CASES_INDEX[16] = { //const uint32_t ALL_CASES_INDEX[16] = {
2942906, 2260392, 2942906, 0, // 2942906, 2260392, 2942906, 0,
2322050, 1876945, 2322050, 0, // 2322050, 1876945, 2322050, 0,
2322050, 1876945, 2322050, 0, // 2322050, 1876945, 2322050, 0,
2942906, 2260392, 2942906, 0, // 2942906, 2260392, 2942906, 0,
}; //};
const uint32_t ALL_CASES_OFFSET[16] = { //const uint32_t ALL_CASES_OFFSET[16] = {
0, 2942906, 5203298, 8146204, // 0, 2942906, 5203298, 8146204,
8146204, 10468254, 12345199, 14667249, // 8146204, 10468254, 12345199, 14667249,
14667249, 16989299, 18866244, 21188294, // 14667249, 16989299, 18866244, 21188294,
21188294, 24131200, 26391592, 29334498, // 21188294, 24131200, 26391592, 29334498,
}; //};
const uint32_t BASIC_RANGES_INDEX[256] = { //const uint32_t BASIC_RANGES_INDEX[256] = {
136384, 49920, 49920, 136384, 49920, 18272, 18272, 49920, // 136384, 49920, 49920, 136384, 49920, 18272, 18272, 49920,
49920, 18272, 18272, 49920, 136384, 49920, 49920, 136384, // 49920, 18272, 18272, 49920, 136384, 49920, 49920, 136384,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589, // 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555, // 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589, // 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555, // 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555, // 136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555,
49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653, // 49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589, // 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555, // 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246, // 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163, // 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246, // 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163, // 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163, // 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244, // 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589, // 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555, // 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246, // 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163, // 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246, // 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163, // 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163, // 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244, // 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555, // 136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555,
49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653, // 49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163, // 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244, // 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163, // 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244, // 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
136384, 48555, 48555, 133653, 48555, 15163, 15163, 43244, // 136384, 48555, 48555, 133653, 48555, 15163, 15163, 43244,
48555, 15163, 15163, 43244, 133653, 43244, 43244, 122125, // 48555, 15163, 15163, 43244, 133653, 43244, 43244, 122125,
}; //};
const uint32_t BASIC_RANGES_OFFSET[256] = { const uint32_t BASIC_RANGES_OFFSET_8bits[256] = {
0, 136384, 186304, 236224, 372608, 422528, 440800, 459072, 0, 136384, 186304, 236224, 372608, 422528, 440800, 459072,
508992, 558912, 577184, 595456, 645376, 781760, 831680, 881600, 508992, 558912, 577184, 595456, 645376, 781760, 831680, 881600,
1017984, 1067904, 1086176, 1104448, 1154368, 1172640, 1178987, 1185334, 1017984, 1067904, 1086176, 1104448, 1154368, 1172640, 1178987, 1185334,
@ -633,7 +633,7 @@ const uint32_t RANGE_PREFIX_INDEX[16][256] = {
}, },
}; };
const uint32_t RANGE_PREFIX_OFFSET[16][256] = { const uint32_t RANGE_PREFIX_OFFSET_8bits[16][256] = {
{ {
0, 70039, 70039, 95633, 165672, 191266, 200793, 210117, 0, 70039, 70039, 95633, 165672, 191266, 200793, 210117,
235711, 258169, 258169, 267696, 290154, 360193, 360193, 385787, 235711, 258169, 258169, 267696, 290154, 360193, 360193, 385787,

Write Preview
Loading…
Cancel
Save