You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@orc.apache.org by om...@apache.org on 2015/07/06 23:52:40 UTC
[11/23] orc git commit: ORC-23. Simplify directory structure.
http://git-wip-us.apache.org/repos/asf/orc/blob/7f55b453/c++/test/TestRle.cc
----------------------------------------------------------------------
diff --git a/c++/test/TestRle.cc b/c++/test/TestRle.cc
new file mode 100644
index 0000000..5cd03a7
--- /dev/null
+++ b/c++/test/TestRle.cc
@@ -0,0 +1,2639 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Adaptor.hh"
+#include "Compression.hh"
+#include "OrcTest.hh"
+#include "RLE.hh"
+#include "wrap/gtest-wrapper.h"
+
+#include <iostream>
+#include <vector>
+
+namespace orc {
+
+std::vector<int64_t> decodeRLEv2(const unsigned char *bytes,
+ unsigned long l,
+ size_t n,
+ size_t count,
+ const char* notNull = nullptr) {
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(bytes,l)), true,
+ RleVersion_2, *getDefaultPool());
+ std::vector<int64_t> results;
+ for (size_t i = 0; i < count; i+=n) {
+ size_t remaining = count - i;
+ size_t nread = std::min(n, remaining);
+ std::vector<int64_t> data(nread);
+ rle->next(data.data(), nread, notNull);
+ if (notNull) {
+ notNull += nread;
+ }
+ results.insert(results.end(), data.begin(), data.end());
+ }
+
+ return results;
+}
+
+void checkResults(const std::vector<int64_t> &e, const std::vector<int64_t> &a,
+ size_t n, const char* notNull = nullptr) {
+ EXPECT_EQ(e.size(), a.size()) << "vectors differ in size";
+ for (size_t i = 0; i < e.size(); ++i) {
+ if (!notNull || notNull[i]) {
+ EXPECT_EQ(e[i], a[i]) << "Output wrong at " << i << ", n=" << n;
+ }
+ }
+}
+
+TEST(RLEv2, basicDelta0) {
+ const size_t count = 20;
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < count; ++i) {
+ values.push_back(static_cast<int64_t>(i));
+ }
+
+ const unsigned char bytes[] = {0xc0,0x13,0x00,0x02};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, count), 7);
+ checkResults(values, decodeRLEv2(bytes, l, count, count), count);
+};
+
+TEST(RLEv2, basicDelta1) {
+ std::vector<int64_t> values(5);
+ values[0] = -500;
+ values[1] = -400;
+ values[2] = -350;
+ values[3] = -325;
+ values[4] = -310;
+
+ const unsigned char bytes[] = {0xce,0x04,0xe7,0x07,0xc8,0x01,0x32,0x19,0x0f};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, basicDelta2) {
+ std::vector<int64_t> values(5);
+ values[0] = -500;
+ values[1] = -600;
+ values[2] = -650;
+ values[3] = -675;
+ values[4] = -710;
+
+ const unsigned char bytes[] = {0xce,0x04,0xe7,0x07,0xc7,0x01,0x32,0x19,0x23};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, basicDelta3) {
+ std::vector<int64_t> values(5);
+ values[0] = 500;
+ values[1] = 400;
+ values[2] = 350;
+ values[3] = 325;
+ values[4] = 310;
+
+ const unsigned char bytes[] = {0xce,0x04,0xe8,0x07,0xc7,0x01,0x32,0x19,0x0f};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, basicDelta4) {
+ std::vector<int64_t> values(5);
+ values[0] = 500;
+ values[1] = 600;
+ values[2] = 650;
+ values[3] = 675;
+ values[4] = 710;
+
+ const unsigned char bytes[] = {0xce,0x04,0xe8,0x07,0xc8,0x01,0x32,0x19,0x23};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, delta0Width) {
+ const unsigned char buffer[] = {0x4e, 0x2, 0x0, 0x1, 0x2, 0xc0, 0x2, 0x42,
+ 0x0};
+ std::unique_ptr<RleDecoder> decoder =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream
+ (buffer, ARRAY_SIZE(buffer))),
+ false, RleVersion_2, *getDefaultPool());
+ int64_t values[6];
+ decoder->next(values, 6, 0);
+ EXPECT_EQ(0, values[0]);
+ EXPECT_EQ(1, values[1]);
+ EXPECT_EQ(2, values[2]);
+ EXPECT_EQ(0x42, values[3]);
+ EXPECT_EQ(0x42, values[4]);
+ EXPECT_EQ(0x42, values[5]);
+}
+
+TEST(RLEv2, basicDelta0WithNulls) {
+ std::vector<int64_t> values;
+ std::vector<char> notNull;
+ for (size_t i = 0; i < 20; ++i) {
+ values.push_back(static_cast<int64_t>(i));
+ notNull.push_back(true);
+ // throw in a null every third value
+ bool addNull = (i % 3 == 0);
+ if (addNull) {
+ values.push_back(-1);
+ notNull.push_back(false);
+ }
+ }
+
+ const unsigned char bytes[] = {0xc0,0x13,0x00,0x02};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ const size_t count = values.size();
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, count, notNull.data()),
+ 1, notNull.data());
+ checkResults(values, decodeRLEv2(bytes, l, 3, count, notNull.data()),
+ 3, notNull.data());
+ checkResults(values, decodeRLEv2(bytes, l, 7, count, notNull.data()),
+ 7, notNull.data());
+ checkResults(values, decodeRLEv2(bytes, l, count, count, notNull.data()),
+ count, notNull.data());
+};
+
+TEST(RLEv2, shortRepeats) {
+ const size_t runLength = 7;
+ const size_t nVals = 10;
+ const size_t count = nVals * runLength;
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < nVals; ++i) {
+ for (size_t j = 0; j < runLength; ++j) {
+ values.push_back(static_cast<int64_t>(i));
+ }
+ }
+
+ const unsigned char bytes[] = {0x04,0x00,0x04,0x02,0x04,0x04,0x04,
+ 0x06,0x04,0x08,0x04,0x0a,0x04,0x0c,
+ 0x04,0x0e,0x04,0x10,0x04,0x12};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, count), 7);
+ checkResults(values, decodeRLEv2(bytes, l, count, count), count);
+};
+
+TEST(RLEv2, multiByteShortRepeats) {
+ const size_t runLength = 7;
+ const size_t nVals = 3;
+ const size_t count = nVals * runLength;
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < nVals; ++i) {
+ for (size_t j = 0; j < runLength; ++j) {
+ values.push_back(static_cast<int64_t>(i)+(1L<<62));
+ }
+ }
+
+ const unsigned char bytes[] = {0x3c,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x3c,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x02,
+ 0x3c,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x04};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, count), 7);
+ checkResults(values, decodeRLEv2(bytes, l, count, count), count);
+};
+
+TEST(RLEv2, 0to2Repeat1Direct) {
+ const unsigned char buffer[] = {0x46, 0x02, 0x02, 0x40};
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(buffer,
+ ARRAY_SIZE(buffer))),
+ true, RleVersion_2, *getDefaultPool());
+ std::vector<int64_t> data(3);
+ rle->next(data.data(), 3, nullptr);
+
+ for (size_t i = 0; i < data.size(); ++i) {
+ EXPECT_EQ(i, data[i]) << "Output wrong at " << i;
+ }
+};
+
+TEST(RLEv2, bitSize2Direct) {
+ // 0,1 repeated 10 times (signed ints)
+ const size_t count = 20;
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < count; ++i) {
+ values.push_back(i%2);
+ }
+
+ const unsigned char bytes[] = {0x42, 0x13, 0x22, 0x22, 0x22, 0x22, 0x22};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, count), 7);
+ checkResults(values, decodeRLEv2(bytes, l, count, count), count);
+};
+
+TEST(RLEv2, bitSize4Direct) {
+ // 0,2 repeated 10 times (signed ints)
+ const size_t count = 20;
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < count; ++i) {
+ values.push_back((i%2)*2);
+ }
+
+ const unsigned char bytes[] = {0x46,0x13,0x04,0x04,0x04,0x04,
+ 0x04,0x04,0x04,0x04,0x04,0x04};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, count), 7);
+ checkResults(values, decodeRLEv2(bytes, l, count, count), count);
+};
+
+TEST(RLEv2, multipleRunsDirect) {
+ std::vector<int64_t> values;
+ // 0,1 repeated 10 times (signed ints)
+ for (size_t i = 0; i < 20; ++i) {
+ values.push_back(i%2);
+ }
+ // 0,2 repeated 10 times (signed ints)
+ for (size_t i = 0; i < 20; ++i) {
+ values.push_back((i%2)*2);
+ }
+
+ const unsigned char bytes[] = {0x42,0x13,0x22,0x22,0x22,0x22,0x22,
+ 0x46,0x13,0x04,0x04,0x04,0x04,0x04,
+ 0x04,0x04,0x04,0x04,0x04};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, largeNegativesDirect) {
+ const unsigned char buffer[] =
+ {0x7e,0x04,0xcf,0xca,0xcc,0x91,0xba,0x38,0x93,0xab,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x99,0xa5,
+ 0xcc,0x28,0x03,0xf7,0xe0,0xff};
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(
+ std::unique_ptr<SeekableInputStream>(
+ new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer))),
+ true, RleVersion_2, *getDefaultPool());
+ std::vector<int64_t> data(5);
+ rle->next(data.data(), 5, nullptr);
+
+ EXPECT_EQ(-7486502418706614742, data[0]) << "Output wrong at " << 0;
+ EXPECT_EQ(0, data[1]) << "Output wrong at " << 1;
+ EXPECT_EQ(1, data[2]) << "Output wrong at " << 2;
+ EXPECT_EQ(1, data[3]) << "Output wrong at " << 3;
+ EXPECT_EQ(-5535739865598783616, data[4]) << "Output wrong at " << 4;
+};
+
+TEST(RLEv2, overflowDirect) {
+ std::vector<int64_t> values(4);
+ values[0] = 4513343538618202719l;
+ values[1] = 4513343538618202711l;
+ values[2] = 2911390882471569739l;
+ values[3] = -9181829309989854913l;
+
+ const unsigned char bytes[] = {0x7e,0x03,0x7d,0x45,0x3c,0x12,0x41,0x48,0xf4,
+ 0xbe,0x7d,0x45,0x3c,0x12,0x41,0x48,0xf4,0xae,
+ 0x50,0xce,0xad,0x2a,0x30,0x0e,0xd2,0x96,0xfe,
+ 0xd8,0xd2,0x38,0x54,0x6e,0x3d,0x81};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, basicPatched0) {
+ long v[] = {2030,2000,2020,1000000,2040,2050,2060,2070,2080,2090};
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < sizeof(v) / sizeof(long); ++i) {
+ values.push_back(v[i]);
+ }
+
+ const unsigned char bytes[] = {0x8e,0x09,0x2b,0x21,0x07,0xd0,0x1e,0x00,0x14,
+ 0x70,0x28,0x32,0x3c,0x46,0x50,0x5a,0xfc,0xe8};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, basicPatched1) {
+ long v[] = {20, 2, 3, 2, 1, 3, 17, 71, 35, 2, 1, 139, 2, 2, 3, 1783, 475, 2,
+ 1, 1, 3, 1, 3, 2, 32, 1, 2, 3, 1, 8, 30, 1, 3, 414, 1, 1, 135, 3,
+ 3, 1, 414, 2, 1, 2, 2, 594, 2, 5, 6, 4, 11, 1, 2, 2, 1, 1, 52, 4,
+ 1, 2, 7, 1, 17, 334, 1, 2, 1, 2, 2, 6, 1, 266, 1, 2, 217, 2, 6, 2,
+ 13, 2, 2, 1, 2, 3, 5, 1, 2, 1, 7244, 11813, 1, 33, 2, -13, 1, 2, 3,
+ 13, 1, 92, 3, 13, 5, 14, 9, 141, 12, 6, 15, 25};
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < sizeof(v) / sizeof(long); ++i) {
+ values.push_back(v[i]);
+ }
+
+ const unsigned char bytes[] = {0x90,0x6d,0x04,0xa4,0x8d,0x10,0x83,0xc2,0x00,
+ 0xf0,0x70,0x40,0x3c,0x54,0x18,0x03,0xc1,0xc9,
+ 0x80,0x78,0x3c,0x21,0x04,0xf4,0x03,0xc1,0xc0,
+ 0xe0,0x80,0x38,0x20,0x0f,0x16,0x83,0x81,0xe1,
+ 0x00,0x70,0x54,0x56,0x0e,0x08,0x6a,0xc1,0xc0,
+ 0xe4,0xa0,0x40,0x20,0x0e,0xd5,0x83,0xc1,0xc0,
+ 0xf0,0x79,0x7c,0x1e,0x12,0x09,0x84,0x43,0x00,
+ 0xe0,0x78,0x3c,0x1c,0x0e,0x20,0x84,0x41,0xc0,
+ 0xf0,0xa0,0x38,0x3d,0x5b,0x07,0x03,0xc1,0xc0,
+ 0xf0,0x78,0x4c,0x1d,0x17,0x07,0x03,0xdc,0xc0,
+ 0xf0,0x98,0x3c,0x34,0x0f,0x07,0x83,0x81,0xe1,
+ 0x00,0x90,0x38,0x1e,0x0e,0x2c,0x8c,0x81,0xc2,
+ 0xe0,0x78,0x00,0x1c,0x0f,0x08,0x06,0x81,0xc6,
+ 0x90,0x80,0x68,0x24,0x1b,0x0b,0x26,0x83,0x21,
+ 0x30,0xe0,0x98,0x3c,0x6f,0x06,0xb7,0x03,0x70};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, mixedPatchedAndShortRepeats) {
+ long v[] = {20, 2, 3, 2, 1, 3, 17, 71, 35, 2, 1, 139, 2, 2, 3, 1783, 475, 2, 1, 1, 3, 1, 3, 2, 32, 1, 2, 3, 1, 8, 30, 1, 3, 414, 1, 1, 135, 3, 3, 1, 414, 2, 1, 2, 2, 594, 2, 5, 6, 4, 11, 1, 2, 2, 1, 1, 52, 4, 1, 2, 7, 1, 17, 334, 1, 2, 1, 2, 2, 6, 1, 266, 1, 2, 217, 2, 6, 2, 13, 2, 2, 1, 2, 3, 5, 1, 2, 1, 7244, 11813, 1, 33, 2, -13, 1, 2, 3, 13, 1, 92, 3, 13, 5, 14, 9, 141, 12, 6, 15, 25, 1, 1, 1, 46, 2, 1, 1, 141, 3, 1, 1, 1, 1, 2, 1, 4, 34, 5, 78, 8, 1, 2, 2, 1, 9, 10, 2, 1, 4, 13, 1, 5, 4, 4, 19, 5, 1, 1, 1, 68, 33, 399, 1, 1885, 25, 5, 2, 4, 1, 1, 2, 16, 1, 2966, 3, 1, 1, 25501, 1, 1, 1, 66, 1, 3, 8, 131, 14, 5, 1, 2, 2, 1, 1, 8, 1, 1, 2, 1, 5, 9, 2, 3, 112, 13, 2, 2, 1, 5, 10, 3, 1, 1, 13, 2, 3, 4, 1, 3, 1, 1, 2, 1, 1, 2, 4, 2, 207, 1, 1, 2, 4, 3, 3, 2, 2, 16};
+ std::vector<int64_t> values;
+ for (size_t i = 0; i < sizeof(v) / sizeof(long); ++i) {
+ values.push_back(v[i]);
+ }
+
+ const unsigned char bytes[] = {0x90,0x6d,0x04,0xa4,0x8d,0x10,0x83,0xc2,0x00,0xf0,0x70,0x40,0x3c,0x54,0x18,0x03,0xc1,0xc9,0x80,0x78,0x3c,0x21,0x04,0xf4,0x03,0xc1,0xc0,0xe0,0x80,0x38,0x20,0x0f,0x16,0x83,0x81,0xe1,0x00,0x70,0x54,0x56,0x0e,0x08,0x6a,0xc1,0xc0,0xe4,0xa0,0x40,0x20,0x0e,0xd5,0x83,0xc1,0xc0,0xf0,0x79,0x7c,0x1e,0x12,0x09,0x84,0x43,0x00,0xe0,0x78,0x3c,0x1c,0x0e,0x20,0x84,0x41,0xc0,0xf0,0xa0,0x38,0x3d,0x5b,0x07,0x03,0xc1,0xc0,0xf0,0x78,0x4c,0x1d,0x17,0x07,0x03,0xdc,0xc0,0xf0,0x98,0x3c,0x34,0x0f,0x07,0x83,0x81,0xe1,0x00,0x90,0x38,0x1e,0x0e,0x2c,0x8c,0x81,0xc2,0xe0,0x78,0x00,0x1c,0x0f,0x08,0x06,0x81,0xc6,0x90,0x80,0x68,0x24,0x1b,0x0b,0x26,0x83,0x21,0x30,0xe0,0x98,0x3c,0x6f,0x06,0xb7,0x03,0x70,0x00,0x02,0x5e,0x05,0x00,0x5c,0x00,0x04,0x00,0x02,0x00,0x02,0x01,0x1a,0x00,0x06,0x01,0x02,0x8a,0x16,0x00,0x41,0x01,0x04,0x00,0xe1,0x10,0xd1,0xc0,0x04,0x10,0x08,0x24,0x10,0x03,0x30,0x01,0x03,0x0d,0x21,0x00,0xb0,0x00,0x02,0x5e,0x12,0x00,0x88,0x00,0x42,0x03,0x1e,0x00,0x02,0x0e,0xba,0x00,0x32
,0x00,0x0a,0x00,0x04,0x00,0x08,0x00,0x02,0x00,0x02,0x00,0x04,0x00,0x20,0x00,0x02,0x17,0x2c,0x00,0x06,0x00,0x02,0x00,0x02,0xc7,0x3a,0x00,0x02,0x8c,0x36,0x00,0xa2,0x01,0x82,0x00,0x10,0x70,0x43,0x42,0x00,0x02,0x04,0x00,0x00,0xe0,0x00,0x01,0x00,0x10,0x40,0x10,0x5b,0xc6,0x01,0x02,0x00,0x20,0x90,0x40,0x00,0x0c,0x02,0x08,0x18,0x00,0x40,0x00,0x01,0x00,0x00,0x08,0x30,0x33,0x80,0x00,0x02,0x0c,0x10,0x20,0x20,0x47,0x80,0x13,0x4c};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+ // Read 1 at a time, then 3 at a time, etc.
+ checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
+ checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
+ checkResults(values, decodeRLEv2(bytes, l, 7, values.size()), 7);
+ checkResults(values, decodeRLEv2(bytes, l, values.size(), values.size()),
+ values.size());
+};
+
+TEST(RLEv2, basicDirectSeek) {
+ // 0,1 repeated 10 times (signed ints) followed by
+ // 0,2 repeated 10 times (signed ints)
+ const unsigned char bytes[] = {0x42,0x13,0x22,0x22,0x22,0x22,0x22,
+ 0x46,0x13,0x04,0x04,0x04,0x04,0x04,
+ 0x04,0x04,0x04,0x04,0x04};
+ unsigned long l = sizeof(bytes) / sizeof(char);
+
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(bytes,l)), true,
+ RleVersion_2, *getDefaultPool());
+ std::list<uint64_t> position;
+ position.push_back(7); // byte position; skip first 20 [0 to 19]
+ position.push_back(13); // value position; skip 13 more [20 to 32]
+
+ PositionProvider location(position);
+ rle->seek(location);
+ std::vector<int64_t> data(3);
+ rle->next(data.data(), 3, nullptr);
+ EXPECT_EQ(2, data[0]);
+ EXPECT_EQ(0, data[1]);
+ EXPECT_EQ(2, data[2]);
+ rle->next(data.data(), 3, nullptr);
+ EXPECT_EQ(0, data[0]);
+ EXPECT_EQ(2, data[1]);
+ EXPECT_EQ(0, data[2]);
+ rle->next(data.data(), 1, nullptr);
+ EXPECT_EQ(2, data[0]);
+};
+
+TEST(RLEv2, bitsLeftByPreviousStream) {
+ // test for #109
+ // 118 DIRECT values, followed by PATHCED values
+ const unsigned char bytes[] = {
+ 0x5a, 0x75, 0x92, 0x42, 0x49, 0x09, 0x2b, 0xa4,
+ 0xae, 0x92, 0xc2, 0x4b, 0x89, 0x2f, 0x24, 0xbc,
+ 0x93, 0x2a, 0x4c, 0xa9, 0x34, 0x24, 0xe0, 0x93,
+ 0x92, 0x4e, 0xe9, 0x40, 0xa5, 0x04, 0x94, 0x12,
+ 0x62, 0xa9, 0xc9, 0xa7, 0x26, 0x9c, 0xaa, 0x73,
+ 0x09, 0xcd, 0x27, 0x34, 0x9c, 0xf2, 0x74, 0x49,
+ 0xd3, 0x27, 0x50, 0x9d, 0x42, 0x75, 0x29, 0xd4,
+ 0xa7, 0x5a, 0x9d, 0xaa, 0x79, 0x89, 0xe9, 0x27,
+ 0xa4, 0x9e, 0xea, 0x7c, 0x29, 0xf6, 0x27, 0xdc,
+ 0x9f, 0xb2, 0x7f, 0x4a, 0x00, 0xa8, 0x14, 0xa0,
+ 0x72, 0x82, 0x8a, 0x19, 0x28, 0x6e, 0xa2, 0x52,
+ 0x89, 0x4a, 0x28, 0x28, 0xa6, 0xa2, 0x9a, 0x8b,
+ 0x6a, 0x2d, 0xa8, 0xb8, 0xa2, 0xe2, 0x8b, 0xaa,
+ 0x53, 0xa9, 0x54, 0xa5, 0x92, 0x98, 0x6a, 0x62,
+ 0xa9, 0x9c, 0xa6, 0x8a, 0x9b, 0xea, 0x70, 0x29,
+ 0xd2, 0xa7, 0x52, 0x9d, 0x4a, 0x77, 0x29, 0xe0,
+ 0xa7, 0xa2, 0x9e, 0xaa, 0x7b, 0x29, 0xf0, 0xa7,
+ 0xd2, 0xa0, 0x0a, 0x84, 0x2a, 0x18, 0xa8, 0x72,
+ 0xa1, 0xca, 0x89, 0x2a, 0x30, 0xa9, 0x4a, 0xa5,
+ 0x4a, 0x96, 0x2a, 0xae, 0xab, 0x02, 0xac, 0x2b,
+ 0x8d, 0x2e, 0x60, 0xb9, 0x82, 0xe7, 0x2b, 0x9f,
+ 0xae, 0x84, 0xba, 0x52, 0xe9, 0xeb, 0xad, 0x2e,
+ 0xb6, 0xbc, 0x32, 0xf1, 0xcb, 0xcc, 0x2f, 0x42,
+ 0xbd, 0x8a, 0xf7, 0xcb, 0xe1, 0xaf, 0xa4, 0xbe,
+ 0x9a, 0xfa, 0x6b, 0xeb, 0xaf, 0xba, 0xbe, 0xea,
+ 0xfd, 0x2b, 0xf4, 0xaf, 0xd8, 0xbf, 0xfb, 0x00,
+ 0x80, // <= end of DIRECT, start of PATCHED =>
+ 0x90,0x6d,0x04,0xa4,0x8d,0x10,0x83,0xc2,0x00,
+ 0xf0,0x70,0x40,0x3c,0x54,0x18,0x03,0xc1,0xc9,
+ 0x80,0x78,0x3c,0x21,0x04,0xf4,0x03,0xc1,0xc0,
+ 0xe0,0x80,0x38,0x20,0x0f,0x16,0x83,0x81,0xe1,
+ 0x00,0x70,0x54,0x56,0x0e,0x08,0x6a,0xc1,0xc0,
+ 0xe4,0xa0,0x40,0x20,0x0e,0xd5,0x83,0xc1,0xc0,
+ 0xf0,0x79,0x7c,0x1e,0x12,0x09,0x84,0x43,0x00,
+ 0xe0,0x78,0x3c,0x1c,0x0e,0x20,0x84,0x41,0xc0,
+ 0xf0,0xa0,0x38,0x3d,0x5b,0x07,0x03,0xc1,0xc0,
+ 0xf0,0x78,0x4c,0x1d,0x17,0x07,0x03,0xdc,0xc0,
+ 0xf0,0x98,0x3c,0x34,0x0f,0x07,0x83,0x81,0xe1,
+ 0x00,0x90,0x38,0x1e,0x0e,0x2c,0x8c,0x81,0xc2,
+ 0xe0,0x78,0x00,0x1c,0x0f,0x08,0x06,0x81,0xc6,
+ 0x90,0x80,0x68,0x24,0x1b,0x0b,0x26,0x83,0x21,
+ 0x30,0xe0,0x98,0x3c,0x6f,0x06,0xb7,0x03,0x70
+ };
+ unsigned long l = sizeof(bytes) / sizeof(unsigned char);
+
+ // PATCHED values.
+ long v[] = {20, 2, 3, 2, 1, 3, 17, 71, 35, 2, 1, 139, 2, 2, 3, 1783, 475, 2,
+ 1, 1, 3, 1, 3, 2, 32, 1, 2, 3, 1, 8, 30, 1, 3, 414, 1, 1, 135, 3,
+ 3, 1, 414, 2, 1, 2, 2, 594, 2, 5, 6, 4, 11, 1, 2, 2, 1, 1, 52, 4,
+ 1, 2, 7, 1, 17, 334, 1, 2, 1, 2, 2, 6, 1, 266, 1, 2, 217, 2, 6, 2,
+ 13, 2, 2, 1, 2, 3, 5, 1, 2, 1, 7244, 11813, 1, 33, 2, -13, 1, 2, 3,
+ 13, 1, 92, 3, 13, 5, 14, 9, 141, 12, 6, 15, 25};
+ unsigned long D = 118, P = sizeof(v) / sizeof(long), N = D + P;
+
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(bytes,l)), true,
+ RleVersion_2, *getDefaultPool());
+
+ std::vector<int64_t> data(N);
+ rle->next(data.data(), N, nullptr);
+ // check patched values
+ for (size_t i=0; i < P; ++i) {
+ EXPECT_EQ(v[i], data[i+D]);
+ }
+};
+
+TEST(RLEv1, simpleTest) {
+ const unsigned char buffer[] = {0x61, 0xff, 0x64, 0xfb, 0x02, 0x03, 0x5, 0x7,
+ 0xb};
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(buffer,
+ ARRAY_SIZE(buffer))),
+ false, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(105);
+ rle->next(data.data(), 105, nullptr);
+
+ for (size_t i = 0; i < 100; ++i) {
+ EXPECT_EQ(100 - i, data[i]) << "Output wrong at " << i;
+ }
+ EXPECT_EQ(2, data[100]);
+ EXPECT_EQ(3, data[101]);
+ EXPECT_EQ(5, data[102]);
+ EXPECT_EQ(7, data[103]);
+ EXPECT_EQ(11, data[104]);
+};
+
+TEST(RLEv1, signedNullLiteralTest) {
+ const unsigned char buffer[]= {0xf8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(buffer,
+ ARRAY_SIZE(buffer))),
+ true, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(8);
+ std::vector<char> notNull(8, 1);
+ rle->next(data.data(), 8, notNull.data());
+
+ for (size_t i = 0; i < 8; ++i) {
+ EXPECT_EQ(i % 2 == 0 ? i/2 : -((i+1)/2),
+ data[i]);
+ }
+}
+
+TEST(RLEv1, splitHeader) {
+ const unsigned char buffer[] = {0x0, 0x00, 0xdc, 0xba, 0x98, 0x76};
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(
+ std::unique_ptr<SeekableInputStream>
+ (new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer), 4)),
+ false, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(200);
+ rle->next(data.data(), 3, nullptr);
+
+ for (size_t i = 0; i < 3; ++i) {
+ EXPECT_EQ(247864668, data[i]) << "Output wrong at " << i;
+ }
+}
+
+TEST(RLEv1, splitRuns) {
+ const unsigned char buffer[] = {0x7d, 0x01, 0xff, 0x01, 0xfb, 0x01,
+ 0x02, 0x03, 0x04, 0x05};
+ SeekableInputStream* const stream =
+ new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer));
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>(stream),
+ false, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(200);
+ for (size_t i = 0; i < 42; ++i) {
+ rle->next(data.data(), 3, nullptr);
+ for (size_t j = 0; j < 3; ++j) {
+ EXPECT_EQ(255 + i * 3 + j, data[j])
+ << "Wrong output at " << i << ", " << j;
+ }
+ }
+ rle->next(data.data(), 3, nullptr);
+ EXPECT_EQ(381, data[0]);
+ EXPECT_EQ(382, data[1]);
+ EXPECT_EQ(1, data[2]);
+ rle->next(data.data(), 3, nullptr);
+ EXPECT_EQ(2, data[0]);
+ EXPECT_EQ(3, data[1]);
+ EXPECT_EQ(4, data[2]);
+ rle->next(data.data(), 1, nullptr);
+ EXPECT_EQ(5, data[0]);
+}
+
+TEST(RLEv1, testSigned) {
+ const unsigned char buffer[] = {0x7f, 0xff, 0x20};
+ SeekableInputStream* const stream =
+ new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer));
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>(stream),
+ true, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(100);
+ rle->next(data.data(), data.size(), nullptr);
+ for (size_t i = 0; i < data.size(); ++i) {
+ EXPECT_EQ(16 - i, data[i]) << "Wrong output at " << i;
+ }
+ rle->next(data.data(), 30, nullptr);
+ for(size_t i = 0; i < 30; ++i) {
+ EXPECT_EQ(16 - 100 - static_cast<long>(i), data[i])
+ << "Wrong output at " << (i + 100);
+ }
+}
+
+TEST(RLEv1, testNull) {
+ const unsigned char buffer[] = {0x75, 0x02, 0x00};
+ SeekableInputStream* const stream =
+ new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer));
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>(stream),
+ true, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(24);
+ std::vector<char> notNull(24);
+ for (size_t i = 0; i < notNull.size(); ++i) {
+ notNull[i] = (i + 1) % 2;
+ }
+ for (size_t i = 0; i < 10; ++i) {
+ for(size_t j = 0; j < data.size(); ++j) {
+ data[j] = -1;
+ }
+ rle->next(data.data(), 24, notNull.data());
+ for (size_t j = 0; j < 24; ++j) {
+ if (notNull[j]) {
+ EXPECT_EQ(i * 24 + j, data[j]);
+ } else {
+ EXPECT_EQ(-1, data[j]);
+ }
+ }
+ }
+}
+
+TEST(RLEv1, testAllNulls) {
+ const unsigned char buffer[] =
+ {0xf0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x3d, 0x00, 0x12};
+ SeekableInputStream* const stream =
+ new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer));
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>(stream),
+ false, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(16, -1);
+ std::vector<char> allNull(16, 0);
+ std::vector<char> noNull(16, 1);
+ rle->next(data.data(), 16, allNull.data());
+ for (size_t i = 0; i < data.size(); ++i) {
+ EXPECT_EQ(-1, data[i]) << "Output wrong at " << i;
+ }
+ rle->next(data.data(), data.size(), noNull.data());
+ for (size_t i = 0; i < data.size(); ++i) {
+ EXPECT_EQ(i, data[i]) << "Output wrong at " << i;
+ data[i] = -1;
+ }
+ rle->next(data.data(), data.size(), allNull.data());
+ for (size_t i = 0; i < data.size(); ++i) {
+ EXPECT_EQ(-1, data[i]) << "Output wrong at " << i;
+ }
+ for (size_t i = 0; i < 4; ++i) {
+ rle->next(data.data(), data.size(), noNull.data());
+ for(size_t j = 0; j < data.size(); ++j) {
+ EXPECT_EQ(18, data[j]) << "Output wrong at " << i;
+ }
+ }
+ rle->next(data.data(), data.size(), allNull.data());
+}
+
+TEST(RLEv1, skipTest) {
+ // Create the RLE stream from Java's TestRunLengthIntegerEncoding.testSkips
+ // for (size_t i = 0; i < 1024; ++i)
+ // out.write(i);
+ // for (size_t i = 1024; i < 2048; ++i)
+ // out.write(i * 256);
+ // This causes the first half to be delta encoded and the second half to
+ // be literal encoded.
+ const unsigned char buffer[] =
+{
+127, 1, 0, 127, 1, 132, 2, 127, 1, 136, 4, 127, 1, 140, 6, 127,
+ 1, 144, 8, 127, 1, 148, 10, 127, 1, 152, 12, 111, 1, 156, 14, 128,
+128, 128, 32, 128, 132, 32, 128, 136, 32, 128, 140, 32, 128, 144, 32, 128,
+148, 32, 128, 152, 32, 128, 156, 32, 128, 160, 32, 128, 164, 32, 128, 168,
+ 32, 128, 172, 32, 128, 176, 32, 128, 180, 32, 128, 184, 32, 128, 188, 32,
+128, 192, 32, 128, 196, 32, 128, 200, 32, 128, 204, 32, 128, 208, 32, 128,
+212, 32, 128, 216, 32, 128, 220, 32, 128, 224, 32, 128, 228, 32, 128, 232,
+ 32, 128, 236, 32, 128, 240, 32, 128, 244, 32, 128, 248, 32, 128, 252, 32,
+128, 128, 33, 128, 132, 33, 128, 136, 33, 128, 140, 33, 128, 144, 33, 128,
+148, 33, 128, 152, 33, 128, 156, 33, 128, 160, 33, 128, 164, 33, 128, 168,
+ 33, 128, 172, 33, 128, 176, 33, 128, 180, 33, 128, 184, 33, 128, 188, 33,
+128, 192, 33, 128, 196, 33, 128, 200, 33, 128, 204, 33, 128, 208, 33, 128,
+212, 33, 128, 216, 33, 128, 220, 33, 128, 224, 33, 128, 228, 33, 128, 232,
+ 33, 128, 236, 33, 128, 240, 33, 128, 244, 33, 128, 248, 33, 128, 252, 33,
+128, 128, 34, 128, 132, 34, 128, 136, 34, 128, 140, 34, 128, 144, 34, 128,
+148, 34, 128, 152, 34, 128, 156, 34, 128, 160, 34, 128, 164, 34, 128, 168,
+ 34, 128, 172, 34, 128, 176, 34, 128, 180, 34, 128, 184, 34, 128, 188, 34,
+128, 192, 34, 128, 196, 34, 128, 200, 34, 128, 204, 34, 128, 208, 34, 128,
+212, 34, 128, 216, 34, 128, 220, 34, 128, 224, 34, 128, 228, 34, 128, 232,
+ 34, 128, 236, 34, 128, 240, 34, 128, 244, 34, 128, 248, 34, 128, 252, 34,
+128, 128, 35, 128, 132, 35, 128, 136, 35, 128, 140, 35, 128, 144, 35, 128,
+148, 35, 128, 152, 35, 128, 156, 35, 128, 160, 35, 128, 164, 35, 128, 168,
+ 35, 128, 172, 35, 128, 176, 35, 128, 180, 35, 128, 184, 35, 128, 188, 35,
+128, 192, 35, 128, 196, 35, 128, 200, 35, 128, 204, 35, 128, 208, 35, 128,
+212, 35, 128, 216, 35, 128, 220, 35, 128, 224, 35, 128, 228, 35, 128, 232,
+ 35, 128, 236, 35, 128, 240, 35, 128, 244, 35, 128, 248, 35, 128, 252, 35,
+128, 128, 128, 36, 128, 132, 36, 128, 136, 36, 128, 140, 36, 128, 144, 36,
+128, 148, 36, 128, 152, 36, 128, 156, 36, 128, 160, 36, 128, 164, 36, 128,
+168, 36, 128, 172, 36, 128, 176, 36, 128, 180, 36, 128, 184, 36, 128, 188,
+ 36, 128, 192, 36, 128, 196, 36, 128, 200, 36, 128, 204, 36, 128, 208, 36,
+128, 212, 36, 128, 216, 36, 128, 220, 36, 128, 224, 36, 128, 228, 36, 128,
+232, 36, 128, 236, 36, 128, 240, 36, 128, 244, 36, 128, 248, 36, 128, 252,
+ 36, 128, 128, 37, 128, 132, 37, 128, 136, 37, 128, 140, 37, 128, 144, 37,
+128, 148, 37, 128, 152, 37, 128, 156, 37, 128, 160, 37, 128, 164, 37, 128,
+168, 37, 128, 172, 37, 128, 176, 37, 128, 180, 37, 128, 184, 37, 128, 188,
+ 37, 128, 192, 37, 128, 196, 37, 128, 200, 37, 128, 204, 37, 128, 208, 37,
+128, 212, 37, 128, 216, 37, 128, 220, 37, 128, 224, 37, 128, 228, 37, 128,
+232, 37, 128, 236, 37, 128, 240, 37, 128, 244, 37, 128, 248, 37, 128, 252,
+ 37, 128, 128, 38, 128, 132, 38, 128, 136, 38, 128, 140, 38, 128, 144, 38,
+128, 148, 38, 128, 152, 38, 128, 156, 38, 128, 160, 38, 128, 164, 38, 128,
+168, 38, 128, 172, 38, 128, 176, 38, 128, 180, 38, 128, 184, 38, 128, 188,
+ 38, 128, 192, 38, 128, 196, 38, 128, 200, 38, 128, 204, 38, 128, 208, 38,
+128, 212, 38, 128, 216, 38, 128, 220, 38, 128, 224, 38, 128, 228, 38, 128,
+232, 38, 128, 236, 38, 128, 240, 38, 128, 244, 38, 128, 248, 38, 128, 252,
+ 38, 128, 128, 39, 128, 132, 39, 128, 136, 39, 128, 140, 39, 128, 144, 39,
+128, 148, 39, 128, 152, 39, 128, 156, 39, 128, 160, 39, 128, 164, 39, 128,
+168, 39, 128, 172, 39, 128, 176, 39, 128, 180, 39, 128, 184, 39, 128, 188,
+ 39, 128, 192, 39, 128, 196, 39, 128, 200, 39, 128, 204, 39, 128, 208, 39,
+128, 212, 39, 128, 216, 39, 128, 220, 39, 128, 224, 39, 128, 228, 39, 128,
+232, 39, 128, 236, 39, 128, 240, 39, 128, 244, 39, 128, 248, 39, 128, 252,
+ 39, 128, 128, 128, 40, 128, 132, 40, 128, 136, 40, 128, 140, 40, 128, 144,
+ 40, 128, 148, 40, 128, 152, 40, 128, 156, 40, 128, 160, 40, 128, 164, 40,
+128, 168, 40, 128, 172, 40, 128, 176, 40, 128, 180, 40, 128, 184, 40, 128,
+188, 40, 128, 192, 40, 128, 196, 40, 128, 200, 40, 128, 204, 40, 128, 208,
+ 40, 128, 212, 40, 128, 216, 40, 128, 220, 40, 128, 224, 40, 128, 228, 40,
+128, 232, 40, 128, 236, 40, 128, 240, 40, 128, 244, 40, 128, 248, 40, 128,
+252, 40, 128, 128, 41, 128, 132, 41, 128, 136, 41, 128, 140, 41, 128, 144,
+ 41, 128, 148, 41, 128, 152, 41, 128, 156, 41, 128, 160, 41, 128, 164, 41,
+128, 168, 41, 128, 172, 41, 128, 176, 41, 128, 180, 41, 128, 184, 41, 128,
+188, 41, 128, 192, 41, 128, 196, 41, 128, 200, 41, 128, 204, 41, 128, 208,
+ 41, 128, 212, 41, 128, 216, 41, 128, 220, 41, 128, 224, 41, 128, 228, 41,
+128, 232, 41, 128, 236, 41, 128, 240, 41, 128, 244, 41, 128, 248, 41, 128,
+252, 41, 128, 128, 42, 128, 132, 42, 128, 136, 42, 128, 140, 42, 128, 144,
+ 42, 128, 148, 42, 128, 152, 42, 128, 156, 42, 128, 160, 42, 128, 164, 42,
+128, 168, 42, 128, 172, 42, 128, 176, 42, 128, 180, 42, 128, 184, 42, 128,
+188, 42, 128, 192, 42, 128, 196, 42, 128, 200, 42, 128, 204, 42, 128, 208,
+ 42, 128, 212, 42, 128, 216, 42, 128, 220, 42, 128, 224, 42, 128, 228, 42,
+128, 232, 42, 128, 236, 42, 128, 240, 42, 128, 244, 42, 128, 248, 42, 128,
+252, 42, 128, 128, 43, 128, 132, 43, 128, 136, 43, 128, 140, 43, 128, 144,
+ 43, 128, 148, 43, 128, 152, 43, 128, 156, 43, 128, 160, 43, 128, 164, 43,
+128, 168, 43, 128, 172, 43, 128, 176, 43, 128, 180, 43, 128, 184, 43, 128,
+188, 43, 128, 192, 43, 128, 196, 43, 128, 200, 43, 128, 204, 43, 128, 208,
+ 43, 128, 212, 43, 128, 216, 43, 128, 220, 43, 128, 224, 43, 128, 228, 43,
+128, 232, 43, 128, 236, 43, 128, 240, 43, 128, 244, 43, 128, 248, 43, 128,
+252, 43, 128, 128, 128, 44, 128, 132, 44, 128, 136, 44, 128, 140, 44, 128,
+144, 44, 128, 148, 44, 128, 152, 44, 128, 156, 44, 128, 160, 44, 128, 164,
+ 44, 128, 168, 44, 128, 172, 44, 128, 176, 44, 128, 180, 44, 128, 184, 44,
+128, 188, 44, 128, 192, 44, 128, 196, 44, 128, 200, 44, 128, 204, 44, 128,
+208, 44, 128, 212, 44, 128, 216, 44, 128, 220, 44, 128, 224, 44, 128, 228,
+ 44, 128, 232, 44, 128, 236, 44, 128, 240, 44, 128, 244, 44, 128, 248, 44,
+128, 252, 44, 128, 128, 45, 128, 132, 45, 128, 136, 45, 128, 140, 45, 128,
+144, 45, 128, 148, 45, 128, 152, 45, 128, 156, 45, 128, 160, 45, 128, 164,
+ 45, 128, 168, 45, 128, 172, 45, 128, 176, 45, 128, 180, 45, 128, 184, 45,
+128, 188, 45, 128, 192, 45, 128, 196, 45, 128, 200, 45, 128, 204, 45, 128,
+208, 45, 128, 212, 45, 128, 216, 45, 128, 220, 45, 128, 224, 45, 128, 228,
+ 45, 128, 232, 45, 128, 236, 45, 128, 240, 45, 128, 244, 45, 128, 248, 45,
+128, 252, 45, 128, 128, 46, 128, 132, 46, 128, 136, 46, 128, 140, 46, 128,
+144, 46, 128, 148, 46, 128, 152, 46, 128, 156, 46, 128, 160, 46, 128, 164,
+ 46, 128, 168, 46, 128, 172, 46, 128, 176, 46, 128, 180, 46, 128, 184, 46,
+128, 188, 46, 128, 192, 46, 128, 196, 46, 128, 200, 46, 128, 204, 46, 128,
+208, 46, 128, 212, 46, 128, 216, 46, 128, 220, 46, 128, 224, 46, 128, 228,
+ 46, 128, 232, 46, 128, 236, 46, 128, 240, 46, 128, 244, 46, 128, 248, 46,
+128, 252, 46, 128, 128, 47, 128, 132, 47, 128, 136, 47, 128, 140, 47, 128,
+144, 47, 128, 148, 47, 128, 152, 47, 128, 156, 47, 128, 160, 47, 128, 164,
+ 47, 128, 168, 47, 128, 172, 47, 128, 176, 47, 128, 180, 47, 128, 184, 47,
+128, 188, 47, 128, 192, 47, 128, 196, 47, 128, 200, 47, 128, 204, 47, 128,
+208, 47, 128, 212, 47, 128, 216, 47, 128, 220, 47, 128, 224, 47, 128, 228,
+ 47, 128, 232, 47, 128, 236, 47, 128, 240, 47, 128, 244, 47, 128, 248, 47,
+128, 252, 47, 128, 128, 128, 48, 128, 132, 48, 128, 136, 48, 128, 140, 48,
+128, 144, 48, 128, 148, 48, 128, 152, 48, 128, 156, 48, 128, 160, 48, 128,
+164, 48, 128, 168, 48, 128, 172, 48, 128, 176, 48, 128, 180, 48, 128, 184,
+ 48, 128, 188, 48, 128, 192, 48, 128, 196, 48, 128, 200, 48, 128, 204, 48,
+128, 208, 48, 128, 212, 48, 128, 216, 48, 128, 220, 48, 128, 224, 48, 128,
+228, 48, 128, 232, 48, 128, 236, 48, 128, 240, 48, 128, 244, 48, 128, 248,
+ 48, 128, 252, 48, 128, 128, 49, 128, 132, 49, 128, 136, 49, 128, 140, 49,
+128, 144, 49, 128, 148, 49, 128, 152, 49, 128, 156, 49, 128, 160, 49, 128,
+164, 49, 128, 168, 49, 128, 172, 49, 128, 176, 49, 128, 180, 49, 128, 184,
+ 49, 128, 188, 49, 128, 192, 49, 128, 196, 49, 128, 200, 49, 128, 204, 49,
+128, 208, 49, 128, 212, 49, 128, 216, 49, 128, 220, 49, 128, 224, 49, 128,
+228, 49, 128, 232, 49, 128, 236, 49, 128, 240, 49, 128, 244, 49, 128, 248,
+ 49, 128, 252, 49, 128, 128, 50, 128, 132, 50, 128, 136, 50, 128, 140, 50,
+128, 144, 50, 128, 148, 50, 128, 152, 50, 128, 156, 50, 128, 160, 50, 128,
+164, 50, 128, 168, 50, 128, 172, 50, 128, 176, 50, 128, 180, 50, 128, 184,
+ 50, 128, 188, 50, 128, 192, 50, 128, 196, 50, 128, 200, 50, 128, 204, 50,
+128, 208, 50, 128, 212, 50, 128, 216, 50, 128, 220, 50, 128, 224, 50, 128,
+228, 50, 128, 232, 50, 128, 236, 50, 128, 240, 50, 128, 244, 50, 128, 248,
+ 50, 128, 252, 50, 128, 128, 51, 128, 132, 51, 128, 136, 51, 128, 140, 51,
+128, 144, 51, 128, 148, 51, 128, 152, 51, 128, 156, 51, 128, 160, 51, 128,
+164, 51, 128, 168, 51, 128, 172, 51, 128, 176, 51, 128, 180, 51, 128, 184,
+ 51, 128, 188, 51, 128, 192, 51, 128, 196, 51, 128, 200, 51, 128, 204, 51,
+128, 208, 51, 128, 212, 51, 128, 216, 51, 128, 220, 51, 128, 224, 51, 128,
+228, 51, 128, 232, 51, 128, 236, 51, 128, 240, 51, 128, 244, 51, 128, 248,
+ 51, 128, 252, 51, 128, 128, 128, 52, 128, 132, 52, 128, 136, 52, 128, 140,
+ 52, 128, 144, 52, 128, 148, 52, 128, 152, 52, 128, 156, 52, 128, 160, 52,
+128, 164, 52, 128, 168, 52, 128, 172, 52, 128, 176, 52, 128, 180, 52, 128,
+184, 52, 128, 188, 52, 128, 192, 52, 128, 196, 52, 128, 200, 52, 128, 204,
+ 52, 128, 208, 52, 128, 212, 52, 128, 216, 52, 128, 220, 52, 128, 224, 52,
+128, 228, 52, 128, 232, 52, 128, 236, 52, 128, 240, 52, 128, 244, 52, 128,
+248, 52, 128, 252, 52, 128, 128, 53, 128, 132, 53, 128, 136, 53, 128, 140,
+ 53, 128, 144, 53, 128, 148, 53, 128, 152, 53, 128, 156, 53, 128, 160, 53,
+128, 164, 53, 128, 168, 53, 128, 172, 53, 128, 176, 53, 128, 180, 53, 128,
+184, 53, 128, 188, 53, 128, 192, 53, 128, 196, 53, 128, 200, 53, 128, 204,
+ 53, 128, 208, 53, 128, 212, 53, 128, 216, 53, 128, 220, 53, 128, 224, 53,
+128, 228, 53, 128, 232, 53, 128, 236, 53, 128, 240, 53, 128, 244, 53, 128,
+248, 53, 128, 252, 53, 128, 128, 54, 128, 132, 54, 128, 136, 54, 128, 140,
+ 54, 128, 144, 54, 128, 148, 54, 128, 152, 54, 128, 156, 54, 128, 160, 54,
+128, 164, 54, 128, 168, 54, 128, 172, 54, 128, 176, 54, 128, 180, 54, 128,
+184, 54, 128, 188, 54, 128, 192, 54, 128, 196, 54, 128, 200, 54, 128, 204,
+ 54, 128, 208, 54, 128, 212, 54, 128, 216, 54, 128, 220, 54, 128, 224, 54,
+128, 228, 54, 128, 232, 54, 128, 236, 54, 128, 240, 54, 128, 244, 54, 128,
+248, 54, 128, 252, 54, 128, 128, 55, 128, 132, 55, 128, 136, 55, 128, 140,
+ 55, 128, 144, 55, 128, 148, 55, 128, 152, 55, 128, 156, 55, 128, 160, 55,
+128, 164, 55, 128, 168, 55, 128, 172, 55, 128, 176, 55, 128, 180, 55, 128,
+184, 55, 128, 188, 55, 128, 192, 55, 128, 196, 55, 128, 200, 55, 128, 204,
+ 55, 128, 208, 55, 128, 212, 55, 128, 216, 55, 128, 220, 55, 128, 224, 55,
+128, 228, 55, 128, 232, 55, 128, 236, 55, 128, 240, 55, 128, 244, 55, 128,
+248, 55, 128, 252, 55, 128, 128, 128, 56, 128, 132, 56, 128, 136, 56, 128,
+140, 56, 128, 144, 56, 128, 148, 56, 128, 152, 56, 128, 156, 56, 128, 160,
+ 56, 128, 164, 56, 128, 168, 56, 128, 172, 56, 128, 176, 56, 128, 180, 56,
+128, 184, 56, 128, 188, 56, 128, 192, 56, 128, 196, 56, 128, 200, 56, 128,
+204, 56, 128, 208, 56, 128, 212, 56, 128, 216, 56, 128, 220, 56, 128, 224,
+ 56, 128, 228, 56, 128, 232, 56, 128, 236, 56, 128, 240, 56, 128, 244, 56,
+128, 248, 56, 128, 252, 56, 128, 128, 57, 128, 132, 57, 128, 136, 57, 128,
+140, 57, 128, 144, 57, 128, 148, 57, 128, 152, 57, 128, 156, 57, 128, 160,
+ 57, 128, 164, 57, 128, 168, 57, 128, 172, 57, 128, 176, 57, 128, 180, 57,
+128, 184, 57, 128, 188, 57, 128, 192, 57, 128, 196, 57, 128, 200, 57, 128,
+204, 57, 128, 208, 57, 128, 212, 57, 128, 216, 57, 128, 220, 57, 128, 224,
+ 57, 128, 228, 57, 128, 232, 57, 128, 236, 57, 128, 240, 57, 128, 244, 57,
+128, 248, 57, 128, 252, 57, 128, 128, 58, 128, 132, 58, 128, 136, 58, 128,
+140, 58, 128, 144, 58, 128, 148, 58, 128, 152, 58, 128, 156, 58, 128, 160,
+ 58, 128, 164, 58, 128, 168, 58, 128, 172, 58, 128, 176, 58, 128, 180, 58,
+128, 184, 58, 128, 188, 58, 128, 192, 58, 128, 196, 58, 128, 200, 58, 128,
+204, 58, 128, 208, 58, 128, 212, 58, 128, 216, 58, 128, 220, 58, 128, 224,
+ 58, 128, 228, 58, 128, 232, 58, 128, 236, 58, 128, 240, 58, 128, 244, 58,
+128, 248, 58, 128, 252, 58, 128, 128, 59, 128, 132, 59, 128, 136, 59, 128,
+140, 59, 128, 144, 59, 128, 148, 59, 128, 152, 59, 128, 156, 59, 128, 160,
+ 59, 128, 164, 59, 128, 168, 59, 128, 172, 59, 128, 176, 59, 128, 180, 59,
+128, 184, 59, 128, 188, 59, 128, 192, 59, 128, 196, 59, 128, 200, 59, 128,
+204, 59, 128, 208, 59, 128, 212, 59, 128, 216, 59, 128, 220, 59, 128, 224,
+ 59, 128, 228, 59, 128, 232, 59, 128, 236, 59, 128, 240, 59, 128, 244, 59,
+128, 248, 59, 128, 252, 59, 128, 128, 128, 60, 128, 132, 60, 128, 136, 60,
+128, 140, 60, 128, 144, 60, 128, 148, 60, 128, 152, 60, 128, 156, 60, 128,
+160, 60, 128, 164, 60, 128, 168, 60, 128, 172, 60, 128, 176, 60, 128, 180,
+ 60, 128, 184, 60, 128, 188, 60, 128, 192, 60, 128, 196, 60, 128, 200, 60,
+128, 204, 60, 128, 208, 60, 128, 212, 60, 128, 216, 60, 128, 220, 60, 128,
+224, 60, 128, 228, 60, 128, 232, 60, 128, 236, 60, 128, 240, 60, 128, 244,
+ 60, 128, 248, 60, 128, 252, 60, 128, 128, 61, 128, 132, 61, 128, 136, 61,
+128, 140, 61, 128, 144, 61, 128, 148, 61, 128, 152, 61, 128, 156, 61, 128,
+160, 61, 128, 164, 61, 128, 168, 61, 128, 172, 61, 128, 176, 61, 128, 180,
+ 61, 128, 184, 61, 128, 188, 61, 128, 192, 61, 128, 196, 61, 128, 200, 61,
+128, 204, 61, 128, 208, 61, 128, 212, 61, 128, 216, 61, 128, 220, 61, 128,
+224, 61, 128, 228, 61, 128, 232, 61, 128, 236, 61, 128, 240, 61, 128, 244,
+ 61, 128, 248, 61, 128, 252, 61, 128, 128, 62, 128, 132, 62, 128, 136, 62,
+128, 140, 62, 128, 144, 62, 128, 148, 62, 128, 152, 62, 128, 156, 62, 128,
+160, 62, 128, 164, 62, 128, 168, 62, 128, 172, 62, 128, 176, 62, 128, 180,
+ 62, 128, 184, 62, 128, 188, 62, 128, 192, 62, 128, 196, 62, 128, 200, 62,
+128, 204, 62, 128, 208, 62, 128, 212, 62, 128, 216, 62, 128, 220, 62, 128,
+224, 62, 128, 228, 62, 128, 232, 62, 128, 236, 62, 128, 240, 62, 128, 244,
+ 62, 128, 248, 62, 128, 252, 62, 128, 128, 63, 128, 132, 63, 128, 136, 63,
+128, 140, 63, 128, 144, 63, 128, 148, 63, 128, 152, 63, 128, 156, 63, 128,
+160, 63, 128, 164, 63, 128, 168, 63, 128, 172, 63, 128, 176, 63, 128, 180,
+ 63, 128, 184, 63, 128, 188, 63, 128, 192, 63, 128, 196, 63, 128, 200, 63,
+128, 204, 63, 128, 208, 63, 128, 212, 63, 128, 216, 63, 128, 220, 63, 128,
+224, 63, 128, 228, 63, 128, 232, 63, 128, 236, 63, 128, 240, 63, 128, 244,
+63, 128, 248, 63, 128, 252, 63};
+ SeekableInputStream* const stream =
+ new SeekableArrayInputStream(buffer, ARRAY_SIZE(buffer));
+ std::unique_ptr<RleDecoder> rle =
+ createRleDecoder(std::unique_ptr<SeekableInputStream>(stream),
+ true, RleVersion_1, *getDefaultPool());
+ std::vector<int64_t> data(1);
+ for (size_t i = 0; i < 2048; i += 10) {
+ rle->next(data.data(), 1, nullptr);
+ if (i < 1024) {
+ EXPECT_EQ(i, data[0]) << "Wrong output at " << i;
+ } else {
+ EXPECT_EQ(256 * i, data[0]) << "Wrong output at " << i;
+ }
+ if (i < 2038) {
+ rle->skip(9);
+ }
+ rle->skip(0);
+ }
+}
+
+TEST(RLEv1, seekTest) {
+ // Create the RLE stream from Java's
+ // TestRunLengthIntegerEncoding.testUncompressedSeek
+ // for (size_t i = 0; i < 1024; ++i)
+ // out.write(i / 4);
+ // for (size_t i = 1024; i < 2048; ++i)
+ // out.write(2 * i);
+ // for (size_t i = 0; i < 2048; ++i)
+ // out.write(junk[i]);
+ // This causes the first half to be delta encoded and the second half to
+ // be literal encoded.
+ const unsigned char buffer[] = {
+ 1, 0, 0, 1, 0, 2, 1, 0, 4, 1, 0, 6, 1, 0, 8, 1,
+ 0, 10, 1, 0, 12, 1, 0, 14, 1, 0, 16, 1, 0, 18, 1, 0,
+ 20, 1, 0, 22, 1, 0, 24, 1, 0, 26, 1, 0, 28, 1, 0, 30,
+ 1, 0, 32, 1, 0, 34, 1, 0, 36, 1, 0, 38, 1, 0, 40, 1,
+ 0, 42, 1, 0, 44, 1, 0, 46, 1, 0, 48, 1, 0, 50, 1, 0,
+ 52, 1, 0, 54, 1, 0, 56, 1, 0, 58, 1, 0, 60, 1, 0, 62,
+ 1, 0, 64, 1, 0, 66, 1, 0, 68, 1, 0, 70, 1, 0, 72, 1,
+ 0, 74, 1, 0, 76, 1, 0, 78, 1, 0, 80, 1, 0, 82, 1, 0,
+ 84, 1, 0, 86, 1, 0, 88, 1, 0, 90, 1, 0, 92, 1, 0, 94,
+ 1, 0, 96, 1, 0, 98, 1, 0, 100, 1, 0, 102, 1, 0, 104, 1,
+ 0, 106, 1, 0, 108, 1, 0, 110, 1, 0, 112, 1, 0, 114, 1, 0,
+116, 1, 0, 118, 1, 0, 120, 1, 0, 122, 1, 0, 124, 1, 0, 126,
+ 1, 0, 128, 1, 1, 0, 130, 1, 1, 0, 132, 1, 1, 0, 134, 1,
+ 1, 0, 136, 1, 1, 0, 138, 1, 1, 0, 140, 1, 1, 0, 142, 1,
+ 1, 0, 144, 1, 1, 0, 146, 1, 1, 0, 148, 1, 1, 0, 150, 1,
+ 1, 0, 152, 1, 1, 0, 154, 1, 1, 0, 156, 1, 1, 0, 158, 1,
+ 1, 0, 160, 1, 1, 0, 162, 1, 1, 0, 164, 1, 1, 0, 166, 1,
+ 1, 0, 168, 1, 1, 0, 170, 1, 1, 0, 172, 1, 1, 0, 174, 1,
+ 1, 0, 176, 1, 1, 0, 178, 1, 1, 0, 180, 1, 1, 0, 182, 1,
+ 1, 0, 184, 1, 1, 0, 186, 1, 1, 0, 188, 1, 1, 0, 190, 1,
+ 1, 0, 192, 1, 1, 0, 194, 1, 1, 0, 196, 1, 1, 0, 198, 1,
+ 1, 0, 200, 1, 1, 0, 202, 1, 1, 0, 204, 1, 1, 0, 206, 1,
+ 1, 0, 208, 1, 1, 0, 210, 1, 1, 0, 212, 1, 1, 0, 214, 1,
+ 1, 0, 216, 1, 1, 0, 218, 1, 1, 0, 220, 1, 1, 0, 222, 1,
+ 1, 0, 224, 1, 1, 0, 226, 1, 1, 0, 228, 1, 1, 0, 230, 1,
+ 1, 0, 232, 1, 1, 0, 234, 1, 1, 0, 236, 1, 1, 0, 238, 1,
+ 1, 0, 240, 1, 1, 0, 242, 1, 1, 0, 244, 1, 1, 0, 246, 1,
+ 1, 0, 248, 1, 1, 0, 250, 1, 1, 0, 252, 1, 1, 0, 254, 1,
+ 1, 0, 128, 2, 1, 0, 130, 2, 1, 0, 132, 2, 1, 0, 134, 2,
+ 1, 0, 136, 2, 1, 0, 138, 2, 1, 0, 140, 2, 1, 0, 142, 2,
+ 1, 0, 144, 2, 1, 0, 146, 2, 1, 0, 148, 2, 1, 0, 150, 2,
+ 1, 0, 152, 2, 1, 0, 154, 2, 1, 0, 156, 2, 1, 0, 158, 2,
+ 1, 0, 160, 2, 1, 0, 162, 2, 1, 0, 164, 2, 1, 0, 166, 2,
+ 1, 0, 168, 2, 1, 0, 170, 2, 1, 0, 172, 2, 1, 0, 174, 2,
+ 1, 0, 176, 2, 1, 0, 178, 2, 1, 0, 180, 2, 1, 0, 182, 2,
+ 1, 0, 184, 2, 1, 0, 186, 2, 1, 0, 188, 2, 1, 0, 190, 2,
+ 1, 0, 192, 2, 1, 0, 194, 2, 1, 0, 196, 2, 1, 0, 198, 2,
+ 1, 0, 200, 2, 1, 0, 202, 2, 1, 0, 204, 2, 1, 0, 206, 2,
+ 1, 0, 208, 2, 1, 0, 210, 2, 1, 0, 212, 2, 1, 0, 214, 2,
+ 1, 0, 216, 2, 1, 0, 218, 2, 1, 0, 220, 2, 1, 0, 222, 2,
+ 1, 0, 224, 2, 1, 0, 226, 2, 1, 0, 228, 2, 1, 0, 230, 2,
+ 1, 0, 232, 2, 1, 0, 234, 2, 1, 0, 236, 2, 1, 0, 238, 2,
+ 1, 0, 240, 2, 1, 0, 242, 2, 1, 0, 244, 2, 1, 0, 246, 2,
+ 1, 0, 248, 2, 1, 0, 250, 2, 1, 0, 252, 2, 1, 0, 254, 2,
+ 1, 0, 128, 3, 1, 0, 130, 3, 1, 0, 132, 3, 1, 0, 134, 3,
+ 1, 0, 136, 3, 1, 0, 138, 3, 1, 0, 140, 3, 1, 0, 142, 3,
+ 1, 0, 144, 3, 1, 0, 146, 3, 1, 0, 148, 3, 1, 0, 150, 3,
+ 1, 0, 152, 3, 1, 0, 154, 3, 1, 0, 156, 3, 1, 0, 158, 3,
+ 1, 0, 160, 3, 1, 0, 162, 3, 1, 0, 164, 3, 1, 0, 166, 3,
+ 1, 0, 168, 3, 1, 0, 170, 3, 1, 0, 172, 3, 1, 0, 174, 3,
+ 1, 0, 176, 3, 1, 0, 178, 3, 1, 0, 180, 3, 1, 0, 182, 3,
+ 1, 0, 184, 3, 1, 0, 186, 3, 1, 0, 188, 3, 1, 0, 190, 3,
+ 1, 0, 192, 3, 1, 0, 194, 3, 1, 0, 196, 3, 1, 0, 198, 3,
+ 1, 0, 200, 3, 1, 0, 202, 3, 1, 0, 204, 3, 1, 0, 206, 3,
+ 1, 0, 208, 3, 1, 0, 210, 3, 1, 0, 212, 3, 1, 0, 214, 3,
+ 1, 0, 216, 3, 1, 0, 218, 3, 1, 0, 220, 3, 1, 0, 222, 3,
+ 1, 0, 224, 3, 1, 0, 226, 3, 1, 0, 228, 3, 1, 0, 230, 3,
+ 1, 0, 232, 3, 1, 0, 234, 3, 1, 0, 236, 3, 1, 0, 238, 3,
+ 1, 0, 240, 3, 1, 0, 242, 3, 1, 0, 244, 3, 1, 0, 246, 3,
+ 1, 0, 248, 3, 1, 0, 250, 3, 1, 0, 252, 3, 1, 0, 254, 3,
+127, 2, 128, 32, 127, 2, 136, 36, 127, 2, 144, 40, 127, 2, 152, 44,
+127, 2, 160, 48, 127, 2, 168, 52, 127, 2, 176, 56, 111, 2, 184, 60,
+128, 147, 150, 232, 240, 8, 168, 134, 179, 187, 12, 246, 145, 173, 142, 11,
+241, 162, 190, 162, 9, 239, 218, 128, 243, 5, 202, 175, 131, 196, 12, 151,
+253, 204, 160, 4, 229, 167, 247, 255, 12, 255, 177, 140, 184, 7, 188, 145,
+181, 229, 1, 178, 190, 158, 163, 8, 147, 179, 151, 132, 8, 150, 133, 222,
+129, 11, 193, 218, 187, 242, 14, 181, 177, 154, 155, 9, 150, 145, 194, 135,
+ 8, 186, 222, 142, 242, 10, 140, 195, 254, 237, 11, 141, 189, 143, 198, 14,
+229, 146, 237, 203, 8, 251, 162, 179, 211, 3, 222, 237, 175, 145, 13, 221,
+178, 163, 162, 3, 211, 192, 165, 189, 14, 230, 228, 168, 250, 4, 141, 140,
+247, 178, 7, 143, 164, 170, 152, 2, 131, 166, 136, 26, 171, 143, 232, 134,
+ 12, 158, 239, 246, 204, 11, 133, 128, 213, 223, 14, 255, 213, 190, 250, 15,
+143, 162, 252, 157, 4, 204, 181, 135, 245, 7, 206, 241, 254, 136, 4, 184,
+182, 211, 190, 15, 172, 156, 202, 135, 10, 249, 180, 139, 131, 4, 202, 128,
+204, 221, 9, 131, 247, 166, 249, 8, 141, 236, 241, 185, 3, 128, 229, 150,
+186, 2, 237, 189, 141, 218, 9, 193, 240, 241, 156, 3, 210, 142, 198, 202,
+ 10, 227, 241, 194, 234, 7, 145, 180, 228, 254, 6, 171, 249, 185, 188, 11,
+215, 135, 224, 219, 4, 133, 132, 178, 165, 7, 205, 180, 133, 209, 11, 198,
+253, 246, 145, 12, 190, 194, 153, 146, 8, 139, 220, 235, 249, 1, 170, 203,
+205, 159, 6, 136, 130, 154, 166, 14, 250, 189, 153, 191, 7, 178, 163, 191,
+158, 12, 251, 138, 135, 245, 10, 175, 249, 219, 164, 14, 136, 185, 220, 188,
+ 7, 170, 135, 221, 146, 7, 209, 224, 204, 171, 11, 216, 144, 236, 172, 1,
+133, 205, 202, 170, 6, 215, 250, 133, 181, 3, 181, 133, 142, 158, 5, 166,
+192, 134, 238, 13, 246, 243, 233, 218, 12, 163, 202, 238, 241, 14, 241, 214,
+224, 215, 2, 212, 192, 237, 243, 10, 163, 165, 163, 206, 6, 159, 161, 227,
+152, 14, 209, 234, 225, 249, 13, 167, 206, 188, 161, 3, 143, 209, 188, 214,
+ 11, 184, 224, 210, 200, 10, 185, 171, 199, 183, 3, 177, 229, 245, 86, 255,
+183, 178, 142, 9, 232, 209, 135, 151, 8, 191, 153, 174, 175, 7, 190, 245,
+224, 174, 9, 243, 165, 145, 169, 1, 145, 161, 221, 249, 13, 195, 221, 244,
+240, 5, 157, 156, 217, 237, 15, 143, 201, 155, 207, 5, 169, 136, 192, 238,
+ 12, 135, 223, 244, 200, 2, 137, 228, 167, 187, 1, 134, 212, 158, 155, 15,
+186, 224, 212, 214, 7, 193, 141, 216, 241, 2, 246, 159, 138, 117, 216, 230,
+215, 29, 204, 178, 147, 255, 8, 195, 140, 136, 164, 11, 234, 204, 155, 222,
+ 10, 193, 156, 138, 187, 8, 161, 161, 184, 212, 1, 128, 141, 162, 133, 13,
+180, 211, 132, 210, 9, 239, 203, 201, 177, 5, 236, 191, 140, 207, 13, 173,
+205, 192, 186, 7, 179, 214, 222, 136, 8, 189, 142, 204, 152, 5, 221, 176,
+135, 241, 1, 223, 146, 195, 166, 11, 146, 133, 226, 137, 6, 150, 243, 247,
+ 1, 153, 246, 184, 42, 234, 194, 229, 98, 237, 144, 253, 133, 11, 196, 131,
+158, 244, 6, 218, 149, 253, 221, 7, 219, 180, 234, 156, 10, 179, 255, 197,
+218, 13, 150, 137, 240, 204, 9, 240, 185, 181, 203, 2, 160, 194, 146, 246,
+ 5, 131, 168, 191, 138, 4, 158, 245, 240, 150, 15, 157, 202, 136, 14, 135,
+154, 226, 240, 5, 153, 168, 212, 222, 8, 128, 218, 198, 244, 133, 13, 183,
+245, 153, 118, 139, 141, 238, 141, 1, 235, 193, 197, 5, 169, 141, 210, 62,
+231, 186, 238, 219, 6, 141, 243, 204, 242, 12, 172, 165, 150, 187, 13, 163,
+254, 250, 230, 12, 203, 166, 166, 223, 3, 177, 155, 168, 182, 4, 213, 130,
+148, 221, 3, 150, 178, 146, 235, 6, 149, 226, 237, 225, 2, 177, 149, 218,
+ 10, 205, 241, 161, 21, 186, 239, 197, 189, 15, 132, 249, 249, 171, 5, 130,
+223, 220, 167, 5, 171, 235, 129, 84, 207, 145, 246, 231, 2, 183, 176, 230,
+148, 11, 180, 142, 254, 128, 1, 171, 251, 177, 177, 1, 188, 190, 157, 222,
+ 11, 140, 195, 192, 141, 10, 200, 139, 160, 247, 9, 139, 247, 194, 144, 1,
+160, 160, 234, 208, 11, 174, 210, 150, 196, 15, 209, 201, 176, 208, 14, 199,
+183, 218, 132, 8, 175, 143, 188, 168, 7, 172, 234, 158, 248, 11, 192, 223,
+160, 152, 7, 178, 134, 130, 235, 3, 243, 134, 181, 181, 4, 225, 135, 251,
+236, 7, 203, 166, 149, 169, 10, 181, 213, 156, 193, 12, 239, 138, 235, 252,
+ 2, 183, 243, 201, 133, 10, 137, 186, 227, 237, 13, 255, 188, 221, 148, 14,
+188, 156, 198, 143, 15, 223, 224, 252, 208, 9, 160, 241, 190, 221, 13, 195,
+241, 163, 241, 9, 199, 253, 138, 163, 12, 173, 251, 143, 133, 12, 167, 246,
+153, 247, 14, 237, 223, 140, 174, 14, 219, 229, 138, 242, 2, 200, 163, 210,
+ 86, 197, 251, 199, 241, 9, 243, 211, 209, 132, 3, 178, 176, 152, 224, 13,
+195, 131, 248, 159, 5, 194, 255, 160, 171, 14, 145, 243, 143, 173, 3, 222,
+168, 246, 134, 2, 178, 145, 204, 240, 1, 176, 240, 236, 165, 14, 254, 145,
+162, 165, 8, 243, 173, 131, 238, 3, 247, 192, 235, 163, 4, 244, 239, 180,
+203, 15, 214, 167, 152, 233, 13, 176, 158, 206, 235, 9, 252, 150, 228, 160,
+ 13, 148, 243, 234, 239, 2, 225, 152, 250, 167, 5, 252, 143, 229, 254, 4,
+184, 202, 161, 157, 14, 233, 190, 185, 195, 9, 159, 223, 240, 216, 11, 132,
+172, 243, 200, 6, 212, 182, 191, 194, 13, 230, 245, 240, 130, 12, 189, 146,
+233, 239, 2, 155, 190, 214, 183, 15, 159, 222, 148, 155, 13, 195, 158, 248,
+112, 224, 219, 145, 234, 12, 145, 169, 172, 135, 10, 234, 184, 245, 220, 4,
+138, 150, 232, 212, 5, 132, 195, 135, 214, 5, 181, 247, 216, 205, 12, 239,
+160, 183, 178, 9, 161, 143, 210, 206, 11, 248, 209, 207, 94, 166, 178, 165,
+ 97, 133, 162, 246, 212, 9, 206, 240, 235, 156, 1, 200, 228, 176, 252, 12,
+163, 215, 219, 141, 1, 236, 133, 216, 202, 9, 220, 170, 222, 242, 10, 239,
+203, 197, 220, 11, 148, 218, 209, 161, 7, 185, 175, 210, 171, 15, 153, 213,
+208, 214, 15, 188, 239, 128, 244, 13, 141, 220, 136, 166, 12, 150, 148, 250,
+175, 13, 130, 145, 226, 216, 1, 216, 204, 215, 193, 9, 191, 211, 181, 229,
+ 14, 233, 168, 165, 9, 240, 188, 146, 132, 12, 173, 220, 201, 244, 4, 140,
+147, 190, 199, 15, 190, 213, 175, 213, 1, 254, 212, 239, 171, 10, 200, 161,
+168, 144, 10, 161, 188, 230, 163, 6, 192, 198, 213, 167, 3, 240, 251, 180,
+243, 5, 202, 165, 247, 147, 7, 173, 191, 133, 228, 3, 229, 139, 154, 210,
+ 7, 147, 254, 164, 236, 13, 162, 214, 180, 128, 8, 202, 176, 252, 143, 13,
+154, 179, 169, 149, 3, 169, 156, 168, 229, 1, 164, 128, 214, 138, 15, 128,
+239, 253, 160, 181, 2, 232, 203, 196, 235, 11, 181, 153, 131, 240, 12, 145,
+178, 179, 206, 12, 134, 244, 215, 141, 10, 138, 228, 171, 244, 7, 246, 160,
+221, 177, 14, 176, 231, 208, 135, 9, 194, 210, 159, 234, 2, 238, 250, 139,
+146, 10, 249, 191, 224, 241, 10, 250, 140, 140, 147, 5, 190, 185, 216, 220,
+ 15, 248, 131, 153, 236, 9, 140, 219, 183, 252, 14, 254, 184, 223, 216, 14,
+253, 211, 235, 254, 14, 252, 180, 147, 152, 9, 147, 221, 188, 174, 1, 222,
+219, 180, 185, 12, 185, 175, 244, 136, 9, 214, 147, 217, 182, 4, 191, 193,
+233, 157, 2, 238, 191, 156, 211, 14, 229, 221, 129, 224, 2, 230, 212, 248,
+128, 3, 186, 165, 136, 84, 129, 216, 148, 139, 15, 150, 231, 196, 184, 8,
+160, 156, 253, 171, 2, 156, 198, 161, 183, 11, 164, 181, 155, 137, 8, 133,
+196, 192, 213, 6, 140, 174, 143, 152, 12, 142, 202, 143, 192, 9, 128, 167,
+234, 152, 13, 214, 131, 156, 246, 14, 167, 223, 250, 135, 4, 233, 185, 236,
+128, 1, 138, 131, 251, 181, 9, 184, 141, 213, 136, 15, 171, 224, 222, 192,
+ 12, 244, 168, 162, 144, 1, 212, 183, 184, 200, 9, 177, 193, 168, 174, 14,
+249, 175, 129, 197, 1, 142, 181, 130, 162, 10, 214, 197, 196, 214, 4, 148,
+146, 228, 202, 13, 213, 154, 241, 127, 165, 166, 144, 164, 4, 205, 251, 139,
+128, 13, 244, 188, 143, 236, 12, 190, 247, 138, 217, 8, 185, 201, 217, 187,
+ 4, 130, 142, 167, 137, 4, 139, 185, 215, 95, 136, 170, 224, 218, 9, 154,
+158, 177, 200, 15, 227, 154, 189, 136, 15, 224, 233, 220, 179, 3, 227, 203,
+160, 188, 7, 236, 228, 239, 162, 15, 214, 227, 159, 242, 4, 151, 252, 232,
+ 42, 151, 166, 168, 245, 3, 135, 180, 250, 243, 15, 167, 254, 137, 160, 13,
+214, 240, 225, 152, 8, 190, 229, 204, 136, 13, 150, 219, 186, 10, 163, 249,
+225, 249, 6, 215, 233, 254, 162, 9, 171, 204, 237, 189, 5, 229, 137, 174,
+157, 6, 135, 205, 140, 164, 10, 189, 136, 130, 244, 1, 210, 222, 223, 247,
+ 1, 189, 128, 142, 203, 12, 232, 241, 180, 195, 12, 237, 228, 243, 183, 7,
+218, 155, 204, 158, 14, 235, 167, 134, 183, 6, 171, 218, 141, 128, 3, 184,
+152, 251, 187, 10, 138, 217, 169, 182, 2, 210, 140, 240, 138, 7, 150, 156,
+232, 128, 9, 209, 231, 181, 174, 14, 243, 210, 173, 34, 220, 254, 188, 199,
+ 14, 245, 195, 226, 124, 141, 228, 248, 228, 15, 158, 166, 194, 150, 6, 152,
+220, 238, 252, 13, 179, 132, 217, 220, 15, 213, 168, 186, 245, 4, 241, 243,
+200, 226, 10, 216, 178, 141, 137, 13, 134, 176, 169, 179, 6, 212, 242, 197,
+ 75, 175, 222, 238, 237, 10, 185, 143, 171, 166, 6, 180, 198, 129, 170, 5,
+159, 129, 176, 134, 11, 130, 248, 213, 183, 12, 204, 162, 169, 238, 8, 139,
+139, 145, 227, 15, 232, 239, 206, 163, 3, 145, 157, 143, 183, 10, 250, 190,
+179, 189, 3, 185, 138, 211, 215, 3, 179, 147, 158, 165, 13, 231, 226, 199,
+245, 11, 147, 179, 178, 190, 1, 208, 217, 154, 195, 14, 226, 194, 229, 142,
+ 8, 198, 175, 184, 231, 4, 199, 198, 191, 24, 184, 134, 226, 231, 10, 152,
+208, 222, 254, 1, 134, 167, 234, 69, 175, 214, 177, 218, 3, 218, 234, 128,
+162, 3, 160, 177, 187, 166, 3, 201, 210, 191, 159, 13, 240, 152, 160, 250,
+ 6, 235, 130, 214, 240, 11, 128, 237, 251, 245, 225, 3, 245, 237, 174, 230,
+ 9, 252, 148, 229, 201, 7, 152, 148, 165, 153, 7, 223, 238, 242, 16, 156,
+212, 237, 228, 7, 139, 153, 178, 37, 219, 217, 217, 172, 15, 178, 168, 128,
+199, 9, 236, 189, 144, 226, 12, 214, 248, 134, 230, 13, 163, 252, 247, 55,
+239, 252, 149, 196, 3, 230, 159, 214, 139, 6, 132, 200, 241, 154, 2, 129,
+231, 153, 173, 12, 235, 131, 255, 157, 2, 246, 190, 145, 55, 205, 201, 240,
+141, 9, 188, 202, 199, 189, 6, 196, 235, 245, 205, 11, 249, 253, 241, 223,
+ 6, 187, 250, 137, 241, 9, 133, 135, 168, 146, 8, 132, 248, 219, 156, 8,
+132, 241, 185, 4, 198, 209, 147, 129, 11, 229, 192, 218, 178, 4, 199, 210,
+138, 166, 13, 244, 148, 172, 141, 2, 194, 215, 171, 220, 1, 192, 248, 230,
+128, 2, 238, 167, 209, 222, 11, 240, 200, 227, 150, 11, 182, 217, 170, 158,
+ 14, 223, 223, 254, 201, 10, 140, 164, 245, 175, 2, 178, 140, 153, 102, 139,
+145, 181, 242, 8, 188, 154, 214, 154, 15, 149, 187, 204, 192, 2, 223, 153,
+219, 51, 245, 236, 130, 133, 5, 197, 138, 169, 80, 243, 162, 164, 167, 1,
+206, 232, 180, 137, 12, 180, 191, 164, 226, 8, 162, 180, 231, 222, 13, 184,
+143, 156, 74, 134, 230, 248, 219, 10, 203, 156, 149, 205, 1, 219, 205, 173,
+167, 10, 174, 146, 180, 141, 7, 214, 231, 229, 231, 10, 181, 246, 174, 180,
+ 15, 236, 175, 222, 241, 7, 191, 150, 253, 209, 8, 233, 139, 167, 149, 13,
+142, 249, 150, 223, 10, 220, 151, 135, 222, 5, 138, 228, 133, 131, 4, 232,
+183, 160, 245, 3, 157, 219, 209, 200, 5, 159, 242, 142, 148, 13, 241, 207,
+248, 177, 11, 179, 226, 169, 150, 13, 169, 201, 212, 218, 8, 172, 214, 220,
+ 31, 155, 173, 251, 231, 12, 221, 150, 137, 174, 15, 146, 137, 251, 255, 14,
+245, 216, 203, 138, 1, 163, 170, 194, 133, 12, 205, 157, 188, 131, 12, 184,
+220, 161, 97, 162, 240, 190, 243, 2, 213, 134, 147, 251, 3, 178, 160, 193,
+188, 14, 214, 153, 226, 140, 12, 191, 208, 235, 174, 13, 138, 188, 204, 236,
+ 11, 214, 135, 129, 235, 10, 198, 242, 226, 128, 11, 154, 219, 163, 144, 7,
+236, 134, 217, 197, 2, 181, 248, 144, 157, 8, 150, 174, 195, 224, 12, 156,
+247, 234, 192, 7, 156, 206, 174, 246, 2, 181, 214, 138, 155, 1, 246, 242,
+141, 152, 9, 207, 157, 139, 243, 1, 153, 135, 158, 249, 6, 162, 129, 144,
+170, 13, 227, 162, 245, 246, 1, 130, 237, 192, 208, 13, 187, 165, 153, 215,
+ 8, 178, 141, 203, 163, 15, 172, 179, 180, 172, 10, 206, 200, 237, 194, 12,
+129, 235, 165, 143, 7, 129, 230, 217, 244, 8, 223, 249, 152, 233, 2, 160,
+224, 204, 187, 10, 167, 211, 138, 247, 7, 207, 204, 131, 200, 1, 207, 240,
+161, 219, 9, 219, 213, 129, 183, 11, 186, 163, 243, 198, 13, 217, 197, 175,
+218, 8, 195, 228, 209, 137, 1, 149, 253, 193, 190, 8, 216, 231, 225, 190,
+ 15, 244, 168, 191, 152, 6, 180, 210, 162, 198, 9, 172, 159, 195, 158, 9,
+173, 151, 226, 34, 143, 231, 162, 212, 6, 250, 171, 192, 187, 11, 229, 212,
+155, 156, 9, 234, 159, 165, 254, 8, 180, 154, 227, 197, 3, 175, 158, 214,
+235, 8, 164, 157, 160, 130, 4, 158, 223, 243, 254, 10, 178, 236, 213, 212,
+ 12, 194, 173, 185, 159, 6, 184, 214, 195, 172, 5, 128, 161, 203, 183, 194,
+ 10, 207, 218, 209, 222, 12, 136, 166, 226, 224, 3, 148, 153, 145, 214, 4,
+164, 178, 253, 243, 4, 173, 162, 237, 129, 4, 236, 134, 193, 169, 14, 140,
+234, 164, 190, 7, 211, 148, 252, 223, 8, 213, 149, 180, 170, 12, 194, 182,
+191, 205, 15, 206, 233, 190, 211, 2, 241, 136, 223, 152, 12, 184, 185, 231,
+176, 10, 201, 166, 182, 211, 4, 209, 201, 205, 235, 1, 141, 184, 205, 173,
+ 15, 244, 222, 218, 113, 175, 190, 179, 140, 4, 234, 232, 231, 183, 8, 174,
+167, 140, 130, 9, 169, 157, 136, 196, 14, 187, 244, 242, 135, 7, 248, 183,
+178, 253, 10, 135, 216, 152, 153, 15, 226, 223, 172, 161, 11, 236, 183, 231,
+216, 3, 183, 169, 209, 137, 13, 130, 219, 233, 167, 4, 168, 132, 197, 161,
+ 7, 164, 146, 152, 207, 4, 239, 229, 147, 130, 2, 172, 156, 244, 148, 6,
+171, 253, 185, 213, 4, 184, 181, 241, 207, 1, 144, 250, 219, 222, 1, 213,
+189, 209, 177, 10, 207, 252, 251, 239, 9, 181, 132, 203, 147, 6, 159, 135,
+181, 18, 215, 252, 202, 234, 7, 207, 215, 210, 222, 12, 195, 211, 185, 171,
+ 14, 178, 132, 165, 140, 9, 139, 160, 171, 250, 1, 248, 176, 203, 170, 14,
+148, 184, 131, 141, 4, 158, 226, 204, 197, 3, 215, 157, 148, 219, 15, 228,
+206, 156, 132, 3, 234, 206, 202, 231, 8, 232, 177, 135, 215, 10, 173, 253,
+176, 172, 5, 144, 188, 170, 229, 14, 200, 165, 144, 50, 198, 153, 206, 184,
+ 3, 150, 128, 128, 141, 14, 155, 221, 221, 199, 12, 229, 199, 160, 156, 3,
+176, 172, 200, 97, 222, 255, 134, 158, 9, 233, 155, 199, 193, 14, 146, 216,
+186, 250, 13, 156, 152, 194, 212, 8, 254, 190, 240, 232, 2, 178, 210, 194,
+160, 3, 142, 216, 141, 184, 10, 173, 210, 214, 187, 2, 161, 211, 201, 143,
+ 5, 213, 149, 210, 222, 15, 134, 165, 184, 171, 9, 211, 175, 153, 241, 9,
+227, 201, 184, 213, 1, 173, 225, 213, 176, 13, 143, 228, 200, 151, 12, 224,
+224, 224, 186, 8, 188, 153, 234, 254, 7, 137, 188, 238, 186, 8, 166, 236,
+135, 180, 13, 202, 174, 133, 194, 13, 179, 243, 158, 193, 13, 210, 173, 128,
+149, 2, 208, 216, 158, 168, 13, 205, 251, 152, 230, 3, 245, 245, 254, 163,
+ 9, 211, 243, 234, 164, 9, 173, 221, 221, 215, 4, 146, 220, 209, 198, 1,
+235, 237, 170, 130, 7, 181, 227, 149, 141, 2, 170, 245, 149, 217, 5, 153,
+179, 215, 195, 14, 249, 206, 140, 148, 1, 247, 200, 219, 152, 15, 165, 228,
+197, 152, 11, 234, 192, 242, 244, 6, 217, 229, 173, 147, 3, 216, 209, 206,
+189, 7, 165, 171, 221, 214, 2, 151, 250, 211, 138, 2, 144, 169, 182, 176,
+ 13, 179, 254, 191, 225, 3, 244, 147, 218, 212, 3, 129, 187, 183, 253, 10,
+218, 149, 188, 168, 10, 223, 241, 149, 129, 8, 209, 128, 150, 126, 153, 139,
+195, 131, 6, 201, 208, 246, 221, 1, 194, 165, 175, 173, 5, 197, 133, 207,
+196, 2, 192, 211, 129, 210, 7, 211, 147, 163, 220, 9, 173, 191, 188, 152,
+ 1, 169, 242, 205, 20, 167, 133, 213, 211, 2, 213, 226, 129, 166, 12, 186,
+202, 155, 203, 5, 180, 251, 220, 174, 12, 145, 228, 247, 146, 12, 196, 151,
+247, 184, 10, 217, 233, 238, 147, 6, 149, 174, 181, 128, 13, 128, 246, 173,
+207, 15, 200, 162, 139, 103, 237, 199, 220, 252, 7, 208, 201, 133, 231, 3,
+140, 148, 223, 137, 5, 128, 242, 251, 140, 228, 11, 214, 205, 158, 228, 2,
+147, 190, 212, 138, 4, 228, 228, 253, 154, 9, 146, 191, 248, 187, 8, 168,
+200, 246, 160, 4, 224, 168, 147, 211, 11, 153, 197, 133, 229, 5, 176, 131,
+167, 203, 6, 213, 183, 189, 178, 10, 185, 222, 229, 183, 5, 171, 185, 208,
+162, 15, 203, 130, 137, 201, 6, 236, 152, 138, 176, 1, 221, 200, 169, 183,
+ 11, 237, 230, 219, 108, 152, 247, 239, 145, 14, 242, 220, 245, 148, 6, 183,
+147, 218, 144, 11, 236, 190, 230, 197, 1, 253, 147, 205, 165, 10, 181, 130,
+138, 249, 10, 193, 135, 148, 142, 10, 232, 132, 254, 163, 4, 244, 153, 241,
+197, 13, 251, 150, 230, 242, 10, 211, 255, 182, 243, 3, 247, 137, 150, 236,
+ 5, 137, 168, 208, 161, 10, 192, 178, 137, 210, 13, 192, 158, 177, 203, 7,
+237, 221, 208, 153, 4, 180, 129, 195, 139, 4, 195, 220, 254, 129, 8, 235,
+249, 252, 142, 2, 171, 195, 208, 162, 12, 205, 185, 192, 166, 9, 208, 205,
+169, 160, 10, 156, 148, 150, 185, 2, 246, 165, 207, 129, 12, 145, 207, 129,
+130, 15, 253, 209, 184, 133, 11, 247, 226, 200, 185, 9, 193, 147, 150, 128,
+ 8, 251, 208, 155, 45, 251, 142, 248, 144, 15, 174, 199, 157, 236, 12, 206,
+215, 156, 131, 14, 224, 242, 193, 145, 9, 194, 231, 136, 243, 7, 135, 188,
+221, 220, 10, 252, 138, 172, 180, 15, 222, 245, 235, 161, 2, 147, 195, 191,
+195, 7, 191, 205, 163, 247, 3, 237, 172, 239, 187, 6, 137, 141, 231, 233,
+ 10, 246, 253, 140, 184, 5, 191, 252, 199, 190, 13, 235, 212, 206, 220, 8,
+163, 219, 233, 232, 13, 166, 129, 242, 168, 12, 131, 217, 184, 209, 7, 138,
+139, 223, 216, 8, 186, 152, 149, 207, 6, 229, 191, 144, 149, 8, 223, 167,
+204, 251, 1, 181, 240, 166, 200, 9, 194, 230, 150, 122, 210, 176, 221, 179,
+ 5, 137, 169, 225, 196, 2, 190, 138, 243, 173, 10, 155, 224, 148, 154, 15,
+180, 176, 218, 153, 2, 194, 220, 179, 239, 3, 209, 243, 151, 171, 1, 135,
+192, 192, 129, 3, 154, 145, 158, 166, 8, 174, 159, 201, 207, 1, 134, 247,
+247, 152, 5, 169, 139, 159, 171, 3, 173, 170, 159, 244, 15, 201, 205, 215,
+223, 9, 227, 214, 226, 134, 14, 237, 245, 216, 153, 1, 207, 208, 244, 63,
+136, 146, 237, 215, 2, 131, 173, 129, 187, 4, 150, 204, 222, 185, 6, 243,
+177, 246, 252, 5, 246, 173, 234, 215, 14, 207, 252, 211, 199, 3, 177, 211,
+230, 228, 5, 208, 143, 209, 191, 13, 173, 192, 232, 246, 12, 132, 255, 207,
+139, 14, 171, 129, 141, 173, 7, 255, 222, 227, 255, 12, 155, 193, 184, 244,
+ 14, 171, 144, 214, 163, 1, 241, 232, 221, 228, 15, 188, 160, 210, 226, 13,
+189, 190, 189, 5, 204, 252, 250, 234, 10, 228, 161, 153, 190, 9, 210, 208,
+187, 214, 7, 198, 154, 214, 242, 9, 197, 163, 254, 27, 220, 251, 130, 172,
+ 2, 193, 147, 157, 255, 14, 242, 131, 138, 180, 14, 200, 239, 175, 239, 5,
+181, 157, 238, 152, 1, 203, 211, 156, 220, 10, 210, 166, 223, 241, 2, 214,
+243, 250, 244, 10, 238, 200, 226, 216, 9, 168, 140, 235, 228, 14, 149, 176,
+161, 188, 9, 180, 224, 247, 138, 11, 168, 159, 157, 226, 7, 216, 226, 212,
+131, 5, 158, 162, 174, 190, 2, 147, 131, 155, 194, 4, 227, 156, 248, 169,
+ 14, 210, 216, 130, 142, 14, 233, 234, 248, 230, 13, 146, 190, 216, 248, 9,
+128, 173, 190, 149, 182, 11, 254, 210, 132, 152, 8, 211, 239, 231, 248, 9,
+132, 255, 247, 168, 7, 149, 224, 145, 136, 14, 162, 220, 148, 134, 6, 204,
+244, 192, 159, 8, 178, 160, 245, 237, 15, 193, 167, 249, 251, 5, 238, 159,
+153, 199, 9, 228, 225, 136, 225, 9, 147, 221, 134, 220, 7, 249, 129, 250,
+131, 5, 255, 249, 227, 129, 15, 183, 246, 177, 190, 10, 217, 182, 196, 128,
+ 6, 136, 242, 159, 173, 1, 244, 128, 137, 210, 10, 154, 223, 230, 173, 7,
+193, 171, 203, 220, 9, 193, 222, 146, 129, 2, 159, 229, 247, 153, 1, 205,
+139, 189, 204, 13, 181, 152, 211, 186, 3, 252, 181, 234, 182, 4, 230, 212,
+233, 169, 13, 134, 211, 157, 165, 1, 218, 165, 218, 239, 4, 148, 140, 245,
+130, 11, 197, 152, 165, 199, 2, 235, 219, 158, 232, 9, 187, 231, 171, 149,
+ 12, 134, 191, 248, 157, 3, 219, 140, 128, 208, 1, 181, 140, 225, 226, 15,
+234, 239, 208, 170, 10, 166, 152, 192, 138, 15, 237, 204, 242, 197, 12, 230,
+224, 210, 68, 128, 170, 249, 251, 10, 193, 202, 171, 142, 7, 235, 192, 224,
+175, 14, 147, 243, 214, 94, 165, 202, 243, 157, 6, 192, 178, 204, 211, 8,
+242, 240, 207, 231, 4, 251, 234, 238, 218, 1, 207, 227, 224, 149, 4, 155,
+215, 210, 203, 2, 164, 248, 235, 166, 6, 226, 234, 165, 222, 13, 228, 197,
+249, 231, 14, 169, 172, 201, 163, 14, 149, 206, 208, 159, 15, 178, 216, 205,
+227, 15, 210, 228, 223, 220, 5, 161, 214, 153, 136, 11, 181, 178, 246, 212,
+ 7, 128, 131, 238, 218, 13, 138, 156, 141, 139, 15, 134, 187, 137, 234, 4,
+152, 215, 181, 142, 6, 160, 185, 166, 193, 13, 213, 145, 204, 240, 13, 190,
+164, 216, 231, 13, 251, 208, 176, 231, 4, 243, 160, 187, 150, 5, 235, 251,
+246, 205, 3, 142, 232, 229, 222, 5, 227, 251, 238, 161, 12, 224, 198, 250,
+176, 3, 187, 162, 200, 223, 5, 199, 133, 234, 181, 3, 167, 160, 247, 232,
+ 4, 174, 198, 216, 180, 15, 144, 251, 131, 187, 10, 161, 171, 169, 190, 9,
+223, 175, 171, 171, 4, 141, 165, 211, 128, 5, 139, 239, 131, 173, 3, 211,
+163, 253, 45, 212, 199, 216, 226, 11, 137, 216, 228, 198, 3, 216, 209, 199,
+233, 3, 249, 144, 225, 146, 1, 216, 184, 225, 218, 9, 197, 219, 219, 247,
+ 12, 214, 227, 243, 240, 14, 221, 155, 244, 141, 4, 239, 249, 179, 130, 4,
+161, 187, 191, 135, 3, 245, 241, 237, 241, 12, 194, 211, 209, 238, 5, 252,
+210, 135, 149, 1, 134, 241, 220, 170, 12, 175, 208, 242, 229, 9, 181, 144,
+172, 202, 7, 170, 195, 174, 180, 5, 198, 153, 178, 158, 6, 146, 142, 204,
+119, 137, 185, 250, 204, 10, 208, 190, 240, 166, 1, 138, 183, 212, 226, 3,
+241, 240, 245, 140, 15, 250, 184, 161, 117, 198, 194, 173, 133, 15, 135, 247,
+179, 180, 11, 158, 233, 195, 162, 2, 209, 143, 142, 203, 13, 156, 215, 224,
+192, 5, 228, 223, 167, 163, 6, 253, 160, 223, 182, 5, 178, 178, 223, 147,
+ 5, 150, 180, 221, 189, 10, 168, 197, 173, 169, 6, 166, 146, 252, 254, 15,
+154, 211, 198, 238, 6, 182, 166, 227, 223, 3, 152, 209, 173, 192, 3, 147,
+255, 130, 153, 9, 152, 159, 128, 195, 7, 204, 199, 174, 227, 8, 149, 133,
+142, 33, 236, 185, 160, 136, 14, 154, 137, 143, 236, 7, 246, 149, 237, 166,
+ 3, 150, 184, 224, 232, 3, 204, 220, 171, 245, 15, 128, 131, 146, 236, 219,
+ 10, 168, 253, 226, 198, 3, 196, 185, 159, 245, 14, 246, 239, 172, 207, 7,
+172, 188, 238, 233, 13, 193, 158, 247, 192, 10, 178, 146, 230, 233, 8, 143,
+221, 252, 145, 5, 169, 173, 160, 149, 7, 141, 199, 235, 35, 225, 224, 227,
+213, 7, 233, 249, 164, 132, 11, 255, 158, 248, 254, 2, 248, 200, 154, 176,
+ 3, 168, 248, 134, 165, 8, 145, 177, 231, 188, 10, 189, 223, 182, 129, 7,
+246, 146, 219, 62, 185, 190, 133, 217, 3, 228, 177, 227, 170, 1, 230, 175,
+223, 120, 150, 130, 206, 166, 5, 223, 216, 157, 168, 1, 225, 151, 175, 248,
+ 5, 140, 228, 227, 235, 7, 243, 148, 219, 250, 3, 250, 215, 234, 130, 1,
+191, 146, 221, 133, 8, 220, 223, 135, 100, 233, 148, 197, 224, 11, 164, 203,
+178, 134, 9, 170, 133, 159, 133, 8, 162, 189, 239, 68, 144, 186, 204, 211,
+ 6, 167, 218, 219, 144, 2, 208, 155, 181, 237, 2, 253, 223, 151, 180, 15,
+137, 132, 173, 135, 7, 172, 137, 239, 146, 13, 250, 140, 255, 211, 11, 231,
+134, 228, 145, 3, 149, 220, 253, 168, 10, 236, 163, 149, 221, 10, 247, 151,
+236, 190, 6, 166, 210, 238, 52, 192, 248, 168, 229, 9, 237, 182, 227, 199,
+ 12, 189, 199, 195, 216, 12, 178, 236, 220, 158, 2, 247, 182, 235, 221, 14,
+219, 148, 216, 159, 15, 158, 234, 200, 167, 2, 184, 132, 251, 232, 2, 138,
+227, 158, 204, 14, 225, 192, 227, 165, 8, 130, 214, 149, 173, 13, 210, 140,
+161, 181, 9, 222, 217, 168, 158, 10, 220, 222, 238, 137, 10, 237, 248, 184,
+ 57, 167, 213, 169, 132, 5, 236, 173, 141, 25, 131, 201, 181, 180, 4, 133,
+182, 179, 134, 14, 243, 180, 195, 169, 11, 145, 153, 139, 242, 14, 210, 148,
+136, 230, 2, 174, 147, 246, 185, 7, 185, 230, 252, 230, 10, 247, 210, 139,
+242, 13, 187, 227, 199, 158, 14, 186, 209, 178, 166, 8, 148, 174, 212, 154,
+ 6, 193, 139, 246, 160, 4, 180, 129, 135, 190, 7, 253, 202, 252, 194, 1,
+145, 192, 198, 192, 2, 136, 201, 194, 165, 5, 238, 198, 216, 222, 8, 148,
+132, 194, 231, 2, 179, 212, 226, 152, 13, 216, 203, 190, 81, 241, 158, 205,
+205, 3, 153, 250, 248, 251, 11, 157, 223, 163, 229, 11, 160, 240, 198, 156,
+ 13, 155, 254, 151, 138, 14, 219, 233, 172, 254, 4, 186, 194, 189, 227, 4,
+169, 243, 181, 201, 14, 161, 158, 146, 201, 3, 135, 139, 242, 206, 4, 222,
+141, 186, 201, 11, 247, 182, 166, 198, 12, 141, 168, 155, 172, 4, 206, 218,
+254, 175, 4, 140, 213, 159, 204, 7, 214, 128, 160, 215, 9, 253, 242, 237,
+147, 8, 162, 233, 151, 181, 5, 183, 223, 151, 21, 132, 164, 206, 242, 1,
+179, 227, 155, 165, 11, 189, 251, 195, 212, 3, 154, 195, 137, 190, 6, 129,
+212, 227, 177, 4, 185, 141, 235, 183, 7, 233, 220, 229, 174, 4, 215, 138,
+248, 25, 161, 210, 193, 241, 14, 239, 201, 231, 152, 12, 240, 169, 204, 169,
+ 14, 228, 195, 196, 225, 6, 250, 159, 144, 234, 1, 167, 238, 191, 142, 11,
+202, 222, 151, 207, 9, 205, 219, 185, 142, 3, 230, 224, 187, 235, 5, 194,
+167, 210, 173, 7, 235, 250, 253, 178, 12, 239, 128, 215, 198, 13, 130, 141,
+191, 238, 3, 173, 252, 172, 217, 14, 129, 203, 164, 16, 191, 131, 153, 141,
+ 8, 133, 200, 131, 240, 15, 173, 165, 172, 11, 182, 247, 244, 165, 9, 128,
+238, 232, 219, 37, 214, 148, 220, 206, 10, 199, 154, 167, 130, 1, 188, 191,
+233, 235, 9, 167, 131, 215, 154, 5, 133, 224, 241, 202, 1, 237, 213, 192,
+223, 4, 160, 202, 178, 132, 10, 248, 217, 142, 133, 12, 199, 164, 231, 189,
+ 5, 240, 129, 134, 189, 6, 173, 135, 204, 176, 15, 164, 142, 214, 137, 8,
+208, 169, 163, 251, 15, 196, 171, 247, 187, 14, 230, 177, 251, 130, 13, 200,
+234, 146, 173, 4, 252, 218, 210, 212, 10, 206, 187, 236, 129, 5, 165, 161,
+220, 171, 11, 135, 129, 179, 205, 2, 240, 251, 134, 254, 3, 136, 185, 186,
+220, 10, 230, 142, 156, 211, 1, 215, 243, 241, 179, 12, 141, 140, 140, 166,
+ 5, 136, 183, 213, 220, 14, 182, 213, 134, 202, 10, 177, 197, 170, 230, 6,
+210, 133, 203, 128, 14, 145, 196, 176, 139, 5, 191, 143, 140, 133, 11, 247,
+155, 221, 233, 10, 131, 192, 238, 143, 3, 194, 196, 146, 129, 9, 245, 183,
+142, 133, 6, 200, 197, 143, 185, 2, 133, 144, 194, 144, 4, 149, 202, 240,
+ 36, 230, 214, 182, 211, 5, 254, 227, 217, 246, 2, 128, 164, 220, 255, 5,
+132, 138, 149, 153, 6, 200, 139, 167, 97, 203, 137, 179, 195, 2, 141, 176,
+199, 134, 9, 165, 244, 225, 254, 3, 136, 180, 252, 193, 3, 200, 165, 159,
+207, 12, 147, 222, 142, 148, 5, 191, 146, 228, 191, 9, 213, 255, 236, 152,
+ 13, 132, 240, 164, 174, 2, 204, 152, 214, 3, 251, 240, 222, 248, 10, 219,
+208, 211, 189, 15, 175, 252, 221, 88, 182, 234, 154, 107, 208, 190, 199, 159,
+ 2, 209, 139, 150, 182, 13, 212, 219, 146, 154, 15, 221, 178, 221, 188, 11,
+148, 200, 197, 17, 129, 218, 170, 253, 11, 164, 244, 228, 252, 2, 220, 175,
+146, 195, 15, 141, 223, 154, 232, 9, 227, 186, 130, 220, 8, 153, 157, 145,
+139, 12, 233, 140, 173, 183, 12, 223, 255, 155, 139, 13, 162, 238, 129, 242,
+ 11, 252, 162, 211, 191, 2, 228, 182, 210, 101, 171, 202, 191, 167, 11, 247,
+189, 170, 255, 3, 217, 150, 238, 215, 10, 173, 188, 234, 177, 5, 166, 139,
+147, 132, 12, 230, 216, 153, 200, 3, 182, 202, 167, 210, 12, 222, 169, 137,
+180, 7, 253, 249, 181, 197, 2, 198, 205, 156, 192, 12, 168, 135, 243, 185,
+ 2, 138, 158, 139, 159, 11, 138, 210, 248, 255, 14, 157, 141, 161, 207, 9,
+218, 206, 244, 191, 4, 222, 169, 188, 238, 5, 133, 211, 152, 218, 14, 248,
+191, 242, 250, 13, 217, 188, 239, 231, 14, 137, 198, 135, 144, 1, 231, 227,
+214, 168, 7, 128, 136, 152, 103, 150, 151, 161, 171, 12, 251, 222, 212, 229,
+ 4, 154, 193, 182, 62, 251, 246, 205, 142, 3, 132, 140, 242, 166, 14, 165,
+231, 192, 250, 6, 136, 154, 230, 163, 1, 230, 228, 246, 182, 3, 187, 215,
+217, 177, 8, 137, 171, 251, 15, 211, 128, 230, 244, 15, 160, 146, 188, 255,
+ 4, 204, 242, 150, 194, 1, 128, 184, 177, 139, 14, 139, 209, 245, 134, 11,
+241, 167, 181, 139, 5, 159, 129, 160, 74, 159, 200, 133, 222, 5, 157, 204,
+165, 199, 10, 193, 159, 169, 151, 11, 205, 219, 226, 134, 9, 197, 252, 179,
+128, 14, 230, 250, 244, 215, 5, 207, 138, 239, 212, 14, 237, 216, 191, 199,
+ 15, 250, 250, 198, 148, 9, 212, 228, 174, 146, 15, 221, 137, 207, 196, 3,
+146, 165, 245, 220, 13, 157, 249, 149, 228, 5, 185, 219, 188, 185, 8, 212,
+150, 240, 218, 15, 128, 211, 229, 202, 129, 14, 132, 225, 178, 226, 1, 251,
+195, 132, 66, 210, 245, 154, 234, 5, 145, 183, 146, 177, 9, 218, 223, 128,
+170, 13, 238, 227, 168, 197, 11, 189, 225, 206, 179, 6, 221, 169, 239, 193,
+ 4, 194, 207, 170, 203, 7, 163, 206, 232, 197, 1, 160, 130, 131, 160, 4,
+139, 146, 149, 173, 10, 140, 240, 243, 180, 4, 231, 180, 202, 245, 9, 146,
+250, 195, 157, 1, 233, 199, 188, 210, 15, 253, 222, 137, 142, 10, 174, 245,
+231, 20, 219, 156, 185, 201, 5, 139, 137, 230, 135, 1, 236, 207, 146, 138,
+ 4, 149, 174, 164, 221, 4, 158, 227, 224, 210, 7, 206, 150, 186, 244, 9,
+156, 183, 159, 142, 13, 176, 152, 163, 193, 8, 190, 229, 232, 155, 7, 234,
+132, 236, 132, 9, 242, 254, 204, 134, 14, 143, 226, 253, 180, 2, 138, 226,
+214, 218, 2, 199, 228, 210, 186, 12, 147, 179, 230, 254, 5, 249, 135, 247,
+147, 10, 148, 253, 186, 214, 12, 250, 240, 173, 159, 14, 162, 215, 177, 42,
+162, 142, 248, 135, 3, 196, 143, 150, 150, 10, 236, 221, 178, 147, 7, 165,
+248, 197, 136, 7, 199, 152, 158, 228, 13, 229, 215, 242, 194, 7, 145, 249,
+246, 181, 13, 134, 191, 196, 245, 3, 161, 251, 235, 200, 14, 255, 232, 248,
+228, 10, 170, 188, 227, 177, 14, 212, 202, 144, 143, 13, 199, 230, 234, 155,
+ 10, 247, 239, 142, 167, 6, 197, 129, 192, 235, 2, 207, 229, 194, 237, 12,
+228, 239, 211, 136, 3, 199, 135, 194, 244, 4, 167, 137, 158, 132, 15, 208,
+199, 176, 183, 2, 161, 181, 218, 155, 11, 218, 235, 160, 207, 5, 250, 181,
+244, 252, 9, 197, 130, 193, 168, 1, 153, 235, 181, 253, 2, 203, 245, 229,
+255, 11, 134, 136, 148, 249, 8, 179, 174, 133, 187, 8, 145, 212, 156, 196,
+ 7, 163, 222, 227, 236, 11, 242, 171, 200, 143, 12, 185, 225, 231, 211, 15,
+135, 230, 213, 153, 6, 254, 187, 227, 167, 2, 147, 191, 160, 185, 12, 177,
+145, 137, 133, 1, 241, 244, 217, 231, 3, 225, 213, 246, 253, 11, 138, 185,
+169, 229, 8, 129, 248, 228, 155, 4, 150, 208, 194, 129, 13, 149, 233, 140,
+159, 7, 149, 223, 199, 33, 153, 214, 176, 117, 175, 193, 163, 144, 9, 135,
+207, 150, 12, 216, 138, 151, 55, 233, 245, 225, 219, 8, 215, 194, 201, 214,
+ 6, 235, 254, 134, 70, 251, 142, 174, 209, 12, 215, 218, 132, 174, 4, 209,
+177, 189, 144, 3, 247, 136, 205, 212, 8, 152, 220, 178, 208, 5, 183, 146,
+202, 149, 6, 248, 229, 196, 211, 12, 226, 191, 237, 227, 7, 234, 157, 195,
+196, 4, 203, 147, 213, 156, 1, 245, 161, 241, 97, 186, 245, 223, 246, 8,
+170, 241, 234, 188, 8, 171, 155, 201, 168, 8, 193, 168, 145, 142, 10, 254,
+183, 192, 202, 14, 137, 175, 147, 223, 9, 176, 133, 131, 166, 12, 211, 168,
+155, 225, 4, 197, 193, 255, 204, 8, 154, 208, 144, 165, 1, 134, 190, 143,
+217, 11, 148, 242, 203, 237, 11, 161, 142, 172, 215, 3, 166, 203, 240, 162,
+ 6, 200, 195, 186, 162, 7, 198, 211, 223, 252, 15, 132, 160, 226, 204, 15,
+158, 187, 167, 222, 6, 174, 214, 139, 220, 9, 130, 243, 221, 206, 6, 190,
+217, 211, 145, 4, 160, 255, 142, 201, 5, 201, 166, 217, 174, 7, 240, 197,
+130, 214, 7, 216, 133, 220, 184, 3, 241, 148, 192, 185, 6, 213, 181, 240,
+210, 2, 137, 194, 206, 172, 5, 221, 189, 134, 241, 10, 128, 180, 234, 178,
+219, 13, 203, 213, 182, 247, 10, 172, 229, 222, 178, 15, 188, 154, 206, 196,
+ 12, 240, 136, 172, 156, 11, 165, 151, 164, 200, 7, 189, 152, 225, 146, 7,
+214, 167, 205, 147, 4, 216, 175, 130, 230, 10, 243, 162, 145, 154, 7, 155,
+169, 190, 182, 6, 255, 212, 152, 251, 6, 147, 152, 160, 237, 2, 170, 228,
+233, 210, 13, 166, 255, 247, 207, 14, 238, 175, 242, 171, 9, 174, 241, 193,
+193, 4, 245, 210, 147, 167, 14, 151, 233, 199, 154, 1, 193, 184, 194, 249,
+ 9, 216, 255, 201, 246, 10, 138, 198, 240, 208, 5, 187, 230, 137, 145, 1,
+200, 237, 144, 115, 131, 149, 167, 201, 15, 249, 130, 240, 202, 5, 141, 220,
+198, 233, 3, 216, 165, 204, 210, 12, 176, 166, 249, 207, 4, 244, 158, 162,
+140, 8, 174, 153, 181, 253, 14, 249, 157, 148, 130, 10, 178, 203, 201, 162,
+ 4, 161, 215, 176, 137, 3, 164, 232, 198, 200, 15, 141, 189, 153, 206, 6,
+148, 138, 219, 252, 12, 147, 134, 206, 210, 9, 214, 186, 141, 183, 10, 235,
+192, 204, 245, 10, 155, 177, 148, 174, 7, 246, 150, 200, 167, 15, 134, 228,
+212, 210, 7, 128, 198, 173, 133, 10, 173, 148, 155, 170, 4, 131, 242, 205,
+148, 14, 154, 220, 156, 236, 11, 213, 150, 219, 145, 4, 171, 231, 199, 224,
+ 12, 190, 139, 161, 155, 3, 136, 151, 199, 129, 9, 182, 161, 156, 237, 1,
+218, 151, 248, 132, 13, 201, 207, 164, 115, 190, 137, 205, 255, 11, 191, 198,
+251, 165, 10, 234, 205, 249, 181, 3, 172, 185, 218, 244, 14, 134, 171, 214,
+151, 9, 152, 245, 182, 215, 10, 204, 161, 209, 196, 14, 180, 134, 204, 240,
+ 4, 242, 196, 170, 185, 13, 156, 255, 134, 178, 14, 203, 145, 211, 216, 3,
+190, 148, 160, 180, 14, 189, 162, 214, 209, 10, 238, 176, 239, 248, 15, 151,
+163, 176, 168, 5, 152, 247, 207, 238, 14, 181, 238, 168, 251, 8, 181, 189,
+202, 33, 232, 239, 229, 226, 5, 133, 156, 212, 180, 4, 224, 169, 249, 216,
+ 4, 198, 245, 205, 147, 8, 231, 232, 149, 230, 8, 243, 161, 191, 162, 3,
+194, 189, 237, 227, 15, 223, 185, 161, 232, 4, 153, 233, 249, 155, 8, 240,
+147, 199, 249, 5, 135, 205, 250, 160, 11, 252, 183, 238, 210, 10, 244, 146,
+156, 160, 5, 196, 252, 142, 22, 191, 148, 222, 231, 11, 182, 201, 163, 219,
+ 13, 199, 238, 233, 179, 4, 180, 199, 255, 249, 4, 254, 237, 180, 213, 2,
+211, 221, 157, 151, 7, 178, 192, 158, 241, 13, 133, 212, 252, 51, 146, 221,
+241, 177, 7, 137, 246, 204, 171, 5, 138, 209, 144, 231, 2, 153, 213, 230,
+179, 4, 171, 244, 213, 172, 3, 191, 201, 249, 129, 3, 184, 184, 186, 243,
+ 11, 145, 176, 183, 103, 145, 131, 206, 147, 14, 136, 134, 191, 173, 9, 180,
+164, 241, 245, 5, 172, 133, 212, 167, 8, 198, 162, 158, 244, 4, 232, 175,
+222, 231, 12, 146, 246, 134, 196, 8, 147, 248, 177, 230, 8, 145, 216, 180,
+139, 12, 224, 254, 191, 222, 1, 182, 145, 213, 232, 10, 178, 139, 143, 237,
+ 9, 253, 230, 172, 181, 13, 225, 218, 252, 132, 6, 141, 175, 159, 197, 14,
+185, 222, 237, 246, 3, 154, 184, 245, 228, 11, 193, 198, 235, 204, 10, 182,
+239, 253, 136, 15, 205, 143, 161, 211, 7, 164, 207, 235, 220, 4, 158, 235,
+183, 187, 9, 203, 201, 147, 139, 3, 169, 181, 153, 201, 11, 222, 206, 192,
+251, 12, 221, 253, 242, 152, 11, 128, 249, 190, 248, 152, 5, 151, 199, 221,
+227, 14, 209, 246, 133, 200, 7, 246, 181, 176, 131, 9, 165, 219, 139, 171,
+ 4, 254, 130, 187, 208, 8, 144, 221, 189, 192, 10, 163, 146, 139, 166, 12,
+231, 177, 223, 205, 9, 229, 179, 214, 227, 2, 132, 153, 150, 154, 5, 242,
+250, 159, 171, 9, 144, 228, 238, 120, 168, 206, 130, 107, 145, 144, 235, 248,
+ 1, 254, 218, 166, 129, 4, 237, 129, 235, 7, 150, 199, 251, 175, 9, 252,
+199, 200, 168, 9, 172, 147, 153, 151, 5, 168, 129, 129, 188, 13, 200, 166,
+192, 192, 8, 154, 184, 218, 232, 2, 155, 202, 193, 156, 12, 182, 241, 250,
+153, 13, 180, 141, 206, 141, 6, 206, 129, 157, 153, 12, 132, 158, 212, 247,
+ 14, 160, 135, 203, 238, 12, 216, 173, 204, 156, 9, 166, 214, 242, 138, 14,
+178, 248, 246, 135, 1, 244, 219, 210, 155, 3, 208, 155, 189, 180, 3, 156,
+189, 171, 174, 13, 162, 161, 233, 108, 231, 134, 177, 255, 11, 216, 159, 226,
+244, 2, 130, 227, 211, 185, 6, 169, 146, 187, 143, 2, 153, 225, 150, 187,
+ 9, 210, 153, 211, 181, 13, 147, 216, 152, 173, 3, 246, 236, 142, 33, 222,
+140, 194, 241, 10, 171, 251, 248, 210, 11, 239, 197, 137, 242, 8, 132, 179,
+189, 209, 6, 181, 221, 179, 161, 2, 168, 172, 241, 163, 2, 203, 241, 250,
+226, 12, 184, 188, 237, 210, 8, 228, 163, 153, 234, 5, 222, 162, 216, 142,
+ 13, 235, 251, 186, 239, 1, 199, 133, 166, 158, 9, 134, 241, 161, 174, 3,
+183, 248, 214, 158, 7, 181, 248, 184, 143, 11, 234, 152, 151, 169, 9, 198,
+134, 159, 251, 7, 144, 176, 211, 121, 199, 255, 166, 132, 5, 201, 243, 215,
+189, 14, 213, 240, 205, 223, 10, 205, 191, 234, 185, 9, 240, 221, 255, 234,
+ 5, 210, 250, 179, 148, 7, 185, 162, 155, 243, 3, 140, 197, 165, 222, 12,
+150, 143, 215, 241, 13, 138, 138, 246, 30, 236, 151, 243, 235, 12, 232, 222,
+197, 223, 5, 177, 198, 228, 194, 4, 130, 172, 242, 221, 11, 208, 235, 221,
+161, 1, 254, 141, 148, 144, 14, 168, 251, 185, 179, 9, 247, 144, 244, 178,
+ 12, 209, 235, 151, 183, 9, 131, 208, 184, 182, 13, 135, 245,
<TRUNCATED>