| /** |
| * Basis Universal single file library. Generated using: |
| * \code |
| * ./combine.sh -r ../../transcoder -o basisu_transcoder.cpp basisu_transcoder-in.cpp |
| * \endcode |
| */ |
| |
| /* |
| * Transcoder build options for known platforms (iOS has ETC, ASTC and PVRTC; |
| * Emscripten adds DXT to iOS's options; Android adds PVRTC2 to Emscripten's |
| * options; other platforms build all except FXT1). |
| * |
| * See https://github.com/BinomialLLC/basis_universal#shrinking-the-transcoders-compiled-size |
| */ |
| #ifdef __APPLE__ |
| #include <TargetConditionals.h> |
| #endif |
| #if TARGET_OS_IPHONE |
| #define BASISD_SUPPORT_DXT1 0 |
| #define BASISD_SUPPORT_DXT5A 0 |
| #endif |
| #if TARGET_OS_IPHONE || defined(__EMSCRIPTEN__) || defined(__ANDROID__) |
| #define BASISD_SUPPORT_BC7 0 |
| #define BASISD_SUPPORT_ATC 0 |
| #ifndef __ANDROID__ |
| #define BASISD_SUPPORT_PVRTC2 0 |
| #endif |
| #endif |
| #define BASISD_SUPPORT_FXT1 0 |
| |
| /* |
| * KTX2 support disabled. |
| */ |
| #define BASISD_SUPPORT_KTX2 0 |
| |
| /**** start inlining basisu_transcoder.cpp ****/ |
| // basisu_transcoder.cpp |
| // Copyright (C) 2019-2021 Binomial LLC. All Rights Reserved. |
| // |
| // Licensed 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. |
| |
| /**** start inlining basisu_transcoder.h ****/ |
| // basisu_transcoder.h |
| // Copyright (C) 2019-2021 Binomial LLC. All Rights Reserved. |
| // Important: If compiling with gcc, be sure strict aliasing is disabled: -fno-strict-aliasing |
| // |
| // Licensed 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. |
| |
| // By default KTX2 support is enabled to simplify compilation. This implies the need for the Zstandard library (which we distribute as a single source file in the "zstd" directory) by default. |
| // Set BASISD_SUPPORT_KTX2 to 0 to completely disable KTX2 support as well as Zstd/miniz usage which is only required for UASTC supercompression in KTX2 files. |
| // Also see BASISD_SUPPORT_KTX2_ZSTD in basisu_transcoder.cpp, which individually disables Zstd usage. |
| #ifndef BASISD_SUPPORT_KTX2 |
| #define BASISD_SUPPORT_KTX2 1 |
| #endif |
| |
| // Set BASISD_SUPPORT_KTX2_ZSTD to 0 to disable Zstd usage and KTX2 UASTC Zstd supercompression support |
| #ifndef BASISD_SUPPORT_KTX2_ZSTD |
| #define BASISD_SUPPORT_KTX2_ZSTD 1 |
| #endif |
| |
| // Set BASISU_FORCE_DEVEL_MESSAGES to 1 to enable debug printf()'s whenever an error occurs, for easier debugging during development. |
| #ifndef BASISU_FORCE_DEVEL_MESSAGES |
| #define BASISU_FORCE_DEVEL_MESSAGES 0 |
| #endif |
| |
| /**** start inlining basisu_transcoder_internal.h ****/ |
| // basisu_transcoder_internal.h - Universal texture format transcoder library. |
| // Copyright (C) 2019-2021 Binomial LLC. All Rights Reserved. |
| // |
| // Important: If compiling with gcc, be sure strict aliasing is disabled: -fno-strict-aliasing |
| // |
| // Licensed 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. |
| |
| #ifdef _MSC_VER |
| #pragma warning (disable: 4127) // conditional expression is constant |
| #endif |
| |
| #define BASISD_LIB_VERSION 116 |
| #define BASISD_VERSION_STRING "01.16" |
| |
| #ifdef _DEBUG |
| #define BASISD_BUILD_DEBUG |
| #else |
| #define BASISD_BUILD_RELEASE |
| #endif |
| |
| /**** start inlining basisu.h ****/ |
| // basisu.h |
| // Copyright (C) 2019-2021 Binomial LLC. All Rights Reserved. |
| // Important: If compiling with gcc, be sure strict aliasing is disabled: -fno-strict-aliasing |
| // |
| // Licensed 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. |
| |
| #ifdef _MSC_VER |
| |
| #pragma warning (disable : 4201) |
| #pragma warning (disable : 4127) // warning C4127: conditional expression is constant |
| #pragma warning (disable : 4530) // C++ exception handler used, but unwind semantics are not enabled. |
| |
| // Slamming this off always for v1.16 because we've gotten rid of most std containers. |
| #ifndef BASISU_NO_ITERATOR_DEBUG_LEVEL |
| #define BASISU_NO_ITERATOR_DEBUG_LEVEL (1) |
| #endif |
| |
| #ifndef BASISU_NO_ITERATOR_DEBUG_LEVEL |
| //#define _HAS_ITERATOR_DEBUGGING 0 |
| |
| #if defined(_DEBUG) || defined(DEBUG) |
| // This is madness, but we need to disable iterator debugging in debug builds or the encoder is unsable because MSVC's iterator debugging implementation is totally broken. |
| #ifndef _ITERATOR_DEBUG_LEVEL |
| #define _ITERATOR_DEBUG_LEVEL 1 |
| #endif |
| #ifndef _SECURE_SCL |
| #define _SECURE_SCL 1 |
| #endif |
| #else // defined(_DEBUG) || defined(DEBUG) |
| #ifndef _SECURE_SCL |
| #define _SECURE_SCL 0 |
| #endif |
| #ifndef _ITERATOR_DEBUG_LEVEL |
| #define _ITERATOR_DEBUG_LEVEL 0 |
| #endif |
| #endif // defined(_DEBUG) || defined(DEBUG) |
| |
| #endif // BASISU_NO_ITERATOR_DEBUG_LEVEL |
| |
| #endif // _MSC_VER |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <math.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <memory.h> |
| #include <limits.h> |
| #include <stdint.h> |
| |
| #include <algorithm> |
| #include <limits> |
| #include <functional> |
| #include <iterator> |
| #include <type_traits> |
| #include <assert.h> |
| #include <random> |
| |
| /**** start inlining basisu_containers.h ****/ |
| // basisu_containers.h |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <stdint.h> |
| #include <assert.h> |
| #include <algorithm> |
| |
| #if defined(__linux__) && !defined(ANDROID) |
| // Only for malloc_usable_size() in basisu_containers_impl.h |
| #include <malloc.h> |
| #define HAS_MALLOC_USABLE_SIZE 1 |
| #endif |
| |
| // Set to 1 to always check vector operator[], front(), and back() even in release. |
| #define BASISU_VECTOR_FORCE_CHECKING 0 |
| |
| // If 1, the vector container will not query the CRT to get the size of resized memory blocks. |
| #define BASISU_VECTOR_DETERMINISTIC 1 |
| |
| #ifdef _MSC_VER |
| #define BASISU_FORCE_INLINE __forceinline |
| #else |
| #define BASISU_FORCE_INLINE inline |
| #endif |
| |
| namespace basisu |
| { |
| enum { cInvalidIndex = -1 }; |
| |
| namespace helpers |
| { |
| inline bool is_power_of_2(uint32_t x) { return x && ((x & (x - 1U)) == 0U); } |
| inline bool is_power_of_2(uint64_t x) { return x && ((x & (x - 1U)) == 0U); } |
| template<class T> const T& minimum(const T& a, const T& b) { return (b < a) ? b : a; } |
| template<class T> const T& maximum(const T& a, const T& b) { return (a < b) ? b : a; } |
| |
| inline uint32_t floor_log2i(uint32_t v) |
| { |
| uint32_t l = 0; |
| while (v > 1U) |
| { |
| v >>= 1; |
| l++; |
| } |
| return l; |
| } |
| |
| inline uint32_t next_pow2(uint32_t val) |
| { |
| val--; |
| val |= val >> 16; |
| val |= val >> 8; |
| val |= val >> 4; |
| val |= val >> 2; |
| val |= val >> 1; |
| return val + 1; |
| } |
| |
| inline uint64_t next_pow2(uint64_t val) |
| { |
| val--; |
| val |= val >> 32; |
| val |= val >> 16; |
| val |= val >> 8; |
| val |= val >> 4; |
| val |= val >> 2; |
| val |= val >> 1; |
| return val + 1; |
| } |
| } // namespace helpers |
| |
| template <typename T> |
| inline T* construct(T* p) |
| { |
| return new (static_cast<void*>(p)) T; |
| } |
| |
| template <typename T, typename U> |
| inline T* construct(T* p, const U& init) |
| { |
| return new (static_cast<void*>(p)) T(init); |
| } |
| |
| template <typename T> |
| inline void construct_array(T* p, size_t n) |
| { |
| T* q = p + n; |
| for (; p != q; ++p) |
| new (static_cast<void*>(p)) T; |
| } |
| |
| template <typename T, typename U> |
| inline void construct_array(T* p, size_t n, const U& init) |
| { |
| T* q = p + n; |
| for (; p != q; ++p) |
| new (static_cast<void*>(p)) T(init); |
| } |
| |
| template <typename T> |
| inline void destruct(T* p) |
| { |
| (void)p; |
| p->~T(); |
| } |
| |
| template <typename T> inline void destruct_array(T* p, size_t n) |
| { |
| T* q = p + n; |
| for (; p != q; ++p) |
| p->~T(); |
| } |
| |
| template<typename T> struct int_traits { enum { cMin = INT32_MIN, cMax = INT32_MAX, cSigned = true }; }; |
| |
| template<> struct int_traits<int8_t> { enum { cMin = INT8_MIN, cMax = INT8_MAX, cSigned = true }; }; |
| template<> struct int_traits<int16_t> { enum { cMin = INT16_MIN, cMax = INT16_MAX, cSigned = true }; }; |
| template<> struct int_traits<int32_t> { enum { cMin = INT32_MIN, cMax = INT32_MAX, cSigned = true }; }; |
| |
| template<> struct int_traits<uint8_t> { enum { cMin = 0, cMax = UINT8_MAX, cSigned = false }; }; |
| template<> struct int_traits<uint16_t> { enum { cMin = 0, cMax = UINT16_MAX, cSigned = false }; }; |
| template<> struct int_traits<uint32_t> { enum { cMin = 0, cMax = UINT32_MAX, cSigned = false }; }; |
| |
| template<typename T> |
| struct scalar_type |
| { |
| enum { cFlag = false }; |
| static inline void construct(T* p) { basisu::construct(p); } |
| static inline void construct(T* p, const T& init) { basisu::construct(p, init); } |
| static inline void construct_array(T* p, size_t n) { basisu::construct_array(p, n); } |
| static inline void destruct(T* p) { basisu::destruct(p); } |
| static inline void destruct_array(T* p, size_t n) { basisu::destruct_array(p, n); } |
| }; |
| |
| template<typename T> struct scalar_type<T*> |
| { |
| enum { cFlag = true }; |
| static inline void construct(T** p) { memset(p, 0, sizeof(T*)); } |
| static inline void construct(T** p, T* init) { *p = init; } |
| static inline void construct_array(T** p, size_t n) { memset(p, 0, sizeof(T*) * n); } |
| static inline void destruct(T** p) { p; } |
| static inline void destruct_array(T** p, size_t n) { p, n; } |
| }; |
| |
| #define BASISU_DEFINE_BUILT_IN_TYPE(X) \ |
| template<> struct scalar_type<X> { \ |
| enum { cFlag = true }; \ |
| static inline void construct(X* p) { memset(p, 0, sizeof(X)); } \ |
| static inline void construct(X* p, const X& init) { memcpy(p, &init, sizeof(X)); } \ |
| static inline void construct_array(X* p, size_t n) { memset(p, 0, sizeof(X) * n); } \ |
| static inline void destruct(X* p) { p; } \ |
| static inline void destruct_array(X* p, size_t n) { p, n; } }; |
| |
| BASISU_DEFINE_BUILT_IN_TYPE(bool) |
| BASISU_DEFINE_BUILT_IN_TYPE(char) |
| BASISU_DEFINE_BUILT_IN_TYPE(unsigned char) |
| BASISU_DEFINE_BUILT_IN_TYPE(short) |
| BASISU_DEFINE_BUILT_IN_TYPE(unsigned short) |
| BASISU_DEFINE_BUILT_IN_TYPE(int) |
| BASISU_DEFINE_BUILT_IN_TYPE(unsigned int) |
| BASISU_DEFINE_BUILT_IN_TYPE(long) |
| BASISU_DEFINE_BUILT_IN_TYPE(unsigned long) |
| #ifdef __GNUC__ |
| BASISU_DEFINE_BUILT_IN_TYPE(long long) |
| BASISU_DEFINE_BUILT_IN_TYPE(unsigned long long) |
| #else |
| BASISU_DEFINE_BUILT_IN_TYPE(__int64) |
| BASISU_DEFINE_BUILT_IN_TYPE(unsigned __int64) |
| #endif |
| BASISU_DEFINE_BUILT_IN_TYPE(float) |
| BASISU_DEFINE_BUILT_IN_TYPE(double) |
| BASISU_DEFINE_BUILT_IN_TYPE(long double) |
| |
| #undef BASISU_DEFINE_BUILT_IN_TYPE |
| |
| template<typename T> |
| struct bitwise_movable { enum { cFlag = false }; }; |
| |
| #define BASISU_DEFINE_BITWISE_MOVABLE(Q) template<> struct bitwise_movable<Q> { enum { cFlag = true }; }; |
| |
| template<typename T> |
| struct bitwise_copyable { enum { cFlag = false }; }; |
| |
| #define BASISU_DEFINE_BITWISE_COPYABLE(Q) template<> struct bitwise_copyable<Q> { enum { cFlag = true }; }; |
| |
| #define BASISU_IS_POD(T) __is_pod(T) |
| |
| #define BASISU_IS_SCALAR_TYPE(T) (scalar_type<T>::cFlag) |
| |
| #if defined(__GNUC__) && __GNUC__<5 |
| #define BASISU_IS_TRIVIALLY_COPYABLE(...) __has_trivial_copy(__VA_ARGS__) |
| #else |
| #define BASISU_IS_TRIVIALLY_COPYABLE(...) std::is_trivially_copyable<__VA_ARGS__>::value |
| #endif |
| |
| // TODO: clean this up |
| #define BASISU_IS_BITWISE_COPYABLE(T) (BASISU_IS_SCALAR_TYPE(T) || BASISU_IS_POD(T) || BASISU_IS_TRIVIALLY_COPYABLE(T) || (bitwise_copyable<T>::cFlag)) |
| |
| #define BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(T) (BASISU_IS_BITWISE_COPYABLE(T) || (bitwise_movable<T>::cFlag)) |
| |
| #define BASISU_HAS_DESTRUCTOR(T) ((!scalar_type<T>::cFlag) && (!__is_pod(T))) |
| |
| typedef char(&yes_t)[1]; |
| typedef char(&no_t)[2]; |
| |
| template <class U> yes_t class_test(int U::*); |
| template <class U> no_t class_test(...); |
| |
| template <class T> struct is_class |
| { |
| enum { value = (sizeof(class_test<T>(0)) == sizeof(yes_t)) }; |
| }; |
| |
| template <typename T> struct is_pointer |
| { |
| enum { value = false }; |
| }; |
| |
| template <typename T> struct is_pointer<T*> |
| { |
| enum { value = true }; |
| }; |
| |
| struct empty_type { }; |
| |
| BASISU_DEFINE_BITWISE_COPYABLE(empty_type); |
| BASISU_DEFINE_BITWISE_MOVABLE(empty_type); |
| |
| template<typename T> struct rel_ops |
| { |
| friend bool operator!=(const T& x, const T& y) { return (!(x == y)); } |
| friend bool operator> (const T& x, const T& y) { return (y < x); } |
| friend bool operator<=(const T& x, const T& y) { return (!(y < x)); } |
| friend bool operator>=(const T& x, const T& y) { return (!(x < y)); } |
| }; |
| |
| struct elemental_vector |
| { |
| void* m_p; |
| uint32_t m_size; |
| uint32_t m_capacity; |
| |
| typedef void (*object_mover)(void* pDst, void* pSrc, uint32_t num); |
| |
| bool increase_capacity(uint32_t min_new_capacity, bool grow_hint, uint32_t element_size, object_mover pRelocate, bool nofail); |
| }; |
| |
| template<typename T> |
| class vector : public rel_ops< vector<T> > |
| { |
| public: |
| typedef T* iterator; |
| typedef const T* const_iterator; |
| typedef T value_type; |
| typedef T& reference; |
| typedef const T& const_reference; |
| typedef T* pointer; |
| typedef const T* const_pointer; |
| |
| inline vector() : |
| m_p(NULL), |
| m_size(0), |
| m_capacity(0) |
| { |
| } |
| |
| inline vector(uint32_t n, const T& init) : |
| m_p(NULL), |
| m_size(0), |
| m_capacity(0) |
| { |
| increase_capacity(n, false); |
| construct_array(m_p, n, init); |
| m_size = n; |
| } |
| |
| inline vector(const vector& other) : |
| m_p(NULL), |
| m_size(0), |
| m_capacity(0) |
| { |
| increase_capacity(other.m_size, false); |
| |
| m_size = other.m_size; |
| |
| if (BASISU_IS_BITWISE_COPYABLE(T)) |
| memcpy(m_p, other.m_p, m_size * sizeof(T)); |
| else |
| { |
| T* pDst = m_p; |
| const T* pSrc = other.m_p; |
| for (uint32_t i = m_size; i > 0; i--) |
| construct(pDst++, *pSrc++); |
| } |
| } |
| |
| inline explicit vector(size_t size) : |
| m_p(NULL), |
| m_size(0), |
| m_capacity(0) |
| { |
| resize(size); |
| } |
| |
| inline ~vector() |
| { |
| if (m_p) |
| { |
| scalar_type<T>::destruct_array(m_p, m_size); |
| free(m_p); |
| } |
| } |
| |
| inline vector& operator= (const vector& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| if (m_capacity >= other.m_size) |
| resize(0); |
| else |
| { |
| clear(); |
| increase_capacity(other.m_size, false); |
| } |
| |
| if (BASISU_IS_BITWISE_COPYABLE(T)) |
| memcpy(m_p, other.m_p, other.m_size * sizeof(T)); |
| else |
| { |
| T* pDst = m_p; |
| const T* pSrc = other.m_p; |
| for (uint32_t i = other.m_size; i > 0; i--) |
| construct(pDst++, *pSrc++); |
| } |
| |
| m_size = other.m_size; |
| |
| return *this; |
| } |
| |
| BASISU_FORCE_INLINE const T* begin() const { return m_p; } |
| BASISU_FORCE_INLINE T* begin() { return m_p; } |
| |
| BASISU_FORCE_INLINE const T* end() const { return m_p + m_size; } |
| BASISU_FORCE_INLINE T* end() { return m_p + m_size; } |
| |
| BASISU_FORCE_INLINE bool empty() const { return !m_size; } |
| BASISU_FORCE_INLINE uint32_t size() const { return m_size; } |
| BASISU_FORCE_INLINE uint32_t size_in_bytes() const { return m_size * sizeof(T); } |
| BASISU_FORCE_INLINE uint32_t capacity() const { return m_capacity; } |
| |
| // operator[] will assert on out of range indices, but in final builds there is (and will never be) any range checking on this method. |
| //BASISU_FORCE_INLINE const T& operator[] (uint32_t i) const { assert(i < m_size); return m_p[i]; } |
| //BASISU_FORCE_INLINE T& operator[] (uint32_t i) { assert(i < m_size); return m_p[i]; } |
| |
| #if !BASISU_VECTOR_FORCE_CHECKING |
| BASISU_FORCE_INLINE const T& operator[] (size_t i) const { assert(i < m_size); return m_p[i]; } |
| BASISU_FORCE_INLINE T& operator[] (size_t i) { assert(i < m_size); return m_p[i]; } |
| #else |
| BASISU_FORCE_INLINE const T& operator[] (size_t i) const |
| { |
| if (i >= m_size) |
| { |
| fprintf(stderr, "operator[] invalid index: %u, max entries %u, type size %u\n", (uint32_t)i, m_size, (uint32_t)sizeof(T)); |
| abort(); |
| } |
| return m_p[i]; |
| } |
| BASISU_FORCE_INLINE T& operator[] (size_t i) |
| { |
| if (i >= m_size) |
| { |
| fprintf(stderr, "operator[] invalid index: %u, max entries %u, type size %u\n", (uint32_t)i, m_size, (uint32_t)sizeof(T)); |
| abort(); |
| } |
| return m_p[i]; |
| } |
| #endif |
| |
| // at() always includes range checking, even in final builds, unlike operator []. |
| // The first element is returned if the index is out of range. |
| BASISU_FORCE_INLINE const T& at(size_t i) const { assert(i < m_size); return (i >= m_size) ? m_p[0] : m_p[i]; } |
| BASISU_FORCE_INLINE T& at(size_t i) { assert(i < m_size); return (i >= m_size) ? m_p[0] : m_p[i]; } |
| |
| #if !BASISU_VECTOR_FORCE_CHECKING |
| BASISU_FORCE_INLINE const T& front() const { assert(m_size); return m_p[0]; } |
| BASISU_FORCE_INLINE T& front() { assert(m_size); return m_p[0]; } |
| |
| BASISU_FORCE_INLINE const T& back() const { assert(m_size); return m_p[m_size - 1]; } |
| BASISU_FORCE_INLINE T& back() { assert(m_size); return m_p[m_size - 1]; } |
| #else |
| BASISU_FORCE_INLINE const T& front() const |
| { |
| if (!m_size) |
| { |
| fprintf(stderr, "front: vector is empty, type size %u\n", (uint32_t)sizeof(T)); |
| abort(); |
| } |
| return m_p[0]; |
| } |
| BASISU_FORCE_INLINE T& front() |
| { |
| if (!m_size) |
| { |
| fprintf(stderr, "front: vector is empty, type size %u\n", (uint32_t)sizeof(T)); |
| abort(); |
| } |
| return m_p[0]; |
| } |
| |
| BASISU_FORCE_INLINE const T& back() const |
| { |
| if(!m_size) |
| { |
| fprintf(stderr, "back: vector is empty, type size %u\n", (uint32_t)sizeof(T)); |
| abort(); |
| } |
| return m_p[m_size - 1]; |
| } |
| BASISU_FORCE_INLINE T& back() |
| { |
| if (!m_size) |
| { |
| fprintf(stderr, "back: vector is empty, type size %u\n", (uint32_t)sizeof(T)); |
| abort(); |
| } |
| return m_p[m_size - 1]; |
| } |
| #endif |
| |
| BASISU_FORCE_INLINE const T* get_ptr() const { return m_p; } |
| BASISU_FORCE_INLINE T* get_ptr() { return m_p; } |
| |
| BASISU_FORCE_INLINE const T* data() const { return m_p; } |
| BASISU_FORCE_INLINE T* data() { return m_p; } |
| |
| // clear() sets the container to empty, then frees the allocated block. |
| inline void clear() |
| { |
| if (m_p) |
| { |
| scalar_type<T>::destruct_array(m_p, m_size); |
| free(m_p); |
| m_p = NULL; |
| m_size = 0; |
| m_capacity = 0; |
| } |
| } |
| |
| inline void clear_no_destruction() |
| { |
| if (m_p) |
| { |
| free(m_p); |
| m_p = NULL; |
| m_size = 0; |
| m_capacity = 0; |
| } |
| } |
| |
| inline void reserve(size_t new_capacity_size_t) |
| { |
| if (new_capacity_size_t > UINT32_MAX) |
| { |
| assert(0); |
| return; |
| } |
| |
| uint32_t new_capacity = (uint32_t)new_capacity_size_t; |
| |
| if (new_capacity > m_capacity) |
| increase_capacity(new_capacity, false); |
| else if (new_capacity < m_capacity) |
| { |
| // Must work around the lack of a "decrease_capacity()" method. |
| // This case is rare enough in practice that it's probably not worth implementing an optimized in-place resize. |
| vector tmp; |
| tmp.increase_capacity(helpers::maximum(m_size, new_capacity), false); |
| tmp = *this; |
| swap(tmp); |
| } |
| } |
| |
| inline bool try_reserve(size_t new_capacity_size_t) |
| { |
| if (new_capacity_size_t > UINT32_MAX) |
| { |
| assert(0); |
| return false; |
| } |
| |
| uint32_t new_capacity = (uint32_t)new_capacity_size_t; |
| |
| if (new_capacity > m_capacity) |
| { |
| if (!increase_capacity(new_capacity, false)) |
| return false; |
| } |
| else if (new_capacity < m_capacity) |
| { |
| // Must work around the lack of a "decrease_capacity()" method. |
| // This case is rare enough in practice that it's probably not worth implementing an optimized in-place resize. |
| vector tmp; |
| tmp.increase_capacity(helpers::maximum(m_size, new_capacity), false); |
| tmp = *this; |
| swap(tmp); |
| } |
| |
| return true; |
| } |
| |
| // resize(0) sets the container to empty, but does not free the allocated block. |
| inline void resize(size_t new_size_size_t, bool grow_hint = false) |
| { |
| if (new_size_size_t > UINT32_MAX) |
| { |
| assert(0); |
| return; |
| } |
| |
| uint32_t new_size = (uint32_t)new_size_size_t; |
| |
| if (m_size != new_size) |
| { |
| if (new_size < m_size) |
| scalar_type<T>::destruct_array(m_p + new_size, m_size - new_size); |
| else |
| { |
| if (new_size > m_capacity) |
| increase_capacity(new_size, (new_size == (m_size + 1)) || grow_hint); |
| |
| scalar_type<T>::construct_array(m_p + m_size, new_size - m_size); |
| } |
| |
| m_size = new_size; |
| } |
| } |
| |
| inline bool try_resize(size_t new_size_size_t, bool grow_hint = false) |
| { |
| if (new_size_size_t > UINT32_MAX) |
| { |
| assert(0); |
| return false; |
| } |
| |
| uint32_t new_size = (uint32_t)new_size_size_t; |
| |
| if (m_size != new_size) |
| { |
| if (new_size < m_size) |
| scalar_type<T>::destruct_array(m_p + new_size, m_size - new_size); |
| else |
| { |
| if (new_size > m_capacity) |
| { |
| if (!increase_capacity(new_size, (new_size == (m_size + 1)) || grow_hint, true)) |
| return false; |
| } |
| |
| scalar_type<T>::construct_array(m_p + m_size, new_size - m_size); |
| } |
| |
| m_size = new_size; |
| } |
| |
| return true; |
| } |
| |
| // If size >= capacity/2, reset() sets the container's size to 0 but doesn't free the allocated block (because the container may be similarly loaded in the future). |
| // Otherwise it blows away the allocated block. See http://www.codercorner.com/blog/?p=494 |
| inline void reset() |
| { |
| if (m_size >= (m_capacity >> 1)) |
| resize(0); |
| else |
| clear(); |
| } |
| |
| inline T* enlarge(uint32_t i) |
| { |
| uint32_t cur_size = m_size; |
| resize(cur_size + i, true); |
| return get_ptr() + cur_size; |
| } |
| |
| inline T* try_enlarge(uint32_t i) |
| { |
| uint32_t cur_size = m_size; |
| if (!try_resize(cur_size + i, true)) |
| return NULL; |
| return get_ptr() + cur_size; |
| } |
| |
| BASISU_FORCE_INLINE void push_back(const T& obj) |
| { |
| assert(!m_p || (&obj < m_p) || (&obj >= (m_p + m_size))); |
| |
| if (m_size >= m_capacity) |
| increase_capacity(m_size + 1, true); |
| |
| scalar_type<T>::construct(m_p + m_size, obj); |
| m_size++; |
| } |
| |
| inline bool try_push_back(const T& obj) |
| { |
| assert(!m_p || (&obj < m_p) || (&obj >= (m_p + m_size))); |
| |
| if (m_size >= m_capacity) |
| { |
| if (!increase_capacity(m_size + 1, true, true)) |
| return false; |
| } |
| |
| scalar_type<T>::construct(m_p + m_size, obj); |
| m_size++; |
| |
| return true; |
| } |
| |
| inline void push_back_value(T obj) |
| { |
| if (m_size >= m_capacity) |
| increase_capacity(m_size + 1, true); |
| |
| scalar_type<T>::construct(m_p + m_size, obj); |
| m_size++; |
| } |
| |
| inline void pop_back() |
| { |
| assert(m_size); |
| |
| if (m_size) |
| { |
| m_size--; |
| scalar_type<T>::destruct(&m_p[m_size]); |
| } |
| } |
| |
| inline void insert(uint32_t index, const T* p, uint32_t n) |
| { |
| assert(index <= m_size); |
| if (!n) |
| return; |
| |
| const uint32_t orig_size = m_size; |
| resize(m_size + n, true); |
| |
| const uint32_t num_to_move = orig_size - index; |
| |
| if (BASISU_IS_BITWISE_COPYABLE(T)) |
| { |
| // This overwrites the destination object bits, but bitwise copyable means we don't need to worry about destruction. |
| memmove(m_p + index + n, m_p + index, sizeof(T) * num_to_move); |
| } |
| else |
| { |
| const T* pSrc = m_p + orig_size - 1; |
| T* pDst = const_cast<T*>(pSrc) + n; |
| |
| for (uint32_t i = 0; i < num_to_move; i++) |
| { |
| assert((pDst - m_p) < (int)m_size); |
| *pDst-- = *pSrc--; |
| } |
| } |
| |
| T* pDst = m_p + index; |
| |
| if (BASISU_IS_BITWISE_COPYABLE(T)) |
| { |
| // This copies in the new bits, overwriting the existing objects, which is OK for copyable types that don't need destruction. |
| memcpy(pDst, p, sizeof(T) * n); |
| } |
| else |
| { |
| for (uint32_t i = 0; i < n; i++) |
| { |
| assert((pDst - m_p) < (int)m_size); |
| *pDst++ = *p++; |
| } |
| } |
| } |
| |
| inline void insert(T* p, const T& obj) |
| { |
| int64_t ofs = p - begin(); |
| if ((ofs < 0) || (ofs > UINT32_MAX)) |
| { |
| assert(0); |
| return; |
| } |
| |
| insert((uint32_t)ofs, &obj, 1); |
| } |
| |
| // push_front() isn't going to be very fast - it's only here for usability. |
| inline void push_front(const T& obj) |
| { |
| insert(0, &obj, 1); |
| } |
| |
| vector& append(const vector& other) |
| { |
| if (other.m_size) |
| insert(m_size, &other[0], other.m_size); |
| return *this; |
| } |
| |
| vector& append(const T* p, uint32_t n) |
| { |
| if (n) |
| insert(m_size, p, n); |
| return *this; |
| } |
| |
| inline void erase(uint32_t start, uint32_t n) |
| { |
| assert((start + n) <= m_size); |
| if ((start + n) > m_size) |
| return; |
| |
| if (!n) |
| return; |
| |
| const uint32_t num_to_move = m_size - (start + n); |
| |
| T* pDst = m_p + start; |
| |
| const T* pSrc = m_p + start + n; |
| |
| if (BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(T)) |
| { |
| // This test is overly cautious. |
| if ((!BASISU_IS_BITWISE_COPYABLE(T)) || (BASISU_HAS_DESTRUCTOR(T))) |
| { |
| // Type has been marked explictly as bitwise movable, which means we can move them around but they may need to be destructed. |
| // First destroy the erased objects. |
| scalar_type<T>::destruct_array(pDst, n); |
| } |
| |
| // Copy "down" the objects to preserve, filling in the empty slots. |
| memmove(pDst, pSrc, num_to_move * sizeof(T)); |
| } |
| else |
| { |
| // Type is not bitwise copyable or movable. |
| // Move them down one at a time by using the equals operator, and destroying anything that's left over at the end. |
| T* pDst_end = pDst + num_to_move; |
| while (pDst != pDst_end) |
| *pDst++ = *pSrc++; |
| |
| scalar_type<T>::destruct_array(pDst_end, n); |
| } |
| |
| m_size -= n; |
| } |
| |
| inline void erase(uint32_t index) |
| { |
| erase(index, 1); |
| } |
| |
| inline void erase(T* p) |
| { |
| assert((p >= m_p) && (p < (m_p + m_size))); |
| erase(static_cast<uint32_t>(p - m_p)); |
| } |
| |
| inline void erase(T *pFirst, T *pEnd) |
| { |
| assert(pFirst <= pEnd); |
| assert(pFirst >= begin() && pFirst <= end()); |
| assert(pEnd >= begin() && pEnd <= end()); |
| |
| int64_t ofs = pFirst - begin(); |
| if ((ofs < 0) || (ofs > UINT32_MAX)) |
| { |
| assert(0); |
| return; |
| } |
| |
| int64_t n = pEnd - pFirst; |
| if ((n < 0) || (n > UINT32_MAX)) |
| { |
| assert(0); |
| return; |
| } |
| |
| erase((uint32_t)ofs, (uint32_t)n); |
| } |
| |
| void erase_unordered(uint32_t index) |
| { |
| assert(index < m_size); |
| |
| if ((index + 1) < m_size) |
| (*this)[index] = back(); |
| |
| pop_back(); |
| } |
| |
| inline bool operator== (const vector& rhs) const |
| { |
| if (m_size != rhs.m_size) |
| return false; |
| else if (m_size) |
| { |
| if (scalar_type<T>::cFlag) |
| return memcmp(m_p, rhs.m_p, sizeof(T) * m_size) == 0; |
| else |
| { |
| const T* pSrc = m_p; |
| const T* pDst = rhs.m_p; |
| for (uint32_t i = m_size; i; i--) |
| if (!(*pSrc++ == *pDst++)) |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| inline bool operator< (const vector& rhs) const |
| { |
| const uint32_t min_size = helpers::minimum(m_size, rhs.m_size); |
| |
| const T* pSrc = m_p; |
| const T* pSrc_end = m_p + min_size; |
| const T* pDst = rhs.m_p; |
| |
| while ((pSrc < pSrc_end) && (*pSrc == *pDst)) |
| { |
| pSrc++; |
| pDst++; |
| } |
| |
| if (pSrc < pSrc_end) |
| return *pSrc < *pDst; |
| |
| return m_size < rhs.m_size; |
| } |
| |
| inline void swap(vector& other) |
| { |
| std::swap(m_p, other.m_p); |
| std::swap(m_size, other.m_size); |
| std::swap(m_capacity, other.m_capacity); |
| } |
| |
| inline void sort() |
| { |
| std::sort(begin(), end()); |
| } |
| |
| inline void unique() |
| { |
| if (!empty()) |
| { |
| sort(); |
| |
| resize(std::unique(begin(), end()) - begin()); |
| } |
| } |
| |
| inline void reverse() |
| { |
| uint32_t j = m_size >> 1; |
| for (uint32_t i = 0; i < j; i++) |
| std::swap(m_p[i], m_p[m_size - 1 - i]); |
| } |
| |
| inline int find(const T& key) const |
| { |
| const T* p = m_p; |
| const T* p_end = m_p + m_size; |
| |
| uint32_t index = 0; |
| |
| while (p != p_end) |
| { |
| if (key == *p) |
| return index; |
| |
| p++; |
| index++; |
| } |
| |
| return cInvalidIndex; |
| } |
| |
| inline int find_sorted(const T& key) const |
| { |
| if (m_size) |
| { |
| // Uniform binary search - Knuth Algorithm 6.2.1 U, unrolled twice. |
| int i = ((m_size + 1) >> 1) - 1; |
| int m = m_size; |
| |
| for (; ; ) |
| { |
| assert(i >= 0 && i < (int)m_size); |
| const T* pKey_i = m_p + i; |
| int cmp = key < *pKey_i; |
| #if defined(_DEBUG) || defined(DEBUG) |
| int cmp2 = *pKey_i < key; |
| assert((cmp != cmp2) || (key == *pKey_i)); |
| #endif |
| if ((!cmp) && (key == *pKey_i)) return i; |
| m >>= 1; |
| if (!m) break; |
| cmp = -cmp; |
| i += (((m + 1) >> 1) ^ cmp) - cmp; |
| if (i < 0) |
| break; |
| |
| assert(i >= 0 && i < (int)m_size); |
| pKey_i = m_p + i; |
| cmp = key < *pKey_i; |
| #if defined(_DEBUG) || defined(DEBUG) |
| cmp2 = *pKey_i < key; |
| assert((cmp != cmp2) || (key == *pKey_i)); |
| #endif |
| if ((!cmp) && (key == *pKey_i)) return i; |
| m >>= 1; |
| if (!m) break; |
| cmp = -cmp; |
| i += (((m + 1) >> 1) ^ cmp) - cmp; |
| if (i < 0) |
| break; |
| } |
| } |
| |
| return cInvalidIndex; |
| } |
| |
| template<typename Q> |
| inline int find_sorted(const T& key, Q less_than) const |
| { |
| if (m_size) |
| { |
| // Uniform binary search - Knuth Algorithm 6.2.1 U, unrolled twice. |
| int i = ((m_size + 1) >> 1) - 1; |
| int m = m_size; |
| |
| for (; ; ) |
| { |
| assert(i >= 0 && i < (int)m_size); |
| const T* pKey_i = m_p + i; |
| int cmp = less_than(key, *pKey_i); |
| if ((!cmp) && (!less_than(*pKey_i, key))) return i; |
| m >>= 1; |
| if (!m) break; |
| cmp = -cmp; |
| i += (((m + 1) >> 1) ^ cmp) - cmp; |
| if (i < 0) |
| break; |
| |
| assert(i >= 0 && i < (int)m_size); |
| pKey_i = m_p + i; |
| cmp = less_than(key, *pKey_i); |
| if ((!cmp) && (!less_than(*pKey_i, key))) return i; |
| m >>= 1; |
| if (!m) break; |
| cmp = -cmp; |
| i += (((m + 1) >> 1) ^ cmp) - cmp; |
| if (i < 0) |
| break; |
| } |
| } |
| |
| return cInvalidIndex; |
| } |
| |
| inline uint32_t count_occurences(const T& key) const |
| { |
| uint32_t c = 0; |
| |
| const T* p = m_p; |
| const T* p_end = m_p + m_size; |
| |
| while (p != p_end) |
| { |
| if (key == *p) |
| c++; |
| |
| p++; |
| } |
| |
| return c; |
| } |
| |
| inline void set_all(const T& o) |
| { |
| if ((sizeof(T) == 1) && (scalar_type<T>::cFlag)) |
| memset(m_p, *reinterpret_cast<const uint8_t*>(&o), m_size); |
| else |
| { |
| T* pDst = m_p; |
| T* pDst_end = pDst + m_size; |
| while (pDst != pDst_end) |
| *pDst++ = o; |
| } |
| } |
| |
| // Caller assumes ownership of the heap block associated with the container. Container is cleared. |
| inline void* assume_ownership() |
| { |
| T* p = m_p; |
| m_p = NULL; |
| m_size = 0; |
| m_capacity = 0; |
| return p; |
| } |
| |
| // Caller is granting ownership of the indicated heap block. |
| // Block must have size constructed elements, and have enough room for capacity elements. |
| // The block must have been allocated using malloc(). |
| // Important: This method is used in Basis Universal. If you change how this container allocates memory, you'll need to change any users of this method. |
| inline bool grant_ownership(T* p, uint32_t size, uint32_t capacity) |
| { |
| // To to prevent the caller from obviously shooting themselves in the foot. |
| if (((p + capacity) > m_p) && (p < (m_p + m_capacity))) |
| { |
| // Can grant ownership of a block inside the container itself! |
| assert(0); |
| return false; |
| } |
| |
| if (size > capacity) |
| { |
| assert(0); |
| return false; |
| } |
| |
| if (!p) |
| { |
| if (capacity) |
| { |
| assert(0); |
| return false; |
| } |
| } |
| else if (!capacity) |
| { |
| assert(0); |
| return false; |
| } |
| |
| clear(); |
| m_p = p; |
| m_size = size; |
| m_capacity = capacity; |
| return true; |
| } |
| |
| private: |
| T* m_p; |
| uint32_t m_size; |
| uint32_t m_capacity; |
| |
| template<typename Q> struct is_vector { enum { cFlag = false }; }; |
| template<typename Q> struct is_vector< vector<Q> > { enum { cFlag = true }; }; |
| |
| static void object_mover(void* pDst_void, void* pSrc_void, uint32_t num) |
| { |
| T* pSrc = static_cast<T*>(pSrc_void); |
| T* const pSrc_end = pSrc + num; |
| T* pDst = static_cast<T*>(pDst_void); |
| |
| while (pSrc != pSrc_end) |
| { |
| // placement new |
| new (static_cast<void*>(pDst)) T(*pSrc); |
| pSrc->~T(); |
| ++pSrc; |
| ++pDst; |
| } |
| } |
| |
| inline bool increase_capacity(uint32_t min_new_capacity, bool grow_hint, bool nofail = false) |
| { |
| return reinterpret_cast<elemental_vector*>(this)->increase_capacity( |
| min_new_capacity, grow_hint, sizeof(T), |
| (BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(T) || (is_vector<T>::cFlag)) ? NULL : object_mover, nofail); |
| } |
| }; |
| |
| template<typename T> struct bitwise_movable< vector<T> > { enum { cFlag = true }; }; |
| |
| // Hash map |
| |
| template <typename T> |
| struct hasher |
| { |
| inline size_t operator() (const T& key) const { return static_cast<size_t>(key); } |
| }; |
| |
| template <typename T> |
| struct equal_to |
| { |
| inline bool operator()(const T& a, const T& b) const { return a == b; } |
| }; |
| |
| // Important: The Hasher and Equals objects must be bitwise movable! |
| template<typename Key, typename Value = empty_type, typename Hasher = hasher<Key>, typename Equals = equal_to<Key> > |
| class hash_map |
| { |
| public: |
| class iterator; |
| class const_iterator; |
| |
| private: |
| friend class iterator; |
| friend class const_iterator; |
| |
| enum state |
| { |
| cStateInvalid = 0, |
| cStateValid = 1 |
| }; |
| |
| enum |
| { |
| cMinHashSize = 4U |
| }; |
| |
| public: |
| typedef hash_map<Key, Value, Hasher, Equals> hash_map_type; |
| typedef std::pair<Key, Value> value_type; |
| typedef Key key_type; |
| typedef Value referent_type; |
| typedef Hasher hasher_type; |
| typedef Equals equals_type; |
| |
| hash_map() : |
| m_hash_shift(32), m_num_valid(0), m_grow_threshold(0) |
| { |
| } |
| |
| hash_map(const hash_map& other) : |
| m_values(other.m_values), |
| m_hash_shift(other.m_hash_shift), |
| m_hasher(other.m_hasher), |
| m_equals(other.m_equals), |
| m_num_valid(other.m_num_valid), |
| m_grow_threshold(other.m_grow_threshold) |
| { |
| } |
| |
| hash_map& operator= (const hash_map& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| clear(); |
| |
| m_values = other.m_values; |
| m_hash_shift = other.m_hash_shift; |
| m_num_valid = other.m_num_valid; |
| m_grow_threshold = other.m_grow_threshold; |
| m_hasher = other.m_hasher; |
| m_equals = other.m_equals; |
| |
| return *this; |
| } |
| |
| inline ~hash_map() |
| { |
| clear(); |
| } |
| |
| const Equals& get_equals() const { return m_equals; } |
| Equals& get_equals() { return m_equals; } |
| |
| void set_equals(const Equals& equals) { m_equals = equals; } |
| |
| const Hasher& get_hasher() const { return m_hasher; } |
| Hasher& get_hasher() { return m_hasher; } |
| |
| void set_hasher(const Hasher& hasher) { m_hasher = hasher; } |
| |
| inline void clear() |
| { |
| if (!m_values.empty()) |
| { |
| if (BASISU_HAS_DESTRUCTOR(Key) || BASISU_HAS_DESTRUCTOR(Value)) |
| { |
| node* p = &get_node(0); |
| node* p_end = p + m_values.size(); |
| |
| uint32_t num_remaining = m_num_valid; |
| while (p != p_end) |
| { |
| if (p->state) |
| { |
| destruct_value_type(p); |
| num_remaining--; |
| if (!num_remaining) |
| break; |
| } |
| |
| p++; |
| } |
| } |
| |
| m_values.clear_no_destruction(); |
| |
| m_hash_shift = 32; |
| m_num_valid = 0; |
| m_grow_threshold = 0; |
| } |
| } |
| |
| inline void reset() |
| { |
| if (!m_num_valid) |
| return; |
| |
| if (BASISU_HAS_DESTRUCTOR(Key) || BASISU_HAS_DESTRUCTOR(Value)) |
| { |
| node* p = &get_node(0); |
| node* p_end = p + m_values.size(); |
| |
| uint32_t num_remaining = m_num_valid; |
| while (p != p_end) |
| { |
| if (p->state) |
| { |
| destruct_value_type(p); |
| p->state = cStateInvalid; |
| |
| num_remaining--; |
| if (!num_remaining) |
| break; |
| } |
| |
| p++; |
| } |
| } |
| else if (sizeof(node) <= 32) |
| { |
| memset(&m_values[0], 0, m_values.size_in_bytes()); |
| } |
| else |
| { |
| node* p = &get_node(0); |
| node* p_end = p + m_values.size(); |
| |
| uint32_t num_remaining = m_num_valid; |
| while (p != p_end) |
| { |
| if (p->state) |
| { |
| p->state = cStateInvalid; |
| |
| num_remaining--; |
| if (!num_remaining) |
| break; |
| } |
| |
| p++; |
| } |
| } |
| |
| m_num_valid = 0; |
| } |
| |
| inline uint32_t size() |
| { |
| return m_num_valid; |
| } |
| |
| inline uint32_t get_table_size() |
| { |
| return m_values.size(); |
| } |
| |
| inline bool empty() |
| { |
| return !m_num_valid; |
| } |
| |
| inline void reserve(uint32_t new_capacity) |
| { |
| uint64_t new_hash_size = helpers::maximum(1U, new_capacity); |
| |
| new_hash_size = new_hash_size * 2ULL; |
| |
| if (!helpers::is_power_of_2(new_hash_size)) |
| new_hash_size = helpers::next_pow2(new_hash_size); |
| |
| new_hash_size = helpers::maximum<uint64_t>(cMinHashSize, new_hash_size); |
| |
| new_hash_size = helpers::minimum<uint64_t>(0x80000000UL, new_hash_size); |
| |
| if (new_hash_size > m_values.size()) |
| rehash((uint32_t)new_hash_size); |
| } |
| |
| class iterator |
| { |
| friend class hash_map<Key, Value, Hasher, Equals>; |
| friend class hash_map<Key, Value, Hasher, Equals>::const_iterator; |
| |
| public: |
| inline iterator() : m_pTable(NULL), m_index(0) { } |
| inline iterator(hash_map_type& table, uint32_t index) : m_pTable(&table), m_index(index) { } |
| inline iterator(const iterator& other) : m_pTable(other.m_pTable), m_index(other.m_index) { } |
| |
| inline iterator& operator= (const iterator& other) |
| { |
| m_pTable = other.m_pTable; |
| m_index = other.m_index; |
| return *this; |
| } |
| |
| // post-increment |
| inline iterator operator++(int) |
| { |
| iterator result(*this); |
| ++*this; |
| return result; |
| } |
| |
| // pre-increment |
| inline iterator& operator++() |
| { |
| probe(); |
| return *this; |
| } |
| |
| inline value_type& operator*() const { return *get_cur(); } |
| inline value_type* operator->() const { return get_cur(); } |
| |
| inline bool operator == (const iterator& b) const { return (m_pTable == b.m_pTable) && (m_index == b.m_index); } |
| inline bool operator != (const iterator& b) const { return !(*this == b); } |
| inline bool operator == (const const_iterator& b) const { return (m_pTable == b.m_pTable) && (m_index == b.m_index); } |
| inline bool operator != (const const_iterator& b) const { return !(*this == b); } |
| |
| private: |
| hash_map_type* m_pTable; |
| uint32_t m_index; |
| |
| inline value_type* get_cur() const |
| { |
| assert(m_pTable && (m_index < m_pTable->m_values.size())); |
| assert(m_pTable->get_node_state(m_index) == cStateValid); |
| |
| return &m_pTable->get_node(m_index); |
| } |
| |
| inline void probe() |
| { |
| assert(m_pTable); |
| m_index = m_pTable->find_next(m_index); |
| } |
| }; |
| |
| class const_iterator |
| { |
| friend class hash_map<Key, Value, Hasher, Equals>; |
| friend class hash_map<Key, Value, Hasher, Equals>::iterator; |
| |
| public: |
| inline const_iterator() : m_pTable(NULL), m_index(0) { } |
| inline const_iterator(const hash_map_type& table, uint32_t index) : m_pTable(&table), m_index(index) { } |
| inline const_iterator(const iterator& other) : m_pTable(other.m_pTable), m_index(other.m_index) { } |
| inline const_iterator(const const_iterator& other) : m_pTable(other.m_pTable), m_index(other.m_index) { } |
| |
| inline const_iterator& operator= (const const_iterator& other) |
| { |
| m_pTable = other.m_pTable; |
| m_index = other.m_index; |
| return *this; |
| } |
| |
| inline const_iterator& operator= (const iterator& other) |
| { |
| m_pTable = other.m_pTable; |
| m_index = other.m_index; |
| return *this; |
| } |
| |
| // post-increment |
| inline const_iterator operator++(int) |
| { |
| const_iterator result(*this); |
| ++*this; |
| return result; |
| } |
| |
| // pre-increment |
| inline const_iterator& operator++() |
| { |
| probe(); |
| return *this; |
| } |
| |
| inline const value_type& operator*() const { return *get_cur(); } |
| inline const value_type* operator->() const { return get_cur(); } |
| |
| inline bool operator == (const const_iterator& b) const { return (m_pTable == b.m_pTable) && (m_index == b.m_index); } |
| inline bool operator != (const const_iterator& b) const { return !(*this == b); } |
| inline bool operator == (const iterator& b) const { return (m_pTable == b.m_pTable) && (m_index == b.m_index); } |
| inline bool operator != (const iterator& b) const { return !(*this == b); } |
| |
| private: |
| const hash_map_type* m_pTable; |
| uint32_t m_index; |
| |
| inline const value_type* get_cur() const |
| { |
| assert(m_pTable && (m_index < m_pTable->m_values.size())); |
| assert(m_pTable->get_node_state(m_index) == cStateValid); |
| |
| return &m_pTable->get_node(m_index); |
| } |
| |
| inline void probe() |
| { |
| assert(m_pTable); |
| m_index = m_pTable->find_next(m_index); |
| } |
| }; |
| |
| inline const_iterator begin() const |
| { |
| if (!m_num_valid) |
| return end(); |
| |
| return const_iterator(*this, find_next(UINT32_MAX)); |
| } |
| |
| inline const_iterator end() const |
| { |
| return const_iterator(*this, m_values.size()); |
| } |
| |
| inline iterator begin() |
| { |
| if (!m_num_valid) |
| return end(); |
| |
| return iterator(*this, find_next(UINT32_MAX)); |
| } |
| |
| inline iterator end() |
| { |
| return iterator(*this, m_values.size()); |
| } |
| |
| // insert_result.first will always point to inserted key/value (or the already existing key/value). |
| // insert_resutt.second will be true if a new key/value was inserted, or false if the key already existed (in which case first will point to the already existing value). |
| typedef std::pair<iterator, bool> insert_result; |
| |
| inline insert_result insert(const Key& k, const Value& v = Value()) |
| { |
| insert_result result; |
| if (!insert_no_grow(result, k, v)) |
| { |
| grow(); |
| |
| // This must succeed. |
| if (!insert_no_grow(result, k, v)) |
| { |
| fprintf(stderr, "insert() failed"); |
| abort(); |
| } |
| } |
| |
| return result; |
| } |
| |
| inline insert_result insert(const value_type& v) |
| { |
| return insert(v.first, v.second); |
| } |
| |
| inline const_iterator find(const Key& k) const |
| { |
| return const_iterator(*this, find_index(k)); |
| } |
| |
| inline iterator find(const Key& k) |
| { |
| return iterator(*this, find_index(k)); |
| } |
| |
| inline bool erase(const Key& k) |
| { |
| uint32_t i = find_index(k); |
| |
| if (i >= m_values.size()) |
| return false; |
| |
| node* pDst = &get_node(i); |
| destruct_value_type(pDst); |
| pDst->state = cStateInvalid; |
| |
| m_num_valid--; |
| |
| for (; ; ) |
| { |
| uint32_t r, j = i; |
| |
| node* pSrc = pDst; |
| |
| do |
| { |
| if (!i) |
| { |
| i = m_values.size() - 1; |
| pSrc = &get_node(i); |
| } |
| else |
| { |
| i--; |
| pSrc--; |
| } |
| |
| if (!pSrc->state) |
| return true; |
| |
| r = hash_key(pSrc->first); |
| |
| } while ((i <= r && r < j) || (r < j && j < i) || (j < i && i <= r)); |
| |
| move_node(pDst, pSrc); |
| |
| pDst = pSrc; |
| } |
| } |
| |
| inline void swap(hash_map_type& other) |
| { |
| m_values.swap(other.m_values); |
| std::swap(m_hash_shift, other.m_hash_shift); |
| std::swap(m_num_valid, other.m_num_valid); |
| std::swap(m_grow_threshold, other.m_grow_threshold); |
| std::swap(m_hasher, other.m_hasher); |
| std::swap(m_equals, other.m_equals); |
| } |
| |
| private: |
| struct node : public value_type |
| { |
| uint8_t state; |
| }; |
| |
| static inline void construct_value_type(value_type* pDst, const Key& k, const Value& v) |
| { |
| if (BASISU_IS_BITWISE_COPYABLE(Key)) |
| memcpy(&pDst->first, &k, sizeof(Key)); |
| else |
| scalar_type<Key>::construct(&pDst->first, k); |
| |
| if (BASISU_IS_BITWISE_COPYABLE(Value)) |
| memcpy(&pDst->second, &v, sizeof(Value)); |
| else |
| scalar_type<Value>::construct(&pDst->second, v); |
| } |
| |
| static inline void construct_value_type(value_type* pDst, const value_type* pSrc) |
| { |
| if ((BASISU_IS_BITWISE_COPYABLE(Key)) && (BASISU_IS_BITWISE_COPYABLE(Value))) |
| { |
| memcpy(pDst, pSrc, sizeof(value_type)); |
| } |
| else |
| { |
| if (BASISU_IS_BITWISE_COPYABLE(Key)) |
| memcpy(&pDst->first, &pSrc->first, sizeof(Key)); |
| else |
| scalar_type<Key>::construct(&pDst->first, pSrc->first); |
| |
| if (BASISU_IS_BITWISE_COPYABLE(Value)) |
| memcpy(&pDst->second, &pSrc->second, sizeof(Value)); |
| else |
| scalar_type<Value>::construct(&pDst->second, pSrc->second); |
| } |
| } |
| |
| static inline void destruct_value_type(value_type* p) |
| { |
| scalar_type<Key>::destruct(&p->first); |
| scalar_type<Value>::destruct(&p->second); |
| } |
| |
| // Moves *pSrc to *pDst efficiently. |
| // pDst should NOT be constructed on entry. |
| static inline void move_node(node* pDst, node* pSrc, bool update_src_state = true) |
| { |
| assert(!pDst->state); |
| |
| if (BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(Key) && BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(Value)) |
| { |
| memcpy(pDst, pSrc, sizeof(node)); |
| } |
| else |
| { |
| if (BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(Key)) |
| memcpy(&pDst->first, &pSrc->first, sizeof(Key)); |
| else |
| { |
| scalar_type<Key>::construct(&pDst->first, pSrc->first); |
| scalar_type<Key>::destruct(&pSrc->first); |
| } |
| |
| if (BASISU_IS_BITWISE_COPYABLE_OR_MOVABLE(Value)) |
| memcpy(&pDst->second, &pSrc->second, sizeof(Value)); |
| else |
| { |
| scalar_type<Value>::construct(&pDst->second, pSrc->second); |
| scalar_type<Value>::destruct(&pSrc->second); |
| } |
| |
| pDst->state = cStateValid; |
| } |
| |
| if (update_src_state) |
| pSrc->state = cStateInvalid; |
| } |
| |
| struct raw_node |
| { |
| inline raw_node() |
| { |
| node* p = reinterpret_cast<node*>(this); |
| p->state = cStateInvalid; |
| } |
| |
| inline ~raw_node() |
| { |
| node* p = reinterpret_cast<node*>(this); |
| if (p->state) |
| hash_map_type::destruct_value_type(p); |
| } |
| |
| inline raw_node(const raw_node& other) |
| { |
| node* pDst = reinterpret_cast<node*>(this); |
| const node* pSrc = reinterpret_cast<const node*>(&other); |
| |
| if (pSrc->state) |
| { |
| hash_map_type::construct_value_type(pDst, pSrc); |
| pDst->state = cStateValid; |
| } |
| else |
| pDst->state = cStateInvalid; |
| } |
| |
| inline raw_node& operator= (const raw_node& rhs) |
| { |
| if (this == &rhs) |
| return *this; |
| |
| node* pDst = reinterpret_cast<node*>(this); |
| const node* pSrc = reinterpret_cast<const node*>(&rhs); |
| |
| if (pSrc->state) |
| { |
| if (pDst->state) |
| { |
| pDst->first = pSrc->first; |
| pDst->second = pSrc->second; |
| } |
| else |
| { |
| hash_map_type::construct_value_type(pDst, pSrc); |
| pDst->state = cStateValid; |
| } |
| } |
| else if (pDst->state) |
| { |
| hash_map_type::destruct_value_type(pDst); |
| pDst->state = cStateInvalid; |
| } |
| |
| return *this; |
| } |
| |
| uint8_t m_bits[sizeof(node)]; |
| }; |
| |
| typedef basisu::vector<raw_node> node_vector; |
| |
| node_vector m_values; |
| uint32_t m_hash_shift; |
| |
| Hasher m_hasher; |
| Equals m_equals; |
| |
| uint32_t m_num_valid; |
| |
| uint32_t m_grow_threshold; |
| |
| inline uint32_t hash_key(const Key& k) const |
| { |
| assert((1U << (32U - m_hash_shift)) == m_values.size()); |
| |
| uint32_t hash = static_cast<uint32_t>(m_hasher(k)); |
| |
| // Fibonacci hashing |
| hash = (2654435769U * hash) >> m_hash_shift; |
| |
| assert(hash < m_values.size()); |
| return hash; |
| } |
| |
| inline const node& get_node(uint32_t index) const |
| { |
| return *reinterpret_cast<const node*>(&m_values[index]); |
| } |
| |
| inline node& get_node(uint32_t index) |
| { |
| return *reinterpret_cast<node*>(&m_values[index]); |
| } |
| |
| inline state get_node_state(uint32_t index) const |
| { |
| return static_cast<state>(get_node(index).state); |
| } |
| |
| inline void set_node_state(uint32_t index, bool valid) |
| { |
| get_node(index).state = valid; |
| } |
| |
| inline void grow() |
| { |
| uint64_t n = m_values.size() * 3ULL; // was * 2 |
| |
| if (!helpers::is_power_of_2(n)) |
| n = helpers::next_pow2(n); |
| |
| if (n > 0x80000000UL) |
| n = 0x80000000UL; |
| |
| rehash(helpers::maximum<uint32_t>(cMinHashSize, (uint32_t)n)); |
| } |
| |
| inline void rehash(uint32_t new_hash_size) |
| { |
| assert(new_hash_size >= m_num_valid); |
| assert(helpers::is_power_of_2(new_hash_size)); |
| |
| if ((new_hash_size < m_num_valid) || (new_hash_size == m_values.size())) |
| return; |
| |
| hash_map new_map; |
| new_map.m_values.resize(new_hash_size); |
| new_map.m_hash_shift = 32U - helpers::floor_log2i(new_hash_size); |
| assert(new_hash_size == (1U << (32U - new_map.m_hash_shift))); |
| new_map.m_grow_threshold = UINT_MAX; |
| |
| node* pNode = reinterpret_cast<node*>(m_values.begin()); |
| node* pNode_end = pNode + m_values.size(); |
| |
| while (pNode != pNode_end) |
| { |
| if (pNode->state) |
| { |
| new_map.move_into(pNode); |
| |
| if (new_map.m_num_valid == m_num_valid) |
| break; |
| } |
| |
| pNode++; |
| } |
| |
| new_map.m_grow_threshold = (new_hash_size + 1U) >> 1U; |
| |
| m_values.clear_no_destruction(); |
| m_hash_shift = 32; |
| |
| swap(new_map); |
| } |
| |
| inline uint32_t find_next(uint32_t index) const |
| { |
| index++; |
| |
| if (index >= m_values.size()) |
| return index; |
| |
| const node* pNode = &get_node(index); |
| |
| for (; ; ) |
| { |
| if (pNode->state) |
| break; |
| |
| if (++index >= m_values.size()) |
| break; |
| |
| pNode++; |
| } |
| |
| return index; |
| } |
| |
| inline uint32_t find_index(const Key& k) const |
| { |
| if (m_num_valid) |
| { |
| uint32_t index = hash_key(k); |
| const node* pNode = &get_node(index); |
| |
| if (pNode->state) |
| { |
| if (m_equals(pNode->first, k)) |
| return index; |
| |
| const uint32_t orig_index = index; |
| |
| for (; ; ) |
| { |
| if (!index) |
| { |
| index = m_values.size() - 1; |
| pNode = &get_node(index); |
| } |
| else |
| { |
| index--; |
| pNode--; |
| } |
| |
| if (index == orig_index) |
| break; |
| |
| if (!pNode->state) |
| break; |
| |
| if (m_equals(pNode->first, k)) |
| return index; |
| } |
| } |
| } |
| |
| return m_values.size(); |
| } |
| |
| inline bool insert_no_grow(insert_result& result, const Key& k, const Value& v = Value()) |
| { |
| if (!m_values.size()) |
| return false; |
| |
| uint32_t index = hash_key(k); |
| node* pNode = &get_node(index); |
| |
| if (pNode->state) |
| { |
| if (m_equals(pNode->first, k)) |
| { |
| result.first = iterator(*this, index); |
| result.second = false; |
| return true; |
| } |
| |
| const uint32_t orig_index = index; |
| |
| for (; ; ) |
| { |
| if (!index) |
| { |
| index = m_values.size() - 1; |
| pNode = &get_node(index); |
| } |
| else |
| { |
| index--; |
| pNode--; |
| } |
| |
| if (orig_index == index) |
| return false; |
| |
| if (!pNode->state) |
| break; |
| |
| if (m_equals(pNode->first, k)) |
| { |
| result.first = iterator(*this, index); |
| result.second = false; |
| return true; |
| } |
| } |
| } |
| |
| if (m_num_valid >= m_grow_threshold) |
| return false; |
| |
| construct_value_type(pNode, k, v); |
| |
| pNode->state = cStateValid; |
| |
| m_num_valid++; |
| assert(m_num_valid <= m_values.size()); |
| |
| result.first = iterator(*this, index); |
| result.second = true; |
| |
| return true; |
| } |
| |
| inline void move_into(node* pNode) |
| { |
| uint32_t index = hash_key(pNode->first); |
| node* pDst_node = &get_node(index); |
| |
| if (pDst_node->state) |
| { |
| const uint32_t orig_index = index; |
| |
| for (; ; ) |
| { |
| if (!index) |
| { |
| index = m_values.size() - 1; |
| pDst_node = &get_node(index); |
| } |
| else |
| { |
| index--; |
| pDst_node--; |
| } |
| |
| if (index == orig_index) |
| { |
| assert(false); |
| return; |
| } |
| |
| if (!pDst_node->state) |
| break; |
| } |
| } |
| |
| move_node(pDst_node, pNode, false); |
| |
| m_num_valid++; |
| } |
| }; |
| |
| template<typename Key, typename Value, typename Hasher, typename Equals> |
| struct bitwise_movable< hash_map<Key, Value, Hasher, Equals> > { enum { cFlag = true }; }; |
| |
| #if BASISU_HASHMAP_TEST |
| extern void hash_map_test(); |
| #endif |
| |
| } // namespace basisu |
| |
| namespace std |
| { |
| template<typename T> |
| inline void swap(basisu::vector<T>& a, basisu::vector<T>& b) |
| { |
| a.swap(b); |
| } |
| |
| template<typename Key, typename Value, typename Hasher, typename Equals> |
| inline void swap(basisu::hash_map<Key, Value, Hasher, Equals>& a, basisu::hash_map<Key, Value, Hasher, Equals>& b) |
| { |
| a.swap(b); |
| } |
| |
| } // namespace std |
| /**** ended inlining basisu_containers.h ****/ |
| |
| #ifdef max |
| #undef max |
| #endif |
| |
| #ifdef min |
| #undef min |
| #endif |
| |
| #ifdef _WIN32 |
| #define strcasecmp _stricmp |
| #endif |
| |
| // Set to one to enable debug printf()'s when any errors occur, for development/debugging. Especially useful for WebGL development. |
| #ifndef BASISU_FORCE_DEVEL_MESSAGES |
| #define BASISU_FORCE_DEVEL_MESSAGES 0 |
| #endif |
| |
| #define BASISU_NOTE_UNUSED(x) (void)(x) |
| #define BASISU_ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) |
| #define BASISU_NO_EQUALS_OR_COPY_CONSTRUCT(x) x(const x &) = delete; x& operator= (const x &) = delete; |
| #define BASISU_ASSUME(x) static_assert(x, #x); |
| #define BASISU_OFFSETOF(s, m) offsetof(s, m) |
| #define BASISU_STRINGIZE(x) #x |
| #define BASISU_STRINGIZE2(x) BASISU_STRINGIZE(x) |
| |
| #if BASISU_FORCE_DEVEL_MESSAGES |
| #define BASISU_DEVEL_ERROR(...) do { basisu::debug_printf(__VA_ARGS__); } while(0) |
| #else |
| #define BASISU_DEVEL_ERROR(...) |
| #endif |
| |
| namespace basisu |
| { |
| // Types/utilities |
| |
| #ifdef _WIN32 |
| const char BASISU_PATH_SEPERATOR_CHAR = '\\'; |
| #else |
| const char BASISU_PATH_SEPERATOR_CHAR = '/'; |
| #endif |
| |
| typedef basisu::vector<uint8_t> uint8_vec; |
| typedef basisu::vector<int16_t> int16_vec; |
| typedef basisu::vector<uint16_t> uint16_vec; |
| typedef basisu::vector<uint32_t> uint_vec; |
| typedef basisu::vector<uint64_t> uint64_vec; |
| typedef basisu::vector<int> int_vec; |
| typedef basisu::vector<bool> bool_vec; |
| |
| void enable_debug_printf(bool enabled); |
| void debug_printf(const char *pFmt, ...); |
| |
| |
| template <typename T> inline void clear_obj(T& obj) { memset(&obj, 0, sizeof(obj)); } |
| |
| template <typename T0, typename T1> inline T0 lerp(T0 a, T0 b, T1 c) { return a + (b - a) * c; } |
| |
| template <typename S> inline S maximum(S a, S b) { return (a > b) ? a : b; } |
| template <typename S> inline S maximum(S a, S b, S c) { return maximum(maximum(a, b), c); } |
| template <typename S> inline S maximum(S a, S b, S c, S d) { return maximum(maximum(maximum(a, b), c), d); } |
| |
| template <typename S> inline S minimum(S a, S b) { return (a < b) ? a : b; } |
| template <typename S> inline S minimum(S a, S b, S c) { return minimum(minimum(a, b), c); } |
| template <typename S> inline S minimum(S a, S b, S c, S d) { return minimum(minimum(minimum(a, b), c), d); } |
| |
| inline float clampf(float value, float low, float high) { if (value < low) value = low; else if (value > high) value = high; return value; } |
| inline float saturate(float value) { return clampf(value, 0, 1.0f); } |
| inline uint8_t minimumub(uint8_t a, uint8_t b) { return (a < b) ? a : b; } |
| inline uint32_t minimumu(uint32_t a, uint32_t b) { return (a < b) ? a : b; } |
| inline int32_t minimumi(int32_t a, int32_t b) { return (a < b) ? a : b; } |
| inline float minimumf(float a, float b) { return (a < b) ? a : b; } |
| inline uint8_t maximumub(uint8_t a, uint8_t b) { return (a > b) ? a : b; } |
| inline uint32_t maximumu(uint32_t a, uint32_t b) { return (a > b) ? a : b; } |
| inline int32_t maximumi(int32_t a, int32_t b) { return (a > b) ? a : b; } |
| inline float maximumf(float a, float b) { return (a > b) ? a : b; } |
| inline int squarei(int i) { return i * i; } |
| inline float squaref(float i) { return i * i; } |
| template<typename T> inline T square(T a) { return a * a; } |
| |
| template <typename S> inline S clamp(S value, S low, S high) { return (value < low) ? low : ((value > high) ? high : value); } |
| |
| inline uint32_t iabs(int32_t i) { return (i < 0) ? static_cast<uint32_t>(-i) : static_cast<uint32_t>(i); } |
| inline uint64_t iabs64(int64_t i) { return (i < 0) ? static_cast<uint64_t>(-i) : static_cast<uint64_t>(i); } |
| |
| template<typename T> inline void clear_vector(T &vec) { vec.erase(vec.begin(), vec.end()); } |
| template<typename T> inline typename T::value_type *enlarge_vector(T &vec, size_t n) { size_t cs = vec.size(); vec.resize(cs + n); return &vec[cs]; } |
| |
| inline bool is_pow2(uint32_t x) { return x && ((x & (x - 1U)) == 0U); } |
| inline bool is_pow2(uint64_t x) { return x && ((x & (x - 1U)) == 0U); } |
| |
| template<typename T> inline T open_range_check(T v, T minv, T maxv) { assert(v >= minv && v < maxv); BASISU_NOTE_UNUSED(minv); BASISU_NOTE_UNUSED(maxv); return v; } |
| template<typename T> inline T open_range_check(T v, T maxv) { assert(v < maxv); BASISU_NOTE_UNUSED(maxv); return v; } |
| |
| inline uint32_t total_bits(uint32_t v) { uint32_t l = 0; for ( ; v > 0U; ++l) v >>= 1; return l; } |
| |
| template<typename T> inline T saturate(T val) { return clamp(val, 0.0f, 1.0f); } |
| |
| template<typename T, typename R> inline void append_vector(T &vec, const R *pObjs, size_t n) |
| { |
| if (n) |
| { |
| if (vec.size()) |
| { |
| assert((pObjs + n) <= vec.begin() || (pObjs >= vec.end())); |
| } |
| const size_t cur_s = vec.size(); |
| vec.resize(cur_s + n); |
| memcpy(&vec[cur_s], pObjs, sizeof(R) * n); |
| } |
| } |
| |
| template<typename T> inline void append_vector(T &vec, const T &other_vec) |
| { |
| assert(&vec != &other_vec); |
| if (other_vec.size()) |
| append_vector(vec, &other_vec[0], other_vec.size()); |
| } |
| |
| template<typename T> inline void vector_ensure_element_is_valid(T &vec, size_t idx) |
| { |
| if (idx >= vec.size()) |
| vec.resize(idx + 1); |
| } |
| |
| template<typename T> inline void vector_sort(T &vec) |
| { |
| if (vec.size()) |
| std::sort(vec.begin(), vec.end()); |
| } |
| |
| template<typename T, typename U> inline bool unordered_set_contains(T& set, const U&obj) |
| { |
| return set.find(obj) != set.end(); |
| } |
| |
| template<typename T> int vector_find(const T &vec, const typename T::value_type &obj) |
| { |
| assert(vec.size() <= INT_MAX); |
| for (size_t i = 0; i < vec.size(); i++) |
| if (vec[i] == obj) |
| return static_cast<int>(i); |
| return -1; |
| } |
| |
| template<typename T> void vector_set_all(T &vec, const typename T::value_type &obj) |
| { |
| for (size_t i = 0; i < vec.size(); i++) |
| vec[i] = obj; |
| } |
| |
| inline uint64_t read_be64(const void *p) |
| { |
| uint64_t val = 0; |
| for (uint32_t i = 0; i < 8; i++) |
| val |= (static_cast<uint64_t>(static_cast<const uint8_t *>(p)[7 - i]) << (i * 8)); |
| return val; |
| } |
| |
| inline void write_be64(void *p, uint64_t x) |
| { |
| for (uint32_t i = 0; i < 8; i++) |
| static_cast<uint8_t *>(p)[7 - i] = static_cast<uint8_t>(x >> (i * 8)); |
| } |
| |
| static inline uint16_t byteswap16(uint16_t x) { return static_cast<uint16_t>((x << 8) | (x >> 8)); } |
| static inline uint32_t byteswap32(uint32_t x) { return ((x << 24) | ((x << 8) & 0x00FF0000) | ((x >> 8) & 0x0000FF00) | (x >> 24)); } |
| |
| inline uint32_t floor_log2i(uint32_t v) |
| { |
| uint32_t b = 0; |
| for (; v > 1U; ++b) |
| v >>= 1; |
| return b; |
| } |
| |
| inline uint32_t ceil_log2i(uint32_t v) |
| { |
| uint32_t b = floor_log2i(v); |
| if ((b != 32) && (v > (1U << b))) |
| ++b; |
| return b; |
| } |
| |
| inline int posmod(int x, int y) |
| { |
| if (x >= 0) |
| return (x < y) ? x : (x % y); |
| int m = (-x) % y; |
| return (m != 0) ? (y - m) : m; |
| } |
| |
| inline bool do_excl_ranges_overlap(int la, int ha, int lb, int hb) |
| { |
| assert(la < ha && lb < hb); |
| if ((ha <= lb) || (la >= hb)) return false; |
| return true; |
| } |
| |
| static inline uint32_t read_le_dword(const uint8_t *pBytes) |
| { |
| return (pBytes[3] << 24U) | (pBytes[2] << 16U) | (pBytes[1] << 8U) | (pBytes[0]); |
| } |
| |
| static inline void write_le_dword(uint8_t* pBytes, uint32_t val) |
| { |
| pBytes[0] = (uint8_t)val; |
| pBytes[1] = (uint8_t)(val >> 8U); |
| pBytes[2] = (uint8_t)(val >> 16U); |
| pBytes[3] = (uint8_t)(val >> 24U); |
| } |
| |
| // Always little endian 1-8 byte unsigned int |
| template<uint32_t NumBytes> |
| struct packed_uint |
| { |
| uint8_t m_bytes[NumBytes]; |
| |
| inline packed_uint() { static_assert(NumBytes <= sizeof(uint64_t), "Invalid NumBytes"); } |
| inline packed_uint(uint64_t v) { *this = v; } |
| inline packed_uint(const packed_uint& other) { *this = other; } |
| |
| inline packed_uint& operator= (uint64_t v) |
| { |
| for (uint32_t i = 0; i < NumBytes; i++) |
| m_bytes[i] = static_cast<uint8_t>(v >> (i * 8)); |
| return *this; |
| } |
| |
| inline packed_uint& operator= (const packed_uint& rhs) |
| { |
| memcpy(m_bytes, rhs.m_bytes, sizeof(m_bytes)); |
| return *this; |
| } |
| |
| inline operator uint32_t() const |
| { |
| switch (NumBytes) |
| { |
| case 1: |
| { |
| return m_bytes[0]; |
| } |
| case 2: |
| { |
| return (m_bytes[1] << 8U) | m_bytes[0]; |
| } |
| case 3: |
| { |
| return (m_bytes[2] << 16U) | (m_bytes[1] << 8U) | m_bytes[0]; |
| } |
| case 4: |
| { |
| return read_le_dword(m_bytes); |
| } |
| case 5: |
| { |
| uint32_t l = read_le_dword(m_bytes); |
| uint32_t h = m_bytes[4]; |
| return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U); |
| } |
| case 6: |
| { |
| uint32_t l = read_le_dword(m_bytes); |
| uint32_t h = (m_bytes[5] << 8U) | m_bytes[4]; |
| return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U); |
| } |
| case 7: |
| { |
| uint32_t l = read_le_dword(m_bytes); |
| uint32_t h = (m_bytes[6] << 16U) | (m_bytes[5] << 8U) | m_bytes[4]; |
| return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U); |
| } |
| case 8: |
| { |
| uint32_t l = read_le_dword(m_bytes); |
| uint32_t h = read_le_dword(m_bytes + 4); |
| return static_cast<uint64_t>(l) | (static_cast<uint64_t>(h) << 32U); |
| } |
| default: |
| { |
| assert(0); |
| return 0; |
| } |
| } |
| } |
| }; |
| |
| enum eZero { cZero }; |
| enum eNoClamp { cNoClamp }; |
| |
| // Rice/Huffman entropy coding |
| |
| // This is basically Deflate-style canonical Huffman, except we allow for a lot more symbols. |
| enum |
| { |
| cHuffmanMaxSupportedCodeSize = 16, cHuffmanMaxSupportedInternalCodeSize = 31, |
| cHuffmanFastLookupBits = 10, |
| cHuffmanMaxSymsLog2 = 14, cHuffmanMaxSyms = 1 << cHuffmanMaxSymsLog2, |
| |
| // Small zero runs |
| cHuffmanSmallZeroRunSizeMin = 3, cHuffmanSmallZeroRunSizeMax = 10, cHuffmanSmallZeroRunExtraBits = 3, |
| |
| // Big zero run |
| cHuffmanBigZeroRunSizeMin = 11, cHuffmanBigZeroRunSizeMax = 138, cHuffmanBigZeroRunExtraBits = 7, |
| |
| // Small non-zero run |
| cHuffmanSmallRepeatSizeMin = 3, cHuffmanSmallRepeatSizeMax = 6, cHuffmanSmallRepeatExtraBits = 2, |
| |
| // Big non-zero run |
| cHuffmanBigRepeatSizeMin = 7, cHuffmanBigRepeatSizeMax = 134, cHuffmanBigRepeatExtraBits = 7, |
| |
| cHuffmanTotalCodelengthCodes = 21, cHuffmanSmallZeroRunCode = 17, cHuffmanBigZeroRunCode = 18, cHuffmanSmallRepeatCode = 19, cHuffmanBigRepeatCode = 20 |
| }; |
| |
| static const uint8_t g_huffman_sorted_codelength_codes[] = { cHuffmanSmallZeroRunCode, cHuffmanBigZeroRunCode, cHuffmanSmallRepeatCode, cHuffmanBigRepeatCode, 0, 8, 7, 9, 6, 0xA, 5, 0xB, 4, 0xC, 3, 0xD, 2, 0xE, 1, 0xF, 0x10 }; |
| const uint32_t cHuffmanTotalSortedCodelengthCodes = sizeof(g_huffman_sorted_codelength_codes) / sizeof(g_huffman_sorted_codelength_codes[0]); |
| |
| // GPU texture formats |
| |
| enum class texture_format |
| { |
| cInvalidTextureFormat = -1, |
| |
| // Block-based formats |
| cETC1, // ETC1 |
| cETC1S, // ETC1 (subset: diff colors only, no subblocks) |
| cETC2_RGB, // ETC2 color block (basisu doesn't support ETC2 planar/T/H modes - just basic ETC1) |
| cETC2_RGBA, // ETC2 EAC alpha block followed by ETC2 color block |
| cETC2_ALPHA, // ETC2 EAC alpha block |
| cBC1, // DXT1 |
| cBC3, // DXT5 (BC4/DXT5A block followed by a BC1/DXT1 block) |
| cBC4, // DXT5A |
| cBC5, // 3DC/DXN (two BC4/DXT5A blocks) |
| cBC7, |
| cASTC4x4, // LDR only |
| cPVRTC1_4_RGB, |
| cPVRTC1_4_RGBA, |
| cATC_RGB, |
| cATC_RGBA_INTERPOLATED_ALPHA, |
| cFXT1_RGB, |
| cPVRTC2_4_RGBA, |
| cETC2_R11_EAC, |
| cETC2_RG11_EAC, |
| cUASTC4x4, |
| cBC1_NV, |
| cBC1_AMD, |
| |
| // Uncompressed/raw pixels |
| cRGBA32, |
| cRGB565, |
| cBGR565, |
| cRGBA4444, |
| cABGR4444 |
| }; |
| |
| inline uint32_t get_bytes_per_block(texture_format fmt) |
| { |
| switch (fmt) |
| { |
| case texture_format::cETC1: |
| case texture_format::cETC1S: |
| case texture_format::cETC2_RGB: |
| case texture_format::cETC2_ALPHA: |
| case texture_format::cBC1: |
| case texture_format::cBC1_NV: |
| case texture_format::cBC1_AMD: |
| case texture_format::cBC4: |
| case texture_format::cPVRTC1_4_RGB: |
| case texture_format::cPVRTC1_4_RGBA: |
| case texture_format::cATC_RGB: |
| case texture_format::cPVRTC2_4_RGBA: |
| case texture_format::cETC2_R11_EAC: |
| return 8; |
| case texture_format::cRGBA32: |
| return sizeof(uint32_t) * 16; |
| default: |
| break; |
| } |
| return 16; |
| } |
| |
| inline uint32_t get_qwords_per_block(texture_format fmt) |
| { |
| return get_bytes_per_block(fmt) >> 3; |
| } |
| |
| inline uint32_t get_block_width(texture_format fmt) |
| { |
| BASISU_NOTE_UNUSED(fmt); |
| switch (fmt) |
| { |
| case texture_format::cFXT1_RGB: |
| return 8; |
| default: |
| break; |
| } |
| return 4; |
| } |
| |
| inline uint32_t get_block_height(texture_format fmt) |
| { |
| BASISU_NOTE_UNUSED(fmt); |
| return 4; |
| } |
| |
| } // namespace basisu |
| |
| /**** ended inlining basisu.h ****/ |
| |
| #define BASISD_znew (z = 36969 * (z & 65535) + (z >> 16)) |
| |
| namespace basisu |
| { |
| extern bool g_debug_printf; |
| } |
| |
| namespace basist |
| { |
| // Low-level formats directly supported by the transcoder (other supported texture formats are combinations of these low-level block formats). |
| // You probably don't care about these enum's unless you are going pretty low-level and calling the transcoder to decode individual slices. |
| enum class block_format |
| { |
| cETC1, // ETC1S RGB |
| cETC2_RGBA, // full ETC2 EAC RGBA8 block |
| cBC1, // DXT1 RGB |
| cBC3, // BC4 block followed by a four color BC1 block |
| cBC4, // DXT5A (alpha block only) |
| cBC5, // two BC4 blocks |
| cPVRTC1_4_RGB, // opaque-only PVRTC1 4bpp |
| cPVRTC1_4_RGBA, // PVRTC1 4bpp RGBA |
| cBC7, // Full BC7 block, any mode |
| cBC7_M5_COLOR, // RGB BC7 mode 5 color (writes an opaque mode 5 block) |
| cBC7_M5_ALPHA, // alpha portion of BC7 mode 5 (cBC7_M5_COLOR output data must have been written to the output buffer first to set the mode/rot fields etc.) |
| cETC2_EAC_A8, // alpha block of ETC2 EAC (first 8 bytes of the 16-bit ETC2 EAC RGBA format) |
| cASTC_4x4, // ASTC 4x4 (either color-only or color+alpha). Note that the transcoder always currently assumes sRGB is not enabled when outputting ASTC |
| // data. If you use a sRGB ASTC format you'll get ~1 LSB of additional error, because of the different way ASTC decoders scale 8-bit endpoints to 16-bits during unpacking. |
| |
| cATC_RGB, |
| cATC_RGBA_INTERPOLATED_ALPHA, |
| cFXT1_RGB, // Opaque-only, has oddball 8x4 pixel block size |
| |
| cPVRTC2_4_RGB, |
| cPVRTC2_4_RGBA, |
| |
| cETC2_EAC_R11, |
| cETC2_EAC_RG11, |
| |
| cIndices, // Used internally: Write 16-bit endpoint and selector indices directly to output (output block must be at least 32-bits) |
| |
| cRGB32, // Writes RGB components to 32bpp output pixels |
| cRGBA32, // Writes RGB255 components to 32bpp output pixels |
| cA32, // Writes alpha component to 32bpp output pixels |
| |
| cRGB565, |
| cBGR565, |
| |
| cRGBA4444_COLOR, |
| cRGBA4444_ALPHA, |
| cRGBA4444_COLOR_OPAQUE, |
| cRGBA4444, |
| |
| cTotalBlockFormats |
| }; |
| |
| const int COLOR5_PAL0_PREV_HI = 9, COLOR5_PAL0_DELTA_LO = -9, COLOR5_PAL0_DELTA_HI = 31; |
| const int COLOR5_PAL1_PREV_HI = 21, COLOR5_PAL1_DELTA_LO = -21, COLOR5_PAL1_DELTA_HI = 21; |
| const int COLOR5_PAL2_PREV_HI = 31, COLOR5_PAL2_DELTA_LO = -31, COLOR5_PAL2_DELTA_HI = 9; |
| const int COLOR5_PAL_MIN_DELTA_B_RUNLEN = 3, COLOR5_PAL_DELTA_5_RUNLEN_VLC_BITS = 3; |
| |
| const uint32_t ENDPOINT_PRED_TOTAL_SYMBOLS = (4 * 4 * 4 * 4) + 1; |
| const uint32_t ENDPOINT_PRED_REPEAT_LAST_SYMBOL = ENDPOINT_PRED_TOTAL_SYMBOLS - 1; |
| const uint32_t ENDPOINT_PRED_MIN_REPEAT_COUNT = 3; |
| const uint32_t ENDPOINT_PRED_COUNT_VLC_BITS = 4; |
| |
| const uint32_t NUM_ENDPOINT_PREDS = 3;// BASISU_ARRAY_SIZE(g_endpoint_preds); |
| const uint32_t CR_ENDPOINT_PRED_INDEX = NUM_ENDPOINT_PREDS - 1; |
| const uint32_t NO_ENDPOINT_PRED_INDEX = 3;//NUM_ENDPOINT_PREDS; |
| const uint32_t MAX_SELECTOR_HISTORY_BUF_SIZE = 64; |
| const uint32_t SELECTOR_HISTORY_BUF_RLE_COUNT_THRESH = 3; |
| const uint32_t SELECTOR_HISTORY_BUF_RLE_COUNT_BITS = 6; |
| const uint32_t SELECTOR_HISTORY_BUF_RLE_COUNT_TOTAL = (1 << SELECTOR_HISTORY_BUF_RLE_COUNT_BITS); |
| |
| uint16_t crc16(const void *r, size_t size, uint16_t crc); |
| |
| class huffman_decoding_table |
| { |
| friend class bitwise_decoder; |
| |
| public: |
| huffman_decoding_table() |
| { |
| } |
| |
| void clear() |
| { |
| basisu::clear_vector(m_code_sizes); |
| basisu::clear_vector(m_lookup); |
| basisu::clear_vector(m_tree); |
| } |
| |
| bool init(uint32_t total_syms, const uint8_t *pCode_sizes, uint32_t fast_lookup_bits = basisu::cHuffmanFastLookupBits) |
| { |
| if (!total_syms) |
| { |
| clear(); |
| return true; |
| } |
| |
| m_code_sizes.resize(total_syms); |
| memcpy(&m_code_sizes[0], pCode_sizes, total_syms); |
| |
| const uint32_t huffman_fast_lookup_size = 1 << fast_lookup_bits; |
| |
| m_lookup.resize(0); |
| m_lookup.resize(huffman_fast_lookup_size); |
| |
| m_tree.resize(0); |
| m_tree.resize(total_syms * 2); |
| |
| uint32_t syms_using_codesize[basisu::cHuffmanMaxSupportedInternalCodeSize + 1]; |
| basisu::clear_obj(syms_using_codesize); |
| for (uint32_t i = 0; i < total_syms; i++) |
| { |
| if (pCode_sizes[i] > basisu::cHuffmanMaxSupportedInternalCodeSize) |
| return false; |
| syms_using_codesize[pCode_sizes[i]]++; |
| } |
| |
| uint32_t next_code[basisu::cHuffmanMaxSupportedInternalCodeSize + 1]; |
| next_code[0] = next_code[1] = 0; |
| |
| uint32_t used_syms = 0, total = 0; |
| for (uint32_t i = 1; i < basisu::cHuffmanMaxSupportedInternalCodeSize; i++) |
| { |
| used_syms += syms_using_codesize[i]; |
| next_code[i + 1] = (total = ((total + syms_using_codesize[i]) << 1)); |
| } |
| |
| if (((1U << basisu::cHuffmanMaxSupportedInternalCodeSize) != total) && (used_syms > 1U)) |
| return false; |
| |
| for (int tree_next = -1, sym_index = 0; sym_index < (int)total_syms; ++sym_index) |
| { |
| uint32_t rev_code = 0, l, cur_code, code_size = pCode_sizes[sym_index]; |
| if (!code_size) |
| continue; |
| |
| cur_code = next_code[code_size]++; |
| |
| for (l = code_size; l > 0; l--, cur_code >>= 1) |
| rev_code = (rev_code << 1) | (cur_code & 1); |
| |
| if (code_size <= fast_lookup_bits) |
| { |
| uint32_t k = (code_size << 16) | sym_index; |
| while (rev_code < huffman_fast_lookup_size) |
| { |
| if (m_lookup[rev_code] != 0) |
| { |
| // Supplied codesizes can't create a valid prefix code. |
| return false; |
| } |
| |
| m_lookup[rev_code] = k; |
| rev_code += (1 << code_size); |
| } |
| continue; |
| } |
| |
| int tree_cur; |
| if (0 == (tree_cur = m_lookup[rev_code & (huffman_fast_lookup_size - 1)])) |
| { |
| const uint32_t idx = rev_code & (huffman_fast_lookup_size - 1); |
| if (m_lookup[idx] != 0) |
| { |
| // Supplied codesizes can't create a valid prefix code. |
| return false; |
| } |
| |
| m_lookup[idx] = tree_next; |
| tree_cur = tree_next; |
| tree_next -= 2; |
| } |
| |
| if (tree_cur >= 0) |
| { |
| // Supplied codesizes can't create a valid prefix code. |
| return false; |
| } |
| |
| rev_code >>= (fast_lookup_bits - 1); |
| |
| for (int j = code_size; j > ((int)fast_lookup_bits + 1); j--) |
| { |
| tree_cur -= ((rev_code >>= 1) & 1); |
| |
| const int idx = -tree_cur - 1; |
| if (idx < 0) |
| return false; |
| else if (idx >= (int)m_tree.size()) |
| m_tree.resize(idx + 1); |
| |
| if (!m_tree[idx]) |
| { |
| m_tree[idx] = (int16_t)tree_next; |
| tree_cur = tree_next; |
| tree_next -= 2; |
| } |
| else |
| { |
| tree_cur = m_tree[idx]; |
| if (tree_cur >= 0) |
| { |
| // Supplied codesizes can't create a valid prefix code. |
| return false; |
| } |
| } |
| } |
| |
| tree_cur -= ((rev_code >>= 1) & 1); |
| |
| const int idx = -tree_cur - 1; |
| if (idx < 0) |
| return false; |
| else if (idx >= (int)m_tree.size()) |
| m_tree.resize(idx + 1); |
| |
| if (m_tree[idx] != 0) |
| { |
| // Supplied codesizes can't create a valid prefix code. |
| return false; |
| } |
| |
| m_tree[idx] = (int16_t)sym_index; |
| } |
| |
| return true; |
| } |
| |
| const basisu::uint8_vec &get_code_sizes() const { return m_code_sizes; } |
| const basisu::int_vec get_lookup() const { return m_lookup; } |
| const basisu::int16_vec get_tree() const { return m_tree; } |
| |
| bool is_valid() const { return m_code_sizes.size() > 0; } |
| |
| private: |
| basisu::uint8_vec m_code_sizes; |
| basisu::int_vec m_lookup; |
| basisu::int16_vec m_tree; |
| }; |
| |
| class bitwise_decoder |
| { |
| public: |
| bitwise_decoder() : |
| m_buf_size(0), |
| m_pBuf(nullptr), |
| m_pBuf_start(nullptr), |
| m_pBuf_end(nullptr), |
| m_bit_buf(0), |
| m_bit_buf_size(0) |
| { |
| } |
| |
| void clear() |
| { |
| m_buf_size = 0; |
| m_pBuf = nullptr; |
| m_pBuf_start = nullptr; |
| m_pBuf_end = nullptr; |
| m_bit_buf = 0; |
| m_bit_buf_size = 0; |
| } |
| |
| bool init(const uint8_t *pBuf, uint32_t buf_size) |
| { |
| if ((!pBuf) && (buf_size)) |
| return false; |
| |
| m_buf_size = buf_size; |
| m_pBuf = pBuf; |
| m_pBuf_start = pBuf; |
| m_pBuf_end = pBuf + buf_size; |
| m_bit_buf = 0; |
| m_bit_buf_size = 0; |
| return true; |
| } |
| |
| void stop() |
| { |
| } |
| |
| inline uint32_t peek_bits(uint32_t num_bits) |
| { |
| if (!num_bits) |
| return 0; |
| |
| assert(num_bits <= 25); |
| |
| while (m_bit_buf_size < num_bits) |
| { |
| uint32_t c = 0; |
| if (m_pBuf < m_pBuf_end) |
| c = *m_pBuf++; |
| |
| m_bit_buf |= (c << m_bit_buf_size); |
| m_bit_buf_size += 8; |
| assert(m_bit_buf_size <= 32); |
| } |
| |
| return m_bit_buf & ((1 << num_bits) - 1); |
| } |
| |
| void remove_bits(uint32_t num_bits) |
| { |
| assert(m_bit_buf_size >= num_bits); |
| |
| m_bit_buf >>= num_bits; |
| m_bit_buf_size -= num_bits; |
| } |
| |
| uint32_t get_bits(uint32_t num_bits) |
| { |
| if (num_bits > 25) |
| { |
| assert(num_bits <= 32); |
| |
| const uint32_t bits0 = peek_bits(25); |
| m_bit_buf >>= 25; |
| m_bit_buf_size -= 25; |
| num_bits -= 25; |
| |
| const uint32_t bits = peek_bits(num_bits); |
| m_bit_buf >>= num_bits; |
| m_bit_buf_size -= num_bits; |
| |
| return bits0 | (bits << 25); |
| } |
| |
| const uint32_t bits = peek_bits(num_bits); |
| |
| m_bit_buf >>= num_bits; |
| m_bit_buf_size -= num_bits; |
| |
| return bits; |
| } |
| |
| uint32_t decode_truncated_binary(uint32_t n) |
| { |
| assert(n >= 2); |
| |
| const uint32_t k = basisu::floor_log2i(n); |
| const uint32_t u = (1 << (k + 1)) - n; |
| |
| uint32_t result = get_bits(k); |
| |
| if (result >= u) |
| result = ((result << 1) | get_bits(1)) - u; |
| |
| return result; |
| } |
| |
| uint32_t decode_rice(uint32_t m) |
| { |
| assert(m); |
| |
| uint32_t q = 0; |
| for (;;) |
| { |
| uint32_t k = peek_bits(16); |
| |
| uint32_t l = 0; |
| while (k & 1) |
| { |
| l++; |
| k >>= 1; |
| } |
| |
| q += l; |
| |
| remove_bits(l); |
| |
| if (l < 16) |
| break; |
| } |
| |
| return (q << m) + (get_bits(m + 1) >> 1); |
| } |
| |
| inline uint32_t decode_vlc(uint32_t chunk_bits) |
| { |
| assert(chunk_bits); |
| |
| const uint32_t chunk_size = 1 << chunk_bits; |
| const uint32_t chunk_mask = chunk_size - 1; |
| |
| uint32_t v = 0; |
| uint32_t ofs = 0; |
| |
| for ( ; ; ) |
| { |
| uint32_t s = get_bits(chunk_bits + 1); |
| v |= ((s & chunk_mask) << ofs); |
| ofs += chunk_bits; |
| |
| if ((s & chunk_size) == 0) |
| break; |
| |
| if (ofs >= 32) |
| { |
| assert(0); |
| break; |
| } |
| } |
| |
| return v; |
| } |
| |
| inline uint32_t decode_huffman(const huffman_decoding_table &ct, int fast_lookup_bits = basisu::cHuffmanFastLookupBits) |
| { |
| assert(ct.m_code_sizes.size()); |
| |
| const uint32_t huffman_fast_lookup_size = 1 << fast_lookup_bits; |
| |
| while (m_bit_buf_size < 16) |
| { |
| uint32_t c = 0; |
| if (m_pBuf < m_pBuf_end) |
| c = *m_pBuf++; |
| |
| m_bit_buf |= (c << m_bit_buf_size); |
| m_bit_buf_size += 8; |
| assert(m_bit_buf_size <= 32); |
| } |
| |
| int code_len; |
| |
| int sym; |
| if ((sym = ct.m_lookup[m_bit_buf & (huffman_fast_lookup_size - 1)]) >= 0) |
| { |
| code_len = sym >> 16; |
| sym &= 0xFFFF; |
| } |
| else |
| { |
| code_len = fast_lookup_bits; |
| do |
| { |
| sym = ct.m_tree[~sym + ((m_bit_buf >> code_len++) & 1)]; // ~sym = -sym - 1 |
| } while (sym < 0); |
| } |
| |
| m_bit_buf >>= code_len; |
| m_bit_buf_size -= code_len; |
| |
| return sym; |
| } |
| |
| bool read_huffman_table(huffman_decoding_table &ct) |
| { |
| ct.clear(); |
| |
| const uint32_t total_used_syms = get_bits(basisu::cHuffmanMaxSymsLog2); |
| |
| if (!total_used_syms) |
| return true; |
| if (total_used_syms > basisu::cHuffmanMaxSyms) |
| return false; |
| |
| uint8_t code_length_code_sizes[basisu::cHuffmanTotalCodelengthCodes]; |
| basisu::clear_obj(code_length_code_sizes); |
| |
| const uint32_t num_codelength_codes = get_bits(5); |
| if ((num_codelength_codes < 1) || (num_codelength_codes > basisu::cHuffmanTotalCodelengthCodes)) |
| return false; |
| |
| for (uint32_t i = 0; i < num_codelength_codes; i++) |
| code_length_code_sizes[basisu::g_huffman_sorted_codelength_codes[i]] = static_cast<uint8_t>(get_bits(3)); |
| |
| huffman_decoding_table code_length_table; |
| if (!code_length_table.init(basisu::cHuffmanTotalCodelengthCodes, code_length_code_sizes)) |
| return false; |
| |
| if (!code_length_table.is_valid()) |
| return false; |
| |
| basisu::uint8_vec code_sizes(total_used_syms); |
| |
| uint32_t cur = 0; |
| while (cur < total_used_syms) |
| { |
| int c = decode_huffman(code_length_table); |
| |
| if (c <= 16) |
| code_sizes[cur++] = static_cast<uint8_t>(c); |
| else if (c == basisu::cHuffmanSmallZeroRunCode) |
| cur += get_bits(basisu::cHuffmanSmallZeroRunExtraBits) + basisu::cHuffmanSmallZeroRunSizeMin; |
| else if (c == basisu::cHuffmanBigZeroRunCode) |
| cur += get_bits(basisu::cHuffmanBigZeroRunExtraBits) + basisu::cHuffmanBigZeroRunSizeMin; |
| else |
| { |
| if (!cur) |
| return false; |
| |
| uint32_t l; |
| if (c == basisu::cHuffmanSmallRepeatCode) |
| l = get_bits(basisu::cHuffmanSmallRepeatExtraBits) + basisu::cHuffmanSmallRepeatSizeMin; |
| else |
| l = get_bits(basisu::cHuffmanBigRepeatExtraBits) + basisu::cHuffmanBigRepeatSizeMin; |
| |
| const uint8_t prev = code_sizes[cur - 1]; |
| if (prev == 0) |
| return false; |
| do |
| { |
| if (cur >= total_used_syms) |
| return false; |
| code_sizes[cur++] = prev; |
| } while (--l > 0); |
| } |
| } |
| |
| if (cur != total_used_syms) |
| return false; |
| |
| return ct.init(total_used_syms, &code_sizes[0]); |
| } |
| |
| private: |
| uint32_t m_buf_size; |
| const uint8_t *m_pBuf; |
| const uint8_t *m_pBuf_start; |
| const uint8_t *m_pBuf_end; |
| |
| uint32_t m_bit_buf; |
| uint32_t m_bit_buf_size; |
| }; |
| |
| inline uint32_t basisd_rand(uint32_t seed) |
| { |
| if (!seed) |
| seed++; |
| uint32_t z = seed; |
| BASISD_znew; |
| return z; |
| } |
| |
| // Returns random number in [0,limit). Max limit is 0xFFFF. |
| inline uint32_t basisd_urand(uint32_t& seed, uint32_t limit) |
| { |
| seed = basisd_rand(seed); |
| return (((seed ^ (seed >> 16)) & 0xFFFF) * limit) >> 16; |
| } |
| |
| class approx_move_to_front |
| { |
| public: |
| approx_move_to_front(uint32_t n) |
| { |
| init(n); |
| } |
| |
| void init(uint32_t n) |
| { |
| m_values.resize(n); |
| m_rover = n / 2; |
| } |
| |
| const basisu::int_vec& get_values() const { return m_values; } |
| basisu::int_vec& get_values() { return m_values; } |
| |
| uint32_t size() const { return (uint32_t)m_values.size(); } |
| |
| const int& operator[] (uint32_t index) const { return m_values[index]; } |
| int operator[] (uint32_t index) { return m_values[index]; } |
| |
| void add(int new_value) |
| { |
| m_values[m_rover++] = new_value; |
| if (m_rover == m_values.size()) |
| m_rover = (uint32_t)m_values.size() / 2; |
| } |
| |
| void use(uint32_t index) |
| { |
| if (index) |
| { |
| //std::swap(m_values[index / 2], m_values[index]); |
| int x = m_values[index / 2]; |
| int y = m_values[index]; |
| m_values[index / 2] = y; |
| m_values[index] = x; |
| } |
| } |
| |
| // returns -1 if not found |
| int find(int value) const |
| { |
| for (uint32_t i = 0; i < m_values.size(); i++) |
| if (m_values[i] == value) |
| return i; |
| return -1; |
| } |
| |
| void reset() |
| { |
| const uint32_t n = (uint32_t)m_values.size(); |
| |
| m_values.clear(); |
| |
| init(n); |
| } |
| |
| private: |
| basisu::int_vec m_values; |
| uint32_t m_rover; |
| }; |
| |
| struct decoder_etc_block; |
| |
| inline uint8_t clamp255(int32_t i) |
| { |
| return (uint8_t)((i & 0xFFFFFF00U) ? (~(i >> 31)) : i); |
| } |
| |
| enum eNoClamp |
| { |
| cNoClamp = 0 |
| }; |
| |
| struct color32 |
| { |
| union |
| { |
| struct |
| { |
| uint8_t r; |
| uint8_t g; |
| uint8_t b; |
| uint8_t a; |
| }; |
| |
| uint8_t c[4]; |
| |
| uint32_t m; |
| }; |
| |
| color32() { } |
| |
| color32(uint32_t vr, uint32_t vg, uint32_t vb, uint32_t va) { set(vr, vg, vb, va); } |
| color32(eNoClamp unused, uint32_t vr, uint32_t vg, uint32_t vb, uint32_t va) { (void)unused; set_noclamp_rgba(vr, vg, vb, va); } |
| |
| void set(uint32_t vr, uint32_t vg, uint32_t vb, uint32_t va) { c[0] = static_cast<uint8_t>(vr); c[1] = static_cast<uint8_t>(vg); c[2] = static_cast<uint8_t>(vb); c[3] = static_cast<uint8_t>(va); } |
| |
| void set_noclamp_rgb(uint32_t vr, uint32_t vg, uint32_t vb) { c[0] = static_cast<uint8_t>(vr); c[1] = static_cast<uint8_t>(vg); c[2] = static_cast<uint8_t>(vb); } |
| void set_noclamp_rgba(uint32_t vr, uint32_t vg, uint32_t vb, uint32_t va) { set(vr, vg, vb, va); } |
| |
| void set_clamped(int vr, int vg, int vb, int va) { c[0] = clamp255(vr); c[1] = clamp255(vg); c[2] = clamp255(vb); c[3] = clamp255(va); } |
| |
| uint8_t operator[] (uint32_t idx) const { assert(idx < 4); return c[idx]; } |
| uint8_t &operator[] (uint32_t idx) { assert(idx < 4); return c[idx]; } |
| |
| bool operator== (const color32&rhs) const { return m == rhs.m; } |
| |
| static color32 comp_min(const color32& a, const color32& b) { return color32(cNoClamp, basisu::minimum(a[0], b[0]), basisu::minimum(a[1], b[1]), basisu::minimum(a[2], b[2]), basisu::minimum(a[3], b[3])); } |
| static color32 comp_max(const color32& a, const color32& b) { return color32(cNoClamp, basisu::maximum(a[0], b[0]), basisu::maximum(a[1], b[1]), basisu::maximum(a[2], b[2]), basisu::maximum(a[3], b[3])); } |
| }; |
| |
| struct endpoint |
| { |
| color32 m_color5; |
| uint8_t m_inten5; |
| bool operator== (const endpoint& rhs) const |
| { |
| return (m_color5.r == rhs.m_color5.r) && (m_color5.g == rhs.m_color5.g) && (m_color5.b == rhs.m_color5.b) && (m_inten5 == rhs.m_inten5); |
| } |
| bool operator!= (const endpoint& rhs) const { return !(*this == rhs); } |
| }; |
| |
| struct selector |
| { |
| // Plain selectors (2-bits per value) |
| uint8_t m_selectors[4]; |
| |
| // ETC1 selectors |
| uint8_t m_bytes[4]; |
| |
| uint8_t m_lo_selector, m_hi_selector; |
| uint8_t m_num_unique_selectors; |
| bool operator== (const selector& rhs) const |
| { |
| return (m_selectors[0] == rhs.m_selectors[0]) && |
| (m_selectors[1] == rhs.m_selectors[1]) && |
| (m_selectors[2] == rhs.m_selectors[2]) && |
| (m_selectors[3] == rhs.m_selectors[3]); |
| } |
| bool operator!= (const selector& rhs) const |
| { |
| return !(*this == rhs); |
| } |
| |
| void init_flags() |
| { |
| uint32_t hist[4] = { 0, 0, 0, 0 }; |
| for (uint32_t y = 0; y < 4; y++) |
| { |
| for (uint32_t x = 0; x < 4; x++) |
| { |
| uint32_t s = get_selector(x, y); |
| hist[s]++; |
| } |
| } |
| |
| m_lo_selector = 3; |
| m_hi_selector = 0; |
| m_num_unique_selectors = 0; |
| |
| for (uint32_t i = 0; i < 4; i++) |
| { |
| if (hist[i]) |
| { |
| m_num_unique_selectors++; |
| if (i < m_lo_selector) m_lo_selector = static_cast<uint8_t>(i); |
| if (i > m_hi_selector) m_hi_selector = static_cast<uint8_t>(i); |
| } |
| } |
| } |
| |
| // Returned selector value ranges from 0-3 and is a direct index into g_etc1_inten_tables. |
| inline uint32_t get_selector(uint32_t x, uint32_t y) const |
| { |
| assert((x < 4) && (y < 4)); |
| return (m_selectors[y] >> (x * 2)) & 3; |
| } |
| |
| void set_selector(uint32_t x, uint32_t y, uint32_t val) |
| { |
| static const uint8_t s_selector_index_to_etc1[4] = { 3, 2, 0, 1 }; |
| |
| assert((x | y | val) < 4); |
| |
| m_selectors[y] &= ~(3 << (x * 2)); |
| m_selectors[y] |= (val << (x * 2)); |
| |
| const uint32_t etc1_bit_index = x * 4 + y; |
| |
| uint8_t *p = &m_bytes[3 - (etc1_bit_index >> 3)]; |
| |
| const uint32_t byte_bit_ofs = etc1_bit_index & 7; |
| const uint32_t mask = 1 << byte_bit_ofs; |
| |
| const uint32_t etc1_val = s_selector_index_to_etc1[val]; |
| |
| const uint32_t lsb = etc1_val & 1; |
| const uint32_t msb = etc1_val >> 1; |
| |
| p[0] &= ~mask; |
| p[0] |= (lsb << byte_bit_ofs); |
| |
| p[-2] &= ~mask; |
| p[-2] |= (msb << byte_bit_ofs); |
| } |
| }; |
| |
| bool basis_block_format_is_uncompressed(block_format tex_type); |
| |
| } // namespace basist |
| |
| |
| |
| /**** ended inlining basisu_transcoder_internal.h ****/ |
| /**** start inlining basisu_transcoder_uastc.h ****/ |
| // basisu_transcoder_uastc.h |
| /**** skipping file: basisu_transcoder_internal.h ****/ |
| |
| namespace basist |
| { |
| struct color_quad_u8 |
| { |
| uint8_t m_c[4]; |
| }; |
| |
| const uint32_t TOTAL_UASTC_MODES = 19; |
| const uint32_t UASTC_MODE_INDEX_SOLID_COLOR = 8; |
| |
| const uint32_t TOTAL_ASTC_BC7_COMMON_PARTITIONS2 = 30; |
| const uint32_t TOTAL_ASTC_BC7_COMMON_PARTITIONS3 = 11; |
| const uint32_t TOTAL_BC7_3_ASTC2_COMMON_PARTITIONS = 19; |
| |
| extern const uint8_t g_uastc_mode_weight_bits[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_weight_ranges[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_endpoint_ranges[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_subsets[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_planes[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_comps[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_has_etc1_bias[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_has_bc1_hint0[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_has_bc1_hint1[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_has_alpha[TOTAL_UASTC_MODES]; |
| extern const uint8_t g_uastc_mode_is_la[TOTAL_UASTC_MODES]; |
| |
| struct astc_bc7_common_partition2_desc |
| { |
| uint8_t m_bc7; |
| uint16_t m_astc; |
| bool m_invert; |
| }; |
| |
| extern const astc_bc7_common_partition2_desc g_astc_bc7_common_partitions2[TOTAL_ASTC_BC7_COMMON_PARTITIONS2]; |
| |
| struct bc73_astc2_common_partition_desc |
| { |
| uint8_t m_bc73; |
| uint16_t m_astc2; |
| uint8_t k; // 0-5 - how to modify the BC7 3-subset pattern to match the ASTC pattern (LSB=invert) |
| }; |
| |
| extern const bc73_astc2_common_partition_desc g_bc7_3_astc2_common_partitions[TOTAL_BC7_3_ASTC2_COMMON_PARTITIONS]; |
| |
| struct astc_bc7_common_partition3_desc |
| { |
| uint8_t m_bc7; |
| uint16_t m_astc; |
| uint8_t m_astc_to_bc7_perm; // converts ASTC to BC7 partition using g_astc_bc7_partition_index_perm_tables[][] |
| }; |
| |
| extern const astc_bc7_common_partition3_desc g_astc_bc7_common_partitions3[TOTAL_ASTC_BC7_COMMON_PARTITIONS3]; |
| |
| extern const uint8_t g_astc_bc7_patterns2[TOTAL_ASTC_BC7_COMMON_PARTITIONS2][16]; |
| extern const uint8_t g_astc_bc7_patterns3[TOTAL_ASTC_BC7_COMMON_PARTITIONS3][16]; |
| extern const uint8_t g_bc7_3_astc2_patterns2[TOTAL_BC7_3_ASTC2_COMMON_PARTITIONS][16]; |
| |
| extern const uint8_t g_astc_bc7_pattern2_anchors[TOTAL_ASTC_BC7_COMMON_PARTITIONS2][3]; |
| extern const uint8_t g_astc_bc7_pattern3_anchors[TOTAL_ASTC_BC7_COMMON_PARTITIONS3][3]; |
| extern const uint8_t g_bc7_3_astc2_patterns2_anchors[TOTAL_BC7_3_ASTC2_COMMON_PARTITIONS][3]; |
| |
| extern const uint32_t g_uastc_mode_huff_codes[TOTAL_UASTC_MODES + 1][2]; |
| |
| extern const uint8_t g_astc_to_bc7_partition_index_perm_tables[6][3]; |
| extern const uint8_t g_bc7_to_astc_partition_index_perm_tables[6][3]; // inverse of g_astc_to_bc7_partition_index_perm_tables |
| |
| extern const uint8_t* s_uastc_to_bc1_weights[6]; |
| |
| uint32_t bc7_convert_partition_index_3_to_2(uint32_t p, uint32_t k); |
| |
| inline uint32_t astc_interpolate(uint32_t l, uint32_t h, uint32_t w, bool srgb) |
| { |
| if (srgb) |
| { |
| l = (l << 8) | 0x80; |
| h = (h << 8) | 0x80; |
| } |
| else |
| { |
| l = (l << 8) | l; |
| h = (h << 8) | h; |
| } |
| |
| uint32_t k = (l * (64 - w) + h * w + 32) >> 6; |
| |
| return k >> 8; |
| } |
| |
| struct astc_block_desc |
| { |
| int m_weight_range; // weight BISE range |
| |
| int m_subsets; // number of ASTC partitions |
| int m_partition_seed; // partition pattern seed |
| int m_cem; // color endpoint mode used by all subsets |
| |
| int m_ccs; // color component selector (dual plane only) |
| bool m_dual_plane; // true if dual plane |
| |
| // Weight and endpoint BISE values. |
| // Note these values are NOT linear, they must be BISE encoded. See Table 97 and Table 107. |
| uint8_t m_endpoints[18]; // endpoint values, in RR GG BB etc. order |
| uint8_t m_weights[64]; // weight index values, raster order, in P0 P1, P0 P1, etc. or P0, P0, P0, P0, etc. order |
| }; |
| |
| const uint32_t BC7ENC_TOTAL_ASTC_RANGES = 21; |
| |
| // See tables 81, 93, 18.13.Endpoint Unquantization |
| const uint32_t TOTAL_ASTC_RANGES = 21; |
| extern const int g_astc_bise_range_table[TOTAL_ASTC_RANGES][3]; |
| |
| struct astc_quant_bin |
| { |
| uint8_t m_unquant; // unquantized value |
| uint8_t m_index; // sorted index |
| }; |
| |
| extern astc_quant_bin g_astc_unquant[BC7ENC_TOTAL_ASTC_RANGES][256]; // [ASTC encoded endpoint index] |
| |
| int astc_get_levels(int range); |
| bool astc_is_valid_endpoint_range(uint32_t range); |
| uint32_t unquant_astc_endpoint(uint32_t packed_bits, uint32_t packed_trits, uint32_t packed_quints, uint32_t range); |
| uint32_t unquant_astc_endpoint_val(uint32_t packed_val, uint32_t range); |
| |
| const uint8_t* get_anchor_indices(uint32_t subsets, uint32_t mode, uint32_t common_pattern, const uint8_t*& pPartition_pattern); |
| |
| // BC7 |
| const uint32_t BC7ENC_BLOCK_SIZE = 16; |
| |
| struct bc7_block |
| { |
| uint64_t m_qwords[2]; |
| }; |
| |
| struct bc7_optimization_results |
| { |
| uint32_t m_mode; |
| uint32_t m_partition; |
| uint8_t m_selectors[16]; |
| uint8_t m_alpha_selectors[16]; |
| color_quad_u8 m_low[3]; |
| color_quad_u8 m_high[3]; |
| uint32_t m_pbits[3][2]; |
| uint32_t m_index_selector; |
| uint32_t m_rotation; |
| }; |
| |
| extern const uint32_t g_bc7_weights1[2]; |
| extern const uint32_t g_bc7_weights2[4]; |
| extern const uint32_t g_bc7_weights3[8]; |
| extern const uint32_t g_bc7_weights4[16]; |
| extern const uint32_t g_astc_weights4[16]; |
| extern const uint32_t g_astc_weights5[32]; |
| extern const uint32_t g_astc_weights_3levels[3]; |
| extern const uint8_t g_bc7_partition1[16]; |
| extern const uint8_t g_bc7_partition2[64 * 16]; |
| extern const uint8_t g_bc7_partition3[64 * 16]; |
| extern const uint8_t g_bc7_table_anchor_index_second_subset[64]; |
| extern const uint8_t g_bc7_table_anchor_index_third_subset_1[64]; |
| extern const uint8_t g_bc7_table_anchor_index_third_subset_2[64]; |
| extern const uint8_t g_bc7_num_subsets[8]; |
| extern const uint8_t g_bc7_partition_bits[8]; |
| extern const uint8_t g_bc7_color_index_bitcount[8]; |
| extern const uint8_t g_bc7_mode_has_p_bits[8]; |
| extern const uint8_t g_bc7_mode_has_shared_p_bits[8]; |
| extern const uint8_t g_bc7_color_precision_table[8]; |
| extern const int8_t g_bc7_alpha_precision_table[8]; |
| extern const uint8_t g_bc7_alpha_index_bitcount[8]; |
| |
| inline bool get_bc7_mode_has_seperate_alpha_selectors(int mode) { return (mode == 4) || (mode == 5); } |
| inline int get_bc7_color_index_size(int mode, int index_selection_bit) { return g_bc7_color_index_bitcount[mode] + index_selection_bit; } |
| inline int get_bc7_alpha_index_size(int mode, int index_selection_bit) { return g_bc7_alpha_index_bitcount[mode] - index_selection_bit; } |
| |
| struct endpoint_err |
| { |
| uint16_t m_error; uint8_t m_lo; uint8_t m_hi; |
| }; |
| |
| extern endpoint_err g_bc7_mode_6_optimal_endpoints[256][2]; // [c][pbit] |
| const uint32_t BC7ENC_MODE_6_OPTIMAL_INDEX = 5; |
| |
| extern endpoint_err g_bc7_mode_5_optimal_endpoints[256]; // [c] |
| const uint32_t BC7ENC_MODE_5_OPTIMAL_INDEX = 1; |
| |
| // Packs a BC7 block from a high-level description. Handles all BC7 modes. |
| void encode_bc7_block(void* pBlock, const bc7_optimization_results* pResults); |
| |
| // Packs an ASTC block |
| // Constraints: Always 4x4, all subset CEM's must be equal, only tested with LDR CEM's. |
| bool pack_astc_block(uint32_t* pDst, const astc_block_desc* pBlock, uint32_t mode); |
| |
| void pack_astc_solid_block(void* pDst_block, const color32& color); |
| |
| #ifdef _DEBUG |
| int astc_compute_texel_partition(int seed, int x, int y, int z, int partitioncount, bool small_block); |
| #endif |
| |
| struct uastc_block |
| { |
| union |
| { |
| uint8_t m_bytes[16]; |
| uint32_t m_dwords[4]; |
| |
| #ifndef __EMSCRIPTEN__ |
| uint64_t m_qwords[2]; |
| #endif |
| }; |
| }; |
| |
| struct unpacked_uastc_block |
| { |
| astc_block_desc m_astc; |
| |
| uint32_t m_mode; |
| uint32_t m_common_pattern; |
| |
| color32 m_solid_color; |
| |
| bool m_bc1_hint0; |
| bool m_bc1_hint1; |
| |
| bool m_etc1_flip; |
| bool m_etc1_diff; |
| uint32_t m_etc1_inten0; |
| uint32_t m_etc1_inten1; |
| |
| uint32_t m_etc1_bias; |
| |
| uint32_t m_etc2_hints; |
| |
| uint32_t m_etc1_selector; |
| uint32_t m_etc1_r, m_etc1_g, m_etc1_b; |
| }; |
| |
| color32 apply_etc1_bias(const color32 &block_color, uint32_t bias, uint32_t limit, uint32_t subblock); |
| |
| struct decoder_etc_block; |
| struct eac_block; |
| |
| bool unpack_uastc(uint32_t mode, uint32_t common_pattern, const color32& solid_color, const astc_block_desc& astc, color32* pPixels, bool srgb); |
| bool unpack_uastc(const unpacked_uastc_block& unpacked_blk, color32* pPixels, bool srgb); |
| |
| bool unpack_uastc(const uastc_block& blk, color32* pPixels, bool srgb); |
| bool unpack_uastc(const uastc_block& blk, unpacked_uastc_block& unpacked, bool undo_blue_contract, bool read_hints = true); |
| |
| bool transcode_uastc_to_astc(const uastc_block& src_blk, void* pDst); |
| |
| bool transcode_uastc_to_bc7(const unpacked_uastc_block& unpacked_src_blk, bc7_optimization_results& dst_blk); |
| bool transcode_uastc_to_bc7(const uastc_block& src_blk, bc7_optimization_results& dst_blk); |
| bool transcode_uastc_to_bc7(const uastc_block& src_blk, void* pDst); |
| |
| void transcode_uastc_to_etc1(unpacked_uastc_block& unpacked_src_blk, color32 block_pixels[4][4], void* pDst); |
| bool transcode_uastc_to_etc1(const uastc_block& src_blk, void* pDst); |
| bool transcode_uastc_to_etc1(const uastc_block& src_blk, void* pDst, uint32_t channel); |
| |
| void transcode_uastc_to_etc2_eac_a8(unpacked_uastc_block& unpacked_src_blk, color32 block_pixels[4][4], void* pDst); |
| bool transcode_uastc_to_etc2_rgba(const uastc_block& src_blk, void* pDst); |
| |
| // Packs 16 scalar values to BC4. Same PSNR as stb_dxt's BC4 encoder, around 13% faster. |
| void encode_bc4(void* pDst, const uint8_t* pPixels, uint32_t stride); |
| |
| void encode_bc1_solid_block(void* pDst, uint32_t fr, uint32_t fg, uint32_t fb); |
| |
| enum |
| { |
| cEncodeBC1HighQuality = 1, |
| cEncodeBC1HigherQuality = 2, |
| cEncodeBC1UseSelectors = 4, |
| }; |
| void encode_bc1(void* pDst, const uint8_t* pPixels, uint32_t flags); |
| |
| // Alternate PCA-free encoder, around 15% faster, same (or slightly higher) avg. PSNR |
| void encode_bc1_alt(void* pDst, const uint8_t* pPixels, uint32_t flags); |
| |
| void transcode_uastc_to_bc1_hint0(const unpacked_uastc_block& unpacked_src_blk, void* pDst); |
| void transcode_uastc_to_bc1_hint1(const unpacked_uastc_block& unpacked_src_blk, const color32 block_pixels[4][4], void* pDst, bool high_quality); |
| |
| bool transcode_uastc_to_bc1(const uastc_block& src_blk, void* pDst, bool high_quality); |
| bool transcode_uastc_to_bc3(const uastc_block& src_blk, void* pDst, bool high_quality); |
| bool transcode_uastc_to_bc4(const uastc_block& src_blk, void* pDst, bool high_quality, uint32_t chan0); |
| bool transcode_uastc_to_bc5(const uastc_block& src_blk, void* pDst, bool high_quality, uint32_t chan0, uint32_t chan1); |
| |
| bool transcode_uastc_to_etc2_eac_r11(const uastc_block& src_blk, void* pDst, bool high_quality, uint32_t chan0); |
| bool transcode_uastc_to_etc2_eac_rg11(const uastc_block& src_blk, void* pDst, bool high_quality, uint32_t chan0, uint32_t chan1); |
| |
| bool transcode_uastc_to_pvrtc1_4_rgb(const uastc_block* pSrc_blocks, void* pDst_blocks, uint32_t num_blocks_x, uint32_t num_blocks_y, bool high_quality, bool from_alpha); |
| bool transcode_uastc_to_pvrtc1_4_rgba(const uastc_block* pSrc_blocks, void* pDst_blocks, uint32_t num_blocks_x, uint32_t num_blocks_y, bool high_quality); |
| |
| // uastc_init() MUST be called before using this module. |
| void uastc_init(); |
| |
| } // namespace basist |
| /**** ended inlining basisu_transcoder_uastc.h ****/ |
| /**** start inlining basisu_file_headers.h ****/ |
| // basis_file_headers.h |
| // Copyright (C) 2019-2020 Binomial LLC. All Rights Reserved. |
| // |
| // Licensed 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. |
| /**** skipping file: basisu_transcoder_internal.h ****/ |
| |
| namespace basist |
| { |
| // Slice desc header flags |
| enum basis_slice_desc_flags |
| { |
| cSliceDescFlagsHasAlpha = 1, |
| |
| // Video only: Frame doesn't refer to previous frame (no usage of conditional replenishment pred symbols) |
| // Currently the first frame is always an I-Frame, all subsequent frames are P-Frames. This will eventually be changed to periodic I-Frames. |
| cSliceDescFlagsFrameIsIFrame = 2 |
| }; |
| |
| #pragma pack(push) |
| #pragma pack(1) |
| struct basis_slice_desc |
| { |
| basisu::packed_uint<3> m_image_index; // The index of the source image provided to the encoder (will always appear in order from first to last, first image index is 0, no skipping allowed) |
| basisu::packed_uint<1> m_level_index; // The mipmap level index (mipmaps will always appear from largest to smallest) |
| basisu::packed_uint<1> m_flags; // enum basis_slice_desc_flags |
| |
| basisu::packed_uint<2> m_orig_width; // The original image width (may not be a multiple of 4 pixels) |
| basisu::packed_uint<2> m_orig_height; // The original image height (may not be a multiple of 4 pixels) |
| |
| basisu::packed_uint<2> m_num_blocks_x; // The slice's block X dimensions. Each block is 4x4 pixels. The slice's pixel resolution may or may not be a power of 2. |
| basisu::packed_uint<2> m_num_blocks_y; // The slice's block Y dimensions. |
| |
| basisu::packed_uint<4> m_file_ofs; // Offset from the start of the file to the start of the slice's data |
| basisu::packed_uint<4> m_file_size; // The size of the compressed slice data in bytes |
| |
| basisu::packed_uint<2> m_slice_data_crc16; // The CRC16 of the compressed slice data, for extra-paranoid use cases |
| }; |
| |
| // File header files |
| enum basis_header_flags |
| { |
| // Always set for ETC1S files. Not set for UASTC files. |
| cBASISHeaderFlagETC1S = 1, |
| |
| // Set if the texture had to be Y flipped before encoding. The actual interpretation of this (is Y up or down?) is up to the user. |
| cBASISHeaderFlagYFlipped = 2, |
| |
| // Set if any slices contain alpha (for ETC1S, if the odd slices contain alpha data) |
| cBASISHeaderFlagHasAlphaSlices = 4, |
| |
| // For ETC1S files, this will be true if the file utilizes a codebook from another .basis file. |
| cBASISHeaderFlagUsesGlobalCodebook = 8, |
| |
| // Set if the texture data is sRGB, otherwise it's linear. |
| // In reality, we have no idea if the texture data is actually linear or sRGB. This is the m_perceptual parameter passed to the compressor. |
| cBASISHeaderFlagSRGB = 16, |
| }; |
| |
| // The image type field attempts to describe how to interpret the image data in a Basis file. |
| // The encoder library doesn't really do anything special or different with these texture types, this is mostly here for the benefit of the user. |
| // We do make sure the various constraints are followed (2DArray/cubemap/videoframes/volume implies that each image has the same resolution and # of mipmap levels, etc., cubemap implies that the # of image slices is a multiple of 6) |
| enum basis_texture_type |
| { |
| cBASISTexType2D = 0, // An arbitrary array of 2D RGB or RGBA images with optional mipmaps, array size = # images, each image may have a different resolution and # of mipmap levels |
| cBASISTexType2DArray = 1, // An array of 2D RGB or RGBA images with optional mipmaps, array size = # images, each image has the same resolution and mipmap levels |
| cBASISTexTypeCubemapArray = 2, // an array of cubemap levels, total # of images must be divisable by 6, in X+, X-, Y+, Y-, Z+, Z- order, with optional mipmaps |
| cBASISTexTypeVideoFrames = 3, // An array of 2D video frames, with optional mipmaps, # frames = # images, each image has the same resolution and # of mipmap levels |
| cBASISTexTypeVolume = 4, // A 3D texture with optional mipmaps, Z dimension = # images, each image has the same resolution and # of mipmap levels |
| |
| cBASISTexTypeTotal |
| }; |
| |
| enum |
| { |
| cBASISMaxUSPerFrame = 0xFFFFFF |
| }; |
| |
| enum class basis_tex_format |
| { |
| cETC1S = 0, |
| cUASTC4x4 = 1 |
| }; |
| |
| struct basis_file_header |
| { |
| enum |
| { |
| cBASISSigValue = ('B' << 8) | 's', |
| cBASISFirstVersion = 0x10 |
| }; |
| |
| basisu::packed_uint<2> m_sig; // 2 byte file signature |
| basisu::packed_uint<2> m_ver; // Baseline file version |
| basisu::packed_uint<2> m_header_size; // Header size in bytes, sizeof(basis_file_header) |
| basisu::packed_uint<2> m_header_crc16; // CRC16 of the remaining header data |
| |
| basisu::packed_uint<4> m_data_size; // The total size of all data after the header |
| basisu::packed_uint<2> m_data_crc16; // The CRC16 of all data after the header |
| |
| basisu::packed_uint<3> m_total_slices; // The total # of compressed slices (1 slice per image, or 2 for alpha .basis files) |
| |
| basisu::packed_uint<3> m_total_images; // The total # of images |
| |
| basisu::packed_uint<1> m_tex_format; // enum basis_tex_format |
| basisu::packed_uint<2> m_flags; // enum basist::header_flags |
| basisu::packed_uint<1> m_tex_type; // enum basist::basis_texture_type |
| basisu::packed_uint<3> m_us_per_frame; // Framerate of video, in microseconds per frame |
| |
| basisu::packed_uint<4> m_reserved; // For future use |
| basisu::packed_uint<4> m_userdata0; // For client use |
| basisu::packed_uint<4> m_userdata1; // For client use |
| |
| basisu::packed_uint<2> m_total_endpoints; // The number of endpoints in the endpoint codebook |
| basisu::packed_uint<4> m_endpoint_cb_file_ofs; // The compressed endpoint codebook's file offset relative to the start of the file |
| basisu::packed_uint<3> m_endpoint_cb_file_size; // The compressed endpoint codebook's size in bytes |
| |
| basisu::packed_uint<2> m_total_selectors; // The number of selectors in the endpoint codebook |
| basisu::packed_uint<4> m_selector_cb_file_ofs; // The compressed selectors codebook's file offset relative to the start of the file |
| basisu::packed_uint<3> m_selector_cb_file_size; // The compressed selector codebook's size in bytes |
| |
| basisu::packed_uint<4> m_tables_file_ofs; // The file offset of the compressed Huffman codelength tables, for decompressing slices |
| basisu::packed_uint<4> m_tables_file_size; // The file size in bytes of the compressed huffman codelength tables |
| |
| basisu::packed_uint<4> m_slice_desc_file_ofs; // The file offset to the slice description array, usually follows the header |
| |
| basisu::packed_uint<4> m_extended_file_ofs; // The file offset of the "extended" header and compressed data, for future use |
| basisu::packed_uint<4> m_extended_file_size; // The file size in bytes of the "extended" header and compressed data, for future use |
| }; |
| #pragma pack (pop) |
| |
| } // namespace basist |
| /**** ended inlining basisu_file_headers.h ****/ |
| |
| namespace basist |
| { |
| // High-level composite texture formats supported by the transcoder. |
| // Each of these texture formats directly correspond to OpenGL/D3D/Vulkan etc. texture formats. |
| // Notes: |
| // - If you specify a texture format that supports alpha, but the .basis file doesn't have alpha, the transcoder will automatically output a |
| // fully opaque (255) alpha channel. |
| // - The PVRTC1 texture formats only support power of 2 dimension .basis files, but this may be relaxed in a future version. |
| // - The PVRTC1 transcoders are real-time encoders, so don't expect the highest quality. We may add a slower encoder with improved quality. |
| // - These enums must be kept in sync with Javascript code that calls the transcoder. |
| enum class transcoder_texture_format |
| { |
| // Compressed formats |
| |
| // ETC1-2 |
| cTFETC1_RGB = 0, // Opaque only, returns RGB or alpha data if cDecodeFlagsTranscodeAlphaDataToOpaqueFormats flag is specified |
| cTFETC2_RGBA = 1, // Opaque+alpha, ETC2_EAC_A8 block followed by a ETC1 block, alpha channel will be opaque for opaque .basis files |
| |
| // BC1-5, BC7 (desktop, some mobile devices) |
| cTFBC1_RGB = 2, // Opaque only, no punchthrough alpha support yet, transcodes alpha slice if cDecodeFlagsTranscodeAlphaDataToOpaqueFormats flag is specified |
| cTFBC3_RGBA = 3, // Opaque+alpha, BC4 followed by a BC1 block, alpha channel will be opaque for opaque .basis files |
| cTFBC4_R = 4, // Red only, alpha slice is transcoded to output if cDecodeFlagsTranscodeAlphaDataToOpaqueFormats flag is specified |
| cTFBC5_RG = 5, // XY: Two BC4 blocks, X=R and Y=Alpha, .basis file should have alpha data (if not Y will be all 255's) |
| cTFBC7_RGBA = 6, // RGB or RGBA, mode 5 for ETC1S, modes (1,2,3,5,6,7) for UASTC |
| |
| // PVRTC1 4bpp (mobile, PowerVR devices) |
| cTFPVRTC1_4_RGB = 8, // Opaque only, RGB or alpha if cDecodeFlagsTranscodeAlphaDataToOpaqueFormats flag is specified, nearly lowest quality of any texture format. |
| cTFPVRTC1_4_RGBA = 9, // Opaque+alpha, most useful for simple opacity maps. If .basis file doesn't have alpha cTFPVRTC1_4_RGB will be used instead. Lowest quality of any supported texture format. |
| |
| // ASTC (mobile, Intel devices, hopefully all desktop GPU's one day) |
| cTFASTC_4x4_RGBA = 10, // Opaque+alpha, ASTC 4x4, alpha channel will be opaque for opaque .basis files. Transcoder uses RGB/RGBA/L/LA modes, void extent, and up to two ([0,47] and [0,255]) endpoint precisions. |
| |
| // ATC (mobile, Adreno devices, this is a niche format) |
| cTFATC_RGB = 11, // Opaque, RGB or alpha if cDecodeFlagsTranscodeAlphaDataToOpaqueFormats flag is specified. ATI ATC (GL_ATC_RGB_AMD) |
| cTFATC_RGBA = 12, // Opaque+alpha, alpha channel will be opaque for opaque .basis files. ATI ATC (GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD) |
| |
| // FXT1 (desktop, Intel devices, this is a super obscure format) |
| cTFFXT1_RGB = 17, // Opaque only, uses exclusively CC_MIXED blocks. Notable for having a 8x4 block size. GL_3DFX_texture_compression_FXT1 is supported on Intel integrated GPU's (such as HD 630). |
| // Punch-through alpha is relatively easy to support, but full alpha is harder. This format is only here for completeness so opaque-only is fine for now. |
| // See the BASISU_USE_ORIGINAL_3DFX_FXT1_ENCODING macro in basisu_transcoder_internal.h. |
| |
| cTFPVRTC2_4_RGB = 18, // Opaque-only, almost BC1 quality, much faster to transcode and supports arbitrary texture dimensions (unlike PVRTC1 RGB). |
| cTFPVRTC2_4_RGBA = 19, // Opaque+alpha, slower to encode than cTFPVRTC2_4_RGB. Premultiplied alpha is highly recommended, otherwise the color channel can leak into the alpha channel on transparent blocks. |
| |
| cTFETC2_EAC_R11 = 20, // R only (ETC2 EAC R11 unsigned) |
| cTFETC2_EAC_RG11 = 21, // RG only (ETC2 EAC RG11 unsigned), R=opaque.r, G=alpha - for tangent space normal maps |
| |
| // Uncompressed (raw pixel) formats |
| cTFRGBA32 = 13, // 32bpp RGBA image stored in raster (not block) order in memory, R is first byte, A is last byte. |
| cTFRGB565 = 14, // 16bpp RGB image stored in raster (not block) order in memory, R at bit position 11 |
| cTFBGR565 = 15, // 16bpp RGB image stored in raster (not block) order in memory, R at bit position 0 |
| cTFRGBA4444 = 16, // 16bpp RGBA image stored in raster (not block) order in memory, R at bit position 12, A at bit position 0 |
| |
| cTFTotalTextureFormats = 22, |
| |
| // Old enums for compatibility with code compiled against previous versions |
| cTFETC1 = cTFETC1_RGB, |
| cTFETC2 = cTFETC2_RGBA, |
| cTFBC1 = cTFBC1_RGB, |
| cTFBC3 = cTFBC3_RGBA, |
| cTFBC4 = cTFBC4_R, |
| cTFBC5 = cTFBC5_RG, |
| |
| // Previously, the caller had some control over which BC7 mode the transcoder output. We've simplified this due to UASTC, which supports numerous modes. |
| cTFBC7_M6_RGB = cTFBC7_RGBA, // Opaque only, RGB or alpha if cDecodeFlagsTranscodeAlphaDataToOpaqueFormats flag is specified. Highest quality of all the non-ETC1 formats. |
| cTFBC7_M5_RGBA = cTFBC7_RGBA, // Opaque+alpha, alpha channel will be opaque for opaque .basis files |
| cTFBC7_M6_OPAQUE_ONLY = cTFBC7_RGBA, |
| cTFBC7_M5 = cTFBC7_RGBA, |
| cTFBC7_ALT = 7, |
| |
| cTFASTC_4x4 = cTFASTC_4x4_RGBA, |
| |
| cTFATC_RGBA_INTERPOLATED_ALPHA = cTFATC_RGBA, |
| }; |
| |
| // For compressed texture formats, this returns the # of bytes per block. For uncompressed, it returns the # of bytes per pixel. |
| // NOTE: Previously, this function was called basis_get_bytes_per_block(), and it always returned 16*bytes_per_pixel for uncompressed formats which was confusing. |
| uint32_t basis_get_bytes_per_block_or_pixel(transcoder_texture_format fmt); |
| |
| // Returns format's name in ASCII |
| const char* basis_get_format_name(transcoder_texture_format fmt); |
| |
| // Returns block format name in ASCII |
| const char* basis_get_block_format_name(block_format fmt); |
| |
| // Returns true if the format supports an alpha channel. |
| bool basis_transcoder_format_has_alpha(transcoder_texture_format fmt); |
| |
| // Returns the basisu::texture_format corresponding to the specified transcoder_texture_format. |
| basisu::texture_format basis_get_basisu_texture_format(transcoder_texture_format fmt); |
| |
| // Returns the texture type's name in ASCII. |
| const char* basis_get_texture_type_name(basis_texture_type tex_type); |
| |
| // Returns true if the transcoder texture type is an uncompressed (raw pixel) format. |
| bool basis_transcoder_format_is_uncompressed(transcoder_texture_format tex_type); |
| |
| // Returns the # of bytes per pixel for uncompressed formats, or 0 for block texture formats. |
| uint32_t basis_get_uncompressed_bytes_per_pixel(transcoder_texture_format fmt); |
| |
| // Returns the block width for the specified texture format, which is currently either 4 or 8 for FXT1. |
| uint32_t basis_get_block_width(transcoder_texture_format tex_type); |
| |
| // Returns the block height for the specified texture format, which is currently always 4. |
| uint32_t basis_get_block_height(transcoder_texture_format tex_type); |
| |
| // Returns true if the specified format was enabled at compile time. |
| bool basis_is_format_supported(transcoder_texture_format tex_type, basis_tex_format fmt = basis_tex_format::cETC1S); |
| |
| // Validates that the output buffer is large enough to hold the entire transcoded texture. |
| // For uncompressed texture formats, most input parameters are in pixels, not blocks. Blocks are 4x4 pixels. |
| bool basis_validate_output_buffer_size(transcoder_texture_format target_format, |
| uint32_t output_blocks_buf_size_in_blocks_or_pixels, |
| uint32_t orig_width, uint32_t orig_height, |
| uint32_t output_row_pitch_in_blocks_or_pixels, |
| uint32_t output_rows_in_pixels, |
| uint32_t total_slice_blocks); |
| |
| class basisu_transcoder; |
| |
| // This struct holds all state used during transcoding. For video, it needs to persist between image transcodes (it holds the previous frame). |
| // For threading you can use one state per thread. |
| struct basisu_transcoder_state |
| { |
| struct block_preds |
| { |
| uint16_t m_endpoint_index; |
| uint8_t m_pred_bits; |
| }; |
| |
| basisu::vector<block_preds> m_block_endpoint_preds[2]; |
| |
| enum { cMaxPrevFrameLevels = 16 }; |
| basisu::vector<uint32_t> m_prev_frame_indices[2][cMaxPrevFrameLevels]; // [alpha_flag][level_index] |
| |
| void clear() |
| { |
| for (uint32_t i = 0; i < 2; i++) |
| { |
| m_block_endpoint_preds[i].clear(); |
| |
| for (uint32_t j = 0; j < cMaxPrevFrameLevels; j++) |
| m_prev_frame_indices[i][j].clear(); |
| } |
| } |
| }; |
| |
| // Low-level helper class that does the actual transcoding. |
| class basisu_lowlevel_etc1s_transcoder |
| { |
| friend class basisu_transcoder; |
| |
| public: |
| basisu_lowlevel_etc1s_transcoder(); |
| |
| void set_global_codebooks(const basisu_lowlevel_etc1s_transcoder* pGlobal_codebook) { m_pGlobal_codebook = pGlobal_codebook; } |
| const basisu_lowlevel_etc1s_transcoder* get_global_codebooks() const { return m_pGlobal_codebook; } |
| |
| bool decode_palettes( |
| uint32_t num_endpoints, const uint8_t* pEndpoints_data, uint32_t endpoints_data_size, |
| uint32_t num_selectors, const uint8_t* pSelectors_data, uint32_t selectors_data_size); |
| |
| bool decode_tables(const uint8_t* pTable_data, uint32_t table_data_size); |
| |
| bool transcode_slice(void* pDst_blocks, uint32_t num_blocks_x, uint32_t num_blocks_y, const uint8_t* pImage_data, uint32_t image_data_size, block_format fmt, |
| uint32_t output_block_or_pixel_stride_in_bytes, bool bc1_allow_threecolor_blocks, const bool is_video, const bool is_alpha_slice, const uint32_t level_index, const uint32_t orig_width, const uint32_t orig_height, uint32_t output_row_pitch_in_blocks_or_pixels = 0, |
| basisu_transcoder_state* pState = nullptr, bool astc_transcode_alpha = false, void* pAlpha_blocks = nullptr, uint32_t output_rows_in_pixels = 0); |
| |
| bool transcode_slice(void* pDst_blocks, uint32_t num_blocks_x, uint32_t num_blocks_y, const uint8_t* pImage_data, uint32_t image_data_size, block_format fmt, |
| uint32_t output_block_or_pixel_stride_in_bytes, bool bc1_allow_threecolor_blocks, const basis_file_header& header, const basis_slice_desc& slice_desc, uint32_t output_row_pitch_in_blocks_or_pixels = 0, |
| basisu_transcoder_state* pState = nullptr, bool astc_transcode_alpha = false, void* pAlpha_blocks = nullptr, uint32_t output_rows_in_pixels = 0) |
| { |
| return transcode_slice(pDst_blocks, num_blocks_x, num_blocks_y, pImage_data, image_data_size, fmt, output_block_or_pixel_stride_in_bytes, bc1_allow_threecolor_blocks, |
| header.m_tex_type == cBASISTexTypeVideoFrames, (slice_desc.m_flags & cSliceDescFlagsHasAlpha) != 0, slice_desc.m_level_index, |
| slice_desc.m_orig_width, slice_desc.m_orig_height, output_row_pitch_in_blocks_or_pixels, pState, |
| astc_transcode_alpha, |
| pAlpha_blocks, |
| output_rows_in_pixels); |
| } |
| |
| // Container independent transcoding |
| bool transcode_image( |
| transcoder_texture_format target_format, |
| void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels, |
| const uint8_t* pCompressed_data, uint32_t compressed_data_length, |
| uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index, |
| uint32_t rgb_offset, uint32_t rgb_length, uint32_t alpha_offset, uint32_t alpha_length, |
| uint32_t decode_flags = 0, |
| bool basis_file_has_alpha_slices = false, |
| bool is_video = false, |
| uint32_t output_row_pitch_in_blocks_or_pixels = 0, |
| basisu_transcoder_state* pState = nullptr, |
| uint32_t output_rows_in_pixels = 0); |
| |
| void clear() |
| { |
| m_local_endpoints.clear(); |
| m_local_selectors.clear(); |
| m_endpoint_pred_model.clear(); |
| m_delta_endpoint_model.clear(); |
| m_selector_model.clear(); |
| m_selector_history_buf_rle_model.clear(); |
| m_selector_history_buf_size = 0; |
| } |
| |
| // Low-level methods |
| typedef basisu::vector<endpoint> endpoint_vec; |
| const endpoint_vec& get_endpoints() const { return m_local_endpoints; } |
| |
| typedef basisu::vector<selector> selector_vec; |
| const selector_vec& get_selectors() const { return m_local_selectors; } |
| |
| private: |
| const basisu_lowlevel_etc1s_transcoder* m_pGlobal_codebook; |
| |
| endpoint_vec m_local_endpoints; |
| selector_vec m_local_selectors; |
| |
| huffman_decoding_table m_endpoint_pred_model, m_delta_endpoint_model, m_selector_model, m_selector_history_buf_rle_model; |
| |
| uint32_t m_selector_history_buf_size; |
| |
| basisu_transcoder_state m_def_state; |
| }; |
| |
| enum basisu_decode_flags |
| { |
| // PVRTC1: decode non-pow2 ETC1S texture level to the next larger power of 2 (not implemented yet, but we're going to support it). Ignored if the slice's dimensions are already a power of 2. |
| cDecodeFlagsPVRTCDecodeToNextPow2 = 2, |
| |
| // When decoding to an opaque texture format, if the basis file has alpha, decode the alpha slice instead of the color slice to the output texture format. |
| // This is primarily to allow decoding of textures with alpha to multiple ETC1 textures (one for color, another for alpha). |
| cDecodeFlagsTranscodeAlphaDataToOpaqueFormats = 4, |
| |
| // Forbid usage of BC1 3 color blocks (we don't support BC1 punchthrough alpha yet). |
| // This flag is used internally when decoding to BC3. |
| cDecodeFlagsBC1ForbidThreeColorBlocks = 8, |
| |
| // The output buffer contains alpha endpoint/selector indices. |
| // Used internally when decoding formats like ASTC that require both color and alpha data to be available when transcoding to the output format. |
| cDecodeFlagsOutputHasAlphaIndices = 16, |
| |
| cDecodeFlagsHighQuality = 32 |
| }; |
| |
| class basisu_lowlevel_uastc_transcoder |
| { |
| friend class basisu_transcoder; |
| |
| public: |
| basisu_lowlevel_uastc_transcoder(); |
| |
| bool transcode_slice(void* pDst_blocks, uint32_t num_blocks_x, uint32_t num_blocks_y, const uint8_t* pImage_data, uint32_t image_data_size, block_format fmt, |
| uint32_t output_block_or_pixel_stride_in_bytes, bool bc1_allow_threecolor_blocks, bool has_alpha, const uint32_t orig_width, const uint32_t orig_height, uint32_t output_row_pitch_in_blocks_or_pixels = 0, |
| basisu_transcoder_state* pState = nullptr, uint32_t output_rows_in_pixels = 0, int channel0 = -1, int channel1 = -1, uint32_t decode_flags = 0); |
| |
| bool transcode_slice(void* pDst_blocks, uint32_t num_blocks_x, uint32_t num_blocks_y, const uint8_t* pImage_data, uint32_t image_data_size, block_format fmt, |
| uint32_t output_block_or_pixel_stride_in_bytes, bool bc1_allow_threecolor_blocks, const basis_file_header& header, const basis_slice_desc& slice_desc, uint32_t output_row_pitch_in_blocks_or_pixels = 0, |
| basisu_transcoder_state* pState = nullptr, uint32_t output_rows_in_pixels = 0, int channel0 = -1, int channel1 = -1, uint32_t decode_flags = 0) |
| { |
| return transcode_slice(pDst_blocks, num_blocks_x, num_blocks_y, pImage_data, image_data_size, fmt, |
| output_block_or_pixel_stride_in_bytes, bc1_allow_threecolor_blocks, (header.m_flags & cBASISHeaderFlagHasAlphaSlices) != 0, slice_desc.m_orig_width, slice_desc.m_orig_height, output_row_pitch_in_blocks_or_pixels, |
| pState, output_rows_in_pixels, channel0, channel1, decode_flags); |
| } |
| |
| // Container independent transcoding |
| bool transcode_image( |
| transcoder_texture_format target_format, |
| void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels, |
| const uint8_t* pCompressed_data, uint32_t compressed_data_length, |
| uint32_t num_blocks_x, uint32_t num_blocks_y, uint32_t orig_width, uint32_t orig_height, uint32_t level_index, |
| uint32_t slice_offset, uint32_t slice_length, |
| uint32_t decode_flags = 0, |
| bool has_alpha = false, |
| bool is_video = false, |
| uint32_t output_row_pitch_in_blocks_or_pixels = 0, |
| basisu_transcoder_state* pState = nullptr, |
| uint32_t output_rows_in_pixels = 0, |
| int channel0 = -1, int channel1 = -1); |
| }; |
| |
| struct basisu_slice_info |
| { |
| uint32_t m_orig_width; |
| uint32_t m_orig_height; |
| |
| uint32_t m_width; |
| uint32_t m_height; |
| |
| uint32_t m_num_blocks_x; |
| uint32_t m_num_blocks_y; |
| uint32_t m_total_blocks; |
| |
| uint32_t m_compressed_size; |
| |
| uint32_t m_slice_index; // the slice index in the .basis file |
| uint32_t m_image_index; // the source image index originally provided to the encoder |
| uint32_t m_level_index; // the mipmap level within this image |
| |
| uint32_t m_unpacked_slice_crc16; |
| |
| bool m_alpha_flag; // true if the slice has alpha data |
| bool m_iframe_flag; // true if the slice is an I-Frame |
| }; |
| |
| typedef basisu::vector<basisu_slice_info> basisu_slice_info_vec; |
| |
| struct basisu_image_info |
| { |
| uint32_t m_image_index; |
| uint32_t m_total_levels; |
| |
| uint32_t m_orig_width; |
| uint32_t m_orig_height; |
| |
| uint32_t m_width; |
| uint32_t m_height; |
| |
| uint32_t m_num_blocks_x; |
| uint32_t m_num_blocks_y; |
| uint32_t m_total_blocks; |
| |
| uint32_t m_first_slice_index; |
| |
| bool m_alpha_flag; // true if the image has alpha data |
| bool m_iframe_flag; // true if the image is an I-Frame |
| }; |
| |
| struct basisu_image_level_info |
| { |
| uint32_t m_image_index; |
| uint32_t m_level_index; |
| |
| uint32_t m_orig_width; |
| uint32_t m_orig_height; |
| |
| uint32_t m_width; |
| uint32_t m_height; |
| |
| uint32_t m_num_blocks_x; |
| uint32_t m_num_blocks_y; |
| uint32_t m_total_blocks; |
| |
| uint32_t m_first_slice_index; |
| |
| uint32_t m_rgb_file_ofs; |
| uint32_t m_rgb_file_len; |
| uint32_t m_alpha_file_ofs; |
| uint32_t m_alpha_file_len; |
| |
| bool m_alpha_flag; // true if the image has alpha data |
| bool m_iframe_flag; // true if the image is an I-Frame |
| }; |
| |
| struct basisu_file_info |
| { |
| uint32_t m_version; |
| uint32_t m_total_header_size; |
| |
| uint32_t m_total_selectors; |
| // will be 0 for UASTC or if the file uses global codebooks |
| uint32_t m_selector_codebook_ofs; |
| uint32_t m_selector_codebook_size; |
| |
| uint32_t m_total_endpoints; |
| // will be 0 for UASTC or if the file uses global codebooks |
| uint32_t m_endpoint_codebook_ofs; |
| uint32_t m_endpoint_codebook_size; |
| |
| uint32_t m_tables_ofs; |
| uint32_t m_tables_size; |
| |
| uint32_t m_slices_size; |
| |
| basis_texture_type m_tex_type; |
| uint32_t m_us_per_frame; |
| |
| // Low-level slice information (1 slice per image for color-only basis files, 2 for alpha basis files) |
| basisu_slice_info_vec m_slice_info; |
| |
| uint32_t m_total_images; // total # of images |
| basisu::vector<uint32_t> m_image_mipmap_levels; // the # of mipmap levels for each image |
| |
| uint32_t m_userdata0; |
| uint32_t m_userdata1; |
| |
| basis_tex_format m_tex_format; // ETC1S, UASTC, etc. |
| |
| bool m_y_flipped; // true if the image was Y flipped |
| bool m_etc1s; // true if the file is ETC1S |
| bool m_has_alpha_slices; // true if the texture has alpha slices (for ETC1S: even slices RGB, odd slices alpha) |
| }; |
| |
| // High-level transcoder class which accepts .basis file data and allows the caller to query information about the file and transcode image levels to various texture formats. |
| // If you're just starting out this is the class you care about. |
| class basisu_transcoder |
| { |
| basisu_transcoder(basisu_transcoder&); |
| basisu_transcoder& operator= (const basisu_transcoder&); |
| |
| public: |
| basisu_transcoder(); |
| |
| // Validates the .basis file. This computes a crc16 over the entire file, so it's slow. |
| bool validate_file_checksums(const void* pData, uint32_t data_size, bool full_validation) const; |
| |
| // Quick header validation - no crc16 checks. |
| bool validate_header(const void* pData, uint32_t data_size) const; |
| |
| basis_texture_type get_texture_type(const void* pData, uint32_t data_size) const; |
| bool get_userdata(const void* pData, uint32_t data_size, uint32_t& userdata0, uint32_t& userdata1) const; |
| |
| // Returns the total number of images in the basis file (always 1 or more). |
| // Note that the number of mipmap levels for each image may differ, and that images may have different resolutions. |
| uint32_t get_total_images(const void* pData, uint32_t data_size) const; |
| |
| basis_tex_format get_tex_format(const void* pData, uint32_t data_size) const; |
| |
| // Returns the number of mipmap levels in an image. |
| uint32_t get_total_image_levels(const void* pData, uint32_t data_size, uint32_t image_index) const; |
| |
| // Returns basic information about an image. Note that orig_width/orig_height may not be a multiple of 4. |
| bool get_image_level_desc(const void* pData, uint32_t data_size, uint32_t image_index, uint32_t level_index, uint32_t& orig_width, uint32_t& orig_height, uint32_t& total_blocks) const; |
| |
| // Returns information about the specified image. |
| bool get_image_info(const void* pData, uint32_t data_size, basisu_image_info& image_info, uint32_t image_index) const; |
| |
| // Returns information about the specified image's mipmap level. |
| bool get_image_level_info(const void* pData, uint32_t data_size, basisu_image_level_info& level_info, uint32_t image_index, uint32_t level_index) const; |
| |
| // Get a description of the basis file and low-level information about each slice. |
| bool get_file_info(const void* pData, uint32_t data_size, basisu_file_info& file_info) const; |
| |
| // start_transcoding() must be called before calling transcode_slice() or transcode_image_level(). |
| // For ETC1S files, this call decompresses the selector/endpoint codebooks, so ideally you would only call this once per .basis file (not each image/mipmap level). |
| bool start_transcoding(const void* pData, uint32_t data_size); |
| |
| bool stop_transcoding(); |
| |
| // Returns true if start_transcoding() has been called. |
| bool get_ready_to_transcode() const { return m_ready_to_transcode; } |
| |
| // transcode_image_level() decodes a single mipmap level from the .basis file to any of the supported output texture formats. |
| // It'll first find the slice(s) to transcode, then call transcode_slice() one or two times to decode both the color and alpha texture data (or RG texture data from two slices for BC5). |
| // If the .basis file doesn't have alpha slices, the output alpha blocks will be set to fully opaque (all 255's). |
| // Currently, to decode to PVRTC1 the basis texture's dimensions in pixels must be a power of 2, due to PVRTC1 format requirements. |
| // output_blocks_buf_size_in_blocks_or_pixels should be at least the image level's total_blocks (num_blocks_x * num_blocks_y), or the total number of output pixels if fmt==cTFRGBA32. |
| // output_row_pitch_in_blocks_or_pixels: Number of blocks or pixels per row. If 0, the transcoder uses the slice's num_blocks_x or orig_width (NOT num_blocks_x * 4). Ignored for PVRTC1 (due to texture swizzling). |
| // output_rows_in_pixels: Ignored unless fmt is uncompressed (cRGBA32, etc.). The total number of output rows in the output buffer. If 0, the transcoder assumes the slice's orig_height (NOT num_blocks_y * 4). |
| // Notes: |
| // - basisu_transcoder_init() must have been called first to initialize the transcoder lookup tables before calling this function. |
| // - This method assumes the output texture buffer is readable. In some cases to handle alpha, the transcoder will write temporary data to the output texture in |
| // a first pass, which will be read in a second pass. |
| bool transcode_image_level( |
| const void* pData, uint32_t data_size, |
| uint32_t image_index, uint32_t level_index, |
| void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels, |
| transcoder_texture_format fmt, |
| uint32_t decode_flags = 0, uint32_t output_row_pitch_in_blocks_or_pixels = 0, basisu_transcoder_state* pState = nullptr, uint32_t output_rows_in_pixels = 0) const; |
| |
| // Finds the basis slice corresponding to the specified image/level/alpha params, or -1 if the slice can't be found. |
| int find_slice(const void* pData, uint32_t data_size, uint32_t image_index, uint32_t level_index, bool alpha_data) const; |
| |
| // transcode_slice() decodes a single slice from the .basis file. It's a low-level API - most likely you want to use transcode_image_level(). |
| // This is a low-level API, and will be needed to be called multiple times to decode some texture formats (like BC3, BC5, or ETC2). |
| // output_blocks_buf_size_in_blocks_or_pixels is just used for verification to make sure the output buffer is large enough. |
| // output_blocks_buf_size_in_blocks_or_pixels should be at least the image level's total_blocks (num_blocks_x * num_blocks_y), or the total number of output pixels if fmt==cTFRGBA32. |
| // output_block_stride_in_bytes: Number of bytes between each output block. |
| // output_row_pitch_in_blocks_or_pixels: Number of blocks or pixels per row. If 0, the transcoder uses the slice's num_blocks_x or orig_width (NOT num_blocks_x * 4). Ignored for PVRTC1 (due to texture swizzling). |
| // output_rows_in_pixels: Ignored unless fmt is cRGBA32. The total number of output rows in the output buffer. If 0, the transcoder assumes the slice's orig_height (NOT num_blocks_y * 4). |
| // Notes: |
| // - basisu_transcoder_init() must have been called first to initialize the transcoder lookup tables before calling this function. |
| bool transcode_slice(const void* pData, uint32_t data_size, uint32_t slice_index, |
| void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels, |
| block_format fmt, uint32_t output_block_stride_in_bytes, uint32_t decode_flags = 0, uint32_t output_row_pitch_in_blocks_or_pixels = 0, basisu_transcoder_state* pState = nullptr, void* pAlpha_blocks = nullptr, |
| uint32_t output_rows_in_pixels = 0, int channel0 = -1, int channel1 = -1) const; |
| |
| static void write_opaque_alpha_blocks( |
| uint32_t num_blocks_x, uint32_t num_blocks_y, |
| void* pOutput_blocks, block_format fmt, |
| uint32_t block_stride_in_bytes, uint32_t output_row_pitch_in_blocks_or_pixels); |
| |
| void set_global_codebooks(const basisu_lowlevel_etc1s_transcoder* pGlobal_codebook) { m_lowlevel_etc1s_decoder.set_global_codebooks(pGlobal_codebook); } |
| const basisu_lowlevel_etc1s_transcoder* get_global_codebooks() const { return m_lowlevel_etc1s_decoder.get_global_codebooks(); } |
| |
| const basisu_lowlevel_etc1s_transcoder& get_lowlevel_etc1s_decoder() const { return m_lowlevel_etc1s_decoder; } |
| basisu_lowlevel_etc1s_transcoder& get_lowlevel_etc1s_decoder() { return m_lowlevel_etc1s_decoder; } |
| |
| const basisu_lowlevel_uastc_transcoder& get_lowlevel_uastc_decoder() const { return m_lowlevel_uastc_decoder; } |
| basisu_lowlevel_uastc_transcoder& get_lowlevel_uastc_decoder() { return m_lowlevel_uastc_decoder; } |
| |
| private: |
| mutable basisu_lowlevel_etc1s_transcoder m_lowlevel_etc1s_decoder; |
| mutable basisu_lowlevel_uastc_transcoder m_lowlevel_uastc_decoder; |
| |
| bool m_ready_to_transcode; |
| |
| int find_first_slice_index(const void* pData, uint32_t data_size, uint32_t image_index, uint32_t level_index) const; |
| |
| bool validate_header_quick(const void* pData, uint32_t data_size) const; |
| }; |
| |
| // basisu_transcoder_init() MUST be called before a .basis file can be transcoded. |
| void basisu_transcoder_init(); |
| |
| enum debug_flags_t |
| { |
| cDebugFlagVisCRs = 1, |
| cDebugFlagVisBC1Sels = 2, |
| cDebugFlagVisBC1Endpoints = 4 |
| }; |
| uint32_t get_debug_flags(); |
| void set_debug_flags(uint32_t f); |
| |
| // ------------------------------------------------------------------------------------------------------ |
| // Optional .KTX2 file format support |
| // KTX2 reading optionally requires miniz or Zstd decompressors for supercompressed UASTC files. |
| // ------------------------------------------------------------------------------------------------------ |
| #if BASISD_SUPPORT_KTX2 |
| #pragma pack(push) |
| #pragma pack(1) |
| struct ktx2_header |
| { |
| uint8_t m_identifier[12]; |
| basisu::packed_uint<4> m_vk_format; |
| basisu::packed_uint<4> m_type_size; |
| basisu::packed_uint<4> m_pixel_width; |
| basisu::packed_uint<4> m_pixel_height; |
| basisu::packed_uint<4> m_pixel_depth; |
| basisu::packed_uint<4> m_layer_count; |
| basisu::packed_uint<4> m_face_count; |
| basisu::packed_uint<4> m_level_count; |
| basisu::packed_uint<4> m_supercompression_scheme; |
| basisu::packed_uint<4> m_dfd_byte_offset; |
| basisu::packed_uint<4> m_dfd_byte_length; |
| basisu::packed_uint<4> m_kvd_byte_offset; |
| basisu::packed_uint<4> m_kvd_byte_length; |
| basisu::packed_uint<8> m_sgd_byte_offset; |
| basisu::packed_uint<8> m_sgd_byte_length; |
| }; |
| |
| struct ktx2_level_index |
| { |
| basisu::packed_uint<8> m_byte_offset; |
| basisu::packed_uint<8> m_byte_length; |
| basisu::packed_uint<8> m_uncompressed_byte_length; |
| }; |
| |
| struct ktx2_etc1s_global_data_header |
| { |
| basisu::packed_uint<2> m_endpoint_count; |
| basisu::packed_uint<2> m_selector_count; |
| basisu::packed_uint<4> m_endpoints_byte_length; |
| basisu::packed_uint<4> m_selectors_byte_length; |
| basisu::packed_uint<4> m_tables_byte_length; |
| basisu::packed_uint<4> m_extended_byte_length; |
| }; |
| |
| struct ktx2_etc1s_image_desc |
| { |
| basisu::packed_uint<4> m_image_flags; |
| basisu::packed_uint<4> m_rgb_slice_byte_offset; |
| basisu::packed_uint<4> m_rgb_slice_byte_length; |
| basisu::packed_uint<4> m_alpha_slice_byte_offset; |
| basisu::packed_uint<4> m_alpha_slice_byte_length; |
| }; |
| |
| struct ktx2_animdata |
| { |
| basisu::packed_uint<4> m_duration; |
| basisu::packed_uint<4> m_timescale; |
| basisu::packed_uint<4> m_loopcount; |
| }; |
| #pragma pack(pop) |
| |
| const uint32_t KTX2_VK_FORMAT_UNDEFINED = 0; |
| const uint32_t KTX2_KDF_DF_MODEL_UASTC = 166; |
| const uint32_t KTX2_KDF_DF_MODEL_ETC1S = 163; |
| const uint32_t KTX2_IMAGE_IS_P_FRAME = 2; |
| const uint32_t KTX2_UASTC_BLOCK_SIZE = 16; |
| const uint32_t KTX2_MAX_SUPPORTED_LEVEL_COUNT = 16; // this is an implementation specific constraint and can be increased |
| |
| // The KTX2 transfer functions supported by KTX2 |
| const uint32_t KTX2_KHR_DF_TRANSFER_LINEAR = 1; |
| const uint32_t KTX2_KHR_DF_TRANSFER_SRGB = 2; |
| |
| enum ktx2_supercompression |
| { |
| KTX2_SS_NONE = 0, |
| KTX2_SS_BASISLZ = 1, |
| KTX2_SS_ZSTANDARD = 2 |
| }; |
| |
| extern const uint8_t g_ktx2_file_identifier[12]; |
| |
| enum ktx2_df_channel_id |
| { |
| KTX2_DF_CHANNEL_ETC1S_RGB = 0U, |
| KTX2_DF_CHANNEL_ETC1S_RRR = 3U, |
| KTX2_DF_CHANNEL_ETC1S_GGG = 4U, |
| KTX2_DF_CHANNEL_ETC1S_AAA = 15U, |
| |
| KTX2_DF_CHANNEL_UASTC_DATA = 0U, |
| KTX2_DF_CHANNEL_UASTC_RGB = 0U, |
| KTX2_DF_CHANNEL_UASTC_RGBA = 3U, |
| KTX2_DF_CHANNEL_UASTC_RRR = 4U, |
| KTX2_DF_CHANNEL_UASTC_RRRG = 5U, |
| KTX2_DF_CHANNEL_UASTC_RG = 6U, |
| }; |
| |
| inline const char* ktx2_get_etc1s_df_channel_id_str(ktx2_df_channel_id id) |
| { |
| switch (id) |
| { |
| case KTX2_DF_CHANNEL_ETC1S_RGB: return "RGB"; |
| case KTX2_DF_CHANNEL_ETC1S_RRR: return "RRR"; |
| case KTX2_DF_CHANNEL_ETC1S_GGG: return "GGG"; |
| case KTX2_DF_CHANNEL_ETC1S_AAA: return "AAA"; |
| default: break; |
| } |
| return "?"; |
| } |
| |
| inline const char* ktx2_get_uastc_df_channel_id_str(ktx2_df_channel_id id) |
| { |
| switch (id) |
| { |
| case KTX2_DF_CHANNEL_UASTC_RGB: return "RGB"; |
| case KTX2_DF_CHANNEL_UASTC_RGBA: return "RGBA"; |
| case KTX2_DF_CHANNEL_UASTC_RRR: return "RRR"; |
| case KTX2_DF_CHANNEL_UASTC_RRRG: return "RRRG"; |
| case KTX2_DF_CHANNEL_UASTC_RG: return "RG"; |
| default: break; |
| } |
| return "?"; |
| } |
| |
| enum ktx2_df_color_primaries |
| { |
| KTX2_DF_PRIMARIES_UNSPECIFIED = 0, |
| KTX2_DF_PRIMARIES_BT709 = 1, |
| KTX2_DF_PRIMARIES_SRGB = 1, |
| KTX2_DF_PRIMARIES_BT601_EBU = 2, |
| KTX2_DF_PRIMARIES_BT601_SMPTE = 3, |
| KTX2_DF_PRIMARIES_BT2020 = 4, |
| KTX2_DF_PRIMARIES_CIEXYZ = 5, |
| KTX2_DF_PRIMARIES_ACES = 6, |
| KTX2_DF_PRIMARIES_ACESCC = 7, |
| KTX2_DF_PRIMARIES_NTSC1953 = 8, |
| KTX2_DF_PRIMARIES_PAL525 = 9, |
| KTX2_DF_PRIMARIES_DISPLAYP3 = 10, |
| KTX2_DF_PRIMARIES_ADOBERGB = 11 |
| }; |
| |
| inline const char* ktx2_get_df_color_primaries_str(ktx2_df_color_primaries p) |
| { |
| switch (p) |
| { |
| case KTX2_DF_PRIMARIES_UNSPECIFIED: return "UNSPECIFIED"; |
| case KTX2_DF_PRIMARIES_BT709: return "BT709"; |
| case KTX2_DF_PRIMARIES_BT601_EBU: return "EBU"; |
| case KTX2_DF_PRIMARIES_BT601_SMPTE: return "SMPTE"; |
| case KTX2_DF_PRIMARIES_BT2020: return "BT2020"; |
| case KTX2_DF_PRIMARIES_CIEXYZ: return "CIEXYZ"; |
| case KTX2_DF_PRIMARIES_ACES: return "ACES"; |
| case KTX2_DF_PRIMARIES_ACESCC: return "ACESCC"; |
| case KTX2_DF_PRIMARIES_NTSC1953: return "NTSC1953"; |
| case KTX2_DF_PRIMARIES_PAL525: return "PAL525"; |
| case KTX2_DF_PRIMARIES_DISPLAYP3: return "DISPLAYP3"; |
| case KTX2_DF_PRIMARIES_ADOBERGB: return "ADOBERGB"; |
| default: break; |
| } |
| return "?"; |
| } |
| |
| // Information about a single 2D texture "image" in a KTX2 file. |
| struct ktx2_image_level_info |
| { |
| // The mipmap level index (0=largest), texture array layer index, and cubemap face index of the image. |
| uint32_t m_level_index; |
| uint32_t m_layer_index; |
| uint32_t m_face_index; |
| |
| // The image's actual (or the original source image's) width/height in pixels, which may not be divisible by 4 pixels. |
| uint32_t m_orig_width; |
| uint32_t m_orig_height; |
| |
| // The image's physical width/height, which will always be divisible by 4 pixels. |
| uint32_t m_width; |
| uint32_t m_height; |
| |
| // The texture's dimensions in 4x4 texel blocks. |
| uint32_t m_num_blocks_x; |
| uint32_t m_num_blocks_y; |
| |
| // The total number of blocks |
| uint32_t m_total_blocks; |
| |
| // true if the image has alpha data |
| bool m_alpha_flag; |
| |
| // true if the image is an I-Frame. Currently, for ETC1S textures, the first frame will always be an I-Frame, and subsequent frames will always be P-Frames. |
| bool m_iframe_flag; |
| }; |
| |
| // Thread-specific ETC1S/supercompressed UASTC transcoder state. (If you're not doing multithreading transcoding you can ignore this.) |
| struct ktx2_transcoder_state |
| { |
| basist::basisu_transcoder_state m_transcoder_state; |
| basisu::uint8_vec m_level_uncomp_data; |
| int m_uncomp_data_level_index; |
| |
| void clear() |
| { |
| m_transcoder_state.clear(); |
| m_level_uncomp_data.clear(); |
| m_uncomp_data_level_index = -1; |
| } |
| }; |
| |
| // This class is quite similar to basisu_transcoder. It treats KTX2 files as a simple container for ETC1S/UASTC texture data. |
| // It does not support 1D or 3D textures. |
| // It only supports 2D and cubemap textures, with or without mipmaps, texture arrays of 2D/cubemap textures, and texture video files. |
| // It only supports raw non-supercompressed UASTC, ETC1S, UASTC+Zstd, or UASTC+zlib compressed files. |
| // DFD (Data Format Descriptor) parsing is purposely as simple as possible. |
| // If you need to know how to interpret the texture channels you'll need to parse the DFD yourself after calling get_dfd(). |
| class ktx2_transcoder |
| { |
| public: |
| ktx2_transcoder(); |
| |
| // Frees all allocations, resets object. |
| void clear(); |
| |
| // init() parses the KTX2 header, level index array, DFD, and key values, but nothing else. |
| // Importantly, it does not parse or decompress the ETC1S global supercompressed data, so some things (like which frames are I/P-Frames) won't be available until start_transcoding() is called. |
| // This method holds a pointer to the file data until clear() is called. |
| bool init(const void* pData, uint32_t data_size); |
| |
| // Returns the data/size passed to init(). |
| const uint8_t* get_data() const { return m_pData; } |
| uint32_t get_data_size() const { return m_data_size; } |
| |
| // Returns the KTX2 header. Valid after init(). |
| const ktx2_header& get_header() const { return m_header; } |
| |
| // Returns the KTX2 level index array. There will be one entry for each mipmap level. Valid after init(). |
| const basisu::vector<ktx2_level_index>& get_level_index() const { return m_levels; } |
| |
| // Returns the texture's width in texels. Always non-zero, might not be divisible by 4. Valid after init(). |
| uint32_t get_width() const { return m_header.m_pixel_width; } |
| |
| // Returns the texture's height in texels. Always non-zero, might not be divisible by 4. Valid after init(). |
| uint32_t get_height() const { return m_header.m_pixel_height; } |
| |
| // Returns the texture's number of mipmap levels. Always returns 1 or higher. Valid after init(). |
| uint32_t get_levels() const { return m_header.m_level_count; } |
| |
| // Returns the number of faces. Returns 1 for 2D textures and or 6 for cubemaps. Valid after init(). |
| uint32_t get_faces() const { return m_header.m_face_count; } |
| |
| // Returns 0 or the number of layers in the texture array or texture video. Valid after init(). |
| uint32_t get_layers() const { return m_header.m_layer_count; } |
| |
| // Returns cETC1S or cUASTC4x4. Valid after init(). |
| basist::basis_tex_format get_format() const { return m_format; } |
| |
| bool is_etc1s() const { return get_format() == basist::basis_tex_format::cETC1S; } |
| |
| bool is_uastc() const { return get_format() == basist::basis_tex_format::cUASTC4x4; } |
| |
| // Returns true if the ETC1S file has two planes (typically RGBA, or RRRG), or true if the UASTC file has alpha data. Valid after init(). |
| uint32_t get_has_alpha() const { return m_has_alpha; } |
| |
| // Returns the entire Data Format Descriptor (DFD) from the KTX2 file. Valid after init(). |
| // See https://www.khronos.org/registry/DataFormat/specs/1.3/dataformat.1.3.html#_the_khronos_data_format_descriptor_overview |
| const basisu::uint8_vec& get_dfd() const { return m_dfd; } |
| |
| // Some basic DFD accessors. Valid after init(). |
| uint32_t get_dfd_color_model() const { return m_dfd_color_model; } |
| |
| // Returns the DFD color primary. |
| // We do not validate the color primaries, so the returned value may not be in the ktx2_df_color_primaries enum. |
| ktx2_df_color_primaries get_dfd_color_primaries() const { return m_dfd_color_prims; } |
| |
| // Returns KTX2_KHR_DF_TRANSFER_LINEAR or KTX2_KHR_DF_TRANSFER_SRGB. |
| uint32_t get_dfd_transfer_func() const { return m_dfd_transfer_func; } |
| |
| uint32_t get_dfd_flags() const { return m_dfd_flags; } |
| |
| // Returns 1 (ETC1S/UASTC) or 2 (ETC1S with an internal alpha channel). |
| uint32_t get_dfd_total_samples() const { return m_dfd_samples; } |
| |
| // Returns the channel mapping for each DFD "sample". UASTC always has 1 sample, ETC1S can have one or two. |
| // Note the returned value SHOULD be one of the ktx2_df_channel_id enums, but we don't validate that. |
| // It's up to the caller to decide what to do if the value isn't in the enum. |
| ktx2_df_channel_id get_dfd_channel_id0() const { return m_dfd_chan0; } |
| ktx2_df_channel_id get_dfd_channel_id1() const { return m_dfd_chan1; } |
| |
| // Key value field data. |
| struct key_value |
| { |
| // The key field is UTF8 and always zero terminated. |
| basisu::uint8_vec m_key; |
| |
| // The value may be empty. It consists of raw bytes which may or may not be zero terminated. |
| basisu::uint8_vec m_value; |
| |
| bool operator< (const key_value& rhs) const { return strcmp((const char*)m_key.data(), (const char *)rhs.m_key.data()) < 0; } |
| }; |
| typedef basisu::vector<key_value> key_value_vec; |
| |
| // Returns the array of key-value entries. This may be empty. Valid after init(). |
| // The order of key values fields in this array exactly matches the order they were stored in the file. The keys are supposed to be sorted by their Unicode code points. |
| const key_value_vec& get_key_values() const { return m_key_values; } |
| |
| const basisu::uint8_vec *find_key(const std::string& key_name) const; |
| |
| // Low-level ETC1S specific accessors |
| |
| // Returns the ETC1S global supercompression data header, which is only valid after start_transcoding() is called. |
| const ktx2_etc1s_global_data_header& get_etc1s_header() const { return m_etc1s_header; } |
| |
| // Returns the array of ETC1S image descriptors, which is only valid after get_etc1s_image_descs() is called. |
| const basisu::vector<ktx2_etc1s_image_desc>& get_etc1s_image_descs() const { return m_etc1s_image_descs; } |
| |
| // Must have called startTranscoding() first |
| uint32_t get_etc1s_image_descs_image_flags(uint32_t level_index, uint32_t layer_index, uint32_t face_index) const; |
| |
| // is_video() is only valid after start_transcoding() is called. |
| // For ETC1S data, if this returns true you must currently transcode the file from first to last frame, in order, without skipping any frames. |
| bool is_video() const { return m_is_video; } |
| |
| // start_transcoding() MUST be called before calling transcode_image(). |
| // This method decompresses the ETC1S global endpoint/selector codebooks, which is not free, so try to avoid calling it excessively. |
| bool start_transcoding(); |
| |
| // get_image_level_info() be called after init(), but the m_iframe_flag's won't be valid until start_transcoding() is called. |
| // You can call this method before calling transcode_image_level() to retrieve basic information about the mipmap level's dimensions, etc. |
| bool get_image_level_info(ktx2_image_level_info& level_info, uint32_t level_index, uint32_t layer_index, uint32_t face_index) const; |
| |
| // transcode_image_level() transcodes a single 2D texture or cubemap face from the KTX2 file. |
| // Internally it uses the same low-level transcode API's as basisu_transcoder::transcode_image_level(). |
| // If the file is UASTC and is supercompressed with Zstandard, and the file is a texture array or cubemap, it's highly recommended that each mipmap level is |
| // completely transcoded before switching to another level. Every time the mipmap level is changed all supercompressed level data must be decompressed using Zstandard as a single unit. |
| // Currently ETC1S videos must always be transcoded from first to last frame (or KTX2 "layer"), in order, with no skipping of frames. |
| // By default this method is not thread safe unless you specify a pointer to a user allocated thread-specific transcoder_state struct. |
| bool transcode_image_level( |
| uint32_t level_index, uint32_t layer_index, uint32_t face_index, |
| void* pOutput_blocks, uint32_t output_blocks_buf_size_in_blocks_or_pixels, |
| basist::transcoder_texture_format fmt, |
| uint32_t decode_flags = 0, uint32_t output_row_pitch_in_blocks_or_pixels = 0, uint32_t output_rows_in_pixels = 0, int channel0 = -1, int channel1 = -1, |
| ktx2_transcoder_state *pState = nullptr); |
| |
| private: |
| const uint8_t* m_pData; |
| uint32_t m_data_size; |
| |
| ktx2_header m_header; |
| basisu::vector<ktx2_level_index> m_levels; |
| basisu::uint8_vec m_dfd; |
| key_value_vec m_key_values; |
| |
| ktx2_etc1s_global_data_header m_etc1s_header; |
| basisu::vector<ktx2_etc1s_image_desc> m_etc1s_image_descs; |
| |
| basist::basis_tex_format m_format; |
| |
| uint32_t m_dfd_color_model; |
| ktx2_df_color_primaries m_dfd_color_prims; |
| uint32_t m_dfd_transfer_func; |
| uint32_t m_dfd_flags; |
| uint32_t m_dfd_samples; |
| ktx2_df_channel_id m_dfd_chan0, m_dfd_chan1; |
| |
| basist::basisu_lowlevel_etc1s_transcoder m_etc1s_transcoder; |
| basist::basisu_lowlevel_uastc_transcoder m_uastc_transcoder; |
| |
| ktx2_transcoder_state m_def_transcoder_state; |
| |
| bool m_has_alpha; |
| bool m_is_video; |
| |
| bool decompress_level_data(uint32_t level_index, basisu::uint8_vec& uncomp_data); |
| bool decompress_etc1s_global_data(); |
| bool read_key_values(); |
| }; |
| |
| #endif // BASISD_SUPPORT_KTX2 |
| |
| // Returns true if the transcoder was compiled with KTX2 support. |
| bool basisu_transcoder_supports_ktx2(); |
| |
| // Returns true if the transcoder was compiled with Zstandard support. |
| bool basisu_transcoder_supports_ktx2_zstd(); |
| |
| } // namespace basisu |
| |
| /**** ended inlining basisu_transcoder.h ****/ |
| #include <limits.h> |
| /**** start inlining basisu_containers_impl.h ****/ |
| // basisu_containers_impl.h |
| // Do not include directly |
| |
| #ifdef _MSC_VER |
| #pragma warning (disable:4127) // warning C4127: conditional expression is constant |
| #endif |
| |
| namespace basisu |
| { |
| bool elemental_vector::increase_capacity(uint32_t min_new_capacity, bool grow_hint, uint32_t element_size, object_mover pMover, bool nofail) |
| { |
| assert(m_size <= m_capacity); |
| |
| if (sizeof(void *) == sizeof(uint64_t)) |
| assert(min_new_capacity < (0x400000000ULL / element_size)); |
| else |
| assert(min_new_capacity < (0x7FFF0000U / element_size)); |
| |
| if (m_capacity >= min_new_capacity) |
| return true; |
| |
| size_t new_capacity = min_new_capacity; |
| if ((grow_hint) && (!helpers::is_power_of_2((uint64_t)new_capacity))) |
| { |
| new_capacity = (size_t)helpers::next_pow2((uint64_t)new_capacity); |
| |
| assert(new_capacity && (new_capacity > m_capacity)); |
| |
| if (new_capacity < min_new_capacity) |
| { |
| if (nofail) |
| return false; |
| fprintf(stderr, "vector too large\n"); |
| abort(); |
| } |
| } |
| |
| const size_t desired_size = element_size * new_capacity; |
| size_t actual_size = 0; |
| if (!pMover) |
| { |
| void* new_p = realloc(m_p, desired_size); |
| if (!new_p) |
| { |
| if (nofail) |
| return false; |
| |
| char buf[256]; |
| #ifdef _MSC_VER |
| sprintf_s(buf, sizeof(buf), "vector: realloc() failed allocating %u bytes", (uint32_t)desired_size); |
| #else |
| sprintf(buf, "vector: realloc() failed allocating %u bytes", (uint32_t)desired_size); |
| #endif |
| fprintf(stderr, "%s", buf); |
| abort(); |
| } |
| |
| #if BASISU_VECTOR_DETERMINISTIC |
| actual_size = desired_size; |
| #elif defined(_MSC_VER) |
| actual_size = _msize(new_p); |
| #elif HAS_MALLOC_USABLE_SIZE |
| actual_size = malloc_usable_size(new_p); |
| #else |
| actual_size = desired_size; |
| #endif |
| m_p = new_p; |
| } |
| else |
| { |
| void* new_p = malloc(desired_size); |
| if (!new_p) |
| { |
| if (nofail) |
| return false; |
| |
| char buf[256]; |
| #ifdef _MSC_VER |
| sprintf_s(buf, sizeof(buf), "vector: malloc() failed allocating %u bytes", (uint32_t)desired_size); |
| #else |
| sprintf(buf, "vector: malloc() failed allocating %u bytes", (uint32_t)desired_size); |
| #endif |
| fprintf(stderr, "%s", buf); |
| abort(); |
| } |
| |
| #if BASISU_VECTOR_DETERMINISTIC |
| actual_size = desired_size; |
| #elif defined(_MSC_VER) |
| actual_size = _msize(new_p); |
| #elif HAS_MALLOC_USABLE_SIZE |
| actual_size = malloc_usable_size(new_p); |
| #else |
| actual_size = desired_size; |
| #endif |
| |
| (*pMover)(new_p, m_p, m_size); |
| |
| if (m_p) |
| free(m_p); |
| |
| m_p = new_p; |
| } |
| |
| if (actual_size > desired_size) |
| m_capacity = static_cast<uint32_t>(actual_size / element_size); |
| else |
| m_capacity = static_cast<uint32_t>(new_capacity); |
| |
| return true; |
| } |
| |
| #if BASISU_HASHMAP_TEST |
| |
| #define HASHMAP_TEST_VERIFY(c) do { if (!(c)) handle_hashmap_test_verify_failure(__LINE__); } while(0) |
| |
| static void handle_hashmap_test_verify_failure(int line) |
| { |
| fprintf(stderr, "HASHMAP_TEST_VERIFY() faild on line %i\n", line); |
| abort(); |
| } |
| |
| class counted_obj |
| { |
| public: |
| counted_obj(uint32_t v = 0) : |
| m_val(v) |
| { |
| m_count++; |
| } |
| |
| counted_obj(const counted_obj& obj) : |
| m_val(obj.m_val) |
| { |
| m_count++; |
| } |
| |
| ~counted_obj() |
| { |
| assert(m_count > 0); |
| m_count--; |
| } |
| |
| static uint32_t m_count; |
| |
| uint32_t m_val; |
| |
| operator size_t() const { return m_val; } |
| |
| bool operator== (const counted_obj& rhs) const { return m_val == rhs.m_val; } |
| bool operator== (const uint32_t rhs) const { return m_val == rhs; } |
| |
| }; |
| |
| uint32_t counted_obj::m_count; |
| |
| static uint32_t urand32() |
| { |
| uint32_t a = rand(); |
| uint32_t b = rand() << 15; |
| uint32_t c = rand() << (32 - 15); |
| return a ^ b ^ c; |
| } |
| |
| static int irand32(int l, int h) |
| { |
| assert(l < h); |
| if (l >= h) |
| return l; |
| |
| uint32_t range = static_cast<uint32_t>(h - l); |
| |
| uint32_t rnd = urand32(); |
| |
| uint32_t rnd_range = static_cast<uint32_t>((((uint64_t)range) * ((uint64_t)rnd)) >> 32U); |
| |
| int result = l + rnd_range; |
| assert((result >= l) && (result < h)); |
| return result; |
| } |
| |
| void hash_map_test() |
| { |
| { |
| basisu::hash_map<uint64_t, uint64_t> k; |
| basisu::hash_map<uint64_t, uint64_t> l; |
| std::swap(k, l); |
| |
| k.begin(); |
| k.end(); |
| k.clear(); |
| k.empty(); |
| k.erase(0); |
| k.insert(0, 1); |
| k.find(0); |
| k.get_equals(); |
| k.get_hasher(); |
| k.get_table_size(); |
| k.reset(); |
| k.reserve(1); |
| k = l; |
| k.set_equals(l.get_equals()); |
| k.set_hasher(l.get_hasher()); |
| k.get_table_size(); |
| } |
| |
| uint32_t seed = 0; |
| for (; ; ) |
| { |
| seed++; |
| |
| typedef basisu::hash_map<counted_obj, counted_obj> my_hash_map; |
| my_hash_map m; |
| |
| const uint32_t n = irand32(0, 100000); |
| |
| printf("%u\n", n); |
| |
| srand(seed); // r1.seed(seed); |
| |
| basisu::vector<int> q; |
| |
| uint32_t count = 0; |
| for (uint32_t i = 0; i < n; i++) |
| { |
| uint32_t v = urand32() & 0x7FFFFFFF; |
| my_hash_map::insert_result res = m.insert(counted_obj(v), counted_obj(v ^ 0xdeadbeef)); |
| if (res.second) |
| { |
| count++; |
| q.push_back(v); |
| } |
| } |
| |
| HASHMAP_TEST_VERIFY(m.size() == count); |
| |
| srand(seed); |
| |
| my_hash_map cm(m); |
| m.clear(); |
| m = cm; |
| cm.reset(); |
| |
| for (uint32_t i = 0; i < n; i++) |
| { |
| uint32_t v = urand32() & 0x7FFFFFFF; |
| my_hash_map::const_iterator it = m.find(counted_obj(v)); |
| HASHMAP_TEST_VERIFY(it != m.end()); |
| HASHMAP_TEST_VERIFY(it->first == v); |
| HASHMAP_TEST_VERIFY(it->second == (v ^ 0xdeadbeef)); |
| } |
| |
| for (uint32_t t = 0; t < 2; t++) |
| { |
| const uint32_t nd = irand32(1, q.size() + 1); |
| for (uint32_t i = 0; i < nd; i++) |
| { |
| uint32_t p = irand32(0, q.size()); |
| |
| int k = q[p]; |
| if (k >= 0) |
| { |
| q[p] = -k - 1; |
| |
| bool s = m.erase(counted_obj(k)); |
| HASHMAP_TEST_VERIFY(s); |
| } |
| } |
| |
| typedef basisu::hash_map<uint32_t, empty_type> uint_hash_set; |
| uint_hash_set s; |
| |
| for (uint32_t i = 0; i < q.size(); i++) |
| { |
| int v = q[i]; |
| |
| if (v >= 0) |
| { |
| my_hash_map::const_iterator it = m.find(counted_obj(v)); |
| HASHMAP_TEST_VERIFY(it != m.end()); |
| HASHMAP_TEST_VERIFY(it->first == (uint32_t)v); |
| HASHMAP_TEST_VERIFY(it->second == ((uint32_t)v ^ 0xdeadbeef)); |
| |
| s.insert(v); |
| } |
| else |
| { |
| my_hash_map::const_iterator it = m.find(counted_obj(-v - 1)); |
| HASHMAP_TEST_VERIFY(it == m.end()); |
| } |
| } |
| |
| uint32_t found_count = 0; |
| for (my_hash_map::const_iterator it = m.begin(); it != m.end(); ++it) |
| { |
| HASHMAP_TEST_VERIFY(it->second == ((uint32_t)it->first ^ 0xdeadbeef)); |
| |
| uint_hash_set::const_iterator fit(s.find((uint32_t)it->first)); |
| HASHMAP_TEST_VERIFY(fit != s.end()); |
| |
| HASHMAP_TEST_VERIFY(fit->first == it->first); |
| |
| found_count++; |
| } |
| |
| HASHMAP_TEST_VERIFY(found_count == s.size()); |
| } |
| |
| HASHMAP_TEST_VERIFY(counted_obj::m_count == m.size() * 2); |
| } |
| } |
| |
| #endif // BASISU_HASHMAP_TEST |
| |
| } // namespace basisu |
| /**** ended inlining basisu_containers_impl.h ****/ |
| |
| #ifndef BASISD_IS_BIG_ENDIAN |
| // TODO: This doesn't work on OSX. How can this be so difficult? |
| //#if defined(__BIG_ENDIAN__) || defined(_BIG_ENDIAN) || defined(BIG_ENDIAN) |
| // #define BASISD_IS_BIG_ENDIAN (1) |
| //#else |
| #define BASISD_IS_BIG_ENDIAN (0) |
| //#endif |
| #endif |
| |
| #ifndef BASISD_USE_UNALIGNED_WORD_READS |
| #ifdef __EMSCRIPTEN__ |
| // Can't use unaligned loads/stores with WebAssembly. |
| #define BASISD_USE_UNALIGNED_WORD_READS (0) |
| #elif defined(_M_AMD64) || defined(_M_IX86) || defined(__i386__) || defined(__x86_64__) |
| #define BASISD_USE_UNALIGNED_WORD_READS (1) |
| #else |
| #define BASISD_USE_UNALIGNED_WORD_READS (0) |
| #endif |
| #endif |
| |
| #define BASISD_SUPPORTED_BASIS_VERSION (0x13) |
| |
| #ifndef BASISD_SUPPORT_KTX2 |
| #error Must have defined BASISD_SUPPORT_KTX2 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_KTX2_ZSTD |
| #error Must have defined BASISD_SUPPORT_KTX2_ZSTD |
| #endif |
| |
| // Set to 1 for fuzz testing. This will disable all CRC16 checks on headers and compressed data. |
| #ifndef BASISU_NO_HEADER_OR_DATA_CRC16_CHECKS |
| #define BASISU_NO_HEADER_OR_DATA_CRC16_CHECKS 0 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_DXT1 |
| #define BASISD_SUPPORT_DXT1 1 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_DXT5A |
| #define BASISD_SUPPORT_DXT5A 1 |
| #endif |
| |
| // Disable all BC7 transcoders if necessary (useful when cross compiling to Javascript) |
| #if defined(BASISD_SUPPORT_BC7) && !BASISD_SUPPORT_BC7 |
| #ifndef BASISD_SUPPORT_BC7_MODE5 |
| #define BASISD_SUPPORT_BC7_MODE5 0 |
| #endif |
| #endif // !BASISD_SUPPORT_BC7 |
| |
| // BC7 mode 5 supports both opaque and opaque+alpha textures, and uses less memory BC1. |
| #ifndef BASISD_SUPPORT_BC7_MODE5 |
| #define BASISD_SUPPORT_BC7_MODE5 1 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_PVRTC1 |
| #define BASISD_SUPPORT_PVRTC1 1 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_ETC2_EAC_A8 |
| #define BASISD_SUPPORT_ETC2_EAC_A8 1 |
| #endif |
| |
| // Set BASISD_SUPPORT_UASTC to 0 to completely disable support for transcoding UASTC files. |
| #ifndef BASISD_SUPPORT_UASTC |
| #define BASISD_SUPPORT_UASTC 1 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_ASTC |
| #define BASISD_SUPPORT_ASTC 1 |
| #endif |
| |
| // Note that if BASISD_SUPPORT_ATC is enabled, BASISD_SUPPORT_DXT5A should also be enabled for alpha support. |
| #ifndef BASISD_SUPPORT_ATC |
| #define BASISD_SUPPORT_ATC 1 |
| #endif |
| |
| // Support for ETC2 EAC R11 and ETC2 EAC RG11 |
| #ifndef BASISD_SUPPORT_ETC2_EAC_RG11 |
| #define BASISD_SUPPORT_ETC2_EAC_RG11 1 |
| #endif |
| |
| // If BASISD_SUPPORT_ASTC_HIGHER_OPAQUE_QUALITY is 1, opaque blocks will be transcoded to ASTC at slightly higher quality (higher than BC1), but the transcoder tables will be 2x as large. |
| // This impacts grayscale and grayscale+alpha textures the most. |
| #ifndef BASISD_SUPPORT_ASTC_HIGHER_OPAQUE_QUALITY |
| #ifdef __EMSCRIPTEN__ |
| // Let's assume size matters more than quality when compiling with emscripten. |
| #define BASISD_SUPPORT_ASTC_HIGHER_OPAQUE_QUALITY 0 |
| #else |
| // Compiling native, so an extra 64K lookup table is probably acceptable. |
| #define BASISD_SUPPORT_ASTC_HIGHER_OPAQUE_QUALITY 1 |
| #endif |
| #endif |
| |
| #ifndef BASISD_SUPPORT_FXT1 |
| #define BASISD_SUPPORT_FXT1 1 |
| #endif |
| |
| #ifndef BASISD_SUPPORT_PVRTC2 |
| #define BASISD_SUPPORT_PVRTC2 1 |
| #endif |
| |
| #if BASISD_SUPPORT_PVRTC2 |
| #if !BASISD_SUPPORT_ATC |
| #error BASISD_SUPPORT_ATC must be 1 if BASISD_SUPPORT_PVRTC2 is 1 |
| #endif |
| #endif |
| |
| #if BASISD_SUPPORT_ATC |
| #if !BASISD_SUPPORT_DXT5A |
| #error BASISD_SUPPORT_DXT5A must be 1 if BASISD_SUPPORT_ATC is 1 |
| #endif |
| #endif |
| |
| #define BASISD_WRITE_NEW_BC7_MODE5_TABLES 0 |
| #define BASISD_WRITE_NEW_DXT1_TABLES 0 |
| #define BASISD_WRITE_NEW_ETC2_EAC_A8_TABLES 0 |
| #define BASISD_WRITE_NEW_ASTC_TABLES 0 |
| #define BASISD_WRITE_NEW_ATC_TABLES 0 |
| #define BASISD_WRITE_NEW_ETC2_EAC_R11_TABLES 0 |
| |
| #ifndef BASISD_ENABLE_DEBUG_FLAGS |
| #define BASISD_ENABLE_DEBUG_FLAGS 0 |
| #endif |
| |
| // If KTX2 support is enabled, we may need Zstd for decompression of supercompressed UASTC files. Include this header. |
| #if BASISD_SUPPORT_KTX2 |
| // If BASISD_SUPPORT_KTX2_ZSTD is 0, UASTC files compressed with Zstd cannot be loaded. |
| #if BASISD_SUPPORT_KTX2_ZSTD |
| // We only use two Zstd API's: ZSTD_decompress() and ZSTD_isError() |
| /**** start inlining zstd ****/ |
| #error Unable to find "zstd" |
| /**** ended inlining zstd ****/ |
| #endif |
| #endif |
| |
| namespace basisu |
| { |
| bool g_debug_printf; |
| |
| void enable_debug_printf(bool enabled) |
| { |
| g_debug_printf = enabled; |
| } |
| |
| void debug_printf(const char* pFmt, ...) |
| { |
| #if BASISU_FORCE_DEVEL_MESSAGES |
| g_debug_printf = true; |
| #endif |
| if (g_debug_printf) |
| { |
| va_list args; |
| va_start(args, pFmt); |
| vprintf(pFmt, args); |
| va_end(args); |
| } |
| } |
| } // namespace basisu |
| |
| namespace basist |
| { |
| |
| #if BASISD_ENABLE_DEBUG_FLAGS |
| static uint32_t g_debug_flags = 0; |
| #endif |
| |
| uint32_t get_debug_flags() |
| { |
| #if BASISD_ENABLE_DEBUG_FLAGS |
| return g_debug_flags; |
| #else |
| return 0; |
| #endif |
| } |
| |
| void set_debug_flags(uint32_t f) |
| { |
| BASISU_NOTE_UNUSED(f); |
| #if BASISD_ENABLE_DEBUG_FLAGS |
| g_debug_flags = f; |
| #endif |
| } |
| |
| inline uint16_t byteswap_uint16(uint16_t v) |
| { |
| return static_cast<uint16_t>((v >> 8) | (v << 8)); |
| } |
| |
| static inline int32_t clampi(int32_t value, int32_t low, int32_t high) { if (value < low) value = low; else if (value > high) value = high; return value; } |
| static inline float clampf(float value, float low, float high) { if (value < low) value = low; else if (value > high) value = high; return value; } |
| static inline float saturate(float value) { return clampf(value, 0, 1.0f); } |
| |
| static inline uint8_t mul_8(uint32_t v, uint32_t q) { v = v * q + 128; return (uint8_t)((v + (v >> 8)) >> 8); } |
| |
| uint16_t crc16(const void* r, size_t size, uint16_t crc) |
| { |
| crc = ~crc; |
| |
| const uint8_t* p = static_cast<const uint8_t*>(r); |
| for (; size; --size) |
| { |
| const uint16_t q = *p++ ^ (crc >> 8); |
| uint16_t k = (q >> 4) ^ q; |
| crc = (((crc << 8) ^ k) ^ (k << 5)) ^ (k << 12); |
| } |
| |
| return static_cast<uint16_t>(~crc); |
| } |
| |
| enum etc_constants |
| { |
| cETC1BytesPerBlock = 8U, |
| |
| cETC1SelectorBits = 2U, |
| cETC1SelectorValues = 1U << cETC1SelectorBits, |
| cETC1SelectorMask = cETC1SelectorValues - 1U, |
| |
| cETC1BlockShift = 2U, |
| cETC1BlockSize = 1U << cETC1BlockShift, |
| |
| cETC1LSBSelectorIndicesBitOffset = 0, |
| cETC1MSBSelectorIndicesBitOffset = 16, |
| |
| cETC1FlipBitOffset = 32, |
| cETC1DiffBitOffset = 33, |
| |
| cETC1IntenModifierNumBits = 3, |
| cETC1IntenModifierValues = 1 << cETC1IntenModifierNumBits, |
| cETC1RightIntenModifierTableBitOffset = 34, |
| cETC1LeftIntenModifierTableBitOffset = 37, |
| |
| // Base+Delta encoding (5 bit bases, 3 bit delta) |
| cETC1BaseColorCompNumBits = 5, |
| cETC1BaseColorCompMax = 1 << cETC1BaseColorCompNumBits, |
| |
| cETC1DeltaColorCompNumBits = 3, |
| cETC1DeltaColorComp = 1 << cETC1DeltaColorCompNumBits, |
| cETC1DeltaColorCompMax = 1 << cETC1DeltaColorCompNumBits, |
| |
| cETC1BaseColor5RBitOffset = 59, |
| cETC1BaseColor5GBitOffset = 51, |
| cETC1BaseColor5BBitOffset = 43, |
| |
| cETC1DeltaColor3RBitOffset = 56, |
| cETC1DeltaColor3GBitOffset = 48, |
| cETC1DeltaColor3BBitOffset = 40, |
| |
| // Absolute (non-delta) encoding (two 4-bit per component bases) |
| cETC1AbsColorCompNumBits = 4, |
| cETC1AbsColorCompMax = 1 << cETC1AbsColorCompNumBits, |
| |
| cETC1AbsColor4R1BitOffset = 60, |
| cETC1AbsColor4G1BitOffset = 52, |
| cETC1AbsColor4B1BitOffset = 44, |
| |
| cETC1AbsColor4R2BitOffset = 56, |
| cETC1AbsColor4G2BitOffset = 48, |
| cETC1AbsColor4B2BitOffset = 40, |
| |
| cETC1ColorDeltaMin = -4, |
| cETC1ColorDeltaMax = 3, |
| |
| // Delta3: |
| // 0 1 2 3 4 5 6 7 |
| // 000 001 010 011 100 101 110 111 |
| // 0 1 2 3 -4 -3 -2 -1 |
| }; |
| |
| #define DECLARE_ETC1_INTEN_TABLE(name, N) \ |
| static const int name[cETC1IntenModifierValues][cETC1SelectorValues] = \ |
| { \ |
| { N * -8, N * -2, N * 2, N * 8 },{ N * -17, N * -5, N * 5, N * 17 },{ N * -29, N * -9, N * 9, N * 29 },{ N * -42, N * -13, N * 13, N * 42 }, \ |
| { N * -60, N * -18, N * 18, N * 60 },{ N * -80, N * -24, N * 24, N * 80 },{ N * -106, N * -33, N * 33, N * 106 },{ N * -183, N * -47, N * 47, N * 183 } \ |
| }; |
| |
| DECLARE_ETC1_INTEN_TABLE(g_etc1_inten_tables, 1); |
| DECLARE_ETC1_INTEN_TABLE(g_etc1_inten_tables16, 16); |
| DECLARE_ETC1_INTEN_TABLE(g_etc1_inten_tables48, 3 * 16); |
| |
| //const uint8_t g_etc1_to_selector_index[cETC1SelectorValues] = { 2, 3, 1, 0 }; |
| const uint8_t g_selector_index_to_etc1[cETC1SelectorValues] = { 3, 2, 0, 1 }; |
| |
| static const uint8_t g_etc_5_to_8[32] = { 0, 8, 16, 24, 33, 41, 49, 57, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165, 173, 181, 189, 198, 206, 214, 222, 231, 239, 247, 255 }; |
| |
| struct decoder_etc_block |
| { |
| // big endian uint64: |
| // bit ofs: 56 48 40 32 24 16 8 0 |
| // byte ofs: b0, b1, b2, b3, b4, b5, b6, b7 |
| union |
| { |
| uint64_t m_uint64; |
| |
| uint32_t m_uint32[2]; |
| |
| uint8_t m_bytes[8]; |
| |
| struct |
| { |
| signed m_dred2 : 3; |
| uint32_t m_red1 : 5; |
| |
| signed m_dgreen2 : 3; |
| uint32_t m_green1 : 5; |
| |
| signed m_dblue2 : 3; |
| uint32_t m_blue1 : 5; |
| |
| uint32_t m_flip : 1; |
| uint32_t m_diff : 1; |
| uint32_t m_cw2 : 3; |
| uint32_t m_cw1 : 3; |
| |
| uint32_t m_selectors; |
| } m_differential; |
| }; |
| |
| inline void clear() |
| { |
| assert(sizeof(*this) == 8); |
| basisu::clear_obj(*this); |
| } |
| |
| inline void set_byte_bits(uint32_t ofs, uint32_t num, uint32_t bits) |
| { |
| assert((ofs + num) <= 64U); |
| assert(num && (num < 32U)); |
| assert((ofs >> 3) == ((ofs + num - 1) >> 3)); |
| assert(bits < (1U << num)); |
| const uint32_t byte_ofs = 7 - (ofs >> 3); |
| const uint32_t byte_bit_ofs = ofs & 7; |
| const uint32_t mask = (1 << num) - 1; |
| m_bytes[byte_ofs] &= ~(mask << byte_bit_ofs); |
| m_bytes[byte_ofs] |= (bits << byte_bit_ofs); |
| } |
| |
| inline void set_flip_bit(bool flip) |
| { |
| m_bytes[3] &= ~1; |
| m_bytes[3] |= static_cast<uint8_t>(flip); |
| } |
| |
| inline void set_diff_bit(bool diff) |
| { |
| m_bytes[3] &= ~2; |
| m_bytes[3] |= (static_cast<uint32_t>(diff) << 1); |
| } |
| |
| // Sets intensity modifier table (0-7) used by subblock subblock_id (0 or 1) |
| inline void set_inten_table(uint32_t subblock_id, uint32_t t) |
| { |
| assert(subblock_id < 2); |
| assert(t < 8); |
| const uint32_t ofs = subblock_id ? 2 : 5; |
| m_bytes[3] &= ~(7 << ofs); |
| m_bytes[3] |= (t << ofs); |
| } |
| |
| // Selector "val" ranges from 0-3 and is a direct index into g_etc1_inten_tables. |
| inline void set_selector(uint32_t x, uint32_t y, uint32_t val) |
| { |
| assert((x | y | val) < 4); |
| const uint32_t bit_index = x * 4 + y; |
| |
| uint8_t* p = &m_bytes[7 - (bit_index >> 3)]; |
| |
| const uint32_t byte_bit_ofs = bit_index & 7; |
| const uint32_t mask = 1 << byte_bit_ofs; |
| |
| static const uint8_t s_selector_index_to_etc1[4] = { 3, 2, 0, 1 }; |
| const uint32_t etc1_val = s_selector_index_to_etc1[val]; |
| |
| const uint32_t lsb = etc1_val & 1; |
| const uint32_t msb = etc1_val >> 1; |
| |
| p[0] &= ~mask; |
| p[0] |= (lsb << byte_bit_ofs); |
| |
| p[-2] &= ~mask; |
| p[-2] |= (msb << byte_bit_ofs); |
| } |
| |
| // Returned encoded selector value ranges from 0-3 (this is NOT a direct index into g_etc1_inten_tables, see get_selector()) |
| inline uint32_t get_raw_selector(uint32_t x, uint32_t y) const |
| { |
| assert((x | y) < 4); |
| |
| const uint32_t bit_index = x * 4 + y; |
| const uint32_t byte_bit_ofs = bit_index & 7; |
| const uint8_t* p = &m_bytes[7 - (bit_index >> 3)]; |
| const uint32_t lsb = (p[0] >> byte_bit_ofs) & 1; |
| const uint32_t msb = (p[-2] >> byte_bit_ofs) & 1; |
| const uint32_t val = lsb | (msb << 1); |
| |
| return val; |
| } |
| |
| // Returned selector value ranges from 0-3 and is a direct index into g_etc1_inten_tables. |
| inline uint32_t get_selector(uint32_t x, uint32_t y) const |
| { |
| static const uint8_t s_etc1_to_selector_index[cETC1SelectorValues] = { 2, 3, 1, 0 }; |
| return s_etc1_to_selector_index[get_raw_selector(x, y)]; |
| } |
| |
| inline void set_raw_selector_bits(uint32_t bits) |
| { |
| m_bytes[4] = static_cast<uint8_t>(bits); |
| m_bytes[5] = static_cast<uint8_t>(bits >> 8); |
| m_bytes[6] = static_cast<uint8_t>(bits >> 16); |
| m_bytes[7] = static_cast<uint8_t>(bits >> 24); |
| } |
| |
| inline bool are_all_selectors_the_same() const |
| { |
| uint32_t v = *reinterpret_cast<const uint32_t*>(&m_bytes[4]); |
| |
| if ((v == 0xFFFFFFFF) || (v == 0xFFFF) || (!v) || (v == 0xFFFF0000)) |
| return true; |
| |
| return false; |
| } |
| |
| inline void set_raw_selector_bits(uint8_t byte0, uint8_t byte1, uint8_t byte2, uint8_t byte3) |
| { |
| m_bytes[4] = byte0; |
| m_bytes[5] = byte1; |
| m_bytes[6] = byte2; |
| m_bytes[7] = byte3; |
| } |
| |
| inline uint32_t get_raw_selector_bits() const |
| { |
| return m_bytes[4] | (m_bytes[5] << 8) | (m_bytes[6] << 16) | (m_bytes[7] << 24); |
| } |
| |
| inline void set_base4_color(uint32_t idx, uint16_t c) |
| { |
| if (idx) |
| { |
| set_byte_bits(cETC1AbsColor4R2BitOffset, 4, (c >> 8) & 15); |
| set_byte_bits(cETC1AbsColor4G2BitOffset, 4, (c >> 4) & 15); |
| set_byte_bits(cETC1AbsColor4B2BitOffset, 4, c & 15); |
| } |
| else |
| { |
| set_byte_bits(cETC1AbsColor4R1BitOffset, 4, (c >> 8) & 15); |
| set_byte_bits(cETC1AbsColor4G1BitOffset, 4, (c >> 4) & 15); |
| set_byte_bits(cETC1AbsColor4B1BitOffset, 4, c & 15); |
| } |
| } |
| |
| inline void set_base5_color(uint16_t c) |
| { |
| set_byte_bits(cETC1BaseColor5RBitOffset, 5, (c >> 10) & 31); |
| set_byte_bits(cETC1BaseColor5GBitOffset, 5, (c >> 5) & 31); |
| set_byte_bits(cETC1BaseColor5BBitOffset, 5, c & 31); |
| } |
| |
| void set_delta3_color(uint16_t c) |
| { |
| set_byte_bits(cETC1DeltaColor3RBitOffset, 3, (c >> 6) & 7); |
| set_byte_bits(cETC1DeltaColor3GBitOffset, 3, (c >> 3) & 7); |
| set_byte_bits(cETC1DeltaColor3BBitOffset, 3, c & 7); |
| } |
| |
| void set_block_color4(const color32& c0_unscaled, const color32& c1_unscaled) |
| { |
| set_diff_bit(false); |
| |
| set_base4_color(0, pack_color4(c0_unscaled, false)); |
| set_base4_color(1, pack_color4(c1_unscaled, false)); |
| } |
| |
| void set_block_color5(const color32& c0_unscaled, const color32& c1_unscaled) |
| { |
| set_diff_bit(true); |
| |
| set_base5_color(pack_color5(c0_unscaled, false)); |
| |
| int dr = c1_unscaled.r - c0_unscaled.r; |
| int dg = c1_unscaled.g - c0_unscaled.g; |
| int db = c1_unscaled.b - c0_unscaled.b; |
| |
| set_delta3_color(pack_delta3(dr, dg, db)); |
| } |
| |
| bool set_block_color5_check(const color32& c0_unscaled, const color32& c1_unscaled) |
| { |
| set_diff_bit(true); |
| |
| set_base5_color(pack_color5(c0_unscaled, false)); |
| |
| int dr = c1_unscaled.r - c0_unscaled.r; |
| int dg = c1_unscaled.g - c0_unscaled.g; |
| int db = c1_unscaled.b - c0_unscaled.b; |
| |
| if (((dr < cETC1ColorDeltaMin) || (dr > cETC1ColorDeltaMax)) || |
| ((dg < cETC1ColorDeltaMin) || (dg > cETC1ColorDeltaMax)) || |
| ((db < cETC1ColorDeltaMin) || (db > cETC1ColorDeltaMax))) |
| return false; |
| |
| set_delta3_color(pack_delta3(dr, dg, db)); |
| |
| return true; |
| } |
| |
| inline uint32_t get_byte_bits(uint32_t ofs, uint32_t num) const |
| { |
| assert((ofs + num) <= 64U); |
| assert(num && (num <= 8U)); |
| assert((ofs >> 3) == ((ofs + num - 1) >> 3)); |
| const uint32_t byte_ofs = 7 - (ofs >> 3); |
| const uint32_t byte_bit_ofs = ofs & 7; |
| return (m_bytes[byte_ofs] >> byte_bit_ofs) & ((1 << num) - 1); |
| } |
| |
| inline uint16_t get_base5_color() const |
| { |
| const uint32_t r = get_byte_bits(cETC1BaseColor5RBitOffset, 5); |
| const uint32_t g = get_byte_bits(cETC1BaseColor5GBitOffset, 5); |
| const uint32_t b = get_byte_bits(cETC1BaseColor5BBitOffset, 5); |
| return static_cast<uint16_t>(b | (g << 5U) | (r << 10U)); |
| } |
| |
| inline uint16_t get_base4_color(uint32_t idx) const |
| { |
| uint32_t r, g, b; |
| if (idx) |
| { |
| r = get_byte_bits(cETC1AbsColor4R2BitOffset, 4); |
| g = get_byte_bits(cETC1AbsColor4G2BitOffset, 4); |
| b = get_byte_bits(cETC1AbsColor4B2BitOffset, 4); |
| } |
| else |
| { |
| r = get_byte_bits(cETC1AbsColor4R1BitOffset, 4); |
| g = get_byte_bits(cETC1AbsColor4G1BitOffset, 4); |
| b = get_byte_bits(cETC1AbsColor4B1BitOffset, 4); |
| } |
| return static_cast<uint16_t>(b | (g << 4U) | (r << 8U)); |
| } |
| |
| inline color32 get_base5_color_unscaled() const |
| { |
| return color32(m_differential.m_red1, m_differential.m_green1, m_differential.m_blue1, 255); |
| } |
| |
| inline bool get_flip_bit() const |
| { |
| return (m_bytes[3] & 1) != 0; |
| } |
| |
| inline bool get_diff_bit() const |
| { |
| return (m_bytes[3] & 2) != 0; |
| } |
| |
| inline uint32_t get_inten_table(uint32_t subblock_id) const |
| { |
| assert(subblock_id < 2); |
| const uint32_t ofs = subblock_id ? 2 : 5; |
| return (m_bytes[3] >> ofs) & 7; |
| } |
| |
| inline uint16_t get_delta3_color() const |
| { |
| const uint32_t r = get_byte_bits(cETC1DeltaColor3RBitOffset, 3); |
| const uint32_t g = get_byte_bits(cETC1DeltaColor3GBitOffset, 3); |
| const uint32_t b = get_byte_bits(cETC1DeltaColor3BBitOffset, 3); |
| return static_cast<uint16_t>(b | (g << 3U) | (r << 6U)); |
| } |
| |
| void get_block_colors(color32* pBlock_colors, uint32_t subblock_index) const |
| { |
| color32 b; |
| |
| if (get_diff_bit()) |
| { |
| if (subblock_index) |
| unpack_color5(b, get_base5_color(), get_delta3_color(), true, 255); |
| else |
| unpack_color5(b, get_base5_color(), true); |
| } |
| else |
| { |
| b = unpack_color4(get_base4_color(subblock_index), true, 255); |
| } |
| |
| const int* pInten_table = g_etc1_inten_tables[get_inten_table(subblock_index)]; |
| |
| pBlock_colors[0].set_noclamp_rgba(clamp255(b.r + pInten_table[0]), clamp255(b.g + pInten_table[0]), clamp255(b.b + pInten_table[0]), 255); |
| pBlock_colors[1].set_noclamp_rgba(clamp255(b.r + pInten_table[1]), clamp255(b.g + pInten_table[1]), clamp255(b.b + pInten_table[1]), 255); |
| pBlock_colors[2].set_noclamp_rgba(clamp255(b.r + pInten_table[2]), clamp255(b.g + pInten_table[2]), clamp255(b.b + pInten_table[2]), 255); |
| pBlock_colors[3].set_noclamp_rgba(clamp255(b.r + pInten_table[3]), clamp255(b.g + pInten_table[3]), clamp255(b.b + pInten_table[3]), 255); |
| } |
| |
| static uint16_t pack_color4(const color32& color, bool scaled, uint32_t bias = 127U) |
| { |
| return pack_color4(color.r, color.g, color.b, scaled, bias); |
| } |
| |
| static uint16_t pack_color4(uint32_t r, uint32_t g, uint32_t b, bool scaled, uint32_t bias = 127U) |
| { |
| if (scaled) |
| { |
| r = (r * 15U + bias) / 255U; |
| g = (g * 15U + bias) / 255U; |
| b = (b * 15U + bias) / 255U; |
| } |
| |
| r = basisu::minimum(r, 15U); |
| g = basisu::minimum(g, 15U); |
| b = basisu::minimum(b, 15U); |
| |
| return static_cast<uint16_t>(b | (g << 4U) | (r << 8U)); |
| } |
| |
| static uint16_t pack_color5(const color32& color, bool scaled, uint32_t bias = 127U) |
| { |
| return pack_color5(color.r, color.g, color.b, scaled, bias); |
| } |
| |
| static uint16_t pack_color5(uint32_t r, uint32_t g, uint32_t b, bool scaled, uint32_t bias = 127U) |
| { |
| if (scaled) |
| { |
| r = (r * 31U + bias) / 255U; |
| g = (g * 31U + bias) / 255U; |
| b = (b * 31U + bias) / 255U; |
| } |
| |
| r = basisu::minimum(r, 31U); |
| g = basisu::minimum(g, 31U); |
| b = basisu::minimum(b, 31U); |
| |
| return static_cast<uint16_t>(b | (g << 5U) | (r << 10U)); |
| } |
| |
| uint16_t pack_delta3(const color32& color) |
| { |
| return pack_delta3(color.r, color.g, color.b); |
| } |
| |
| uint16_t pack_delta3(int r, int g, int b) |
| { |
| assert((r >= cETC1ColorDeltaMin) && (r <= cETC1ColorDeltaMax)); |
| assert((g >= cETC1ColorDeltaMin) && (g <= cETC1ColorDeltaMax)); |
| assert((b >= cETC1ColorDeltaMin) && (b <= cETC1ColorDeltaMax)); |
| if (r < 0) r += 8; |
| if (g < 0) g += 8; |
| if (b < 0) b += 8; |
| return static_cast<uint16_t>(b | (g << 3) | (r << 6)); |
| } |
| |
| static void unpack_delta3(int& r, int& g, int& b, uint16_t packed_delta3) |
| { |
| r = (packed_delta3 >> 6) & 7; |
| g = (packed_delta3 >> 3) & 7; |
| b = packed_delta3 & 7; |
| if (r >= 4) r -= 8; |
| if (g >= 4) g -= 8; |
| if (b >= 4) b -= 8; |
| } |
| |
| static color32 unpack_color5(uint16_t packed_color5, bool scaled, uint32_t alpha) |
| { |
| uint32_t b = packed_color5 & 31U; |
| uint32_t g = (packed_color5 >> 5U) & 31U; |
| uint32_t r = (packed_color5 >> 10U) & 31U; |
| |
| if (scaled) |
| { |
| b = (b << 3U) | (b >> 2U); |
| g = (g << 3U) | (g >> 2U); |
| r = (r << 3U) | (r >> 2U); |
| } |
| |
| assert(alpha <= 255); |
| |
| return color32(cNoClamp, r, g, b, alpha); |
| } |
| |
| static void unpack_color5(uint32_t& r, uint32_t& g, uint32_t& b, uint16_t packed_color5, bool scaled) |
| { |
| color32 c(unpack_color5(packed_color5, scaled, 0)); |
| r = c.r; |
| g = c.g; |
| b = c.b; |
| } |
| |
| static void unpack_color5(color32& result, uint16_t packed_color5, bool scaled) |
| { |
| result = unpack_color5(packed_color5, scaled, 255); |
| } |
| |
| static bool unpack_color5(color32& result, uint16_t packed_color5, uint16_t packed_delta3, bool scaled, uint32_t alpha) |
| { |
| int dr, dg, db; |
| unpack_delta3(dr, dg, db, packed_delta3); |
| |
| int r = ((packed_color5 >> 10U) & 31U) + dr; |
| int g = ((packed_color5 >> 5U) & 31U) + dg; |
| int b = (packed_color5 & 31U) + db; |
| |
| bool success = true; |
| if (static_cast<uint32_t>(r | g | b) > 31U) |
| { |
| success = false; |
| r = basisu::clamp<int>(r, 0, 31); |
| g = basisu::clamp<int>(g, 0, 31); |
| b = basisu::clamp<int>(b, 0, 31); |
| } |
| |
| if (scaled) |
| { |
| b = (b << 3U) | (b >> 2U); |
| g = (g << 3U) | (g >> 2U); |
| r = (r << 3U) | (r >> 2U); |
| } |
| |
| result.set_noclamp_rgba(r, g, b, basisu::minimum(alpha, 255U)); |
| return success; |
| } |
| |
| static color32 unpack_color4(uint16_t packed_color4, bool scaled, uint32_t alpha) |
| { |
| uint32_t b = packed_color4 & 15U; |
| uint32_t g = (packed_color4 >> 4U) & 15U; |
| uint32_t r = (packed_color4 >> 8U) & 15U; |
| |
| if (scaled) |
| { |
| b = (b << 4U) | b; |
| g = (g << 4U) | g; |
| r = (r << 4U) | r; |
| } |
| |
| return color32(cNoClamp, r, g, b, basisu::minimum(alpha, 255U)); |
| } |
| |
| static void unpack_color4(uint32_t& r, uint32_t& g, uint32_t& b, uint16_t packed_color4, bool scaled) |
| { |
| color32 c(unpack_color4(packed_color4, scaled, 0)); |
| r = c.r; |
| g = c.g; |
| b = c.b; |
| } |
| |
| static void get_diff_subblock_colors(color32* pDst, uint16_t packed_color5, uint32_t table_idx) |
| { |
| assert(table_idx < cETC1IntenModifierValues); |
| const int* pInten_modifer_table = &g_etc1_inten_tables[table_idx][0]; |
| |
| uint32_t r, g, b; |
| unpack_color5(r, g, b, packed_color5, true); |
| |
| const int ir = static_cast<int>(r), ig = static_cast<int>(g), ib = static_cast<int>(b); |
| |
| const int y0 = pInten_modifer_table[0]; |
| pDst[0].set(clamp255(ir + y0), clamp255(ig + y0), clamp255(ib + y0), 255); |
| |
| const int y1 = pInten_modifer_table[1]; |
| pDst[1].set(clamp255(ir + y1), clamp255(ig + y1), clamp255(ib + y1), 255); |
| |
| const int y2 = pInten_modifer_table[2]; |
| pDst[2].set(clamp255(ir + y2), clamp255(ig + y2), clamp255(ib + y2), 255); |
| |
| const int y3 = pInten_modifer_table[3]; |
| pDst[3].set(clamp255(ir + y3), clamp255(ig + y3), clamp255(ib + y3), 255); |
| } |
| |
| static int clamp255(int x) |
| { |
| if (x & 0xFFFFFF00) |
| { |
| if (x < 0) |
| x = 0; |
| else if (x > 255) |
| x = 255; |
| } |
| |
| return x; |
| } |
| |
| static void get_block_colors5(color32* pBlock_colors, const color32& base_color5, uint32_t inten_table) |
| { |
| color32 b(base_color5); |
| |
| b.r = (b.r << 3) | (b.r >> 2); |
| b.g = (b.g << 3) | (b.g >> 2); |
| b.b = (b.b << 3) | (b.b >> 2); |
| |
| const int* pInten_table = g_etc1_inten_tables[inten_table]; |
| |
| pBlock_colors[0].set(clamp255(b.r + pInten_table[0]), clamp255(b.g + pInten_table[0]), clamp255(b.b + pInten_table[0]), 255); |
| pBlock_colors[1].set(clamp255(b.r + pInten_table[1]), clamp255(b.g + pInten_table[1]), clamp255(b.b + pInten_table[1]), 255); |
| pBlock_colors[2].set(clamp255(b.r + pInten_table[2]), clamp255(b.g + pInten_table[2]), clamp255(b.b + pInten_table[2]), 255); |
| pBlock_colors[3].set(clamp255(b.r + pInten_table[3]), clamp255(b.g + pInten_table[3]), clamp255(b.b + pInten_table[3]), 255); |
| } |
| |
| static void get_block_color5(const color32& base_color5, uint32_t inten_table, uint32_t index, uint32_t& r, uint32_t &g, uint32_t &b) |
| { |
| assert(index < 4); |
| |
| uint32_t br = (base_color5.r << 3) | (base_color5.r >> 2); |
| uint32_t bg = (base_color5.g << 3) | (base_color5.g >> 2); |
| uint32_t bb = (base_color5.b << 3) | (base_color5.b >> 2); |
| |
| const int* pInten_table = g_etc1_inten_tables[inten_table]; |
| |
| r = clamp255(br + pInten_table[index]); |
| g = clamp255(bg + pInten_table[index]); |
| b = clamp255(bb + pInten_table[index]); |
| } |
| |
| static void get_block_color5_r(const color32& base_color5, uint32_t inten_table, uint32_t index, uint32_t &r) |
| { |
| assert(index < 4); |
| |
| uint32_t br = (base_color5.r << 3) | (base_color5.r >> 2); |
| |
| const int* pInten_table = g_etc1_inten_tables[inten_table]; |
| |
| r = clamp255(br + pInten_table[index]); |
| } |
| |
| static void get_block_colors5_g(int* pBlock_colors, const color32& base_color5, uint32_t inten_table) |
| { |
| const int g = (base_color5.g << 3) | (base_color5.g >> 2); |
| |
| const int* pInten_table = g_etc1_inten_tables[inten_table]; |
| |
| pBlock_colors[0] = clamp255(g + pInten_table[0]); |
| pBlock_colors[1] = clamp255(g + pInten_table[1]); |
| pBlock_colors[2] = clamp255(g + pInten_table[2]); |
| pBlock_colors[3] = clamp255(g + pInten_table[3]); |
| } |
| |
| static void get_block_colors5_bounds(color32* pBlock_colors, const color32& base_color5, uint32_t inten_table, uint32_t l = 0, uint32_t h = 3) |
| { |
| color32 b(base_color5); |
| |
| b.r = (b.r << 3) | (b.r >> 2); |
| b.g = (b.g << 3) | (b.g >> 2); |
| b.b = (b.b << 3) | (b.b >> 2); |
| |
| const int* pInten_table = g_etc1_inten_tables[inten_table]; |
| |
| pBlock_colors[0].set(clamp255(b.r + pInten_table[l]), clamp255(b.g + pInten_table[l]), clamp255(b.b + pInten_table[l]), 255); |
| pBlock_colors[1].set(clamp255(b.r + pInten_table[h]), clamp255(b.g + pInten_table[h]), clamp255(b.b + pInten_table[h]), 255); |
| } |
| |
| static void get_block_colors5_bounds_g(uint32_t* pBlock_colors, const color32& base_color5, uint32_t inten_table, uint32_t l = 0, uint32_t h = 3) |
| { |
| color32 b(base_color5); |
| |
| b.g = (b.g << 3) | (b.g >> 2); |
| |
| const int* pInten_table = g_etc1_inten_tables[inten_table]; |
| |
| pBlock_colors[0] = clamp255(b.g + pInten_table[l]); |
| pBlock_colors[1] = clamp255(b.g + pInten_table[h]); |
| } |
| }; |
| |
| enum dxt_constants |
| { |
| cDXT1SelectorBits = 2U, cDXT1SelectorValues = 1U << cDXT1SelectorBits, cDXT1SelectorMask = cDXT1SelectorValues - 1U, |
| cDXT5SelectorBits = 3U, cDXT5SelectorValues = 1U << cDXT5SelectorBits, cDXT5SelectorMask = cDXT5SelectorValues - 1U, |
| }; |
| |
| static const uint8_t g_etc1_x_selector_unpack[4][256] = |
| { |
| { |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, |
| }, |
| { |
| 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, |
| 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, |
| 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, |
| 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, |
| 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, |
| 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, |
| 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, |
| 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, 2, 2, 3, 3, |
| }, |
| |
| { |
| 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, |
| 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, |
| 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, |
| 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, |
| 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, |
| 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, |
| 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, |
| 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, |
| }, |
| |
| { |
| 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, |
| 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, |
| 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, |
| 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, |
| 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, |
| 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, |
| 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, |
| 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, |
| } |
| }; |
| |
| struct dxt1_block |
| { |
| enum { cTotalEndpointBytes = 2, cTotalSelectorBytes = 4 }; |
| |
| uint8_t m_low_color[cTotalEndpointBytes]; |
| uint8_t m_high_color[cTotalEndpointBytes]; |
| uint8_t m_selectors[cTotalSelectorBytes]; |
| |
| inline void clear() { basisu::clear_obj(*this); } |
| |
| inline uint32_t get_high_color() const { return m_high_color[0] | (m_high_color[1] << 8U); } |
| inline uint32_t get_low_color() const { return m_low_color[0] | (m_low_color[1] << 8U); } |
| inline void set_low_color(uint16_t c) { m_low_color[0] = static_cast<uint8_t>(c & 0xFF); m_low_color[1] = static_cast<uint8_t>((c >> 8) & 0xFF); } |
| inline void set_high_color(uint16_t c) { m_high_color[0] = static_cast<uint8_t>(c & 0xFF); m_high_color[1] = static_cast<uint8_t>((c >> 8) & 0xFF); } |
| inline uint32_t get_selector(uint32_t x, uint32_t y) const { assert((x < 4U) && (y < 4U)); return (m_selectors[y] >> (x * cDXT1SelectorBits)) & cDXT1SelectorMask; } |
| inline void set_selector(uint32_t x, uint32_t y, uint32_t val) { assert((x < 4U) && (y < 4U) && (val < 4U)); m_selectors[y] &= (~(cDXT1SelectorMask << (x * cDXT1SelectorBits))); m_selectors[y] |= (val << (x * cDXT1SelectorBits)); } |
| |
| static uint16_t pack_color(const color32& color, bool scaled, uint32_t bias = 127U) |
| { |
| uint32_t r = color.r, g = color.g, b = color.b; |
| if (scaled) |
| { |
| r = (r * 31U + bias) / 255U; |
| g = (g * 63U + bias) / 255U; |
| b = (b * 31U + bias) / 255U; |
| } |
| return static_cast<uint16_t>(basisu::minimum(b, 31U) | (basisu::minimum(g, 63U) << 5U) | (basisu::minimum(r, 31U) << 11U)); |
| } |
| |
| static uint16_t pack_unscaled_color(uint32_t r, uint32_t g, uint32_t b) { return static_cast<uint16_t>(b | (g << 5U) | (r << 11U)); } |
| }; |
| |
| struct dxt_selector_range |
| { |
| uint32_t m_low; |
| uint32_t m_high; |
| }; |
| |
| struct etc1_to_dxt1_56_solution |
| { |
| uint8_t m_lo; |
| uint8_t m_hi; |
| uint16_t m_err; |
| }; |
| |
| #if BASISD_SUPPORT_DXT1 |
| static dxt_selector_range g_etc1_to_dxt1_selector_ranges[] = |
| { |
| { 0, 3 }, |
| |
| { 1, 3 }, |
| { 0, 2 }, |
| |
| { 1, 2 }, |
| |
| { 2, 3 }, |
| { 0, 1 }, |
| }; |
| |
| const uint32_t NUM_ETC1_TO_DXT1_SELECTOR_RANGES = sizeof(g_etc1_to_dxt1_selector_ranges) / sizeof(g_etc1_to_dxt1_selector_ranges[0]); |
| |
| static uint32_t g_etc1_to_dxt1_selector_range_index[4][4]; |
| |
| const uint32_t NUM_ETC1_TO_DXT1_SELECTOR_MAPPINGS = 10; |
| static const uint8_t g_etc1_to_dxt1_selector_mappings[NUM_ETC1_TO_DXT1_SELECTOR_MAPPINGS][4] = |
| { |
| { 0, 0, 1, 1 }, |
| { 0, 0, 1, 2 }, |
| { 0, 0, 1, 3 }, |
| { 0, 0, 2, 3 }, |
| { 0, 1, 1, 1 }, |
| { 0, 1, 2, 2 }, |
| { 0, 1, 2, 3 }, |
| { 0, 2, 3, 3 }, |
| { 1, 2, 2, 2 }, |
| { 1, 2, 3, 3 }, |
| }; |
| |
| static uint8_t g_etc1_to_dxt1_selector_mappings_raw_dxt1_256[NUM_ETC1_TO_DXT1_SELECTOR_MAPPINGS][256]; |
| static uint8_t g_etc1_to_dxt1_selector_mappings_raw_dxt1_inv_256[NUM_ETC1_TO_DXT1_SELECTOR_MAPPINGS][256]; |
| |
| static const etc1_to_dxt1_56_solution g_etc1_to_dxt_6[32 * 8 * NUM_ETC1_TO_DXT1_SELECTOR_MAPPINGS * NUM_ETC1_TO_DXT1_SELECTOR_RANGES] = { |
| /**** start inlining basisu_transcoder_tables_dxt1_6.inc ****/ |
| // Copyright (C) 2017-2019 Binomial LLC. All Rights Reserved. |
| // |
| // Licensed 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. |
| {0,4,18},{0,3,4},{0,2,0},{0,2,9},{0,3,36},{0,2,22},{0,2,13},{0,1,24},{0,1,41},{0,1,25},{0,4,18},{0,3,4},{0,2,0},{0,2,9},{1,1,36},{0,2,22},{0,2,13},{0,1,24},{3,0,36},{0,1,24},{0,2,0},{0,2,0},{0,2,0},{0,1,0},{0,1,2},{0,1,1},{0,1,1},{0,0,4},{0,0,4},{0,0,4},{0,2,0}, |
| {0,2,0},{0,2,0},{0,1,0},{0,1,2},{0,1,1},{0,1,1},{0,0,4},{1,0,2},{0,0,4},{2,0,18},{0,3,4},{0,2,0},{0,2,9},{2,0,18},{4,0,18},{0,2,9},{0,1,20},{4,0,18},{0,1,20},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{1,8,38},{1,6,21},{1,4,24}, |
| {1,4,24},{0,8,52},{0,5,18},{0,4,1},{0,3,24},{0,4,77},{0,3,40},{2,6,22},{1,6,5},{2,4,4},{1,4,8},{4,0,52},{0,5,18},{0,4,1},{0,3,24},{8,0,52},{0,3,24},{1,6,20},{1,6,20},{1,6,20},{1,3,21},{0,6,8},{0,4,1},{0,4,1},{0,2,5},{0,3,24},{0,2,9},{2,4,4},{2,4,4},{2,4,4},{2,3,4},{3,0,8}, |
| {1,3,1},{1,3,1},{1,2,4},{6,0,8},{1,2,4},{5,0,18},{1,6,1},{2,4,0},{0,4,0},{5,0,18},{10,0,18},{0,4,0},{0,3,20},{10,0,18},{0,3,20},{1,0,20},{1,0,20},{1,0,20},{1,0,20},{0,5,0},{0,5,0},{0,5,0},{0,2,1},{0,2,5},{0,2,5},{3,10,38},{3,8,21},{3,6,24},{3,6,24},{2,10,52},{2,7,18},{2,6,1}, |
| {2,5,24},{0,7,53},{1,5,21},{4,8,22},{3,8,5},{4,6,4},{3,6,8},{7,0,52},{2,7,18},{2,6,1},{1,5,20},{14,0,52},{1,5,20},{3,8,20},{3,8,20},{3,8,20},{3,5,21},{2,8,8},{2,6,1},{2,6,1},{2,4,5},{0,6,8},{1,5,5},{4,6,4},{4,6,4},{4,6,4},{4,5,4},{6,0,8},{3,5,1},{3,5,1},{3,4,4},{12,0,8}, |
| {3,4,4},{8,0,18},{3,8,1},{4,6,0},{2,6,0},{8,0,18},{16,0,18},{2,6,0},{0,5,20},{16,0,18},{0,5,20},{3,0,20},{3,0,20},{3,0,20},{3,0,20},{2,7,0},{2,7,0},{2,7,0},{2,4,1},{1,5,1},{1,5,1},{5,12,38},{5,10,21},{5,8,24},{5,8,24},{4,12,52},{4,9,18},{4,8,1},{4,7,24},{2,9,53},{3,7,21},{6,10,22}, |
| {5,10,5},{6,8,4},{5,8,8},{2,16,51},{4,9,18},{4,8,1},{3,7,20},{20,0,51},{3,7,20},{5,10,20},{5,10,20},{5,10,20},{5,7,21},{4,10,8},{4,8,1},{4,8,1},{4,6,5},{2,8,8},{3,7,5},{6,8,4},{6,8,4},{6,8,4},{6,7,4},{9,0,8},{5,7,1},{5,7,1},{5,6,4},{18,0,8},{5,6,4},{11,0,18},{5,10,1},{6,8,0}, |
| {4,8,0},{11,0,18},{22,0,18},{4,8,0},{0,7,20},{22,0,18},{0,7,20},{5,0,20},{5,0,20},{5,0,20},{5,0,20},{4,9,0},{4,9,0},{4,9,0},{4,6,1},{3,7,1},{3,7,1},{7,15,36},{7,12,19},{7,10,28},{7,10,20},{6,15,52},{6,11,22},{6,10,7},{6,9,28},{3,12,52},{5,9,27},{8,13,19},{8,11,3},{8,10,3},{8,10,6},{13,1,51}, |
| {6,11,21},{7,10,3},{5,9,27},{27,0,51},{5,9,27},{7,12,19},{7,12,19},{7,12,19},{7,10,19},{6,13,9},{6,10,6},{6,10,6},{6,9,3},{5,10,9},{5,9,2},{8,10,2},{8,10,2},{8,10,2},{8,9,2},{12,1,8},{7,10,2},{7,10,2},{5,9,2},{25,0,8},{5,9,2},{14,1,18},{7,12,1},{8,10,2},{6,10,2},{14,1,18},{15,7,18},{6,10,2}, |
| {0,9,26},{15,7,18},{0,9,26},{7,0,18},{7,0,18},{7,0,18},{7,0,18},{6,11,2},{6,11,2},{6,11,2},{6,9,2},{5,9,1},{5,9,1},{9,16,38},{9,14,19},{9,12,28},{9,12,20},{8,17,52},{8,13,22},{8,12,7},{8,11,28},{5,14,52},{7,11,27},{10,15,19},{10,13,3},{10,12,3},{10,12,6},{16,1,51},{8,13,21},{9,12,3},{7,11,27},{33,0,51}, |
| {7,11,27},{9,14,19},{9,14,19},{9,14,19},{9,12,19},{8,15,9},{8,12,6},{8,12,6},{8,11,3},{7,12,9},{7,11,2},{10,12,2},{10,12,2},{10,12,2},{10,11,2},{15,1,8},{9,12,2},{9,12,2},{7,11,2},{31,0,8},{7,11,2},{17,0,18},{9,14,1},{10,12,2},{8,12,2},{17,0,18},{34,0,18},{8,12,2},{0,11,26},{34,0,18},{0,11,26},{9,0,18}, |
| {9,0,18},{9,0,18},{9,0,18},{8,13,2},{8,13,2},{8,13,2},{8,11,2},{7,11,1},{7,11,1},{11,18,38},{11,16,19},{11,14,28},{11,14,20},{10,19,52},{10,15,22},{10,14,7},{10,13,28},{7,16,52},{9,13,27},{12,16,21},{12,15,3},{12,14,3},{12,14,6},{19,1,51},{10,15,21},{11,14,3},{9,13,27},{39,0,51},{9,13,27},{11,16,18},{11,16,18},{11,16,18}, |
| {11,14,19},{10,17,9},{10,14,6},{10,14,6},{10,13,3},{9,14,9},{9,13,2},{12,14,2},{12,14,2},{12,14,2},{12,13,2},{15,7,8},{11,14,2},{11,14,2},{9,13,2},{31,3,8},{9,13,2},{20,0,18},{11,16,1},{12,14,2},{10,14,2},{20,0,18},{40,0,18},{10,14,2},{0,13,26},{40,0,18},{0,13,26},{11,0,18},{11,0,18},{11,0,18},{11,0,18},{10,15,2}, |
| {10,15,2},{10,15,2},{10,13,2},{9,13,1},{9,13,1},{13,20,38},{13,18,19},{13,16,27},{13,16,19},{12,21,52},{12,17,19},{12,16,5},{12,15,28},{10,17,52},{11,15,27},{14,18,21},{14,17,3},{14,16,1},{13,16,10},{22,1,51},{12,17,18},{13,16,2},{11,15,27},{45,0,51},{11,15,27},{13,18,18},{13,18,18},{13,18,18},{13,16,19},{12,19,9},{12,16,5},{12,16,5}, |
| {12,15,3},{10,16,11},{11,15,2},{14,16,1},{14,16,1},{14,16,1},{14,15,2},{15,13,8},{13,16,2},{13,16,2},{11,15,2},{31,6,8},{11,15,2},{23,0,18},{13,18,1},{14,16,0},{12,16,0},{23,0,18},{46,0,18},{12,16,0},{0,15,26},{46,0,18},{0,15,26},{13,0,18},{13,0,18},{13,0,18},{13,0,18},{12,17,1},{12,17,1},{12,17,1},{12,15,2},{11,15,1}, |
| {11,15,1},{15,23,38},{15,20,21},{15,18,37},{15,18,21},{15,22,55},{15,19,23},{15,18,5},{14,17,30},{13,19,56},{13,17,28},{16,21,19},{16,19,3},{16,18,3},{16,18,6},{17,17,51},{15,19,19},{15,18,1},{14,17,26},{51,0,51},{14,17,26},{15,21,20},{15,21,20},{15,21,20},{15,18,20},{15,19,14},{15,18,4},{15,18,4},{14,17,5},{13,18,9},{13,17,3},{16,18,2}, |
| {16,18,2},{16,18,2},{16,17,2},{24,1,8},{15,18,0},{15,18,0},{14,17,1},{49,0,8},{14,17,1},{26,1,18},{15,20,1},{16,18,2},{15,18,1},{26,1,18},{53,0,18},{15,18,1},{0,17,26},{53,0,18},{0,17,26},{15,0,20},{15,0,20},{15,0,20},{15,0,20},{15,18,4},{15,18,4},{15,18,4},{14,17,4},{13,17,2},{13,17,2},{17,25,36},{17,22,19},{17,20,28}, |
| {17,20,20},{16,25,52},{16,21,22},{16,20,7},{16,19,28},{15,21,56},{15,19,28},{18,23,19},{18,21,3},{18,20,3},{18,20,6},{20,17,51},{16,21,21},{17,20,3},{14,20,26},{57,0,51},{14,20,26},{17,22,19},{17,22,19},{17,22,19},{17,20,19},{16,23,9},{16,20,6},{16,20,6},{16,19,3},{15,20,9},{15,19,3},{18,20,2},{18,20,2},{18,20,2},{18,19,2},{27,1,8}, |
| {17,20,2},{17,20,2},{15,19,2},{55,0,8},{15,19,2},{29,1,18},{17,22,1},{18,20,2},{16,20,2},{29,1,18},{59,0,18},{16,20,2},{0,19,26},{59,0,18},{0,19,26},{17,0,18},{17,0,18},{17,0,18},{17,0,18},{16,21,2},{16,21,2},{16,21,2},{16,19,2},{15,19,2},{15,19,2},{19,27,36},{19,24,19},{19,22,28},{19,22,20},{18,27,52},{18,23,22},{18,22,7}, |
| {18,21,28},{15,24,56},{17,21,27},{20,25,19},{20,23,3},{20,22,3},{20,22,6},{23,17,51},{18,23,21},{19,22,3},{17,21,27},{63,0,51},{17,21,27},{19,24,19},{19,24,19},{19,24,19},{19,22,19},{18,25,9},{18,22,6},{18,22,6},{18,21,3},{17,22,9},{17,21,2},{20,22,2},{20,22,2},{20,22,2},{20,21,2},{30,1,8},{19,22,2},{19,22,2},{17,21,2},{61,0,8}, |
| {17,21,2},{31,3,18},{19,24,1},{20,22,2},{18,22,2},{31,3,18},{63,1,18},{18,22,2},{0,21,26},{63,1,18},{0,21,26},{19,0,18},{19,0,18},{19,0,18},{19,0,18},{18,23,2},{18,23,2},{18,23,2},{18,21,2},{17,21,1},{17,21,1},{21,29,36},{21,26,19},{21,24,28},{21,24,20},{20,29,52},{20,25,22},{20,24,7},{20,23,28},{17,26,52},{19,23,27},{22,27,19}, |
| {22,25,3},{22,24,3},{22,24,6},{34,1,51},{20,25,21},{21,24,3},{19,23,27},{63,3,51},{19,23,27},{21,26,19},{21,26,19},{21,26,19},{21,24,19},{20,27,9},{20,24,6},{20,24,6},{20,23,3},{19,24,9},{19,23,2},{22,24,2},{22,24,2},{22,24,2},{22,23,2},{33,1,8},{21,24,2},{21,24,2},{19,23,2},{63,2,8},{19,23,2},{31,9,18},{21,26,1},{22,24,2}, |
| {20,24,2},{31,9,18},{63,4,18},{20,24,2},{0,23,26},{63,4,18},{0,23,26},{21,0,18},{21,0,18},{21,0,18},{21,0,18},{20,25,2},{20,25,2},{20,25,2},{20,23,2},{19,23,1},{19,23,1},{23,31,40},{23,29,24},{23,27,33},{23,26,24},{23,30,55},{22,28,24},{23,26,8},{22,26,28},{20,28,51},{21,26,21},{24,29,20},{24,28,1},{24,27,4},{24,26,5},{38,0,51}, |
| {22,28,20},{23,26,4},{20,26,20},{62,7,51},{20,26,20},{23,29,20},{23,29,20},{23,29,20},{23,26,20},{23,28,12},{23,26,4},{23,26,4},{22,25,4},{20,27,9},{22,25,4},{24,27,0},{24,27,0},{24,27,0},{24,26,1},{31,12,8},{23,26,0},{23,26,0},{22,25,0},{62,6,8},{22,25,0},{38,1,18},{24,28,1},{24,27,4},{23,26,4},{38,1,18},{45,16,18},{23,26,4}, |
| {0,26,20},{45,16,18},{0,26,20},{23,0,20},{23,0,20},{23,0,20},{23,0,20},{23,26,4},{23,26,4},{23,26,4},{22,25,4},{21,26,1},{21,26,1},{25,33,38},{25,31,24},{25,29,33},{25,28,24},{25,32,55},{24,30,24},{25,28,8},{24,28,28},{22,30,51},{23,28,21},{26,31,20},{26,30,1},{26,29,4},{26,28,5},{41,0,51},{24,30,20},{25,28,4},{22,28,20},{62,10,51}, |
| {22,28,20},{25,31,20},{25,31,20},{25,31,20},{25,28,20},{25,30,12},{25,28,4},{25,28,4},{24,27,4},{22,29,9},{24,27,4},{26,29,0},{26,29,0},{26,29,0},{26,28,1},{31,18,8},{25,28,0},{25,28,0},{24,27,0},{62,9,8},{24,27,0},{41,1,18},{26,30,1},{26,29,4},{25,28,4},{41,1,18},{51,16,18},{25,28,4},{0,28,20},{51,16,18},{0,28,20},{25,0,20}, |
| {25,0,20},{25,0,20},{25,0,20},{25,28,4},{25,28,4},{25,28,4},{24,27,4},{23,28,1},{23,28,1},{27,35,38},{27,32,21},{27,31,33},{27,30,24},{27,34,55},{26,32,24},{27,30,8},{26,30,28},{25,31,56},{25,30,21},{28,33,18},{28,32,2},{28,31,4},{28,30,5},{44,0,51},{26,32,20},{27,30,4},{24,30,20},{62,13,51},{24,30,20},{27,33,20},{27,33,20},{27,33,20}, |
| {27,30,20},{27,31,14},{27,30,4},{27,30,4},{26,29,4},{24,31,9},{26,29,4},{28,31,0},{28,31,0},{28,31,0},{28,30,1},{34,17,8},{27,30,0},{27,30,0},{26,29,0},{62,12,8},{26,29,0},{44,1,18},{27,32,1},{28,31,4},{27,30,4},{44,1,18},{57,16,18},{27,30,4},{0,30,20},{57,16,18},{0,30,20},{27,0,20},{27,0,20},{27,0,20},{27,0,20},{27,30,4}, |
| {27,30,4},{27,30,4},{26,29,4},{25,30,1},{25,30,1},{29,37,38},{29,34,21},{29,32,37},{29,32,21},{29,36,55},{29,33,23},{29,32,5},{28,32,39},{27,33,56},{26,32,30},{30,35,18},{30,34,2},{30,32,2},{30,32,5},{47,0,51},{29,33,19},{29,32,1},{26,32,26},{46,24,51},{26,32,26},{29,35,20},{29,35,20},{29,35,20},{29,32,20},{29,33,14},{29,32,4},{29,32,4}, |
| {28,31,4},{27,32,9},{28,31,4},{30,33,0},{30,33,0},{30,33,0},{30,31,4},{37,17,8},{29,32,0},{29,32,0},{28,31,0},{62,15,8},{28,31,0},{47,1,18},{29,34,1},{30,32,2},{29,32,1},{47,1,18},{63,16,18},{29,32,1},{0,32,26},{63,16,18},{0,32,26},{29,0,20},{29,0,20},{29,0,20},{29,0,20},{29,32,4},{29,32,4},{29,32,4},{28,31,4},{28,31,4}, |
| {28,31,4},{31,40,44},{31,37,28},{32,35,40},{31,34,31},{31,38,53},{31,35,21},{31,34,7},{31,34,30},{28,36,51},{29,34,21},{32,37,20},{32,36,1},{32,35,4},{32,34,5},{50,0,51},{30,36,19},{31,34,6},{28,34,21},{62,19,51},{28,34,21},{31,38,26},{31,38,26},{31,38,26},{31,34,27},{31,36,9},{31,34,3},{31,34,3},{31,33,2},{29,34,10},{30,33,2},{32,35,0}, |
| {32,35,0},{32,35,0},{32,34,1},{49,0,8},{31,34,2},{31,34,2},{30,33,1},{62,18,8},{30,33,1},{47,8,18},{32,36,1},{32,35,4},{31,34,5},{47,8,18},{62,20,18},{31,34,5},{0,34,20},{62,20,18},{0,34,20},{31,0,26},{31,0,26},{31,0,26},{31,0,26},{31,35,1},{31,35,1},{31,35,1},{31,33,2},{29,34,1},{29,34,1},{33,41,40},{33,39,24},{33,37,33}, |
| {33,36,24},{33,40,55},{32,38,24},{33,36,8},{32,36,28},{30,38,51},{31,36,21},{34,39,20},{34,38,1},{34,37,4},{34,36,5},{53,0,51},{32,38,20},{33,36,4},{30,36,21},{62,22,51},{30,36,21},{33,39,20},{33,39,20},{33,39,20},{33,36,20},{33,38,12},{33,36,4},{33,36,4},{32,35,4},{31,36,10},{32,35,4},{34,37,0},{34,37,0},{34,37,0},{34,36,1},{52,0,8}, |
| {33,36,0},{33,36,0},{32,35,0},{62,21,8},{32,35,0},{47,14,18},{34,38,1},{34,37,4},{33,36,4},{47,14,18},{62,23,18},{33,36,4},{0,36,20},{62,23,18},{0,36,20},{33,0,20},{33,0,20},{33,0,20},{33,0,20},{33,36,4},{33,36,4},{33,36,4},{32,35,4},{31,36,1},{31,36,1},{35,43,40},{35,41,24},{35,39,33},{35,38,24},{35,42,55},{34,40,24},{35,38,8}, |
| {34,38,28},{32,40,51},{33,38,21},{36,41,20},{36,40,1},{36,39,4},{36,38,5},{56,0,51},{34,40,20},{35,38,4},{32,38,20},{62,25,51},{32,38,20},{35,41,20},{35,41,20},{35,41,20},{35,38,20},{35,40,12},{35,38,4},{35,38,4},{34,37,4},{32,39,9},{34,37,4},{36,39,0},{36,39,0},{36,39,0},{36,38,1},{55,0,8},{35,38,0},{35,38,0},{34,37,0},{62,24,8}, |
| {34,37,0},{48,17,18},{36,40,1},{36,39,4},{35,38,4},{48,17,18},{62,26,18},{35,38,4},{0,38,20},{62,26,18},{0,38,20},{35,0,20},{35,0,20},{35,0,20},{35,0,20},{35,38,4},{35,38,4},{35,38,4},{34,37,4},{33,38,1},{33,38,1},{37,45,40},{37,43,24},{37,41,33},{37,40,24},{37,44,55},{36,42,24},{37,40,8},{36,40,28},{34,42,51},{35,40,21},{38,43,20}, |
| {38,42,1},{38,41,4},{38,40,5},{59,0,51},{36,42,20},{37,40,4},{34,40,20},{62,28,51},{34,40,20},{37,43,20},{37,43,20},{37,43,20},{37,40,20},{37,42,12},{37,40,4},{37,40,4},{36,39,4},{34,41,9},{36,39,4},{38,41,0},{38,41,0},{38,41,0},{38,40,1},{58,0,8},{37,40,0},{37,40,0},{36,39,0},{62,27,8},{36,39,0},{51,17,18},{38,42,1},{38,41,4}, |
| {37,40,4},{51,17,18},{62,29,18},{37,40,4},{0,40,20},{62,29,18},{0,40,20},{37,0,20},{37,0,20},{37,0,20},{37,0,20},{37,40,4},{37,40,4},{37,40,4},{36,39,4},{35,40,1},{35,40,1},{40,46,44},{40,44,27},{40,43,28},{39,43,28},{39,47,52},{39,44,22},{39,43,3},{38,42,28},{36,44,53},{37,42,19},{40,46,19},{40,44,2},{40,43,3},{40,42,10},{62,1,51}, |
| {38,44,19},{39,43,2},{37,42,18},{63,31,51},{37,42,18},{40,44,26},{40,44,26},{40,44,26},{40,42,26},{39,44,11},{39,43,2},{39,43,2},{39,41,2},{37,43,11},{38,41,3},{40,44,1},{40,44,1},{40,44,1},{40,42,1},{53,16,8},{40,42,1},{40,42,1},{39,41,1},{63,30,8},{39,41,1},{63,0,18},{40,44,1},{40,43,2},{38,43,1},{63,0,18},{62,32,18},{38,43,1}, |
| {0,42,18},{62,32,18},{0,42,18},{39,0,26},{39,0,26},{39,0,26},{39,0,26},{39,43,1},{39,43,1},{39,43,1},{39,41,1},{37,42,1},{37,42,1},{42,48,44},{42,46,27},{42,45,28},{41,45,28},{41,48,53},{41,46,22},{41,45,3},{40,44,28},{38,46,53},{39,44,19},{42,48,19},{42,46,2},{42,45,3},{42,44,10},{63,5,51},{40,46,19},{41,45,2},{39,44,18},{47,42,51}, |
| {39,44,18},{42,46,26},{42,46,26},{42,46,26},{42,44,26},{41,46,11},{41,45,2},{41,45,2},{41,43,2},{39,45,11},{40,43,3},{42,46,1},{42,46,1},{42,46,1},{42,44,1},{56,16,8},{42,44,1},{42,44,1},{41,43,1},{62,33,8},{41,43,1},{63,6,18},{42,46,1},{42,45,2},{40,45,1},{63,6,18},{62,35,18},{40,45,1},{0,44,18},{62,35,18},{0,44,18},{41,0,26}, |
| {41,0,26},{41,0,26},{41,0,26},{41,45,1},{41,45,1},{41,45,1},{41,43,1},{39,44,1},{39,44,1},{44,50,44},{44,48,26},{44,47,28},{43,47,28},{43,50,53},{43,47,27},{43,47,3},{42,46,28},{40,48,51},{41,46,19},{44,50,19},{44,48,1},{44,47,3},{44,46,10},{63,11,51},{42,48,19},{43,47,2},{41,46,18},{47,45,51},{41,46,18},{44,48,26},{44,48,26},{44,48,26}, |
| {44,46,26},{43,48,9},{43,47,2},{43,47,2},{43,45,2},{41,47,11},{42,45,3},{44,48,1},{44,48,1},{44,48,1},{44,46,1},{59,16,8},{44,46,1},{44,46,1},{43,45,1},{62,36,8},{43,45,1},{63,12,18},{44,48,0},{44,47,2},{42,47,1},{63,12,18},{62,38,18},{42,47,1},{0,46,18},{62,38,18},{0,46,18},{43,0,26},{43,0,26},{43,0,26},{43,0,26},{43,47,1}, |
| {43,47,1},{43,47,1},{43,45,1},{41,46,1},{41,46,1},{46,52,44},{46,50,26},{46,49,31},{45,48,31},{45,52,53},{45,49,21},{45,48,7},{45,48,30},{42,50,51},{43,48,21},{46,52,19},{46,50,1},{46,49,6},{46,48,6},{55,32,51},{44,50,19},{45,48,6},{42,48,21},{46,48,51},{42,48,21},{46,50,26},{46,50,26},{46,50,26},{45,48,27},{45,50,9},{45,48,3},{45,48,3}, |
| {45,47,2},{43,48,10},{44,47,3},{46,50,1},{46,50,1},{46,50,1},{46,48,2},{62,16,8},{45,48,2},{45,48,2},{45,47,1},{62,39,8},{45,47,1},{63,18,18},{46,50,0},{47,48,4},{45,48,5},{63,18,18},{62,41,18},{45,48,5},{0,48,20},{62,41,18},{0,48,20},{45,0,26},{45,0,26},{45,0,26},{45,0,26},{45,49,1},{45,49,1},{45,49,1},{45,47,1},{43,48,1}, |
| {43,48,1},{48,54,44},{48,52,27},{48,51,28},{48,50,35},{47,55,51},{47,52,21},{47,51,3},{47,50,22},{45,52,52},{45,50,19},{48,54,19},{48,52,2},{48,51,3},{48,50,10},{63,23,51},{47,52,21},{47,51,3},{45,50,18},{63,43,51},{45,50,18},{48,52,26},{48,52,26},{48,52,26},{48,50,26},{47,53,8},{47,51,2},{47,51,2},{47,49,1},{45,51,8},{46,49,5},{48,52,1}, |
| {48,52,1},{48,52,1},{48,50,1},{63,21,8},{48,50,1},{48,50,1},{47,49,1},{63,42,8},{47,49,1},{63,25,18},{48,52,1},{48,51,2},{46,51,1},{63,25,18},{63,44,18},{46,51,1},{0,50,18},{63,44,18},{0,50,18},{48,0,26},{48,0,26},{48,0,26},{48,0,26},{47,51,1},{47,51,1},{47,51,1},{47,49,0},{45,50,1},{45,50,1},{50,56,44},{50,54,27},{50,53,28}, |
| {49,53,28},{49,57,52},{49,54,22},{49,53,3},{48,52,28},{47,54,52},{47,52,19},{50,56,19},{50,54,2},{50,53,3},{50,52,10},{63,29,51},{48,54,19},{49,53,2},{47,52,18},{63,46,51},{47,52,18},{50,54,26},{50,54,26},{50,54,26},{50,52,26},{49,54,11},{49,53,2},{49,53,2},{49,51,2},{47,53,8},{48,51,3},{50,54,1},{50,54,1},{50,54,1},{50,52,1},{63,27,8}, |
| {50,52,1},{50,52,1},{49,51,1},{63,45,8},{49,51,1},{63,31,18},{50,54,1},{50,53,2},{48,53,1},{63,31,18},{63,47,18},{48,53,1},{0,52,18},{63,47,18},{0,52,18},{49,0,26},{49,0,26},{49,0,26},{49,0,26},{49,53,1},{49,53,1},{49,53,1},{49,51,1},{47,52,1},{47,52,1},{52,58,44},{52,56,27},{52,55,28},{51,55,28},{51,59,52},{51,56,22},{51,55,3}, |
| {50,54,28},{48,56,53},{49,54,19},{52,58,19},{52,56,2},{52,55,3},{52,54,10},{63,35,51},{50,56,19},{51,55,2},{49,54,18},{63,49,51},{49,54,18},{52,56,26},{52,56,26},{52,56,26},{52,54,26},{51,56,11},{51,55,2},{51,55,2},{51,53,2},{49,55,11},{50,53,3},{52,56,1},{52,56,1},{52,56,1},{52,54,1},{63,33,8},{52,54,1},{52,54,1},{51,53,1},{47,56,8}, |
| {51,53,1},{57,48,18},{52,56,1},{52,55,2},{50,55,1},{57,48,18},{62,50,18},{50,55,1},{0,54,18},{62,50,18},{0,54,18},{51,0,26},{51,0,26},{51,0,26},{51,0,26},{51,55,1},{51,55,1},{51,55,1},{51,53,1},{49,54,1},{49,54,1},{54,60,44},{54,58,27},{54,57,28},{53,57,28},{53,61,52},{53,58,22},{53,57,3},{52,56,28},{50,58,53},{51,56,19},{54,60,19}, |
| {54,58,2},{54,57,3},{54,56,10},{63,41,51},{52,58,19},{53,57,2},{51,56,18},{63,52,51},{51,56,18},{54,58,26},{54,58,26},{54,58,26},{54,56,26},{53,58,11},{53,57,2},{53,57,2},{53,55,2},{51,57,11},{52,55,3},{54,58,1},{54,58,1},{54,58,1},{54,56,1},{63,39,8},{54,56,1},{54,56,1},{53,55,1},{47,59,8},{53,55,1},{60,48,18},{54,58,1},{54,57,2}, |
| {52,57,1},{60,48,18},{62,53,18},{52,57,1},{0,56,18},{62,53,18},{0,56,18},{53,0,26},{53,0,26},{53,0,26},{53,0,26},{53,57,1},{53,57,1},{53,57,1},{53,55,1},{51,56,1},{51,56,1},{56,63,38},{56,61,21},{56,59,24},{56,59,24},{55,63,52},{55,60,18},{55,59,1},{55,58,24},{53,60,53},{54,58,21},{57,61,22},{56,61,5},{57,59,4},{56,59,8},{63,47,52}, |
| {55,60,18},{55,59,1},{54,58,20},{63,55,52},{54,58,20},{56,61,20},{56,61,20},{56,61,20},{56,58,21},{55,61,8},{55,59,1},{55,59,1},{55,57,5},{53,59,8},{54,58,5},{57,59,4},{57,59,4},{57,59,4},{57,58,4},{61,49,8},{56,58,1},{56,58,1},{56,57,4},{63,54,8},{56,57,4},{63,49,18},{56,61,1},{57,59,0},{55,59,0},{63,49,18},{63,56,18},{55,59,0}, |
| {0,58,20},{63,56,18},{0,58,20},{56,0,20},{56,0,20},{56,0,20},{56,0,20},{55,60,0},{55,60,0},{55,60,0},{55,57,1},{54,58,1},{54,58,1},{58,63,56},{58,63,21},{58,61,24},{58,61,24},{58,63,68},{57,62,18},{57,61,1},{57,60,24},{55,62,53},{56,60,21},{59,63,22},{58,63,5},{59,61,4},{58,61,8},{63,53,52},{57,62,18},{57,61,1},{56,60,20},{63,58,52}, |
| {56,60,20},{58,63,20},{58,63,20},{58,63,20},{58,60,21},{57,63,8},{57,61,1},{57,61,1},{57,59,5},{55,61,8},{56,60,5},{59,61,4},{59,61,4},{59,61,4},{59,60,4},{63,51,8},{58,60,1},{58,60,1},{58,59,4},{63,57,8},{58,59,4},{63,55,18},{58,63,1},{59,61,0},{57,61,0},{63,55,18},{63,59,18},{57,61,0},{0,60,20},{63,59,18},{0,60,20},{58,0,20}, |
| {58,0,20},{58,0,20},{58,0,20},{57,62,0},{57,62,0},{57,62,0},{57,59,1},{56,60,1},{56,60,1},{60,63,88},{60,63,40},{60,63,24},{60,63,24},{60,63,88},{59,63,37},{59,63,1},{59,62,24},{58,63,63},{58,62,21},{61,63,40},{61,63,13},{61,63,4},{60,63,8},{63,59,52},{60,63,24},{59,63,1},{58,62,20},{63,61,52},{58,62,20},{60,63,24},{60,63,24},{60,63,24}, |
| {60,62,21},{60,63,24},{59,63,1},{59,63,1},{59,61,5},{57,63,8},{58,62,5},{61,63,4},{61,63,4},{61,63,4},{61,62,4},{63,57,8},{60,62,1},{60,62,1},{60,61,4},{63,60,8},{60,61,4},{63,61,18},{61,63,9},{61,63,0},{59,63,0},{63,61,18},{63,62,18},{59,63,0},{0,62,20},{63,62,18},{0,62,20},{60,0,20},{60,0,20},{60,0,20},{60,0,20},{59,63,1}, |
| {59,63,1},{59,63,1},{59,61,1},{58,62,1},{58,62,1},{62,63,38},{62,63,33},{62,63,29},{62,63,24},{62,63,35},{62,63,25},{62,63,21},{61,63,1},{61,63,23},{60,63,4},{63,63,4},{63,63,4},{63,63,4},{63,63,4},{63,63,4},{63,63,4},{63,63,4},{62,63,0},{63,63,4},{62,63,0},{62,63,29},{62,63,29},{62,63,29},{62,63,24},{62,63,26},{62,63,21},{62,63,21}, |
| {61,63,1},{61,63,14},{60,63,4},{63,63,4},{63,63,4},{63,63,4},{63,63,4},{63,62,4},{63,63,4},{63,63,4},{62,63,0},{62,63,4},{62,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{62,0,20},{62,0,20},{62,0,20},{62,0,20},{61,63,16},{61,63,16},{61,63,16},{61,63,1},{60,63,4}, |
| {60,63,4},{0,8,74},{0,6,10},{0,4,1},{0,4,26},{0,6,154},{0,4,99},{0,3,50},{0,2,115},{0,3,170},{0,2,119},{0,8,74},{0,6,10},{0,4,1},{0,4,26},{3,0,154},{0,4,99},{0,3,50},{0,2,115},{6,0,154},{0,2,115},{0,4,0},{0,4,0},{0,4,0},{0,2,0},{0,2,13},{0,2,4},{0,2,4},{0,1,5},{0,1,14},{0,1,6},{0,4,0}, |
| {0,4,0},{0,4,0},{0,2,0},{1,0,13},{0,2,4},{0,2,4},{0,1,5},{2,0,13},{0,1,5},{4,0,74},{0,6,10},{0,4,1},{0,4,26},{4,0,74},{8,0,74},{0,4,26},{0,3,74},{8,0,74},{0,3,74},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,14,83},{0,10,10},{1,6,27}, |
| {0,6,19},{0,11,243},{0,7,110},{0,5,34},{0,4,139},{0,5,280},{0,4,164},{1,12,75},{1,9,2},{1,6,11},{1,6,18},{5,1,243},{0,7,110},{0,5,34},{0,4,139},{11,0,243},{0,4,139},{0,10,9},{0,10,9},{0,10,9},{0,5,9},{0,6,50},{0,5,9},{0,5,9},{0,3,26},{0,3,66},{0,2,33},{1,8,1},{1,8,1},{1,8,1},{1,4,2},{3,0,50}, |
| {0,5,9},{0,5,9},{0,3,26},{6,0,50},{0,3,26},{7,0,74},{1,9,1},{2,6,1},{0,6,10},{7,0,74},{14,0,74},{0,6,10},{0,5,74},{14,0,74},{0,5,74},{0,0,9},{0,0,9},{0,0,9},{0,0,9},{0,2,1},{0,2,1},{0,2,1},{0,1,1},{0,1,2},{0,1,2},{1,18,137},{1,12,74},{2,9,98},{1,8,67},{0,16,244},{0,10,78},{0,8,2}, |
| {0,6,115},{0,8,344},{0,6,179},{3,14,75},{3,11,2},{3,8,11},{3,8,18},{8,1,243},{0,10,78},{0,8,2},{0,6,115},{15,1,243},{0,6,115},{1,14,65},{1,14,65},{1,14,65},{1,7,66},{0,12,50},{0,8,1},{0,8,1},{0,5,5},{0,5,104},{0,5,41},{3,10,1},{3,10,1},{3,10,1},{3,6,2},{6,0,50},{0,8,1},{0,8,1},{0,5,5},{12,0,50}, |
| {0,5,5},{2,16,72},{3,11,1},{4,8,1},{0,8,1},{2,16,72},{20,0,72},{0,8,1},{0,7,74},{20,0,72},{0,7,74},{1,0,65},{1,0,65},{1,0,65},{1,0,65},{0,8,1},{0,8,1},{0,8,1},{0,4,1},{0,3,25},{0,3,25},{3,20,146},{3,14,83},{4,11,115},{3,10,76},{2,18,245},{2,12,79},{2,10,3},{1,8,108},{0,11,293},{0,8,103},{5,16,73}, |
| {5,13,2},{5,10,11},{5,10,18},{11,1,243},{1,13,75},{2,10,2},{0,8,94},{15,4,243},{0,8,94},{3,16,74},{3,16,74},{3,16,74},{3,9,75},{2,14,51},{2,10,2},{2,10,2},{2,7,6},{0,9,75},{0,7,6},{5,12,1},{5,12,1},{5,12,1},{5,8,2},{9,0,50},{2,10,1},{2,10,1},{0,7,2},{18,0,50},{0,7,2},{5,16,72},{5,13,1},{6,10,1}, |
| {2,10,1},{5,16,72},{26,0,72},{2,10,1},{0,9,74},{26,0,72},{0,9,74},{3,0,74},{3,0,74},{3,0,74},{3,0,74},{2,10,2},{2,10,2},{2,10,2},{2,6,2},{0,7,5},{0,7,5},{6,21,152},{6,16,82},{6,13,109},{5,12,84},{4,21,243},{4,15,78},{4,13,8},{4,11,108},{0,14,255},{0,11,77},{7,19,72},{7,15,1},{7,13,8},{7,12,13},{6,17,243}, |
| {3,15,72},{5,12,5},{0,11,73},{29,0,243},{0,11,73},{6,16,81},{6,16,81},{6,16,81},{5,12,80},{4,17,50},{4,13,4},{4,13,4},{4,9,5},{0,12,52},{1,10,4},{7,15,0},{7,15,0},{7,15,0},{7,11,0},{12,1,50},{5,12,1},{5,12,1},{3,9,4},{25,0,50},{3,9,4},{16,1,72},{7,15,1},{8,13,4},{5,12,4},{16,1,72},{33,0,72},{5,12,4}, |
| {0,11,72},{33,0,72},{0,11,72},{5,0,80},{5,0,80},{5,0,80},{5,0,80},{4,13,0},{4,13,0},{4,13,0},{4,9,1},{1,10,0},{1,10,0},{8,23,152},{8,18,82},{8,15,109},{7,14,84},{6,23,243},{6,16,75},{6,15,8},{6,13,108},{1,17,244},{2,13,77},{9,21,72},{9,17,1},{9,15,8},{9,14,13},{17,1,243},{5,17,72},{7,14,5},{1,13,72},{35,0,243}, |
| {1,13,72},{8,18,81},{8,18,81},{8,18,81},{7,14,80},{6,19,50},{6,15,4},{6,15,4},{6,11,5},{2,14,52},{3,12,4},{9,16,1},{9,16,1},{9,16,1},{9,13,0},{15,1,50},{7,14,1},{7,14,1},{5,11,4},{31,0,50},{5,11,4},{19,1,72},{9,17,1},{10,15,4},{7,14,4},{19,1,72},{39,0,72},{7,14,4},{0,13,72},{39,0,72},{0,13,72},{7,0,80}, |
| {7,0,80},{7,0,80},{7,0,80},{6,15,0},{6,15,0},{6,15,0},{6,11,1},{3,12,0},{3,12,0},{10,25,152},{10,20,82},{10,17,114},{9,16,82},{8,25,243},{8,18,75},{8,16,2},{8,15,108},{3,19,244},{4,15,77},{11,23,72},{11,19,1},{11,16,10},{11,16,17},{20,1,243},{7,19,72},{8,16,2},{3,15,72},{41,0,243},{3,15,72},{10,20,81},{10,20,81},{10,20,81}, |
| {10,15,81},{8,21,50},{8,16,1},{8,16,1},{8,13,5},{4,16,52},{5,14,4},{11,18,1},{11,18,1},{11,18,1},{11,15,0},{15,7,50},{8,16,1},{8,16,1},{7,13,4},{31,3,50},{7,13,4},{22,1,72},{11,19,1},{12,16,2},{8,16,1},{22,1,72},{45,0,72},{8,16,1},{0,15,72},{45,0,72},{0,15,72},{9,0,80},{9,0,80},{9,0,80},{9,0,80},{8,17,0}, |
| {8,17,0},{8,17,0},{8,13,1},{5,14,0},{5,14,0},{12,27,152},{12,22,82},{12,19,114},{11,18,82},{10,27,243},{10,20,75},{10,18,2},{10,16,106},{5,21,244},{6,17,79},{13,25,72},{13,21,1},{13,18,10},{13,18,17},{23,1,243},{9,21,72},{10,18,2},{5,17,74},{47,0,243},{5,17,74},{12,22,81},{12,22,81},{12,22,81},{12,17,80},{10,23,50},{10,18,1},{10,18,1}, |
| {10,15,5},{6,18,52},{8,15,9},{13,20,1},{13,20,1},{13,20,1},{13,17,1},{15,13,50},{10,18,1},{10,18,1},{9,15,4},{31,6,50},{9,15,4},{25,1,72},{13,21,1},{14,18,2},{10,18,1},{25,1,72},{47,2,72},{10,18,1},{0,17,74},{47,2,72},{0,17,74},{11,0,80},{11,0,80},{11,0,80},{11,0,80},{10,19,0},{10,19,0},{10,19,0},{10,15,1},{7,16,0}, |
| {7,16,0},{14,30,146},{14,24,78},{14,21,114},{14,20,79},{12,30,244},{12,23,79},{12,21,7},{12,19,109},{7,23,244},{9,19,76},{15,28,73},{15,23,2},{15,21,14},{15,20,14},{27,0,243},{11,23,75},{13,20,4},{7,19,73},{46,4,243},{7,19,73},{14,25,74},{14,25,74},{14,25,74},{14,19,75},{12,25,53},{12,21,3},{12,21,3},{12,17,6},{8,21,52},{9,18,6},{15,23,1}, |
| {15,23,1},{15,23,1},{15,19,1},{24,1,50},{13,20,0},{13,20,0},{11,17,5},{49,0,50},{11,17,5},{20,17,72},{15,23,1},{16,21,4},{13,20,4},{20,17,72},{57,0,72},{13,20,4},{0,19,72},{57,0,72},{0,19,72},{14,0,74},{14,0,74},{14,0,74},{14,0,74},{12,22,1},{12,22,1},{12,22,1},{12,17,2},{9,18,2},{9,18,2},{16,31,152},{16,26,81},{16,23,109}, |
| {16,22,88},{14,32,244},{14,25,79},{14,23,7},{14,21,109},{9,25,244},{11,21,76},{17,29,72},{17,25,1},{17,23,8},{17,22,13},{30,0,243},{13,25,75},{15,22,4},{9,21,73},{46,7,243},{9,21,73},{16,27,80},{16,27,80},{16,27,80},{16,21,81},{14,27,53},{14,23,3},{14,23,3},{14,19,6},{10,23,52},{11,20,6},{17,25,0},{17,25,0},{17,25,0},{17,21,0},{27,1,50}, |
| {15,22,0},{15,22,0},{13,19,5},{55,0,50},{13,19,5},{23,17,72},{17,25,1},{18,23,4},{15,22,4},{23,17,72},{63,0,72},{15,22,4},{0,21,72},{63,0,72},{0,21,72},{16,0,80},{16,0,80},{16,0,80},{16,0,80},{14,24,1},{14,24,1},{14,24,1},{14,19,2},{11,20,2},{11,20,2},{18,33,152},{18,28,81},{18,25,109},{17,24,84},{16,33,243},{16,27,78},{16,25,8}, |
| {16,23,108},{11,27,244},{13,23,76},{19,31,72},{19,27,1},{19,25,8},{19,24,13},{32,1,243},{15,27,75},{17,24,5},{11,23,73},{46,10,243},{11,23,73},{18,29,80},{18,29,80},{18,29,80},{17,24,80},{16,29,50},{16,25,4},{16,25,4},{16,21,5},{12,25,52},{13,22,6},{19,27,0},{19,27,0},{19,27,0},{19,23,0},{30,1,50},{17,24,1},{17,24,1},{15,21,5},{61,0,50}, |
| {15,21,5},{34,1,72},{19,27,1},{20,25,4},{17,24,4},{34,1,72},{63,3,72},{17,24,4},{0,23,72},{63,3,72},{0,23,72},{17,0,80},{17,0,80},{17,0,80},{17,0,80},{16,25,0},{16,25,0},{16,25,0},{16,21,1},{13,22,2},{13,22,2},{20,35,152},{20,30,81},{20,27,109},{19,26,84},{18,35,243},{18,29,78},{18,27,8},{18,25,108},{13,29,244},{15,25,76},{21,33,72}, |
| {21,29,1},{21,27,8},{21,26,13},{35,1,243},{17,29,72},{19,26,5},{13,25,73},{46,13,243},{13,25,73},{20,31,80},{20,31,80},{20,31,80},{19,26,80},{18,31,50},{18,27,4},{18,27,4},{18,23,5},{14,27,52},{15,24,6},{21,29,0},{21,29,0},{21,29,0},{21,25,0},{33,1,50},{19,26,1},{19,26,1},{17,23,4},{63,2,50},{17,23,4},{37,1,72},{21,29,1},{22,27,4}, |
| {19,26,4},{37,1,72},{63,6,72},{19,26,4},{0,25,72},{63,6,72},{0,25,72},{19,0,80},{19,0,80},{19,0,80},{19,0,80},{18,27,0},{18,27,0},{18,27,0},{18,23,1},{15,24,2},{15,24,2},{22,38,146},{22,32,78},{22,29,111},{22,28,84},{20,38,244},{20,31,74},{20,29,4},{20,27,100},{14,32,247},{17,27,75},{23,36,73},{23,32,3},{23,29,11},{23,28,14},{39,0,243}, |
| {20,31,73},{20,29,3},{16,27,74},{62,8,243},{16,27,74},{22,33,74},{22,33,74},{22,33,74},{22,28,75},{20,33,53},{20,29,3},{20,29,3},{20,25,10},{16,29,50},{18,26,2},{23,31,2},{23,31,2},{23,31,2},{23,27,2},{31,12,50},{21,28,1},{21,28,1},{18,26,1},{62,6,50},{18,26,1},{41,0,72},{23,32,2},{24,29,2},{19,29,2},{41,0,72},{62,10,72},{19,29,2}, |
| {0,27,74},{62,10,72},{0,27,74},{22,0,74},{22,0,74},{22,0,74},{22,0,74},{20,30,1},{20,30,1},{20,30,1},{20,25,1},{18,26,1},{18,26,1},{24,40,146},{24,34,78},{24,31,111},{24,30,84},{22,40,244},{22,33,79},{22,31,4},{22,29,100},{17,33,244},{19,29,75},{25,38,73},{25,33,2},{25,31,11},{25,30,14},{42,0,243},{21,33,75},{22,31,3},{18,29,74},{62,11,243}, |
| {18,29,74},{24,35,74},{24,35,74},{24,35,74},{24,30,75},{22,35,53},{22,31,3},{22,31,3},{22,27,10},{18,31,50},{20,28,2},{25,33,1},{25,33,1},{25,33,1},{25,29,2},{31,18,50},{23,30,1},{23,30,1},{20,28,1},{62,9,50},{20,28,1},{44,0,72},{25,33,1},{26,31,2},{21,31,2},{44,0,72},{62,13,72},{21,31,2},{0,29,74},{62,13,72},{0,29,74},{24,0,74}, |
| {24,0,74},{24,0,74},{24,0,74},{22,32,1},{22,32,1},{22,32,1},{22,27,1},{20,28,1},{20,28,1},{26,42,146},{26,36,78},{26,33,114},{26,32,79},{24,42,244},{24,35,79},{24,33,7},{24,31,100},{19,35,244},{21,31,75},{27,40,73},{27,35,2},{28,33,13},{27,32,14},{45,0,243},{23,35,75},{25,32,4},{20,31,74},{62,14,243},{20,31,74},{26,37,74},{26,37,74},{26,37,74}, |
| {26,32,75},{24,37,53},{24,33,3},{24,33,3},{24,29,10},{20,33,52},{22,30,2},{27,35,1},{27,35,1},{27,35,1},{27,31,2},{34,17,50},{25,32,0},{25,32,0},{22,30,1},{62,12,50},{22,30,1},{47,0,72},{27,35,1},{28,33,4},{25,32,4},{47,0,72},{46,24,72},{25,32,4},{0,31,74},{46,24,72},{0,31,74},{26,0,74},{26,0,74},{26,0,74},{26,0,74},{24,34,1}, |
| {24,34,1},{24,34,1},{24,29,1},{22,30,1},{22,30,1},{28,44,146},{28,38,78},{28,35,114},{28,34,79},{26,44,244},{26,37,79},{26,35,7},{26,33,109},{21,37,244},{23,33,76},{29,42,73},{29,37,2},{30,35,13},{29,34,14},{47,2,243},{25,37,75},{27,34,4},{21,33,73},{62,17,243},{21,33,73},{28,39,74},{28,39,74},{28,39,74},{28,33,75},{26,39,53},{26,35,3},{26,35,3}, |
| {26,31,10},{22,35,52},{23,32,6},{29,37,1},{29,37,1},{29,37,1},{29,33,1},{37,17,50},{27,34,0},{27,34,0},{23,32,5},{62,15,50},{23,32,5},{49,1,72},{29,37,1},{30,35,4},{27,34,4},{49,1,72},{46,27,72},{27,34,4},{0,33,72},{46,27,72},{0,33,72},{28,0,74},{28,0,74},{28,0,74},{28,0,74},{26,36,1},{26,36,1},{26,36,1},{26,31,1},{23,32,2}, |
| {23,32,2},{30,46,146},{30,41,77},{31,37,121},{30,36,81},{29,45,247},{28,39,77},{28,37,9},{28,35,103},{24,39,248},{25,35,76},{31,44,78},{31,40,4},{32,37,11},{31,36,17},{51,0,243},{28,39,73},{28,37,5},{24,35,74},{47,28,243},{24,35,74},{30,42,72},{30,42,72},{30,42,72},{30,36,72},{29,40,54},{29,36,6},{29,36,6},{28,34,9},{24,37,51},{26,34,2},{31,40,4}, |
| {31,40,4},{31,40,4},{31,35,5},{49,0,50},{29,36,2},{29,36,2},{26,34,1},{62,18,50},{26,34,1},{53,0,72},{31,40,0},{32,37,2},{28,37,1},{53,0,72},{62,22,72},{28,37,1},{0,35,74},{62,22,72},{0,35,74},{30,0,72},{30,0,72},{30,0,72},{30,0,72},{29,36,5},{29,36,5},{29,36,5},{28,33,4},{26,34,1},{26,34,1},{32,48,146},{32,42,79},{32,39,111}, |
| {32,38,84},{31,47,247},{30,41,77},{30,39,9},{30,37,103},{26,41,248},{27,37,76},{33,46,73},{33,42,3},{33,39,11},{33,38,14},{54,0,243},{30,41,73},{30,39,5},{26,37,74},{47,31,243},{26,37,74},{32,43,75},{32,43,75},{32,43,75},{32,38,75},{31,42,54},{31,38,6},{31,38,6},{30,36,9},{26,39,51},{28,36,2},{33,41,2},{33,41,2},{33,41,2},{33,37,2},{52,0,50}, |
| {31,38,2},{31,38,2},{28,36,1},{62,21,50},{28,36,1},{56,0,72},{33,42,2},{34,39,2},{30,39,1},{56,0,72},{62,25,72},{30,39,1},{0,37,74},{62,25,72},{0,37,74},{32,0,74},{32,0,74},{32,0,74},{32,0,74},{31,38,5},{31,38,5},{31,38,5},{30,35,4},{28,36,1},{28,36,1},{34,50,146},{34,44,79},{34,41,111},{34,40,84},{32,50,244},{32,43,74},{32,41,4}, |
| {32,39,100},{28,43,248},{29,39,76},{35,48,73},{35,44,3},{35,41,11},{35,40,14},{57,0,243},{32,43,73},{32,41,3},{28,39,74},{50,32,243},{28,39,74},{34,45,75},{34,45,75},{34,45,75},{34,40,75},{32,46,51},{32,41,3},{32,41,3},{32,37,10},{28,41,51},{30,38,2},{35,43,2},{35,43,2},{35,43,2},{35,39,2},{55,0,50},{33,40,1},{33,40,1},{30,38,1},{62,24,50}, |
| {30,38,1},{59,0,72},{35,44,2},{36,41,2},{31,41,2},{59,0,72},{62,28,72},{31,41,2},{0,39,74},{62,28,72},{0,39,74},{34,0,74},{34,0,74},{34,0,74},{34,0,74},{32,42,1},{32,42,1},{32,42,1},{32,37,1},{30,38,1},{30,38,1},{36,52,146},{36,46,79},{36,43,111},{36,42,84},{34,52,244},{34,45,74},{34,43,4},{34,41,100},{30,45,248},{31,41,76},{37,50,73}, |
| {37,46,3},{37,43,11},{37,42,14},{60,0,243},{34,45,73},{34,43,3},{30,41,74},{56,32,243},{30,41,74},{36,47,75},{36,47,75},{36,47,75},{36,42,75},{34,47,53},{34,43,3},{34,43,3},{34,39,10},{30,43,51},{32,40,2},{37,45,2},{37,45,2},{37,45,2},{37,41,2},{58,0,50},{35,42,1},{35,42,1},{32,40,1},{62,27,50},{32,40,1},{62,0,72},{37,46,2},{38,43,2}, |
| {33,43,2},{62,0,72},{62,31,72},{33,43,2},{0,41,74},{62,31,72},{0,41,74},{36,0,74},{36,0,74},{36,0,74},{36,0,74},{34,44,1},{34,44,1},{34,44,1},{34,39,1},{32,40,1},{32,40,1},{38,54,146},{38,49,77},{39,45,120},{38,45,76},{37,53,247},{36,47,78},{37,45,5},{36,43,100},{31,48,243},{33,43,81},{40,50,78},{39,48,4},{40,45,8},{39,45,20},{63,1,243}, |
| {36,47,74},{37,45,1},{33,43,80},{63,32,243},{33,43,80},{38,50,72},{38,50,72},{38,50,72},{38,44,72},{37,48,54},{37,45,5},{37,45,5},{36,42,8},{32,45,53},{34,42,1},{40,46,4},{40,46,4},{40,46,4},{40,43,4},{53,16,50},{37,45,1},{37,45,1},{35,42,0},{63,30,50},{35,42,0},{63,5,72},{39,48,0},{41,45,1},{36,45,0},{63,5,72},{47,42,72},{36,45,0}, |
| {0,43,80},{47,42,72},{0,43,80},{38,0,72},{38,0,72},{38,0,72},{38,0,72},{37,45,4},{37,45,4},{37,45,4},{37,41,4},{34,42,1},{34,42,1},{40,56,146},{40,51,77},{41,47,120},{40,47,76},{39,55,247},{38,49,77},{39,47,5},{38,45,100},{34,49,248},{35,45,81},{42,52,78},{41,50,4},{42,47,8},{41,47,20},{63,7,243},{38,49,73},{39,47,1},{35,45,80},{63,35,243}, |
| {35,45,80},{40,52,72},{40,52,72},{40,52,72},{40,46,72},{39,50,54},{39,47,5},{39,47,5},{38,44,8},{34,47,53},{36,44,1},{42,48,4},{42,48,4},{42,48,4},{42,45,4},{56,16,50},{39,47,1},{39,47,1},{37,44,0},{62,33,50},{37,44,0},{63,11,72},{41,50,0},{43,47,1},{38,47,0},{63,11,72},{47,45,72},{38,47,0},{0,45,80},{47,45,72},{0,45,80},{40,0,72}, |
| {40,0,72},{40,0,72},{40,0,72},{39,47,4},{39,47,4},{39,47,4},{39,43,4},{36,44,1},{36,44,1},{42,58,146},{42,53,77},{43,49,121},{42,48,81},{41,57,247},{40,51,77},{40,49,9},{40,47,100},{36,51,248},{37,47,81},{44,54,78},{43,52,4},{44,49,6},{43,48,17},{63,13,243},{40,51,73},{40,49,5},{37,47,80},{63,38,243},{37,47,80},{42,54,72},{42,54,72},{42,54,72}, |
| {42,48,72},{41,52,54},{41,48,6},{41,48,6},{40,46,8},{36,49,51},{38,46,1},{44,50,4},{44,50,4},{44,50,4},{44,47,4},{59,16,50},{41,48,2},{41,48,2},{39,46,0},{62,36,50},{39,46,0},{55,32,72},{43,52,0},{44,49,2},{40,49,1},{55,32,72},{46,48,72},{40,49,1},{0,47,80},{46,48,72},{0,47,80},{42,0,72},{42,0,72},{42,0,72},{42,0,72},{41,48,5}, |
| {41,48,5},{41,48,5},{41,45,4},{38,46,1},{38,46,1},{44,60,146},{44,55,77},{45,51,121},{44,50,81},{43,59,247},{42,53,77},{42,51,9},{42,49,103},{38,53,248},{39,49,76},{46,56,78},{45,54,4},{46,51,6},{45,50,17},{63,19,243},{42,53,73},{42,51,5},{38,49,74},{63,41,243},{38,49,74},{44,56,72},{44,56,72},{44,56,72},{44,50,72},{43,54,54},{43,50,6},{43,50,6}, |
| {42,48,9},{38,51,51},{40,48,2},{46,52,4},{46,52,4},{46,52,4},{46,49,4},{62,16,50},{43,50,2},{43,50,2},{40,48,1},{62,39,50},{40,48,1},{58,32,72},{45,54,0},{46,51,2},{42,51,1},{58,32,72},{52,48,72},{42,51,1},{0,49,74},{52,48,72},{0,49,74},{44,0,72},{44,0,72},{44,0,72},{44,0,72},{43,50,5},{43,50,5},{43,50,5},{43,47,4},{40,48,1}, |
| {40,48,1},{46,63,146},{46,57,79},{47,53,115},{46,53,78},{45,61,245},{45,55,77},{45,53,2},{44,51,105},{39,56,243},{42,51,82},{48,59,76},{48,55,9},{48,53,8},{47,53,18},{59,33,243},{44,55,74},{45,53,1},{41,51,80},{55,48,243},{41,51,80},{46,59,74},{46,59,74},{46,59,74},{46,52,75},{45,57,51},{45,53,2},{45,53,2},{44,50,10},{41,53,51},{42,50,1},{48,54,4}, |
| {48,54,4},{48,54,4},{48,51,4},{63,21,50},{45,53,1},{45,53,1},{43,50,0},{63,42,50},{43,50,0},{63,29,72},{47,56,2},{49,53,1},{44,53,1},{63,29,72},{63,46,72},{44,53,1},{0,51,80},{63,46,72},{0,51,80},{46,0,74},{46,0,74},{46,0,74},{46,0,74},{45,53,1},{45,53,1},{45,53,1},{45,49,1},{42,50,1},{42,50,1},{48,63,152},{48,59,77},{49,55,120}, |
| {48,55,76},{47,63,245},{47,57,77},{47,55,2},{46,53,105},{41,58,243},{44,53,82},{50,61,76},{49,58,4},{50,55,8},{49,55,20},{62,33,243},{46,57,74},{47,55,1},{43,53,80},{61,48,243},{43,53,80},{48,60,72},{48,60,72},{48,60,72},{48,54,72},{47,59,51},{47,55,2},{47,55,2},{46,52,10},{43,55,51},{44,52,1},{50,56,4},{50,56,4},{50,56,4},{50,53,4},{63,27,50}, |
| {47,55,1},{47,55,1},{45,52,0},{63,45,50},{45,52,0},{63,35,72},{49,58,0},{51,55,1},{46,55,1},{63,35,72},{63,49,72},{46,55,1},{0,53,80},{63,49,72},{0,53,80},{48,0,72},{48,0,72},{48,0,72},{48,0,72},{47,55,1},{47,55,1},{47,55,1},{47,51,1},{44,52,1},{44,52,1},{51,63,184},{50,61,77},{51,57,120},{50,57,76},{49,63,268},{48,59,78},{49,57,5}, |
| {48,55,100},{43,60,243},{46,55,82},{52,63,76},{51,60,4},{52,57,8},{51,57,20},{63,37,243},{48,59,74},{49,57,1},{45,55,80},{63,50,243},{45,55,80},{50,62,72},{50,62,72},{50,62,72},{50,56,72},{49,60,56},{49,57,5},{49,57,5},{48,54,8},{45,57,51},{46,54,1},{52,58,4},{52,58,4},{52,58,4},{52,55,4},{63,33,50},{49,57,1},{49,57,1},{47,54,0},{47,56,50}, |
| {47,54,0},{63,41,72},{51,60,0},{53,57,1},{48,57,0},{63,41,72},{63,52,72},{48,57,0},{0,55,80},{63,52,72},{0,55,80},{50,0,72},{50,0,72},{50,0,72},{50,0,72},{49,57,4},{49,57,4},{49,57,4},{49,53,4},{46,54,1},{46,54,1},{53,63,226},{52,63,77},{53,59,120},{52,59,76},{52,63,300},{50,61,78},{51,59,5},{50,57,100},{45,62,243},{47,57,84},{54,63,84}, |
| {53,62,4},{54,59,8},{53,59,20},{63,43,243},{49,62,73},{51,59,1},{47,57,80},{63,53,243},{47,57,80},{52,63,76},{52,63,76},{52,63,76},{52,58,72},{51,62,56},{51,59,5},{51,59,5},{50,56,8},{47,59,51},{48,56,1},{54,60,4},{54,60,4},{54,60,4},{54,57,4},{63,39,50},{51,59,1},{51,59,1},{49,56,0},{47,59,50},{49,56,0},{63,47,72},{53,62,0},{55,59,1}, |
| {50,59,0},{63,47,72},{63,55,72},{50,59,0},{0,57,80},{63,55,72},{0,57,80},{52,0,72},{52,0,72},{52,0,72},{52,0,72},{51,59,4},{51,59,4},{51,59,4},{51,55,4},{48,56,1},{48,56,1},{56,63,314},{55,63,115},{55,62,115},{54,61,76},{54,63,364},{53,63,79},{53,61,3},{52,59,108},{48,63,252},{49,60,79},{57,63,115},{56,63,10},{56,61,11},{56,61,18},{63,50,243}, |
| {53,63,78},{53,61,2},{47,60,75},{62,57,243},{47,60,75},{54,63,99},{54,63,99},{54,63,99},{54,60,75},{53,63,69},{53,61,2},{53,61,2},{53,58,6},{49,61,51},{50,58,6},{56,63,1},{56,63,1},{56,63,1},{56,59,2},{61,49,50},{53,61,1},{53,61,1},{51,58,2},{63,54,50},{51,58,2},{63,53,74},{56,63,9},{57,61,1},{53,61,1},{63,53,74},{63,58,74},{53,61,1}, |
| {0,60,74},{63,58,74},{0,60,74},{54,0,74},{54,0,74},{54,0,74},{54,0,74},{53,61,2},{53,61,2},{53,61,2},{53,57,2},{50,59,2},{50,59,2},{57,63,371},{57,63,179},{57,63,115},{56,63,75},{57,63,387},{55,63,123},{55,63,2},{54,61,91},{52,63,286},{51,62,70},{59,63,146},{58,63,59},{58,63,10},{58,63,17},{63,55,221},{57,63,98},{55,63,1},{49,62,66},{63,59,221}, |
| {49,62,66},{57,63,115},{57,63,115},{57,63,115},{56,62,75},{56,63,93},{55,63,2},{55,63,2},{55,60,6},{51,63,51},{52,60,6},{58,63,10},{58,63,10},{58,63,10},{58,61,2},{63,51,50},{55,63,1},{55,63,1},{53,60,2},{63,57,50},{53,60,2},{63,59,61},{60,63,25},{59,63,0},{55,63,0},{63,59,61},{63,61,61},{55,63,0},{0,62,65},{63,61,61},{0,62,65},{56,0,74}, |
| {56,0,74},{56,0,74},{56,0,74},{55,63,2},{55,63,2},{55,63,2},{55,59,2},{52,61,2},{52,61,2},{60,63,259},{59,63,190},{59,63,154},{58,63,90},{59,63,270},{58,63,91},{57,63,35},{57,62,22},{56,63,194},{54,63,11},{61,63,70},{60,63,42},{60,63,26},{60,63,2},{63,59,94},{60,63,42},{59,63,13},{53,63,10},{63,61,94},{53,63,10},{59,63,154},{59,63,154},{59,63,154}, |
| {58,63,90},{58,63,147},{57,63,35},{57,63,35},{57,62,6},{55,63,77},{54,62,6},{60,63,26},{60,63,26},{60,63,26},{60,63,2},{63,57,50},{59,63,13},{59,63,13},{55,62,2},{63,60,50},{55,62,2},{63,62,5},{62,63,4},{62,63,0},{61,63,0},{63,62,5},{62,63,5},{61,63,0},{0,63,9},{62,63,5},{0,63,9},{58,0,74},{58,0,74},{58,0,74},{58,0,74},{57,63,10}, |
| {57,63,10},{57,63,10},{57,61,2},{54,63,2},{54,63,2},{61,63,162},{61,63,135},{61,63,126},{60,63,90},{61,63,154},{60,63,66},{60,63,50},{59,63,2},{59,63,109},{57,63,10},{62,63,19},{62,63,14},{62,63,10},{62,63,5},{63,62,17},{62,63,12},{62,63,8},{59,63,1},{62,63,17},{59,63,1},{61,63,126},{61,63,126},{61,63,126},{60,63,90},{60,63,98},{60,63,50},{60,63,50}, |
| {59,63,2},{58,63,62},{57,63,10},{62,63,10},{62,63,10},{62,63,10},{62,63,5},{63,61,13},{62,63,8},{62,63,8},{59,63,1},{63,62,13},{59,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{60,0,74},{60,0,74},{60,0,74},{60,0,74},{60,63,34},{60,63,34},{60,63,34},{59,63,2},{57,63,10}, |
| {57,63,10},{0,14,202},{0,10,25},{0,7,1},{0,6,74},{0,10,441},{0,6,282},{0,5,133},{0,4,318},{0,5,477},{0,4,343},{0,14,202},{0,10,25},{0,7,1},{0,6,74},{5,0,441},{0,6,282},{0,5,133},{0,4,318},{10,0,441},{0,4,318},{0,7,0},{0,7,0},{0,7,0},{0,3,1},{0,3,41},{0,3,17},{0,3,17},{0,2,26},{0,2,45},{0,1,30},{0,7,0}, |
| {0,7,0},{0,7,0},{0,3,1},{2,0,41},{0,3,17},{0,3,17},{0,2,26},{3,0,41},{0,2,26},{7,0,202},{0,10,25},{0,7,1},{0,6,74},{7,0,202},{14,0,202},{0,6,74},{0,5,202},{14,0,202},{0,5,202},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,20,200},{0,14,1},{0,10,25}, |
| {0,8,41},{0,14,686},{0,9,362},{0,8,141},{0,5,467},{0,6,762},{0,5,503},{0,20,200},{0,14,1},{0,10,25},{0,8,41},{7,0,686},{0,9,362},{0,8,141},{0,5,467},{14,0,686},{0,5,467},{0,13,0},{0,13,0},{0,13,0},{0,6,1},{0,6,145},{0,5,52},{0,5,52},{0,3,89},{0,3,161},{0,3,105},{0,13,0},{0,13,0},{0,13,0},{0,6,1},{3,0,145}, |
| {0,5,52},{0,5,52},{0,3,89},{6,0,145},{0,3,89},{2,16,200},{0,14,1},{2,9,1},{0,8,41},{2,16,200},{20,0,200},{0,8,41},{0,7,202},{20,0,200},{0,7,202},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{1,24,225},{1,16,27},{1,12,83},{1,11,51},{0,19,724},{0,12,299},{0,10,62}, |
| {0,8,414},{0,9,875},{0,7,500},{2,22,201},{2,16,6},{2,12,26},{1,11,35},{10,0,723},{0,12,299},{0,10,62},{0,8,414},{14,3,723},{0,8,414},{1,17,25},{1,17,25},{1,17,25},{1,9,25},{0,12,162},{0,8,25},{0,8,25},{0,5,61},{0,5,216},{0,5,97},{2,15,1},{2,15,1},{2,15,1},{2,8,2},{6,0,162},{0,8,25},{0,8,25},{0,5,61},{12,0,162}, |
| {0,5,61},{5,16,200},{1,16,2},{4,11,1},{0,11,17},{5,16,200},{26,0,200},{0,11,17},{0,9,202},{26,0,200},{0,9,202},{1,0,25},{1,0,25},{1,0,25},{1,0,25},{0,5,1},{0,5,1},{0,5,1},{0,3,1},{0,2,8},{0,2,8},{2,28,313},{2,19,118},{2,14,203},{2,13,130},{0,25,724},{0,16,236},{0,13,6},{0,10,339},{0,11,984},{0,10,508},{4,24,201}, |
| {4,17,5},{4,14,26},{3,13,35},{13,0,723},{0,16,236},{0,13,6},{0,10,339},{14,6,723},{0,10,339},{2,21,113},{2,21,113},{2,21,113},{2,11,114},{0,18,162},{0,12,2},{0,12,2},{0,7,34},{0,8,280},{0,7,115},{4,17,1},{4,17,1},{4,17,1},{4,10,2},{9,0,162},{0,12,2},{0,12,2},{0,7,34},{18,0,162},{0,7,34},{16,0,200},{3,18,2},{6,13,1}, |
| {0,13,2},{16,0,200},{32,0,200},{0,13,2},{0,11,202},{32,0,200},{0,11,202},{2,0,113},{2,0,113},{2,0,113},{2,0,113},{0,11,1},{0,11,1},{0,11,1},{0,6,1},{0,5,40},{0,5,40},{4,31,408},{4,22,216},{4,16,317},{3,15,216},{1,30,723},{1,19,216},{1,15,9},{0,12,312},{0,15,1000},{0,12,440},{6,27,200},{6,20,1},{7,16,29},{5,15,36},{16,0,723}, |
| {0,19,203},{2,15,5},{0,12,296},{32,0,723},{0,12,296},{4,23,209},{4,23,209},{4,23,209},{4,14,208},{1,23,162},{1,16,4},{1,16,4},{1,10,20},{0,11,294},{0,10,89},{6,19,1},{6,19,1},{6,19,1},{6,13,0},{12,1,162},{2,15,1},{2,15,1},{0,10,8},{25,0,162},{0,10,8},{19,1,200},{6,20,1},{8,15,5},{2,15,4},{19,1,200},{39,0,200},{2,15,4}, |
| {0,13,200},{39,0,200},{0,13,200},{3,0,208},{3,0,208},{3,0,208},{3,0,208},{1,16,0},{1,16,0},{1,16,0},{1,9,1},{0,8,45},{0,8,45},{6,33,408},{6,24,216},{6,18,317},{5,17,213},{3,32,723},{3,21,216},{3,17,2},{2,14,312},{0,18,888},{0,14,293},{8,29,200},{8,22,1},{9,17,26},{8,17,37},{19,0,723},{1,22,200},{3,17,2},{0,14,257},{38,0,723}, |
| {0,14,257},{6,25,209},{6,25,209},{6,25,209},{5,16,208},{3,25,162},{3,17,1},{3,17,1},{3,12,20},{0,15,228},{0,12,20},{8,21,1},{8,21,1},{8,21,1},{8,15,0},{15,1,162},{3,17,1},{3,17,1},{0,12,4},{31,0,162},{0,12,4},{22,1,200},{8,22,1},{10,17,2},{3,17,1},{22,1,200},{45,0,200},{3,17,1},{0,15,200},{45,0,200},{0,15,200},{5,0,208}, |
| {5,0,208},{5,0,208},{5,0,208},{3,18,0},{3,18,0},{3,18,0},{3,11,1},{0,11,13},{0,11,13},{8,35,408},{8,26,216},{8,20,317},{7,19,213},{5,34,723},{5,23,216},{5,19,2},{4,16,298},{0,22,804},{0,16,228},{10,31,200},{10,24,1},{11,19,26},{10,19,37},{22,0,723},{3,24,200},{5,19,2},{0,16,227},{44,0,723},{0,16,227},{8,27,209},{8,27,209},{8,27,209}, |
| {7,18,208},{5,27,162},{5,19,1},{5,19,1},{5,14,20},{0,18,180},{0,15,4},{10,23,1},{10,23,1},{10,23,1},{10,17,1},{15,7,162},{5,19,1},{5,19,1},{2,14,4},{31,3,162},{2,14,4},{25,1,200},{10,24,1},{12,19,2},{5,19,1},{25,1,200},{47,2,200},{5,19,1},{0,17,202},{47,2,200},{0,17,202},{7,0,208},{7,0,208},{7,0,208},{7,0,208},{5,20,0}, |
| {5,20,0},{5,20,0},{5,13,1},{0,15,0},{0,15,0},{10,37,408},{10,28,216},{10,22,317},{9,21,213},{7,36,723},{7,25,216},{7,21,2},{6,18,298},{0,25,748},{1,19,218},{12,33,200},{12,26,1},{13,21,26},{12,21,37},{25,0,723},{5,26,200},{7,21,2},{0,19,211},{50,0,723},{0,19,211},{10,29,209},{10,29,209},{10,29,209},{9,20,208},{7,29,162},{7,21,1},{7,21,1}, |
| {7,16,17},{0,21,164},{3,16,3},{12,25,1},{12,25,1},{12,25,1},{12,19,1},{15,13,162},{7,21,1},{7,21,1},{4,16,1},{31,6,162},{4,16,1},{28,1,200},{12,26,1},{14,21,2},{7,21,1},{28,1,200},{47,5,200},{7,21,1},{0,19,202},{47,5,200},{0,19,202},{9,0,208},{9,0,208},{9,0,208},{9,0,208},{7,22,0},{7,22,0},{7,22,0},{7,15,1},{2,17,0}, |
| {2,17,0},{12,39,404},{12,30,212},{13,24,318},{12,23,215},{9,39,724},{9,27,212},{9,24,7},{8,20,306},{0,28,724},{3,21,210},{14,35,203},{14,28,2},{15,24,22},{14,23,30},{28,1,723},{7,28,203},{10,23,4},{0,21,201},{47,5,723},{0,21,201},{12,32,202},{12,32,202},{12,32,202},{12,22,202},{9,31,165},{9,24,3},{9,24,3},{9,18,14},{2,24,164},{4,19,6},{14,28,1}, |
| {14,28,1},{14,28,1},{14,21,1},{24,1,162},{10,23,0},{10,23,0},{6,18,5},{49,0,162},{6,18,5},{23,17,200},{14,28,1},{16,24,4},{10,23,4},{23,17,200},{63,0,200},{10,23,4},{0,21,200},{63,0,200},{0,21,200},{12,0,202},{12,0,202},{12,0,202},{12,0,202},{9,25,1},{9,25,1},{9,25,1},{9,17,2},{4,19,2},{4,19,2},{14,41,404},{14,32,215},{15,26,318}, |
| {14,25,215},{11,41,724},{11,29,212},{11,26,7},{10,22,306},{2,30,724},{5,23,210},{16,37,200},{16,30,1},{17,26,24},{16,25,40},{31,1,723},{9,30,203},{12,25,4},{2,23,201},{47,8,723},{2,23,201},{14,34,202},{14,34,202},{14,34,202},{14,24,202},{11,33,163},{11,26,3},{11,26,3},{11,20,14},{4,26,164},{6,21,6},{16,30,0},{16,30,0},{16,30,0},{16,23,0},{27,1,162}, |
| {12,25,0},{12,25,0},{8,20,5},{55,0,162},{8,20,5},{34,1,200},{16,30,1},{18,26,4},{12,25,4},{34,1,200},{63,3,200},{12,25,4},{0,23,200},{63,3,200},{0,23,200},{14,0,202},{14,0,202},{14,0,202},{14,0,202},{11,27,1},{11,27,1},{11,27,1},{11,19,2},{6,21,2},{6,21,2},{16,43,408},{16,34,216},{16,28,312},{16,27,221},{13,43,724},{13,31,212},{13,28,7}, |
| {12,24,306},{4,32,724},{7,25,210},{18,39,200},{18,32,1},{19,28,24},{17,27,36},{34,0,723},{11,32,201},{14,27,4},{4,25,201},{47,11,723},{4,25,201},{16,35,209},{16,35,209},{16,35,209},{16,26,208},{13,35,163},{13,28,3},{13,28,3},{13,22,14},{6,28,164},{8,23,6},{18,31,1},{18,31,1},{18,31,1},{18,25,0},{30,1,162},{14,27,0},{14,27,0},{10,22,5},{61,0,162}, |
| {10,22,5},{37,1,200},{18,32,1},{20,28,4},{14,27,4},{37,1,200},{63,6,200},{14,27,4},{0,25,200},{63,6,200},{0,25,200},{16,0,208},{16,0,208},{16,0,208},{16,0,208},{13,29,1},{13,29,1},{13,29,1},{13,21,2},{8,23,2},{8,23,2},{18,45,408},{18,36,216},{18,30,312},{17,29,216},{15,45,724},{15,33,210},{15,30,7},{14,26,306},{6,34,724},{9,27,210},{20,41,200}, |
| {20,34,1},{21,30,24},{19,29,36},{37,0,723},{13,34,201},{16,29,5},{6,27,201},{47,14,723},{6,27,201},{18,37,209},{18,37,209},{18,37,209},{18,28,208},{15,37,163},{15,30,3},{15,30,3},{15,24,14},{8,30,164},{10,25,6},{20,33,1},{20,33,1},{20,33,1},{20,27,0},{33,1,162},{16,29,1},{16,29,1},{12,24,5},{63,2,162},{12,24,5},{40,1,200},{20,34,1},{22,30,4}, |
| {16,29,4},{40,1,200},{63,9,200},{16,29,4},{0,27,200},{63,9,200},{0,27,200},{17,0,208},{17,0,208},{17,0,208},{17,0,208},{15,31,1},{15,31,1},{15,31,1},{15,23,2},{10,25,2},{10,25,2},{20,47,404},{20,38,212},{21,32,318},{20,31,215},{17,47,724},{17,35,212},{17,32,7},{16,29,308},{8,36,724},{11,29,210},{22,44,201},{22,36,2},{23,32,22},{22,31,35},{40,1,723}, |
| {15,36,206},{17,32,6},{9,29,202},{63,9,723},{9,29,202},{20,40,202},{20,40,202},{20,40,202},{20,30,203},{17,39,165},{17,32,3},{17,32,3},{17,26,19},{10,32,164},{13,27,2},{22,36,1},{22,36,1},{22,36,1},{22,29,2},{31,12,162},{18,31,1},{18,31,1},{13,27,1},{62,6,162},{13,27,1},{44,0,200},{22,36,1},{24,32,4},{16,32,4},{44,0,200},{62,13,200},{16,32,4}, |
| {0,29,202},{62,13,200},{0,29,202},{20,0,202},{20,0,202},{20,0,202},{20,0,202},{17,33,1},{17,33,1},{17,33,1},{17,25,1},{13,27,1},{13,27,1},{22,49,404},{22,40,212},{23,34,318},{22,33,215},{19,49,724},{19,37,212},{19,34,7},{18,31,308},{10,38,724},{13,31,210},{24,46,201},{24,38,2},{25,34,22},{24,33,30},{43,1,723},{17,38,203},{20,33,4},{11,31,202},{63,12,723}, |
| {11,31,202},{22,42,202},{22,42,202},{22,42,202},{22,32,202},{19,41,165},{19,34,3},{19,34,3},{19,28,19},{12,34,164},{15,29,2},{24,38,1},{24,38,1},{24,38,1},{24,31,2},{31,18,162},{20,33,0},{20,33,0},{15,29,1},{62,9,162},{15,29,1},{47,0,200},{24,38,1},{26,34,4},{20,33,4},{47,0,200},{46,24,200},{20,33,4},{0,31,202},{46,24,200},{0,31,202},{22,0,202}, |
| {22,0,202},{22,0,202},{22,0,202},{19,35,1},{19,35,1},{19,35,1},{19,27,1},{15,29,1},{15,29,1},{24,51,404},{24,42,212},{25,36,318},{24,35,215},{21,51,724},{21,39,212},{21,36,7},{20,32,306},{12,40,724},{15,33,213},{26,47,203},{26,40,2},{27,36,22},{26,35,30},{46,1,723},{19,40,203},{22,35,4},{13,33,200},{63,15,723},{13,33,200},{24,44,202},{24,44,202},{24,44,202}, |
| {24,34,202},{21,43,165},{21,36,3},{21,36,3},{21,30,19},{14,36,164},{17,31,2},{26,40,1},{26,40,1},{26,40,1},{26,33,1},{34,17,162},{22,35,0},{22,35,0},{17,31,1},{62,12,162},{17,31,1},{49,1,200},{26,40,1},{28,36,4},{22,35,4},{49,1,200},{46,27,200},{22,35,4},{0,33,200},{46,27,200},{0,33,200},{24,0,202},{24,0,202},{24,0,202},{24,0,202},{21,37,1}, |
| {21,37,1},{21,37,1},{21,29,1},{17,31,1},{17,31,1},{26,53,404},{26,44,212},{27,38,318},{26,37,215},{23,53,724},{23,41,212},{23,38,7},{22,34,306},{14,42,724},{17,35,210},{28,49,203},{28,42,2},{29,38,22},{28,37,30},{47,5,723},{21,42,203},{24,37,4},{15,35,200},{63,18,723},{15,35,200},{26,46,202},{26,46,202},{26,46,202},{26,36,202},{23,45,165},{23,38,3},{23,38,3}, |
| {23,32,14},{16,38,164},{18,33,6},{28,42,1},{28,42,1},{28,42,1},{28,35,1},{37,17,162},{24,37,0},{24,37,0},{20,32,5},{62,15,162},{20,32,5},{52,1,200},{28,42,1},{30,38,4},{24,37,4},{52,1,200},{46,30,200},{24,37,4},{0,35,200},{46,30,200},{0,35,200},{26,0,202},{26,0,202},{26,0,202},{26,0,202},{23,39,1},{23,39,1},{23,39,1},{23,31,1},{18,33,2}, |
| {18,33,2},{28,56,400},{28,46,216},{29,40,314},{28,39,213},{26,53,728},{25,44,215},{25,40,9},{25,37,306},{17,44,728},{19,37,210},{31,50,204},{30,45,4},{31,40,21},{30,39,29},{52,1,723},{24,44,201},{25,40,5},{17,37,202},{46,30,723},{17,37,202},{28,49,200},{28,49,200},{28,49,200},{28,38,201},{26,46,166},{26,39,6},{26,39,6},{25,34,17},{18,40,163},{21,35,2},{31,43,4}, |
| {31,43,4},{31,43,4},{31,37,4},{49,0,162},{26,39,2},{26,39,2},{21,35,1},{62,18,162},{21,35,1},{56,0,200},{30,45,0},{32,40,2},{25,40,1},{56,0,200},{62,25,200},{25,40,1},{0,37,202},{62,25,200},{0,37,202},{28,0,200},{28,0,200},{28,0,200},{28,0,200},{26,39,5},{26,39,5},{26,39,5},{25,33,4},{21,35,1},{21,35,1},{30,58,400},{30,48,217},{31,42,314}, |
| {30,41,213},{28,55,728},{27,46,215},{27,42,9},{27,39,306},{19,46,728},{21,39,210},{32,54,201},{32,47,3},{33,42,19},{32,41,35},{55,1,723},{26,46,201},{27,42,5},{19,39,202},{47,32,723},{19,39,202},{30,51,200},{30,51,200},{30,51,200},{30,40,201},{28,48,166},{28,41,6},{28,41,6},{27,36,17},{20,42,163},{23,37,2},{32,46,2},{32,46,2},{32,46,2},{32,39,2},{52,0,162}, |
| {28,41,2},{28,41,2},{23,37,1},{62,21,162},{23,37,1},{59,0,200},{32,47,2},{34,42,2},{27,42,1},{59,0,200},{62,28,200},{27,42,1},{0,39,202},{62,28,200},{0,39,202},{30,0,200},{30,0,200},{30,0,200},{30,0,200},{28,41,5},{28,41,5},{28,41,5},{27,35,4},{23,37,1},{23,37,1},{32,60,402},{32,50,212},{32,44,324},{32,43,215},{30,57,728},{29,47,216},{29,44,9}, |
| {29,41,306},{20,48,724},{23,41,210},{34,56,201},{34,48,2},{35,44,19},{34,43,35},{58,1,723},{28,48,201},{29,44,5},{21,41,202},{53,32,723},{21,41,202},{32,52,202},{32,52,202},{32,52,202},{32,42,203},{30,50,166},{30,43,6},{30,43,6},{29,38,17},{22,44,163},{25,39,2},{34,48,1},{34,48,1},{34,48,1},{34,41,2},{55,0,162},{30,43,2},{30,43,2},{25,39,1},{62,24,162}, |
| {25,39,1},{62,0,200},{34,48,1},{36,44,2},{29,44,1},{62,0,200},{62,31,200},{29,44,1},{0,41,202},{62,31,200},{0,41,202},{32,0,202},{32,0,202},{32,0,202},{32,0,202},{30,43,5},{30,43,5},{30,43,5},{29,37,4},{25,39,1},{25,39,1},{34,62,402},{34,52,212},{34,46,324},{34,45,215},{31,61,728},{31,49,210},{31,46,9},{31,43,306},{22,50,724},{25,43,210},{36,58,201}, |
| {36,50,2},{37,46,19},{36,45,35},{61,1,723},{30,50,201},{31,46,5},{23,43,202},{59,32,723},{23,43,202},{34,54,202},{34,54,202},{34,54,202},{34,44,203},{31,54,166},{31,46,8},{31,46,8},{31,40,17},{24,46,163},{27,41,2},{36,50,1},{36,50,1},{36,50,1},{36,43,2},{58,0,162},{32,45,1},{32,45,1},{27,41,1},{62,27,162},{27,41,1},{63,4,200},{36,50,1},{38,46,2}, |
| {31,46,1},{63,4,200},{62,34,200},{31,46,1},{0,43,202},{62,34,200},{0,43,202},{34,0,202},{34,0,202},{34,0,202},{34,0,202},{31,47,5},{31,47,5},{31,47,5},{31,39,4},{27,41,1},{27,41,1},{36,63,408},{36,54,216},{37,48,314},{36,47,217},{34,62,727},{33,52,215},{33,48,9},{32,45,308},{24,53,723},{28,45,217},{39,58,206},{38,53,4},{39,48,21},{38,47,36},{63,4,723}, |
| {32,52,201},{33,48,5},{26,45,208},{62,34,723},{26,45,208},{36,57,200},{36,57,200},{36,57,200},{36,47,201},{34,54,166},{33,48,8},{33,48,8},{33,43,20},{26,48,163},{29,43,1},{39,51,4},{39,51,4},{39,51,4},{39,45,4},{53,16,162},{35,47,4},{35,47,4},{30,43,0},{63,30,162},{30,43,0},{63,11,200},{38,53,0},{40,48,2},{33,48,1},{63,11,200},{47,45,200},{33,48,1}, |
| {0,45,208},{47,45,200},{0,45,208},{36,0,200},{36,0,200},{36,0,200},{36,0,200},{34,47,5},{34,47,5},{34,47,5},{34,41,4},{29,43,1},{29,43,1},{39,63,440},{38,56,216},{39,50,314},{38,49,213},{36,63,728},{35,54,215},{35,50,9},{34,47,308},{26,55,723},{30,47,217},{41,60,206},{40,55,4},{41,50,21},{40,49,29},{63,10,723},{34,54,201},{35,50,5},{28,47,208},{62,37,723}, |
| {28,47,208},{38,59,200},{38,59,200},{38,59,200},{38,48,201},{36,56,166},{36,49,6},{36,49,6},{35,45,20},{28,50,163},{31,45,1},{41,53,4},{41,53,4},{41,53,4},{41,47,4},{56,16,162},{36,49,2},{36,49,2},{32,45,0},{62,33,162},{32,45,0},{55,32,200},{40,55,0},{42,50,2},{35,50,1},{55,32,200},{46,48,200},{35,50,1},{0,47,208},{46,48,200},{0,47,208},{38,0,200}, |
| {38,0,200},{38,0,200},{38,0,200},{36,49,5},{36,49,5},{36,49,5},{36,43,4},{31,45,1},{31,45,1},{41,63,482},{40,58,216},{41,52,314},{40,51,213},{39,63,760},{37,56,215},{37,52,9},{37,49,306},{28,57,723},{31,49,215},{43,62,206},{42,57,4},{43,52,21},{42,51,29},{63,16,723},{36,56,201},{37,52,5},{29,49,203},{62,40,723},{29,49,203},{40,61,200},{40,61,200},{40,61,200}, |
| {40,50,201},{38,58,166},{38,51,6},{38,51,6},{37,47,20},{30,52,163},{33,47,1},{43,55,4},{43,55,4},{43,55,4},{43,49,4},{59,16,162},{38,51,2},{38,51,2},{34,47,0},{62,36,162},{34,47,0},{58,32,200},{42,57,0},{44,52,2},{37,52,1},{58,32,200},{52,48,200},{37,52,1},{0,49,202},{52,48,200},{0,49,202},{40,0,200},{40,0,200},{40,0,200},{40,0,200},{38,51,5}, |
| {38,51,5},{38,51,5},{38,45,4},{33,47,1},{33,47,1},{43,63,530},{42,60,216},{43,54,314},{42,53,213},{41,63,799},{39,58,215},{39,54,9},{39,51,306},{30,59,723},{33,51,210},{45,63,212},{44,59,4},{45,54,21},{44,53,29},{63,22,723},{38,58,201},{39,54,5},{31,51,203},{62,43,723},{31,51,203},{42,63,200},{42,63,200},{42,63,200},{42,52,201},{40,60,166},{40,53,6},{40,53,6}, |
| {39,48,17},{32,54,163},{35,49,2},{45,57,4},{45,57,4},{45,57,4},{45,51,4},{62,16,162},{40,53,2},{40,53,2},{35,49,1},{62,39,162},{35,49,1},{61,32,200},{44,59,0},{46,54,2},{39,54,1},{61,32,200},{58,48,200},{39,54,1},{0,51,202},{58,48,200},{0,51,202},{42,0,200},{42,0,200},{42,0,200},{42,0,200},{40,53,5},{40,53,5},{40,53,5},{40,47,4},{35,49,1}, |
| {35,49,1},{46,63,626},{44,63,222},{45,57,315},{44,56,211},{44,63,869},{41,60,213},{42,56,2},{41,53,298},{32,61,723},{36,53,217},{48,63,244},{47,60,5},{47,56,26},{46,55,34},{61,32,723},{40,60,202},{42,56,1},{34,53,208},{58,48,723},{34,53,208},{44,63,218},{44,63,218},{44,63,218},{44,55,203},{42,63,163},{42,56,2},{42,56,2},{41,51,25},{35,56,163},{37,51,1},{47,60,1}, |
| {47,60,1},{47,60,1},{47,53,2},{63,21,162},{42,56,1},{42,56,1},{38,51,0},{63,42,162},{38,51,0},{63,35,200},{46,61,2},{49,56,1},{41,56,1},{63,35,200},{63,49,200},{41,56,1},{0,53,208},{63,49,200},{0,53,208},{44,0,202},{44,0,202},{44,0,202},{44,0,202},{42,56,1},{42,56,1},{42,56,1},{42,49,1},{37,51,1},{37,51,1},{48,63,728},{47,63,238},{47,59,315}, |
| {46,58,211},{46,63,937},{43,62,213},{44,58,2},{43,55,298},{34,63,723},{38,55,217},{50,63,286},{48,63,4},{49,58,20},{48,57,36},{63,34,723},{42,62,202},{44,58,1},{36,55,208},{62,49,723},{36,55,208},{47,63,234},{47,63,234},{47,63,234},{46,57,203},{44,63,181},{44,58,2},{44,58,2},{43,53,25},{37,58,163},{39,53,1},{49,61,4},{49,61,4},{49,61,4},{49,55,4},{63,27,162}, |
| {44,58,1},{44,58,1},{40,53,0},{63,45,162},{40,53,0},{63,41,200},{48,63,0},{51,58,1},{43,58,1},{63,41,200},{63,52,200},{43,58,1},{0,55,208},{63,52,200},{0,55,208},{46,0,202},{46,0,202},{46,0,202},{46,0,202},{44,58,1},{44,58,1},{44,58,1},{44,51,1},{39,53,1},{39,53,1},{50,63,866},{49,63,317},{49,61,312},{48,60,216},{48,63,1048},{46,63,219},{46,60,2}, |
| {45,57,298},{38,63,748},{40,57,217},{53,63,350},{51,63,20},{51,60,20},{50,59,36},{63,40,723},{46,63,218},{46,60,1},{38,57,208},{62,52,723},{38,57,208},{48,63,264},{48,63,264},{48,63,264},{48,59,201},{47,63,205},{46,60,2},{46,60,2},{45,55,25},{39,60,163},{41,55,1},{51,63,4},{51,63,4},{51,63,4},{51,57,4},{63,33,162},{46,60,1},{46,60,1},{42,55,0},{47,56,162}, |
| {42,55,0},{63,47,200},{52,63,13},{53,60,1},{45,60,1},{63,47,200},{63,55,200},{45,60,1},{0,57,208},{63,55,200},{0,57,208},{48,0,200},{48,0,200},{48,0,200},{48,0,200},{46,60,1},{46,60,1},{46,60,1},{46,53,1},{41,55,1},{41,55,1},{53,63,1026},{51,63,440},{51,63,312},{50,62,216},{51,63,1144},{48,63,280},{48,62,5},{47,59,298},{43,63,827},{42,59,217},{55,63,428}, |
| {54,63,100},{53,62,20},{52,61,36},{63,46,723},{49,63,266},{48,62,1},{40,59,208},{62,55,723},{40,59,208},{51,63,296},{51,63,296},{51,63,296},{50,61,201},{49,63,248},{48,62,5},{48,62,5},{47,57,25},{41,62,163},{43,57,1},{53,63,13},{53,63,13},{53,63,13},{53,59,4},{63,39,162},{48,62,1},{48,62,1},{44,57,0},{47,59,162},{44,57,0},{63,53,200},{55,63,53},{55,62,1}, |
| {47,62,1},{63,53,200},{63,58,200},{47,62,1},{0,59,208},{63,58,200},{0,59,208},{50,0,200},{50,0,200},{50,0,200},{50,0,200},{48,62,4},{48,62,4},{48,62,4},{48,55,4},{43,57,1},{43,57,1},{54,63,955},{54,63,523},{53,63,362},{52,63,202},{54,63,1027},{51,63,283},{50,63,14},{49,60,198},{47,63,735},{44,61,118},{57,63,338},{56,63,141},{56,63,41},{55,63,17},{63,51,546}, |
| {53,63,233},{51,63,2},{43,61,113},{63,57,546},{43,61,113},{53,63,362},{53,63,362},{53,63,362},{52,63,202},{51,63,315},{50,63,14},{50,63,14},{49,59,19},{44,63,171},{46,59,3},{56,63,41},{56,63,41},{56,63,41},{55,61,2},{61,49,162},{51,63,2},{51,63,2},{47,59,1},{63,54,162},{47,59,1},{63,57,113},{58,63,50},{57,63,1},{52,63,0},{63,57,113},{63,60,113},{52,63,0}, |
| {0,61,113},{63,60,113},{0,61,113},{52,0,202},{52,0,202},{52,0,202},{52,0,202},{50,63,5},{50,63,5},{50,63,5},{50,57,2},{45,60,0},{45,60,0},{57,63,779},{56,63,542},{56,63,442},{54,63,227},{56,63,830},{54,63,251},{53,63,78},{51,62,70},{51,63,587},{47,62,25},{59,63,218},{58,63,123},{58,63,74},{57,63,2},{63,55,333},{56,63,145},{55,63,25},{47,62,25},{63,59,333}, |
| {47,62,25},{56,63,442},{56,63,442},{56,63,442},{54,63,227},{54,63,371},{53,63,78},{53,63,78},{51,61,19},{48,63,219},{47,61,6},{58,63,74},{58,63,74},{58,63,74},{57,63,2},{63,51,162},{55,63,25},{55,63,25},{48,61,2},{63,57,162},{48,61,2},{63,60,25},{61,63,10},{60,63,1},{58,63,0},{63,60,25},{62,62,25},{58,63,0},{0,62,25},{62,62,25},{0,62,25},{54,0,202}, |
| {54,0,202},{54,0,202},{54,0,202},{52,63,26},{52,63,26},{52,63,26},{52,59,2},{47,62,0},{47,62,0},{59,63,684},{57,63,538},{57,63,474},{57,63,282},{57,63,682},{56,63,285},{55,63,171},{53,63,18},{54,63,482},{49,63,5},{60,63,153},{60,63,105},{60,63,89},{59,63,37},{63,59,193},{58,63,107},{58,63,58},{50,63,1},{63,61,193},{50,63,1},{57,63,474},{57,63,474},{57,63,474}, |
| {57,63,282},{57,63,426},{55,63,171},{55,63,171},{53,63,18},{52,63,278},{49,63,5},{60,63,89},{60,63,89},{60,63,89},{59,63,37},{63,57,145},{58,63,58},{58,63,58},{50,63,1},{63,60,145},{50,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{56,0,202},{56,0,202},{56,0,202},{56,0,202},{54,63,50}, |
| {54,63,50},{54,63,50},{54,61,2},{49,63,5},{49,63,5},{60,63,426},{59,63,375},{59,63,339},{58,63,251},{59,63,415},{57,63,202},{57,63,138},{56,63,2},{55,63,295},{53,63,29},{62,63,43},{62,63,38},{62,63,34},{61,63,10},{63,61,54},{61,63,27},{60,63,17},{56,63,1},{63,62,54},{56,63,1},{59,63,339},{59,63,339},{59,63,339},{58,63,251},{59,63,294},{57,63,138},{57,63,138}, |
| {56,63,2},{55,63,174},{53,63,29},{62,63,34},{62,63,34},{62,63,34},{61,63,10},{63,60,41},{60,63,17},{60,63,17},{56,63,1},{62,62,41},{56,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{58,0,202},{58,0,202},{58,0,202},{58,0,202},{57,63,74},{57,63,74},{57,63,74},{56,63,2},{53,63,29}, |
| {53,63,29},{0,20,421},{0,14,50},{0,10,4},{0,9,157},{0,14,925},{0,9,589},{0,8,264},{0,6,701},{0,6,1005},{0,5,738},{0,20,421},{0,14,50},{0,10,4},{0,9,157},{7,0,925},{0,9,589},{0,8,264},{0,6,701},{14,0,925},{0,6,701},{0,10,0},{0,10,0},{0,10,0},{0,5,0},{0,5,85},{0,4,34},{0,4,34},{0,2,50},{0,2,93},{0,2,54},{0,10,0}, |
| {0,10,0},{0,10,0},{0,5,0},{2,1,85},{0,4,34},{0,4,34},{0,2,50},{5,0,85},{0,2,50},{10,1,421},{0,14,50},{0,10,4},{0,9,157},{10,1,421},{20,0,421},{0,9,157},{0,7,421},{20,0,421},{0,7,421},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,26,421},{0,18,13},{0,13,20}, |
| {0,11,100},{0,18,1261},{0,11,701},{0,10,294},{0,7,857},{0,8,1382},{0,7,938},{0,26,421},{0,18,13},{0,13,20},{0,11,100},{9,0,1261},{0,11,701},{0,10,294},{0,7,857},{18,0,1261},{0,7,857},{0,16,0},{0,16,0},{0,16,0},{0,8,0},{0,8,221},{0,6,89},{0,6,89},{0,4,125},{0,4,246},{0,4,150},{0,16,0},{0,16,0},{0,16,0},{0,8,0},{4,0,221}, |
| {0,6,89},{0,6,89},{0,4,125},{8,0,221},{0,4,125},{13,1,421},{0,18,13},{2,12,4},{0,11,100},{13,1,421},{26,0,421},{0,11,100},{0,9,421},{26,0,421},{0,9,421},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,32,430},{0,22,10},{1,15,70},{0,13,70},{0,22,1517},{0,14,730},{0,13,257}, |
| {0,9,974},{0,11,1713},{0,8,1109},{1,30,422},{1,21,5},{2,15,45},{0,13,70},{11,1,1514},{0,14,730},{0,13,257},{0,9,974},{15,4,1514},{0,9,974},{0,22,9},{0,22,9},{0,22,9},{0,11,9},{0,12,338},{0,9,106},{0,9,106},{0,5,181},{0,5,392},{0,5,217},{1,20,1},{1,20,1},{1,20,1},{1,10,2},{6,0,338},{0,9,106},{0,9,106},{0,5,181},{12,0,338}, |
| {0,5,181},{16,0,421},{0,22,1},{4,14,4},{0,13,61},{16,0,421},{32,0,421},{0,13,61},{0,11,421},{32,0,421},{0,11,421},{0,0,9},{0,0,9},{0,0,9},{0,0,9},{0,2,1},{0,2,1},{0,2,1},{0,1,1},{0,1,2},{0,1,2},{1,36,486},{1,24,69},{2,17,163},{1,16,115},{0,28,1517},{0,18,614},{0,15,126},{0,11,857},{0,14,1841},{0,11,1053},{3,32,422}, |
| {3,23,5},{3,17,46},{2,15,70},{14,1,1514},{0,18,614},{0,15,126},{0,11,857},{15,7,1514},{0,11,857},{1,26,65},{1,26,65},{1,26,65},{1,13,66},{0,18,338},{0,13,45},{0,13,45},{0,8,125},{0,8,456},{0,7,211},{3,22,1},{3,22,1},{3,22,1},{3,12,2},{9,0,338},{0,13,45},{0,13,45},{0,8,125},{18,0,338},{0,8,125},{19,0,421},{2,24,1},{6,16,1}, |
| {0,16,37},{19,0,421},{38,0,421},{0,16,37},{0,13,421},{38,0,421},{0,13,421},{1,0,65},{1,0,65},{1,0,65},{1,0,65},{0,8,1},{0,8,1},{0,8,1},{0,4,1},{0,3,25},{0,3,25},{3,39,629},{3,27,213},{3,20,365},{2,18,237},{0,35,1514},{0,22,506},{0,18,24},{0,14,750},{0,16,2003},{0,13,1050},{5,35,421},{5,25,2},{6,19,45},{5,17,72},{17,1,1514}, |
| {0,22,506},{0,18,24},{0,14,750},{35,0,1514},{0,14,750},{3,28,209},{3,28,209},{3,28,209},{2,16,208},{0,25,338},{0,17,9},{0,17,9},{0,10,72},{0,11,566},{0,10,241},{5,24,1},{5,24,1},{5,24,1},{5,15,0},{12,1,338},{0,17,9},{0,17,9},{0,10,72},{25,0,338},{0,10,72},{22,1,421},{4,26,1},{8,18,5},{0,18,8},{22,1,421},{45,0,421},{0,18,8}, |
| {0,15,421},{45,0,421},{0,15,421},{2,0,208},{2,0,208},{2,0,208},{2,0,208},{0,15,0},{0,15,0},{0,15,0},{0,8,1},{0,6,80},{0,6,80},{4,43,821},{4,30,418},{5,22,621},{3,20,420},{0,41,1514},{0,25,450},{0,20,5},{0,16,670},{0,19,2187},{0,15,1109},{7,37,421},{7,27,2},{8,21,45},{7,19,72},{20,1,1514},{0,25,450},{0,20,5},{0,16,670},{41,0,1514}, |
| {0,16,670},{4,32,400},{4,32,400},{4,32,400},{4,18,400},{0,31,338},{0,20,1},{0,20,1},{0,13,40},{0,14,694},{0,11,297},{7,26,1},{7,26,1},{7,26,1},{7,17,1},{15,1,338},{0,20,1},{0,20,1},{0,13,40},{31,0,338},{0,13,40},{25,1,421},{6,28,1},{10,20,5},{0,20,4},{25,1,421},{51,0,421},{0,20,4},{0,17,421},{51,0,421},{0,17,421},{3,0,400}, |
| {3,0,400},{3,0,400},{3,0,400},{0,21,0},{0,21,0},{0,21,0},{0,11,1},{0,8,149},{0,8,149},{5,47,846},{6,32,451},{6,23,662},{5,22,445},{2,43,1515},{1,28,446},{2,22,6},{0,18,638},{0,22,2046},{0,18,878},{9,39,421},{9,29,2},{10,23,45},{9,21,72},{23,1,1514},{0,28,426},{2,22,5},{0,18,589},{47,0,1514},{0,18,589},{5,36,425},{5,36,425},{5,36,425}, |
| {5,21,426},{2,32,341},{2,22,2},{2,22,2},{1,15,38},{0,16,606},{0,14,158},{9,28,1},{9,28,1},{9,28,1},{9,19,1},{15,7,338},{2,22,1},{2,22,1},{0,15,20},{31,3,338},{0,15,20},{28,1,421},{8,30,1},{12,22,5},{2,22,4},{28,1,421},{57,0,421},{2,22,4},{0,19,421},{57,0,421},{0,19,421},{5,0,425},{5,0,425},{5,0,425},{5,0,425},{2,23,1}, |
| {2,23,1},{2,23,1},{2,13,2},{0,12,97},{0,12,97},{7,49,846},{8,33,450},{8,25,662},{7,24,445},{4,45,1515},{3,30,446},{4,24,6},{2,20,638},{0,25,1886},{0,19,682},{11,41,421},{11,31,2},{12,25,45},{11,23,72},{26,1,1514},{1,31,421},{4,24,5},{0,20,545},{53,0,1514},{0,20,545},{7,38,425},{7,38,425},{7,38,425},{7,23,426},{4,34,341},{4,24,2},{4,24,2}, |
| {4,16,42},{0,20,500},{0,16,62},{11,30,1},{11,30,1},{11,30,1},{11,21,1},{15,13,338},{4,24,1},{4,24,1},{0,17,5},{31,6,338},{0,17,5},{31,1,421},{10,32,1},{14,24,5},{4,24,4},{31,1,421},{63,0,421},{4,24,4},{0,21,421},{63,0,421},{0,21,421},{7,0,425},{7,0,425},{7,0,425},{7,0,425},{4,25,1},{4,25,1},{4,25,1},{4,15,2},{0,16,37}, |
| {0,16,37},{10,49,846},{10,36,445},{11,28,650},{10,26,450},{6,47,1517},{5,32,446},{6,27,3},{4,22,646},{0,29,1751},{0,22,522},{13,44,422},{13,34,3},{14,27,46},{13,26,74},{30,0,1514},{3,33,422},{6,27,3},{0,22,497},{46,7,1514},{0,22,497},{10,39,425},{10,39,425},{10,39,425},{10,24,426},{6,37,338},{6,27,2},{6,27,2},{6,19,40},{0,24,410},{0,19,9},{13,33,1}, |
| {13,33,1},{13,33,1},{13,23,1},{24,1,338},{7,26,0},{7,26,0},{1,19,5},{49,0,338},{1,19,5},{35,0,421},{12,34,1},{16,27,1},{5,27,1},{35,0,421},{63,3,421},{5,27,1},{0,23,421},{63,3,421},{0,23,421},{10,0,425},{10,0,425},{10,0,425},{10,0,425},{6,28,0},{6,28,0},{6,28,0},{6,17,1},{0,19,5},{0,19,5},{12,51,846},{12,38,445},{13,30,650}, |
| {12,28,450},{8,49,1517},{7,34,446},{8,29,3},{6,24,646},{0,32,1647},{0,25,458},{15,46,422},{15,36,3},{16,29,42},{15,28,74},{32,1,1514},{5,35,422},{8,29,3},{0,25,457},{46,10,1514},{0,25,457},{12,41,425},{12,41,425},{12,41,425},{12,26,426},{8,39,338},{8,29,2},{8,29,2},{8,21,40},{0,27,362},{1,22,5},{15,35,1},{15,35,1},{15,35,1},{15,25,1},{27,1,338}, |
| {9,28,0},{9,28,0},{3,21,5},{55,0,338},{3,21,5},{38,0,421},{14,36,1},{18,29,1},{7,29,1},{38,0,421},{63,6,421},{7,29,1},{0,25,421},{63,6,421},{0,25,421},{12,0,425},{12,0,425},{12,0,425},{12,0,425},{8,30,0},{8,30,0},{8,30,0},{8,19,1},{1,22,1},{1,22,1},{14,53,846},{14,40,445},{15,32,661},{14,30,450},{10,51,1517},{9,36,446},{10,31,3}, |
| {8,26,646},{0,35,1575},{0,27,446},{17,47,421},{17,37,2},{18,31,42},{17,30,73},{35,1,1514},{7,37,422},{10,31,3},{0,27,430},{46,13,1514},{0,27,430},{14,43,425},{14,43,425},{14,43,425},{14,28,426},{10,41,338},{10,31,2},{10,31,2},{10,23,40},{0,31,341},{3,24,5},{17,36,1},{17,36,1},{17,36,1},{17,27,0},{30,1,338},{11,30,0},{11,30,0},{5,23,5},{61,0,338}, |
| {5,23,5},{41,0,421},{16,38,1},{20,31,1},{9,31,1},{41,0,421},{63,9,421},{9,31,1},{0,27,421},{63,9,421},{0,27,421},{14,0,425},{14,0,425},{14,0,425},{14,0,425},{10,31,1},{10,31,1},{10,31,1},{10,21,1},{3,24,1},{3,24,1},{16,55,854},{16,42,451},{16,33,662},{15,32,446},{12,53,1517},{11,38,446},{12,32,9},{10,28,646},{0,39,1533},{2,29,446},{19,49,421}, |
| {19,39,2},{20,33,45},{18,31,81},{38,1,1514},{9,39,422},{13,32,6},{0,29,422},{45,16,1514},{0,29,422},{15,47,433},{15,47,433},{15,47,433},{15,31,433},{12,43,338},{12,32,5},{12,32,5},{12,25,40},{1,33,339},{5,26,5},{19,38,1},{19,38,1},{19,38,1},{19,29,0},{33,1,338},{13,32,2},{13,32,2},{7,25,5},{63,2,338},{7,25,5},{44,0,421},{18,40,1},{22,32,5}, |
| {12,32,5},{44,0,421},{63,12,421},{12,32,5},{0,29,421},{63,12,421},{0,29,421},{15,0,433},{15,0,433},{15,0,433},{15,0,433},{12,33,1},{12,33,1},{12,33,1},{12,23,1},{5,26,1},{5,26,1},{18,58,846},{18,44,445},{19,36,650},{18,34,450},{14,56,1515},{14,40,447},{14,35,7},{13,31,646},{0,42,1515},{5,31,445},{21,52,422},{21,42,2},{22,35,46},{21,34,74},{42,0,1514}, |
| {12,41,422},{14,35,6},{2,31,425},{62,11,1514},{2,31,425},{18,47,425},{18,47,425},{18,47,425},{18,32,426},{14,46,339},{14,35,6},{14,35,6},{14,27,35},{4,35,341},{8,28,5},{21,41,1},{21,41,1},{21,41,1},{21,31,2},{31,12,338},{15,34,0},{15,34,0},{8,28,1},{62,6,338},{8,28,1},{47,0,421},{21,42,1},{24,35,1},{13,35,1},{47,0,421},{62,16,421},{13,35,1}, |
| {0,31,425},{62,16,421},{0,31,425},{18,0,425},{18,0,425},{18,0,425},{18,0,425},{14,36,1},{14,36,1},{14,36,1},{14,25,1},{7,29,1},{7,29,1},{20,60,846},{20,46,445},{21,38,650},{20,36,450},{16,58,1514},{16,41,449},{16,37,3},{15,32,630},{2,44,1515},{7,33,441},{23,54,422},{23,44,2},{24,37,46},{23,36,74},{45,0,1514},{14,43,422},{16,37,3},{4,33,421},{62,14,1514}, |
| {4,33,421},{20,49,425},{20,49,425},{20,49,425},{20,34,426},{16,47,340},{16,37,2},{16,37,2},{16,29,34},{6,37,341},{10,30,5},{23,43,1},{23,43,1},{23,43,1},{23,33,1},{31,18,338},{17,36,0},{17,36,0},{10,30,1},{62,9,338},{10,30,1},{50,0,421},{23,44,1},{26,37,1},{15,37,1},{50,0,421},{62,19,421},{15,37,1},{0,33,421},{62,19,421},{0,33,421},{20,0,425}, |
| {20,0,425},{20,0,425},{20,0,425},{16,38,0},{16,38,0},{16,38,0},{16,27,0},{9,31,1},{9,31,1},{22,62,846},{22,48,445},{23,40,650},{22,38,450},{18,60,1514},{18,43,449},{18,39,3},{16,34,646},{4,46,1515},{9,35,441},{25,56,422},{25,46,2},{26,39,46},{25,38,74},{47,2,1514},{16,45,425},{18,39,3},{6,35,421},{62,17,1514},{6,35,421},{22,51,425},{22,51,425},{22,51,425}, |
| {22,36,426},{18,49,338},{18,39,2},{18,39,2},{18,31,34},{8,39,341},{11,32,6},{25,45,1},{25,45,1},{25,45,1},{25,35,1},{34,17,338},{19,38,0},{19,38,0},{12,32,4},{62,12,338},{12,32,4},{53,0,421},{25,46,1},{28,39,1},{17,39,1},{53,0,421},{62,22,421},{17,39,1},{0,35,421},{62,22,421},{0,35,421},{22,0,425},{22,0,425},{22,0,425},{22,0,425},{18,40,0}, |
| {18,40,0},{18,40,0},{18,29,0},{11,32,2},{11,32,2},{24,63,850},{24,50,445},{25,42,650},{24,40,450},{20,62,1514},{20,45,449},{20,41,3},{18,36,646},{6,48,1517},{11,37,441},{27,58,422},{27,48,3},{28,41,46},{27,40,74},{47,8,1514},{18,47,425},{20,41,3},{8,37,421},{62,20,1514},{8,37,421},{24,53,425},{24,53,425},{24,53,425},{24,38,426},{20,51,338},{20,41,2},{20,41,2}, |
| {20,33,40},{10,41,341},{13,34,6},{27,47,1},{27,47,1},{27,47,1},{27,37,1},{37,17,338},{21,40,0},{21,40,0},{14,34,4},{62,15,338},{14,34,4},{56,0,421},{26,48,1},{30,41,1},{19,41,1},{56,0,421},{62,25,421},{19,41,1},{0,37,421},{62,25,421},{0,37,421},{24,0,425},{24,0,425},{24,0,425},{24,0,425},{20,42,0},{20,42,0},{20,42,0},{20,31,0},{13,34,2}, |
| {13,34,2},{26,63,882},{26,52,447},{27,44,646},{26,42,446},{23,62,1526},{22,48,447},{22,43,5},{21,39,646},{8,50,1515},{13,39,443},{30,58,425},{29,50,4},{30,44,45},{29,42,69},{54,0,1514},{20,49,422},{22,43,4},{10,39,426},{47,31,1514},{10,39,426},{26,56,421},{26,56,421},{26,56,421},{26,41,421},{22,54,339},{22,43,5},{22,43,5},{22,35,35},{12,43,338},{16,36,5},{30,48,4}, |
| {30,48,4},{30,48,4},{30,39,4},{49,0,338},{23,42,2},{23,42,2},{16,36,1},{62,18,338},{16,36,1},{59,0,421},{29,50,0},{32,43,1},{22,43,0},{59,0,421},{62,28,421},{22,43,0},{0,39,425},{62,28,421},{0,39,425},{26,0,421},{26,0,421},{26,0,421},{26,0,421},{22,44,2},{22,44,2},{22,44,2},{22,33,1},{15,37,1},{15,37,1},{29,63,922},{28,54,447},{29,46,646}, |
| {28,44,446},{25,63,1535},{24,50,447},{24,45,5},{23,41,646},{10,52,1515},{15,41,443},{31,62,425},{31,52,4},{32,45,45},{31,44,69},{57,0,1514},{22,51,422},{24,45,4},{12,41,426},{50,32,1514},{12,41,426},{28,58,421},{28,58,421},{28,58,421},{28,43,421},{24,56,339},{24,45,5},{24,45,5},{24,37,35},{14,45,338},{18,38,5},{31,52,4},{31,52,4},{31,52,4},{31,41,5},{52,0,338}, |
| {25,44,2},{25,44,2},{18,38,1},{62,21,338},{18,38,1},{62,0,421},{31,52,0},{34,45,1},{24,45,0},{62,0,421},{62,31,421},{24,45,0},{0,41,425},{62,31,421},{0,41,425},{28,0,421},{28,0,421},{28,0,421},{28,0,421},{24,46,2},{24,46,2},{24,46,2},{24,35,1},{17,39,1},{17,39,1},{31,63,994},{30,56,447},{31,48,655},{30,46,446},{28,63,1575},{26,52,447},{26,47,5}, |
| {25,43,646},{12,54,1515},{17,43,445},{33,63,426},{33,54,2},{34,47,45},{33,46,66},{60,0,1514},{24,53,422},{26,47,4},{14,43,426},{56,32,1514},{14,43,426},{30,60,421},{30,60,421},{30,60,421},{30,45,421},{26,58,339},{26,47,5},{26,47,5},{26,39,35},{16,47,338},{20,40,5},{33,53,1},{33,53,1},{33,53,1},{33,43,2},{55,0,338},{27,46,2},{27,46,2},{20,40,1},{62,24,338}, |
| {20,40,1},{63,4,421},{33,54,1},{36,47,1},{26,47,0},{63,4,421},{62,34,421},{26,47,0},{0,43,425},{62,34,421},{0,43,425},{30,0,421},{30,0,421},{30,0,421},{30,0,421},{26,48,1},{26,48,1},{26,48,1},{26,37,1},{19,41,1},{19,41,1},{33,63,1082},{32,58,445},{33,50,650},{32,48,450},{30,63,1638},{28,54,447},{28,49,7},{27,45,646},{14,56,1515},{19,45,445},{36,63,434}, |
| {35,56,2},{36,49,46},{35,48,74},{63,0,1514},{26,55,422},{28,49,6},{16,45,425},{62,32,1514},{16,45,425},{32,61,425},{32,61,425},{32,61,425},{32,47,426},{28,60,339},{28,49,6},{28,49,6},{28,41,35},{18,49,341},{22,42,5},{35,55,1},{35,55,1},{35,55,1},{35,45,2},{58,0,338},{29,48,0},{29,48,0},{22,42,1},{62,27,338},{22,42,1},{63,10,421},{35,56,1},{38,49,1}, |
| {27,49,1},{63,10,421},{62,37,421},{27,49,1},{0,45,425},{62,37,421},{0,45,425},{32,0,425},{32,0,425},{32,0,425},{32,0,425},{28,50,1},{28,50,1},{28,50,1},{28,39,1},{21,43,1},{21,43,1},{36,63,1206},{34,61,446},{35,52,646},{34,50,446},{33,63,1710},{30,56,445},{31,51,5},{29,47,638},{17,58,1515},{22,47,450},{39,63,469},{37,58,5},{38,52,45},{37,50,69},{63,7,1514}, |
| {27,58,422},{31,51,1},{19,47,433},{63,35,1514},{19,47,433},{34,63,422},{34,63,422},{34,63,422},{34,49,421},{31,61,342},{31,51,5},{31,51,5},{30,43,36},{20,51,338},{24,44,2},{38,56,4},{38,56,4},{38,56,4},{38,47,4},{53,16,338},{31,51,1},{31,51,1},{25,44,0},{63,30,338},{25,44,0},{63,17,421},{37,58,1},{40,51,1},{30,51,0},{63,17,421},{63,40,421},{30,51,0}, |
| {0,47,433},{63,40,421},{0,47,433},{34,0,421},{34,0,421},{34,0,421},{34,0,421},{31,51,4},{31,51,4},{31,51,4},{31,41,4},{23,45,1},{23,45,1},{38,63,1350},{36,63,446},{37,54,646},{36,52,446},{36,63,1814},{32,58,447},{32,53,5},{31,48,638},{19,60,1515},{23,49,443},{41,63,517},{39,60,5},{40,54,45},{39,52,69},{63,13,1514},{29,60,422},{32,53,4},{20,49,426},{63,38,1514}, |
| {20,49,426},{36,63,437},{36,63,437},{36,63,437},{36,51,421},{33,62,347},{32,53,5},{32,53,5},{32,45,33},{22,53,338},{26,46,2},{40,58,4},{40,58,4},{40,58,4},{40,49,4},{56,16,338},{33,52,2},{33,52,2},{27,46,0},{62,33,338},{27,46,0},{63,23,421},{39,60,1},{42,53,1},{32,53,0},{63,23,421},{63,43,421},{32,53,0},{0,49,425},{63,43,421},{0,49,425},{36,0,421}, |
| {36,0,421},{36,0,421},{36,0,421},{32,54,2},{32,54,2},{32,54,2},{32,43,2},{25,47,1},{25,47,1},{40,63,1466},{38,63,474},{39,56,646},{38,54,446},{38,63,1931},{34,60,447},{34,55,5},{33,51,646},{21,62,1515},{25,51,443},{43,63,569},{41,62,5},{42,56,45},{41,54,69},{63,19,1514},{32,61,422},{34,55,4},{22,51,426},{63,41,1514},{22,51,426},{38,63,470},{38,63,470},{38,63,470}, |
| {38,53,421},{35,63,355},{34,55,5},{34,55,5},{34,47,33},{24,55,338},{28,48,3},{42,60,4},{42,60,4},{42,60,4},{42,51,4},{59,16,338},{35,54,2},{35,54,2},{28,48,2},{62,36,338},{28,48,2},{63,29,421},{41,62,1},{44,55,1},{34,55,0},{63,29,421},{63,46,421},{34,55,0},{0,51,425},{63,46,421},{0,51,425},{38,0,421},{38,0,421},{38,0,421},{38,0,421},{34,56,2}, |
| {34,56,2},{34,56,2},{34,45,2},{27,49,1},{27,49,1},{43,63,1634},{41,63,546},{41,58,646},{40,56,446},{40,63,2039},{36,62,447},{36,57,5},{35,53,646},{24,63,1521},{27,53,443},{46,63,633},{44,63,9},{44,58,45},{43,56,69},{63,25,1514},{34,63,422},{36,57,4},{24,53,426},{63,44,1514},{24,53,426},{40,63,502},{40,63,502},{40,63,502},{40,55,421},{37,63,379},{36,57,5},{36,57,5}, |
| {36,49,35},{26,57,338},{30,50,3},{44,62,4},{44,62,4},{44,62,4},{44,53,4},{62,16,338},{37,56,2},{37,56,2},{30,50,2},{62,39,338},{30,50,2},{63,34,421},{44,63,5},{46,57,1},{36,57,0},{63,34,421},{62,49,421},{36,57,0},{0,53,425},{62,49,421},{0,53,425},{40,0,421},{40,0,421},{40,0,421},{40,0,421},{36,58,2},{36,58,2},{36,58,2},{36,47,2},{29,51,1}, |
| {29,51,1},{45,63,1866},{43,63,689},{43,60,650},{42,59,447},{43,63,2201},{38,63,469},{39,59,6},{37,55,638},{29,63,1590},{30,55,450},{48,63,741},{46,63,69},{46,60,46},{45,58,70},{62,33,1514},{38,63,465},{39,59,2},{25,56,425},{61,48,1514},{25,56,425},{43,63,545},{43,63,545},{43,63,545},{42,57,422},{40,63,424},{39,59,5},{39,59,5},{38,51,36},{29,59,339},{32,52,2},{46,63,5}, |
| {46,63,5},{46,63,5},{46,55,2},{63,21,338},{39,59,1},{39,59,1},{33,52,0},{63,42,338},{33,52,0},{63,41,421},{48,63,41},{49,59,2},{38,59,2},{63,41,421},{63,52,421},{38,59,2},{0,56,425},{63,52,421},{0,56,425},{42,0,421},{42,0,421},{42,0,421},{42,0,421},{39,59,4},{39,59,4},{39,59,4},{39,49,4},{31,53,1},{31,53,1},{48,63,2070},{46,63,889},{45,62,650}, |
| {44,61,447},{46,63,2361},{41,63,573},{41,61,6},{39,57,638},{32,63,1710},{32,57,450},{51,63,837},{49,63,184},{48,62,49},{47,60,70},{63,37,1514},{43,63,545},{41,61,2},{27,58,425},{63,50,1514},{27,58,425},{45,63,614},{45,63,614},{45,63,614},{44,59,422},{43,63,488},{41,61,5},{41,61,5},{40,53,36},{31,61,339},{34,54,2},{48,63,20},{48,63,20},{48,63,20},{48,57,4},{63,27,338}, |
| {41,61,1},{41,61,1},{35,54,0},{63,45,338},{35,54,0},{63,47,421},{51,63,97},{51,61,2},{40,61,2},{63,47,421},{63,55,421},{40,61,2},{0,58,425},{63,55,421},{0,58,425},{44,0,421},{44,0,421},{44,0,421},{44,0,421},{41,61,4},{41,61,4},{41,61,4},{41,51,4},{33,55,1},{33,55,1},{50,63,2239},{48,63,1109},{47,63,701},{46,62,441},{48,63,2469},{44,63,720},{43,63,5}, |
| {41,59,605},{37,63,1804},{34,59,417},{54,63,916},{51,63,308},{51,63,52},{49,62,56},{63,43,1459},{46,63,618},{43,63,1},{31,59,400},{63,53,1459},{31,59,400},{47,63,701},{47,63,701},{47,63,701},{46,61,422},{45,63,566},{43,63,5},{43,63,5},{42,55,36},{32,63,341},{36,56,2},{51,63,52},{51,63,52},{51,63,52},{50,59,4},{63,33,338},{43,63,1},{43,63,1},{37,56,0},{47,56,338}, |
| {37,56,0},{63,53,392},{55,63,157},{53,63,1},{42,63,1},{63,53,392},{63,58,392},{42,63,1},{0,59,400},{63,58,392},{0,59,400},{46,0,421},{46,0,421},{46,0,421},{46,0,421},{43,63,4},{43,63,4},{43,63,4},{43,53,4},{35,57,1},{35,57,1},{51,63,1901},{50,63,1114},{49,63,785},{48,63,421},{51,63,2093},{46,63,574},{45,63,38},{44,60,356},{40,63,1476},{36,60,213},{55,63,684}, |
| {54,63,260},{53,63,85},{51,63,20},{63,47,1064},{49,63,426},{47,63,8},{35,60,208},{63,55,1064},{35,60,208},{49,63,785},{49,63,785},{49,63,785},{48,63,421},{48,63,661},{45,63,38},{45,63,38},{44,57,36},{37,63,371},{38,58,2},{53,63,85},{53,63,85},{53,63,85},{52,61,4},{63,39,338},{47,63,8},{47,63,8},{39,58,0},{47,59,338},{39,58,0},{63,56,200},{57,63,80},{56,63,1}, |
| {48,63,0},{63,56,200},{62,60,200},{48,63,0},{0,60,208},{62,60,200},{0,60,208},{48,0,421},{48,0,421},{48,0,421},{48,0,421},{45,63,13},{45,63,13},{45,63,13},{45,55,4},{37,59,1},{37,59,1},{54,63,1646},{52,63,1119},{51,63,886},{50,63,470},{53,63,1761},{48,63,526},{48,63,126},{46,61,146},{44,63,1218},{39,62,69},{57,63,450},{56,63,245},{56,63,145},{54,63,2},{63,51,722}, |
| {52,63,290},{51,63,50},{38,62,65},{63,57,722},{38,62,65},{51,63,886},{51,63,886},{51,63,886},{50,63,470},{50,63,776},{48,63,126},{48,63,126},{47,59,42},{41,63,446},{40,60,5},{56,63,145},{56,63,145},{56,63,145},{54,63,2},{61,49,338},{51,63,50},{51,63,50},{42,60,1},{63,54,338},{42,60,1},{63,59,61},{60,63,25},{59,63,0},{55,63,0},{63,59,61},{63,61,61},{55,63,0}, |
| {0,62,65},{63,61,61},{0,62,65},{50,0,421},{50,0,421},{50,0,421},{50,0,421},{48,63,45},{48,63,45},{48,63,45},{47,57,2},{40,61,1},{40,61,1},{56,63,1518},{54,63,1118},{54,63,974},{52,63,565},{54,63,1526},{51,63,534},{51,63,278},{48,62,57},{47,63,1090},{42,63,10},{59,63,354},{58,63,251},{57,63,194},{56,63,50},{63,55,509},{55,63,234},{54,63,106},{42,63,9},{63,59,509}, |
| {42,63,9},{54,63,974},{54,63,974},{54,63,974},{52,63,565},{53,63,904},{51,63,278},{51,63,278},{48,61,38},{44,63,574},{42,62,5},{57,63,194},{57,63,194},{57,63,194},{56,63,50},{63,51,338},{54,63,106},{54,63,106},{44,62,1},{63,57,338},{44,62,1},{63,62,5},{62,63,4},{62,63,0},{61,63,0},{63,62,5},{62,63,5},{61,63,0},{0,63,9},{62,63,5},{0,63,9},{52,0,421}, |
| {52,0,421},{52,0,421},{52,0,421},{50,63,72},{50,63,72},{50,63,72},{49,59,5},{42,63,1},{42,63,1},{57,63,1197},{56,63,994},{56,63,894},{54,63,565},{56,63,1210},{54,63,493},{53,63,332},{50,63,13},{51,63,861},{45,63,17},{60,63,209},{60,63,161},{60,63,145},{58,63,50},{63,58,294},{58,63,147},{57,63,89},{47,63,1},{62,61,294},{47,63,1},{56,63,894},{56,63,894},{56,63,894}, |
| {54,63,565},{54,63,781},{53,63,332},{53,63,332},{50,63,13},{48,63,501},{45,63,17},{60,63,145},{60,63,145},{60,63,145},{58,63,50},{63,55,221},{57,63,89},{57,63,89},{47,63,1},{63,59,221},{47,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{54,0,421},{54,0,421},{54,0,421},{54,0,421},{52,63,117}, |
| {52,63,117},{52,63,117},{51,61,5},{45,63,17},{45,63,17},{58,63,925},{57,63,765},{57,63,701},{57,63,509},{57,63,845},{55,63,423},{54,63,301},{53,63,5},{52,63,598},{49,63,52},{61,63,97},{61,63,70},{61,63,61},{60,63,17},{63,60,113},{60,63,57},{59,63,40},{53,63,1},{62,62,113},{53,63,1},{57,63,701},{57,63,701},{57,63,701},{57,63,509},{57,63,589},{54,63,301},{54,63,301}, |
| {53,63,5},{51,63,365},{49,63,52},{61,63,61},{61,63,61},{61,63,61},{60,63,17},{63,58,85},{59,63,40},{59,63,40},{53,63,1},{62,61,85},{53,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{56,0,421},{56,0,421},{56,0,421},{56,0,421},{54,63,157},{54,63,157},{54,63,157},{53,63,5},{49,63,52}, |
| {49,63,52},{0,29,882},{0,21,116},{0,15,4},{0,13,320},{0,19,1899},{0,14,1214},{0,11,573},{0,8,1421},{0,9,2052},{0,8,1521},{0,29,882},{0,21,116},{0,15,4},{0,13,320},{10,0,1896},{0,14,1214},{0,11,573},{0,8,1421},{14,3,1896},{0,8,1421},{0,14,0},{0,14,0},{0,14,0},{0,7,0},{0,7,162},{0,5,61},{0,5,61},{0,3,100},{0,3,180},{0,3,116},{0,14,0}, |
| {0,14,0},{0,14,0},{0,7,0},{3,1,162},{0,5,61},{0,5,61},{0,3,100},{7,0,162},{0,3,100},{6,17,882},{0,21,116},{0,15,4},{0,13,320},{6,17,882},{29,0,882},{0,13,320},{0,10,884},{29,0,882},{0,10,884},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,35,882},{0,25,50},{0,17,10}, |
| {0,15,260},{0,23,2355},{0,16,1355},{0,14,589},{0,10,1656},{0,11,2567},{0,10,1825},{0,35,882},{0,25,50},{0,17,10},{0,15,260},{3,17,2355},{0,16,1355},{0,14,589},{0,10,1656},{23,0,2355},{0,10,1656},{0,19,1},{0,19,1},{0,19,1},{0,10,0},{0,10,338},{0,8,125},{0,8,125},{0,4,200},{0,5,374},{0,4,225},{0,19,1},{0,19,1},{0,19,1},{0,10,0},{5,0,338}, |
| {0,8,125},{0,8,125},{0,4,200},{10,0,338},{0,4,200},{17,1,882},{0,25,50},{1,17,2},{0,15,260},{17,1,882},{35,0,882},{0,15,260},{0,12,884},{35,0,882},{0,12,884},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,41,882},{0,28,10},{1,19,69},{0,17,193},{0,28,2899},{0,19,1539},{0,16,643}, |
| {0,11,1965},{0,13,3209},{0,11,2161},{0,41,882},{0,28,10},{1,19,53},{0,17,193},{14,0,2899},{0,19,1539},{0,16,643},{0,11,1965},{28,0,2899},{0,11,1965},{0,25,1},{0,25,1},{0,25,1},{0,13,0},{0,13,578},{0,11,221},{0,11,221},{0,6,356},{0,6,644},{0,5,401},{0,25,1},{0,25,1},{0,25,1},{0,13,0},{6,1,578},{0,11,221},{0,11,221},{0,6,356},{13,0,578}, |
| {0,6,356},{20,1,882},{0,28,10},{3,19,2},{0,17,193},{20,1,882},{41,0,882},{0,17,193},{0,14,884},{41,0,882},{0,14,884},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{1,45,902},{1,31,24},{1,21,142},{0,19,166},{0,33,3048},{0,22,1443},{0,18,481},{0,13,1908},{0,16,3492},{0,13,2197},{2,43,886}, |
| {1,31,8},{3,21,73},{1,19,153},{16,1,3048},{0,22,1443},{0,18,481},{0,13,1908},{33,0,3048},{0,13,1908},{1,29,21},{1,29,21},{1,29,21},{1,15,21},{0,18,648},{0,14,169},{0,14,169},{0,8,325},{0,8,766},{0,7,421},{2,27,5},{2,27,5},{2,27,5},{2,15,4},{9,0,648},{0,14,169},{0,14,169},{0,8,325},{18,0,648},{0,8,325},{23,1,882},{0,31,2},{5,21,2}, |
| {0,19,130},{23,1,882},{47,0,882},{0,19,130},{0,16,890},{47,0,882},{0,16,890},{1,0,20},{1,0,20},{1,0,20},{1,0,20},{0,5,0},{0,5,0},{0,5,0},{0,2,1},{0,2,5},{0,2,5},{2,49,997},{2,34,114},{3,24,290},{1,22,234},{0,39,3051},{0,25,1256},{0,21,258},{0,16,1764},{0,19,3685},{0,15,2195},{4,46,883},{3,33,10},{5,23,74},{3,21,154},{15,10,3048}, |
| {0,25,1256},{0,21,258},{0,16,1764},{30,5,3048},{0,16,1764},{2,34,113},{2,34,113},{2,34,113},{2,18,113},{0,25,648},{0,17,89},{0,17,89},{0,10,242},{0,11,876},{0,10,411},{4,30,1},{4,30,1},{4,30,1},{4,17,1},{12,1,648},{0,17,89},{0,17,89},{0,10,242},{25,0,648},{0,10,242},{27,0,882},{3,33,1},{8,23,1},{0,22,80},{27,0,882},{46,4,882},{0,22,80}, |
| {0,18,884},{46,4,882},{0,18,884},{2,0,113},{2,0,113},{2,0,113},{2,0,113},{0,11,1},{0,11,1},{0,11,1},{0,6,1},{0,5,40},{0,5,40},{3,53,1149},{3,36,274},{4,27,513},{3,24,362},{0,45,3051},{0,28,1128},{0,24,122},{0,18,1605},{0,22,3901},{0,16,2173},{6,47,885},{5,35,10},{7,25,74},{5,23,154},{15,16,3048},{0,28,1128},{0,24,122},{0,18,1605},{30,8,3048}, |
| {0,18,1605},{3,38,265},{3,38,265},{3,38,265},{3,20,266},{0,31,648},{0,21,34},{0,21,34},{0,13,170},{0,14,1004},{0,11,457},{6,32,1},{6,32,1},{6,32,1},{6,19,1},{15,1,648},{0,21,34},{0,21,34},{0,13,170},{31,0,648},{0,13,170},{30,0,882},{5,35,1},{10,25,1},{0,24,41},{30,0,882},{46,7,882},{0,24,41},{0,20,884},{46,7,882},{0,20,884},{3,0,265}, |
| {3,0,265},{3,0,265},{3,0,265},{0,17,0},{0,17,0},{0,17,0},{0,9,1},{0,8,104},{0,8,104},{4,57,1365},{4,39,498},{5,28,793},{4,26,561},{0,51,3048},{0,31,1032},{0,26,41},{0,20,1509},{0,24,4147},{0,19,2149},{8,49,885},{7,37,10},{9,27,74},{7,25,154},{17,17,3048},{0,31,1032},{0,26,41},{0,20,1509},{51,0,3048},{0,20,1509},{4,42,481},{4,42,481},{4,42,481}, |
| {4,23,481},{0,36,650},{0,25,4},{0,25,4},{0,15,130},{0,16,1161},{0,14,481},{8,34,1},{8,34,1},{8,34,1},{8,21,1},{15,7,648},{0,25,4},{0,25,4},{0,15,130},{31,3,648},{0,15,130},{32,1,882},{7,37,1},{12,27,1},{0,26,25},{32,1,882},{46,10,882},{0,26,25},{0,22,884},{46,10,882},{0,22,884},{4,0,481},{4,0,481},{4,0,481},{4,0,481},{0,23,0}, |
| {0,23,0},{0,23,0},{0,12,1},{0,9,193},{0,9,193},{5,61,1645},{5,42,795},{7,30,1177},{4,28,826},{0,57,3048},{0,35,954},{0,29,9},{0,22,1380},{0,27,4419},{0,21,2197},{10,51,885},{9,39,10},{11,29,74},{9,27,154},{20,17,3048},{0,35,954},{0,29,9},{0,22,1380},{57,0,3048},{0,22,1380},{5,46,761},{5,46,761},{5,46,761},{5,25,762},{0,42,650},{0,28,4},{0,28,4}, |
| {0,17,85},{0,19,1345},{0,16,557},{10,36,1},{10,36,1},{10,36,1},{10,23,1},{15,13,648},{1,27,1},{1,27,1},{0,17,85},{31,6,648},{0,17,85},{35,1,882},{9,39,1},{14,29,1},{0,29,9},{35,1,882},{46,13,882},{0,29,9},{0,24,884},{46,13,882},{0,24,884},{5,0,761},{5,0,761},{5,0,761},{5,0,761},{0,29,0},{0,29,0},{0,29,0},{0,15,1},{0,11,296}, |
| {0,11,296},{7,63,1774},{7,44,924},{8,33,1320},{6,30,941},{2,60,3052},{1,38,924},{2,31,10},{0,24,1302},{0,31,4300},{0,24,1942},{12,54,882},{12,40,8},{13,32,68},{11,29,161},{32,0,3048},{0,39,898},{2,31,6},{0,24,1266},{62,1,3048},{0,24,1266},{7,48,885},{7,48,885},{7,48,885},{7,28,884},{2,45,652},{2,31,9},{2,31,9},{1,20,62},{0,22,1275},{0,19,419},{12,39,0}, |
| {12,39,0},{12,39,0},{12,25,1},{24,1,648},{3,30,0},{3,30,0},{0,20,45},{49,0,648},{0,20,45},{39,0,882},{11,41,1},{16,31,2},{1,31,1},{39,0,882},{62,8,882},{1,31,1},{0,26,882},{62,8,882},{0,26,882},{7,0,884},{7,0,884},{7,0,884},{7,0,884},{2,32,4},{2,32,4},{2,32,4},{2,17,4},{0,16,250},{0,16,250},{9,63,1798},{9,46,924},{10,35,1320}, |
| {9,32,936},{4,62,3052},{3,40,924},{4,33,9},{2,26,1302},{0,33,4023},{0,26,1647},{14,56,882},{14,42,8},{15,34,68},{13,31,161},{35,0,3048},{0,42,882},{4,33,5},{0,27,1170},{62,4,3048},{0,27,1170},{9,50,885},{9,50,885},{9,50,885},{9,30,884},{4,47,652},{4,32,8},{4,32,8},{3,22,62},{0,25,1107},{0,22,243},{14,41,0},{14,41,0},{14,41,0},{14,27,1},{27,1,648}, |
| {5,32,1},{5,32,1},{0,22,18},{55,0,648},{0,22,18},{42,0,882},{13,43,1},{18,33,1},{2,33,0},{42,0,882},{62,11,882},{2,33,0},{0,28,882},{62,11,882},{0,28,882},{9,0,884},{9,0,884},{9,0,884},{9,0,884},{4,34,4},{4,34,4},{4,34,4},{4,19,4},{0,19,146},{0,19,146},{12,63,1846},{11,48,924},{12,37,1320},{11,34,936},{6,63,3055},{5,42,924},{6,35,9}, |
| {4,28,1302},{0,36,3799},{0,28,1356},{16,58,883},{16,44,9},{17,35,74},{15,33,161},{38,0,3048},{2,44,882},{6,35,5},{0,29,1110},{62,7,3048},{0,29,1110},{11,52,885},{11,52,885},{11,52,885},{11,32,885},{6,49,652},{6,34,8},{6,34,8},{5,24,62},{0,29,969},{0,24,109},{16,42,1},{16,42,1},{16,42,1},{16,29,2},{30,1,648},{7,34,1},{7,34,1},{0,24,9},{61,0,648}, |
| {0,24,9},{45,0,882},{15,45,1},{20,35,1},{4,35,0},{45,0,882},{62,14,882},{4,35,0},{0,30,882},{62,14,882},{0,30,882},{11,0,884},{11,0,884},{11,0,884},{11,0,884},{6,36,4},{6,36,4},{6,36,4},{6,21,4},{0,22,74},{0,22,74},{14,63,1912},{13,50,924},{14,39,1320},{13,36,936},{9,63,3087},{7,44,924},{8,37,9},{6,30,1302},{0,39,3607},{0,31,1156},{18,60,883}, |
| {18,46,9},{19,37,74},{17,35,154},{41,0,3048},{4,46,882},{8,37,5},{0,31,1035},{62,10,3048},{0,31,1035},{13,54,885},{13,54,885},{13,54,885},{13,34,885},{8,51,652},{8,36,8},{8,36,8},{7,26,62},{0,33,846},{0,27,37},{18,44,1},{18,44,1},{18,44,1},{18,31,2},{33,1,648},{9,36,1},{9,36,1},{0,27,1},{63,2,648},{0,27,1},{47,2,882},{16,48,1},{22,37,1}, |
| {6,37,0},{47,2,882},{62,17,882},{6,37,0},{0,32,884},{62,17,882},{0,32,884},{13,0,884},{13,0,884},{13,0,884},{13,0,884},{8,38,4},{8,38,4},{8,38,4},{8,23,4},{0,26,29},{0,26,29},{16,63,2014},{15,52,932},{16,40,1341},{15,38,932},{12,63,3141},{9,46,924},{10,39,7},{9,32,1308},{0,43,3436},{0,33,1003},{20,62,884},{20,48,8},{21,40,74},{19,37,161},{36,16,3048}, |
| {6,48,882},{10,39,6},{0,33,978},{63,13,3048},{0,33,978},{15,57,882},{15,57,882},{15,57,882},{15,36,882},{10,54,649},{10,39,6},{10,39,6},{9,28,61},{0,36,737},{1,29,8},{20,47,0},{20,47,0},{20,47,0},{20,33,1},{31,12,648},{11,38,1},{11,38,1},{2,29,1},{62,6,648},{2,29,1},{51,0,882},{19,49,1},{24,39,1},{9,39,1},{51,0,882},{47,28,882},{9,39,1}, |
| {0,34,882},{47,28,882},{0,34,882},{15,0,882},{15,0,882},{15,0,882},{15,0,882},{10,40,2},{10,40,2},{10,40,2},{10,25,2},{0,30,2},{0,30,2},{19,63,2126},{17,54,924},{18,42,1341},{16,40,941},{14,63,3204},{11,48,924},{12,41,7},{11,34,1308},{0,46,3300},{0,35,939},{22,63,890},{22,50,8},{23,42,74},{21,39,161},{39,16,3048},{8,50,882},{12,41,6},{0,35,939},{62,16,3048}, |
| {0,35,939},{17,59,884},{17,59,884},{17,59,884},{17,38,884},{12,56,649},{12,41,6},{12,41,6},{11,30,61},{0,39,681},{3,31,8},{22,49,0},{22,49,0},{22,49,0},{22,35,1},{31,18,648},{13,40,1},{13,40,1},{4,31,1},{62,9,648},{4,31,1},{54,0,882},{21,51,1},{26,41,1},{11,41,1},{54,0,882},{47,31,882},{11,41,1},{0,36,882},{47,31,882},{0,36,882},{17,0,884}, |
| {17,0,884},{17,0,884},{17,0,884},{12,42,2},{12,42,2},{12,42,2},{12,27,2},{2,32,1},{2,32,1},{20,63,2264},{19,56,924},{20,44,1341},{18,42,941},{17,63,3292},{13,50,924},{14,43,7},{13,36,1308},{0,50,3192},{0,38,923},{25,63,906},{24,52,8},{25,44,74},{23,41,161},{50,0,3048},{10,52,882},{14,43,6},{0,38,907},{62,19,3048},{0,38,907},{19,61,884},{19,61,884},{19,61,884}, |
| {19,40,884},{14,58,649},{14,43,6},{14,43,6},{13,32,67},{0,42,657},{4,33,10},{24,51,0},{24,51,0},{24,51,0},{24,37,1},{34,17,648},{15,42,1},{15,42,1},{6,33,1},{62,12,648},{6,33,1},{57,0,882},{23,53,1},{28,43,1},{13,43,1},{57,0,882},{50,32,882},{13,43,1},{0,38,882},{50,32,882},{0,38,882},{19,0,884},{19,0,884},{19,0,884},{19,0,884},{14,44,2}, |
| {14,44,2},{14,44,2},{14,29,2},{4,34,1},{4,34,1},{23,63,2376},{21,58,924},{22,46,1341},{20,44,941},{19,63,3391},{15,52,924},{16,45,10},{15,38,1308},{0,53,3112},{2,40,923},{27,63,948},{26,54,8},{27,46,74},{25,43,161},{53,0,3048},{12,54,882},{16,45,6},{0,40,891},{62,22,3048},{0,40,891},{21,63,884},{21,63,884},{21,63,884},{21,42,884},{16,59,652},{16,45,9},{16,45,9}, |
| {15,34,67},{1,45,650},{6,35,10},{26,53,0},{26,53,0},{26,53,0},{26,39,1},{37,17,648},{17,44,0},{17,44,0},{8,35,1},{62,15,648},{8,35,1},{60,0,882},{25,55,1},{30,45,1},{15,45,1},{60,0,882},{56,32,882},{15,45,1},{0,40,882},{56,32,882},{0,40,882},{21,0,884},{21,0,884},{21,0,884},{21,0,884},{16,46,4},{16,46,4},{16,46,4},{16,31,4},{6,36,1}, |
| {6,36,1},{26,63,2564},{23,61,927},{24,49,1324},{23,47,935},{22,63,3529},{17,54,924},{18,47,10},{17,41,1302},{0,56,3060},{5,42,924},{30,63,1003},{28,57,6},{29,48,67},{28,46,158},{56,1,3048},{15,56,883},{19,47,8},{1,42,884},{63,25,3048},{1,42,884},{23,63,891},{23,63,891},{23,63,891},{23,44,883},{18,62,649},{18,47,6},{18,47,6},{17,36,61},{4,47,652},{9,37,8},{28,55,2}, |
| {28,55,2},{28,55,2},{28,42,2},{49,0,648},{19,46,2},{19,46,2},{11,37,0},{62,18,648},{11,37,0},{63,1,882},{27,58,2},{32,47,4},{17,47,5},{63,1,882},{63,32,882},{17,47,5},{0,42,884},{63,32,882},{0,42,884},{23,0,882},{23,0,882},{23,0,882},{23,0,882},{18,48,2},{18,48,2},{18,48,2},{18,33,2},{8,38,1},{8,38,1},{28,63,2774},{25,63,927},{26,51,1324}, |
| {25,48,932},{25,63,3681},{19,56,924},{20,49,7},{19,43,1302},{0,59,3052},{7,44,924},{32,63,1074},{30,59,6},{31,50,67},{30,48,170},{59,1,3048},{16,58,885},{20,49,6},{3,44,884},{63,28,3048},{3,44,884},{25,63,918},{25,63,918},{25,63,918},{25,46,883},{20,63,651},{20,49,6},{20,49,6},{19,38,61},{5,49,651},{11,39,8},{30,57,2},{30,57,2},{30,57,2},{30,44,2},{52,0,648}, |
| {21,48,1},{21,48,1},{13,39,0},{62,21,648},{13,39,0},{63,7,882},{29,60,2},{34,49,1},{19,49,1},{63,7,882},{63,35,882},{19,49,1},{0,44,884},{63,35,882},{0,44,884},{25,0,882},{25,0,882},{25,0,882},{25,0,882},{20,50,2},{20,50,2},{20,50,2},{20,35,2},{10,40,1},{10,40,1},{31,63,2998},{28,63,951},{28,53,1324},{27,50,932},{26,63,3844},{21,58,924},{22,51,7}, |
| {21,45,1302},{2,61,3052},{9,46,924},{34,63,1146},{32,61,9},{33,52,74},{32,50,169},{62,1,3048},{18,60,885},{22,51,6},{5,46,884},{63,31,3048},{5,46,884},{28,63,950},{28,63,950},{28,63,950},{27,48,882},{23,63,675},{22,51,6},{22,51,6},{21,40,61},{7,51,651},{13,41,8},{32,59,0},{32,59,0},{32,59,0},{32,46,1},{55,0,648},{23,50,1},{23,50,1},{15,41,0},{62,24,648}, |
| {15,41,0},{63,13,882},{31,62,2},{36,51,1},{21,51,1},{63,13,882},{63,38,882},{21,51,1},{0,46,884},{63,38,882},{0,46,884},{27,0,882},{27,0,882},{27,0,882},{27,0,882},{22,52,2},{22,52,2},{22,52,2},{22,37,2},{12,42,1},{12,42,1},{33,63,3224},{30,63,1031},{30,55,1324},{29,52,932},{29,63,3996},{23,60,924},{24,53,7},{23,47,1302},{4,63,3052},{11,48,922},{37,63,1226}, |
| {34,63,9},{35,54,74},{33,51,161},{63,5,3048},{20,62,885},{24,53,6},{6,48,882},{47,42,3048},{6,48,882},{30,63,995},{30,63,995},{30,63,995},{29,50,882},{25,63,705},{24,53,6},{24,53,6},{23,42,61},{9,53,651},{15,43,8},{34,61,0},{34,61,0},{34,61,0},{34,47,4},{58,0,648},{25,52,1},{25,52,1},{16,43,1},{62,27,648},{16,43,1},{63,19,882},{33,63,4},{38,53,1}, |
| {23,53,1},{63,19,882},{63,41,882},{23,53,1},{0,48,882},{63,41,882},{0,48,882},{29,0,882},{29,0,882},{29,0,882},{29,0,882},{24,54,2},{24,54,2},{24,54,2},{24,39,2},{14,44,1},{14,44,1},{34,63,3510},{32,63,1202},{33,57,1335},{31,54,936},{33,63,4252},{25,63,925},{26,55,13},{25,49,1309},{9,63,3091},{13,50,918},{40,63,1349},{37,63,38},{37,56,77},{36,54,158},{60,17,3048}, |
| {24,63,894},{27,55,8},{9,50,884},{63,37,3048},{9,50,884},{32,63,1058},{32,63,1058},{32,63,1058},{31,52,885},{28,63,762},{26,55,9},{26,55,9},{26,44,61},{11,56,650},{17,45,11},{36,63,2},{36,63,2},{36,63,2},{36,50,2},{53,16,648},{28,54,1},{28,54,1},{19,45,1},{63,30,648},{19,45,1},{59,33,882},{37,63,29},{40,56,4},{26,55,4},{59,33,882},{55,48,882},{26,55,4}, |
| {0,50,884},{55,48,882},{0,50,884},{31,0,884},{31,0,884},{31,0,884},{31,0,884},{26,57,0},{26,57,0},{26,57,0},{26,42,1},{16,47,2},{16,47,2},{37,63,3734},{34,63,1399},{35,59,1335},{33,57,935},{34,63,4441},{28,63,957},{28,57,13},{27,51,1309},{13,63,3192},{15,52,918},{43,63,1485},{39,63,131},{39,58,77},{38,56,158},{63,17,3048},{28,63,957},{29,57,8},{11,52,884},{63,40,3048}, |
| {11,52,884},{34,63,1110},{34,63,1110},{34,63,1110},{33,54,883},{30,63,840},{28,57,9},{28,57,9},{28,46,61},{13,58,650},{19,47,11},{39,63,10},{39,63,10},{39,63,10},{38,52,2},{56,16,648},{30,56,1},{30,56,1},{21,47,1},{62,33,648},{21,47,1},{62,33,882},{41,63,80},{42,58,4},{28,57,4},{62,33,882},{61,48,882},{28,57,4},{0,52,884},{61,48,882},{0,52,884},{33,0,882}, |
| {33,0,882},{33,0,882},{33,0,882},{28,59,0},{28,59,0},{28,59,0},{28,44,1},{18,48,1},{18,48,1},{40,63,4022},{37,63,1647},{37,61,1335},{35,59,935},{37,63,4657},{31,63,1085},{30,59,13},{29,53,1309},{18,63,3339},{17,54,924},{45,63,1635},{42,63,275},{41,60,77},{40,58,158},{63,23,3048},{32,63,1044},{31,59,8},{13,54,884},{63,43,3048},{13,54,884},{36,63,1203},{36,63,1203},{36,63,1203}, |
| {35,56,883},{33,63,915},{30,59,9},{30,59,9},{30,48,65},{15,60,650},{21,49,8},{41,63,25},{41,63,25},{41,63,25},{40,54,2},{59,16,648},{32,57,4},{32,57,4},{23,49,0},{62,36,648},{23,49,0},{63,37,882},{44,63,160},{44,60,4},{30,59,4},{63,37,882},{63,50,882},{30,59,4},{0,54,884},{63,50,882},{0,54,884},{35,0,882},{35,0,882},{35,0,882},{35,0,882},{30,61,0}, |
| {30,61,0},{30,61,0},{30,46,1},{20,50,1},{20,50,1},{42,63,4364},{40,63,1991},{39,63,1335},{37,61,935},{40,63,4905},{34,63,1287},{32,61,10},{31,55,1309},{21,63,3555},{19,56,924},{48,63,1796},{44,63,465},{43,62,77},{42,60,158},{63,29,3048},{35,63,1188},{33,61,8},{15,56,884},{63,46,3048},{15,56,884},{39,63,1299},{39,63,1299},{39,63,1299},{37,58,883},{34,63,1017},{32,61,6},{32,61,6}, |
| {32,50,66},{17,62,650},{23,51,8},{43,63,45},{43,63,45},{43,63,45},{42,56,2},{62,16,648},{33,60,2},{33,60,2},{25,51,0},{62,39,648},{25,51,0},{63,43,882},{48,63,260},{46,62,4},{30,62,4},{63,43,882},{63,53,882},{30,62,4},{0,56,884},{63,53,882},{0,56,884},{37,0,882},{37,0,882},{37,0,882},{37,0,882},{32,63,1},{32,63,1},{32,63,1},{32,47,2},{22,52,1}, |
| {22,52,1},{45,63,4441},{43,63,2286},{41,63,1421},{39,62,916},{43,63,4878},{37,63,1410},{34,63,9},{33,57,1141},{26,63,3535},{21,58,795},{50,63,1770},{47,63,609},{46,63,85},{44,62,120},{63,35,2814},{40,63,1194},{35,63,2},{17,58,762},{63,49,2814},{17,58,762},{41,63,1421},{41,63,1421},{41,63,1421},{39,61,885},{37,63,1130},{34,63,9},{34,63,9},{34,52,61},{20,63,651},{25,53,11},{46,63,85}, |
| {46,63,85},{46,63,85},{44,58,4},{63,21,648},{36,62,1},{36,62,1},{27,53,2},{63,42,648},{27,53,2},{63,48,761},{51,63,305},{48,63,1},{34,63,0},{63,48,761},{62,56,761},{34,63,0},{0,58,761},{62,56,761},{0,58,761},{39,0,884},{39,0,884},{39,0,884},{39,0,884},{34,63,9},{34,63,9},{34,63,9},{34,50,1},{24,55,2},{24,55,2},{46,63,3945},{43,63,2238},{43,63,1509}, |
| {41,63,885},{45,63,4345},{38,63,1230},{37,63,41},{34,58,781},{30,63,3066},{24,59,494},{51,63,1386},{48,63,530},{48,63,130},{46,62,45},{63,39,2249},{43,63,914},{39,63,8},{21,59,482},{47,59,2249},{21,59,482},{43,63,1509},{43,63,1509},{43,63,1509},{41,63,885},{40,63,1242},{37,63,41},{37,63,41},{36,54,61},{24,63,689},{27,55,11},{48,63,130},{48,63,130},{48,63,130},{46,60,4},{63,27,648}, |
| {39,63,8},{39,63,8},{29,55,2},{63,45,648},{29,55,2},{63,51,481},{54,63,193},{51,63,1},{40,63,0},{63,51,481},{63,57,481},{40,63,0},{0,59,481},{63,57,481},{0,59,481},{41,0,884},{41,0,884},{41,0,884},{41,0,884},{37,63,25},{37,63,25},{37,63,25},{36,52,1},{26,57,2},{26,57,2},{48,63,3571},{46,63,2182},{46,63,1653},{43,63,900},{46,63,3838},{41,63,1094},{40,63,137}, |
| {37,59,490},{32,63,2703},{27,60,270},{53,63,1106},{51,63,458},{50,63,193},{48,63,10},{63,43,1769},{46,63,698},{42,63,40},{25,60,266},{63,53,1769},{25,60,266},{46,63,1653},{46,63,1653},{46,63,1653},{43,63,900},{43,63,1386},{40,63,137},{40,63,137},{38,56,61},{29,63,779},{29,57,11},{50,63,193},{50,63,193},{50,63,193},{48,62,1},{63,33,648},{42,63,40},{42,63,40},{31,57,2},{47,56,648}, |
| {31,57,2},{63,54,265},{57,63,113},{54,63,1},{46,63,0},{63,54,265},{62,59,265},{46,63,0},{0,60,265},{62,59,265},{0,60,265},{43,0,884},{43,0,884},{43,0,884},{43,0,884},{39,63,52},{39,63,52},{39,63,52},{38,54,1},{28,59,2},{28,59,2},{50,63,3307},{48,63,2195},{48,63,1795},{46,63,964},{48,63,3435},{43,63,1026},{42,63,296},{39,60,269},{37,63,2410},{30,61,115},{54,63,882}, |
| {54,63,450},{53,63,265},{50,63,10},{63,47,1374},{48,63,546},{46,63,89},{29,61,114},{63,55,1374},{29,61,114},{48,63,1795},{48,63,1795},{48,63,1795},{46,63,964},{45,63,1560},{42,63,296},{42,63,296},{40,58,61},{32,63,891},{31,59,11},{53,63,265},{53,63,265},{53,63,265},{50,63,10},{63,39,648},{46,63,89},{46,63,89},{33,59,1},{47,59,648},{33,59,1},{63,57,113},{58,63,50},{57,63,1}, |
| {52,63,0},{63,57,113},{63,60,113},{52,63,0},{0,61,113},{63,60,113},{0,61,113},{45,0,884},{45,0,884},{45,0,884},{45,0,884},{41,63,97},{41,63,97},{41,63,97},{40,56,1},{30,61,2},{30,61,2},{51,63,3032},{51,63,2264},{50,63,1965},{48,63,1096},{51,63,3096},{46,63,1059},{46,63,530},{41,62,126},{40,63,2191},{33,62,25},{57,63,680},{56,63,465},{55,63,356},{53,63,68},{63,51,1032}, |
| {52,63,450},{49,63,185},{34,62,20},{63,57,1032},{34,62,20},{50,63,1965},{50,63,1965},{50,63,1965},{48,63,1096},{48,63,1736},{46,63,530},{46,63,530},{42,60,62},{37,63,1086},{33,62,9},{55,63,356},{55,63,356},{55,63,356},{53,63,68},{61,49,648},{49,63,185},{49,63,185},{36,61,4},{63,54,648},{36,61,4},{63,61,18},{61,63,9},{61,63,0},{59,63,0},{63,61,18},{63,62,18},{59,63,0}, |
| {0,62,20},{63,62,18},{0,62,20},{47,0,890},{47,0,890},{47,0,890},{47,0,890},{44,63,149},{44,63,149},{44,63,149},{42,58,1},{32,63,0},{32,63,0},{54,63,2756},{52,63,2249},{51,63,2004},{50,63,1224},{53,63,2803},{48,63,1092},{48,63,692},{44,62,58},{43,63,1991},{35,63,16},{59,63,566},{57,63,420},{57,63,356},{55,63,125},{63,55,771},{55,63,386},{52,63,241},{38,63,0},{63,59,771}, |
| {38,63,0},{51,63,2004},{51,63,2004},{51,63,2004},{50,63,1224},{50,63,1802},{48,63,692},{48,63,692},{44,62,42},{40,63,1166},{35,63,16},{57,63,356},{57,63,356},{57,63,356},{55,63,125},{63,50,580},{52,63,241},{52,63,241},{38,63,0},{62,57,580},{38,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{49,0,884}, |
| {49,0,884},{49,0,884},{49,0,884},{46,63,193},{46,63,193},{46,63,193},{44,60,1},{35,63,16},{35,63,16},{54,63,2276},{54,63,1844},{54,63,1700},{52,63,1125},{54,63,2180},{51,63,948},{49,63,649},{46,63,10},{46,63,1551},{39,63,58},{60,63,324},{59,63,257},{59,63,221},{57,63,68},{63,57,452},{57,63,228},{55,63,137},{44,63,0},{63,60,452},{44,63,0},{54,63,1700},{54,63,1700},{54,63,1700}, |
| {52,63,1125},{51,63,1460},{49,63,649},{49,63,649},{46,63,10},{43,63,926},{39,63,58},{59,63,221},{59,63,221},{59,63,221},{57,63,68},{63,53,340},{55,63,137},{55,63,137},{44,63,0},{63,58,340},{44,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{51,0,884},{51,0,884},{51,0,884},{51,0,884},{48,63,260}, |
| {48,63,260},{48,63,260},{46,62,1},{39,63,58},{39,63,58},{57,63,1844},{55,63,1585},{55,63,1464},{54,63,1044},{56,63,1747},{52,63,850},{51,63,596},{48,63,4},{48,63,1204},{43,63,117},{60,63,164},{60,63,116},{60,63,100},{59,63,40},{63,59,216},{58,63,114},{58,63,65},{50,63,0},{63,61,216},{50,63,0},{55,63,1464},{55,63,1464},{55,63,1464},{54,63,1044},{54,63,1188},{51,63,596},{51,63,596}, |
| {48,63,4},{46,63,750},{43,63,117},{60,63,100},{60,63,100},{60,63,100},{59,63,40},{63,56,164},{58,63,65},{58,63,65},{50,63,0},{62,60,164},{50,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{53,0,884},{53,0,884},{53,0,884},{53,0,884},{51,63,340},{51,63,340},{51,63,340},{48,63,4},{43,63,117}, |
| {43,63,117},{0,39,1568},{0,28,194},{0,19,10},{0,16,586},{0,26,3371},{0,17,2169},{0,16,1027},{0,10,2532},{0,12,3648},{0,10,2701},{0,39,1568},{0,28,194},{0,19,10},{0,16,586},{5,16,3371},{0,17,2169},{0,16,1027},{0,10,2532},{26,0,3371},{0,10,2532},{0,18,0},{0,18,0},{0,18,0},{0,9,0},{0,9,288},{0,8,109},{0,8,109},{0,4,164},{0,4,321},{0,4,189},{0,18,0}, |
| {0,18,0},{0,18,0},{0,9,0},{4,1,288},{0,8,109},{0,8,109},{0,4,164},{9,0,288},{0,4,164},{19,1,1568},{0,28,194},{0,19,10},{0,16,586},{19,1,1568},{39,0,1568},{0,16,586},{0,13,1568},{39,0,1568},{0,13,1568},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,45,1568},{0,31,106},{0,22,10}, |
| {0,18,481},{0,30,3968},{0,19,2355},{0,18,1057},{0,13,2852},{0,14,4319},{0,11,3117},{0,45,1568},{0,31,106},{0,22,10},{0,18,481},{15,0,3968},{0,19,2355},{0,18,1057},{0,13,2852},{30,0,3968},{0,13,2852},{0,24,0},{0,24,0},{0,24,0},{0,12,0},{0,12,512},{0,10,205},{0,10,205},{0,5,313},{0,5,566},{0,5,349},{0,24,0},{0,24,0},{0,24,0},{0,12,0},{6,0,512}, |
| {0,10,205},{0,10,205},{0,5,313},{12,0,512},{0,5,313},{22,1,1568},{0,31,106},{1,22,1},{0,18,481},{22,1,1568},{45,0,1568},{0,18,481},{0,15,1568},{45,0,1568},{0,15,1568},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,50,1570},{0,34,52},{1,24,58},{0,21,377},{0,34,4652},{0,22,2571},{0,19,1107}, |
| {0,14,3225},{0,16,5108},{0,13,3525},{0,50,1570},{0,34,52},{1,24,42},{0,21,377},{15,4,4651},{0,22,2571},{0,19,1107},{0,14,3225},{30,2,4651},{0,14,3225},{0,30,0},{0,30,0},{0,30,0},{0,15,0},{0,15,800},{0,11,317},{0,11,317},{0,7,468},{0,7,889},{0,7,549},{0,30,0},{0,30,0},{0,30,0},{0,15,0},{7,1,800},{0,11,317},{0,11,317},{0,7,468},{15,0,800}, |
| {0,7,468},{25,1,1568},{0,34,52},{3,24,1},{0,21,377},{25,1,1568},{47,2,1568},{0,21,377},{0,17,1570},{47,2,1568},{0,17,1570},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,56,1570},{0,38,13},{1,27,138},{0,24,305},{0,38,5419},{0,25,2819},{0,22,1187},{0,16,3659},{0,17,6013},{0,14,4061},{0,56,1570}, |
| {0,38,13},{1,27,122},{0,24,305},{19,0,5419},{0,25,2819},{0,22,1187},{0,16,3659},{38,0,5419},{0,16,3659},{0,36,0},{0,36,0},{0,36,0},{0,18,0},{0,18,1152},{0,14,445},{0,14,445},{0,8,697},{0,8,1270},{0,8,797},{0,36,0},{0,36,0},{0,36,0},{0,18,0},{9,0,1152},{0,14,445},{0,14,445},{0,8,697},{18,0,1152},{0,8,697},{28,1,1568},{0,38,13},{5,26,1}, |
| {0,24,305},{28,1,1568},{47,5,1568},{0,24,305},{0,19,1570},{47,5,1568},{0,19,1570},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{1,61,1609},{1,41,43},{2,29,250},{1,26,301},{0,45,5419},{0,28,2552},{0,25,820},{0,18,3377},{0,21,6243},{0,18,3953},{2,59,1569},{2,41,10},{3,29,125},{1,26,285},{22,1,5419}, |
| {0,28,2552},{0,25,820},{0,18,3377},{45,0,5419},{0,18,3377},{1,40,42},{1,40,42},{1,40,42},{1,21,42},{0,25,1152},{0,19,292},{0,19,292},{0,11,569},{0,11,1380},{0,10,747},{2,38,2},{2,38,2},{2,38,2},{2,20,2},{12,1,1152},{0,19,292},{0,19,292},{0,11,569},{25,0,1152},{0,11,569},{23,17,1568},{0,42,1},{7,28,1},{0,26,233},{23,17,1568},{63,0,1568},{0,26,233}, |
| {0,21,1568},{63,0,1568},{0,21,1568},{1,0,41},{1,0,41},{1,0,41},{1,0,41},{0,7,0},{0,7,0},{0,7,0},{0,3,1},{0,3,17},{0,3,17},{2,63,1731},{2,44,146},{3,31,441},{1,28,370},{0,50,5420},{0,33,2329},{0,27,554},{0,21,3217},{0,23,6476},{0,19,3861},{4,61,1569},{4,43,10},{5,31,125},{3,28,285},{25,1,5419},{0,33,2329},{0,27,554},{0,21,3217},{47,2,5419}, |
| {0,21,3217},{2,44,146},{2,44,146},{2,44,146},{2,23,146},{0,31,1152},{0,22,180},{0,22,180},{0,13,458},{0,14,1508},{0,13,747},{4,40,2},{4,40,2},{4,40,2},{4,22,2},{15,1,1152},{0,22,180},{0,22,180},{0,13,458},{31,0,1152},{0,13,458},{34,1,1568},{2,44,1},{9,30,1},{0,28,164},{34,1,1568},{63,3,1568},{0,28,164},{0,23,1568},{63,3,1568},{0,23,1568},{2,0,145}, |
| {2,0,145},{2,0,145},{2,0,145},{0,13,0},{0,13,0},{0,13,0},{0,6,1},{0,5,52},{0,5,52},{4,63,1977},{3,47,318},{5,33,675},{3,30,498},{0,56,5420},{0,36,2129},{0,30,338},{0,22,3012},{0,25,6733},{0,21,3825},{6,63,1569},{6,45,10},{8,33,123},{5,30,285},{28,1,5419},{0,36,2129},{0,30,338},{0,22,3012},{47,5,5419},{0,22,3012},{3,48,313},{3,48,313},{3,48,313}, |
| {3,26,314},{0,36,1154},{0,25,100},{0,25,100},{0,16,388},{0,16,1665},{0,14,757},{6,42,2},{6,42,2},{6,42,2},{6,24,2},{15,7,1152},{0,25,100},{0,25,100},{0,16,388},{31,3,1152},{0,16,388},{37,1,1568},{4,46,1},{11,32,2},{0,30,113},{37,1,1568},{63,6,1568},{0,30,113},{0,25,1568},{63,6,1568},{0,25,1568},{3,0,313},{3,0,313},{3,0,313},{3,0,313},{0,19,0}, |
| {0,19,0},{0,19,0},{0,9,1},{0,8,116},{0,8,116},{6,63,2353},{4,49,562},{6,35,1006},{3,32,715},{0,62,5420},{0,39,1961},{0,32,174},{0,24,2817},{0,28,7013},{0,24,3841},{9,63,1577},{8,47,10},{10,35,123},{7,31,290},{31,1,5419},{0,39,1961},{0,32,174},{0,24,2817},{47,8,5419},{0,24,2817},{4,52,545},{4,52,545},{4,52,545},{4,28,546},{0,42,1154},{0,29,45},{0,29,45}, |
| {0,18,289},{0,19,1849},{0,16,797},{8,44,2},{8,44,2},{8,44,2},{8,26,2},{15,13,1152},{0,29,45},{0,29,45},{0,18,289},{31,6,1152},{0,18,289},{40,1,1568},{6,48,1},{13,34,2},{0,33,73},{40,1,1568},{63,9,1568},{0,33,73},{0,27,1568},{63,9,1568},{0,27,1568},{4,0,545},{4,0,545},{4,0,545},{4,0,545},{0,25,0},{0,25,0},{0,25,0},{0,12,1},{0,11,212}, |
| {0,11,212},{8,63,2980},{6,52,920},{7,38,1444},{5,34,1012},{2,63,5504},{0,42,1814},{0,35,57},{0,27,2630},{0,31,7380},{0,25,3860},{11,63,1604},{10,49,13},{12,37,116},{10,33,292},{34,1,5419},{0,42,1814},{0,35,57},{0,27,2630},{63,3,5419},{0,27,2630},{5,57,884},{5,57,884},{5,57,884},{5,31,884},{0,49,1152},{0,33,5},{0,33,5},{0,21,221},{0,22,2091},{0,19,875},{11,45,4}, |
| {11,45,4},{11,45,4},{11,28,4},{24,1,1152},{0,33,5},{0,33,5},{0,21,221},{49,0,1152},{0,21,221},{44,0,1568},{8,50,1},{15,36,4},{0,35,32},{44,0,1568},{62,13,1568},{0,35,32},{0,29,1570},{62,13,1568},{0,29,1570},{5,0,884},{5,0,884},{5,0,884},{5,0,884},{0,31,1},{0,31,1},{0,31,1},{0,16,1},{0,14,349},{0,14,349},{9,63,3638},{7,55,1309},{8,39,1940}, |
| {6,36,1365},{3,63,5739},{0,45,1718},{0,38,17},{0,29,2514},{0,34,7760},{0,28,3900},{14,63,1636},{12,51,13},{14,39,116},{12,35,292},{37,1,5419},{0,45,1718},{0,38,17},{0,29,2514},{63,6,5419},{0,29,2514},{6,61,1252},{6,61,1252},{6,61,1252},{6,33,1253},{0,55,1152},{0,37,4},{0,37,4},{0,22,162},{0,25,2339},{0,21,989},{13,47,4},{13,47,4},{13,47,4},{13,30,4},{27,1,1152}, |
| {1,36,1},{1,36,1},{0,22,162},{55,0,1152},{0,22,162},{47,0,1568},{10,52,1},{17,38,1},{0,38,16},{47,0,1568},{46,24,1568},{0,38,16},{0,31,1570},{46,24,1568},{0,31,1570},{6,0,1252},{6,0,1252},{6,0,1252},{6,0,1252},{0,37,0},{0,37,0},{0,37,0},{0,19,1},{0,16,490},{0,16,490},{11,63,4328},{8,57,1644},{10,41,2360},{7,39,1656},{6,63,6079},{0,49,1644},{1,40,17}, |
| {0,31,2359},{0,36,7943},{0,30,3834},{16,63,1689},{14,53,13},{16,41,129},{14,37,292},{40,1,5419},{0,49,1640},{1,40,13},{0,31,2355},{63,9,5419},{0,31,2355},{8,63,1576},{8,63,1576},{8,63,1576},{7,36,1576},{1,59,1156},{1,39,13},{1,39,13},{0,25,110},{0,28,2475},{0,24,1017},{15,49,4},{15,49,4},{15,49,4},{15,32,4},{30,1,1152},{3,38,1},{3,38,1},{0,25,106},{61,0,1152}, |
| {0,25,106},{49,1,1568},{12,54,1},{19,40,1},{0,40,4},{49,1,1568},{46,27,1568},{0,40,4},{0,33,1568},{46,27,1568},{0,33,1568},{7,0,1576},{7,0,1576},{7,0,1576},{7,0,1576},{1,41,4},{1,41,4},{1,41,4},{1,21,4},{0,19,578},{0,19,578},{14,63,4584},{10,59,1644},{12,43,2360},{9,41,1656},{8,63,6244},{2,51,1644},{3,42,17},{1,33,2308},{0,42,7575},{0,32,3345},{19,63,1761}, |
| {16,55,10},{17,43,125},{16,40,290},{43,1,5419},{0,52,1592},{3,42,13},{0,33,2225},{63,12,5419},{0,33,2225},{10,63,1585},{10,63,1585},{10,63,1585},{9,38,1576},{3,61,1156},{3,41,13},{3,41,13},{2,27,110},{0,31,2211},{0,25,699},{16,52,2},{16,52,2},{16,52,2},{16,34,2},{33,1,1152},{5,40,1},{5,40,1},{0,27,61},{63,2,1152},{0,27,61},{52,1,1568},{14,56,1},{21,42,1}, |
| {1,42,0},{52,1,1568},{46,30,1568},{1,42,0},{0,35,1568},{46,30,1568},{0,35,1568},{9,0,1576},{9,0,1576},{9,0,1576},{9,0,1576},{3,43,4},{3,43,4},{3,43,4},{3,23,4},{0,22,410},{0,22,410},{15,63,4826},{12,62,1650},{14,46,2355},{11,43,1660},{11,63,6452},{4,54,1641},{5,44,15},{3,35,2308},{0,45,7165},{0,35,2875},{22,63,1862},{18,57,9},{20,45,126},{18,42,281},{47,0,5419}, |
| {0,56,1568},{6,44,10},{0,35,2091},{46,24,5419},{0,35,2091},{12,63,1606},{12,63,1606},{12,63,1606},{12,40,1571},{5,63,1155},{5,44,14},{5,44,14},{4,29,109},{0,33,1977},{0,28,424},{19,53,4},{19,53,4},{19,53,4},{19,36,4},{31,12,1152},{7,42,1},{7,42,1},{0,30,29},{62,6,1152},{0,30,29},{56,0,1568},{17,58,1},{24,44,2},{3,44,2},{56,0,1568},{62,25,1568},{3,44,2}, |
| {0,37,1570},{62,25,1568},{0,37,1570},{12,0,1570},{12,0,1570},{12,0,1570},{12,0,1570},{5,46,1},{5,46,1},{5,46,1},{5,25,2},{0,25,260},{0,25,260},{17,63,5096},{14,63,1652},{15,48,2358},{13,45,1660},{14,63,6668},{6,56,1641},{7,46,15},{5,37,2308},{0,47,6891},{0,36,2543},{23,63,1956},{20,59,9},{22,47,126},{20,44,281},{49,1,5419},{2,58,1568},{8,46,10},{0,38,1979},{46,27,5419}, |
| {0,38,1979},{14,63,1651},{14,63,1651},{14,63,1651},{14,42,1571},{8,63,1179},{7,46,14},{7,46,14},{6,31,109},{0,38,1778},{0,31,232},{21,55,4},{21,55,4},{21,55,4},{21,38,4},{31,18,1152},{9,44,1},{9,44,1},{0,32,10},{62,9,1152},{0,32,10},{59,0,1568},{19,60,1},{26,46,2},{5,46,2},{59,0,1568},{62,28,1568},{5,46,2},{0,39,1570},{62,28,1568},{0,39,1570},{14,0,1570}, |
| {14,0,1570},{14,0,1570},{14,0,1570},{7,48,1},{7,48,1},{7,48,1},{7,27,2},{0,28,164},{0,28,164},{20,63,5352},{17,63,1708},{18,49,2360},{15,47,1660},{15,63,6877},{8,58,1641},{9,48,14},{7,39,2308},{0,50,6576},{0,39,2215},{26,63,2052},{22,61,9},{24,49,116},{22,46,281},{52,1,5419},{4,60,1568},{9,48,13},{0,40,1907},{46,30,5419},{0,40,1907},{16,63,1697},{16,63,1697},{16,63,1697}, |
| {16,44,1577},{10,63,1209},{9,48,14},{9,48,14},{8,33,115},{0,42,1601},{0,33,110},{23,57,4},{23,57,4},{23,57,4},{23,40,4},{34,17,1152},{11,46,1},{11,46,1},{0,34,2},{62,12,1152},{0,34,2},{62,0,1568},{21,62,1},{28,48,1},{7,48,0},{62,0,1568},{62,31,1568},{7,48,0},{0,41,1570},{62,31,1568},{0,41,1570},{16,0,1576},{16,0,1576},{16,0,1576},{16,0,1576},{9,50,1}, |
| {9,50,1},{9,50,1},{9,29,2},{0,33,85},{0,33,85},{23,63,5672},{19,63,1825},{20,51,2360},{17,49,1656},{19,63,7135},{10,60,1641},{11,50,14},{9,41,2308},{0,53,6336},{0,42,1983},{29,63,2180},{24,63,9},{26,51,116},{24,48,293},{55,1,5419},{6,62,1568},{11,50,13},{0,42,1814},{47,32,5419},{0,42,1814},{19,63,1761},{19,63,1761},{19,63,1761},{17,46,1576},{12,63,1249},{11,50,14},{11,50,14}, |
| {10,35,115},{0,45,1449},{0,36,30},{25,59,4},{25,59,4},{25,59,4},{25,42,4},{37,17,1152},{13,48,0},{13,48,0},{1,36,2},{62,15,1152},{1,36,2},{63,4,1568},{23,63,4},{30,50,1},{9,50,0},{63,4,1568},{62,34,1568},{9,50,0},{0,43,1570},{62,34,1568},{0,43,1570},{17,0,1576},{17,0,1576},{17,0,1576},{17,0,1576},{11,52,1},{11,52,1},{11,52,1},{11,31,2},{0,36,29}, |
| {0,36,29},{25,63,6066},{21,63,2039},{22,54,2355},{19,51,1660},{20,63,7420},{12,62,1635},{13,52,14},{11,43,2316},{0,57,6109},{0,44,1789},{31,63,2369},{27,63,38},{28,53,115},{26,50,286},{59,0,5419},{9,63,1577},{14,52,11},{0,44,1740},{62,28,5419},{0,44,1740},{21,63,1843},{21,63,1843},{21,63,1843},{20,48,1571},{15,63,1314},{13,52,13},{13,52,13},{12,37,116},{0,48,1329},{0,39,13},{27,62,1}, |
| {27,62,1},{27,62,1},{27,44,2},{49,0,1152},{15,50,2},{15,50,2},{4,38,4},{62,18,1152},{4,38,4},{63,11,1568},{27,63,37},{32,52,2},{12,52,1},{63,11,1568},{47,45,1568},{12,52,1},{0,45,1576},{47,45,1568},{0,45,1576},{20,0,1570},{20,0,1570},{20,0,1570},{20,0,1570},{13,54,1},{13,54,1},{13,54,1},{13,34,1},{0,40,4},{0,40,4},{28,63,6434},{23,63,2268},{24,56,2355}, |
| {21,53,1660},{23,63,7668},{14,63,1652},{15,54,14},{13,45,2316},{0,61,5924},{0,47,1685},{34,63,2502},{29,63,123},{30,55,115},{28,52,286},{62,0,5419},{13,63,1627},{16,54,10},{0,47,1676},{62,31,5419},{0,47,1676},{23,63,1907},{23,63,1907},{23,63,1907},{22,50,1571},{17,63,1395},{15,54,13},{15,54,13},{14,39,116},{0,51,1241},{2,41,13},{29,63,2},{29,63,2},{29,63,2},{29,46,2},{52,0,1152}, |
| {17,52,1},{17,52,1},{6,40,4},{62,21,1152},{6,40,4},{55,32,1568},{31,63,97},{34,54,2},{14,54,1},{55,32,1568},{46,48,1568},{14,54,1},{0,47,1576},{46,48,1568},{0,47,1576},{22,0,1570},{22,0,1570},{22,0,1570},{22,0,1570},{15,56,1},{15,56,1},{15,56,1},{15,36,1},{1,43,1},{1,43,1},{29,63,6756},{26,63,2548},{26,58,2355},{23,55,1660},{26,63,7948},{17,63,1716},{17,56,15}, |
| {15,47,2316},{0,63,5773},{0,49,1638},{37,63,2694},{32,63,262},{32,57,126},{30,54,286},{63,4,5419},{17,63,1715},{18,56,10},{0,49,1634},{62,34,5419},{0,49,1634},{25,63,2018},{25,63,2018},{25,63,2018},{24,52,1571},{20,63,1483},{17,56,14},{17,56,14},{16,41,109},{0,54,1185},{4,43,13},{31,63,17},{31,63,17},{31,63,17},{31,48,2},{55,0,1152},{19,54,1},{19,54,1},{8,42,4},{62,24,1152}, |
| {8,42,4},{58,32,1568},{34,63,169},{36,56,2},{15,56,2},{58,32,1568},{52,48,1568},{15,56,2},{0,49,1570},{52,48,1568},{0,49,1570},{24,0,1570},{24,0,1570},{24,0,1570},{24,0,1570},{17,58,1},{17,58,1},{17,58,1},{17,37,2},{3,45,1},{3,45,1},{31,63,7218},{29,63,2924},{28,60,2355},{25,57,1660},{29,63,8260},{20,63,1884},{19,58,15},{17,49,2308},{3,63,5933},{2,51,1638},{39,63,2892}, |
| {34,63,445},{34,59,126},{32,56,281},{63,10,5419},{21,63,1849},{20,58,10},{0,51,1606},{62,37,5419},{0,51,1606},{28,63,2130},{28,63,2130},{28,63,2130},{26,54,1571},{23,63,1603},{19,58,14},{19,58,14},{18,43,109},{0,58,1156},{6,45,13},{33,63,40},{33,63,40},{33,63,40},{33,50,4},{58,0,1152},{21,56,1},{21,56,1},{10,44,4},{62,27,1152},{10,44,4},{61,32,1568},{38,63,274},{38,58,2}, |
| {17,58,2},{61,32,1568},{58,48,1568},{17,58,2},{0,51,1570},{58,48,1568},{0,51,1570},{26,0,1570},{26,0,1570},{26,0,1570},{26,0,1570},{19,60,1},{19,60,1},{19,60,1},{19,39,2},{5,47,1},{5,47,1},{34,63,7586},{31,63,3453},{30,62,2357},{28,59,1668},{31,63,8699},{23,63,2180},{21,60,21},{19,51,2316},{7,63,6224},{4,53,1634},{42,63,3131},{37,63,722},{36,62,125},{34,58,278},{55,32,5419}, |
| {26,63,2052},{22,60,9},{0,53,1580},{46,48,5419},{0,53,1580},{30,63,2272},{30,63,2272},{30,63,2272},{28,56,1568},{25,63,1746},{21,60,17},{21,60,17},{21,45,113},{1,61,1154},{9,47,14},{36,63,74},{36,63,74},{36,63,74},{35,52,2},{53,16,1152},{23,59,1},{23,59,1},{11,47,1},{63,30,1152},{11,47,1},{63,35,1568},{43,63,433},{40,60,4},{20,60,4},{63,35,1568},{63,49,1568},{20,60,4}, |
| {0,53,1576},{63,49,1568},{0,53,1576},{28,0,1568},{28,0,1568},{28,0,1568},{28,0,1568},{21,63,0},{21,63,0},{21,63,0},{21,42,0},{7,49,1},{7,49,1},{37,63,8018},{34,63,3915},{32,63,2410},{30,61,1668},{34,63,8985},{26,63,2548},{23,62,21},{21,53,2316},{12,63,6555},{6,55,1634},{43,63,3345},{40,63,1026},{38,63,129},{36,60,278},{58,32,5419},{30,63,2274},{24,62,9},{0,55,1577},{52,48,5419}, |
| {0,55,1577},{32,63,2406},{32,63,2406},{32,63,2406},{30,58,1568},{28,63,1890},{23,62,17},{23,62,17},{23,47,113},{3,63,1154},{11,49,12},{38,63,125},{38,63,125},{38,63,125},{37,54,2},{56,16,1152},{25,61,1},{25,61,1},{14,48,5},{62,33,1152},{14,48,5},{63,41,1568},{46,63,585},{42,62,4},{22,62,4},{63,41,1568},{63,52,1568},{22,62,4},{0,55,1576},{63,52,1568},{0,55,1576},{30,0,1568}, |
| {30,0,1568},{30,0,1568},{30,0,1568},{23,63,4},{23,63,4},{23,63,4},{23,44,0},{9,51,1},{9,51,1},{39,63,7700},{35,63,4026},{34,63,2514},{32,62,1611},{37,63,8485},{29,63,2424},{26,63,20},{23,55,1896},{15,63,6115},{9,56,1308},{46,63,2973},{43,63,1034},{40,63,169},{37,61,194},{63,27,4803},{32,63,2024},{27,63,1},{2,57,1253},{63,45,4803},{2,57,1253},{34,63,2514},{34,63,2514},{34,63,2514}, |
| {32,60,1570},{29,63,2056},{26,63,20},{26,63,20},{24,49,116},{7,63,1164},{13,51,12},{40,63,169},{40,63,169},{40,63,169},{39,56,2},{59,16,1152},{27,63,1},{27,63,1},{16,50,4},{62,36,1152},{16,50,4},{63,45,1250},{48,63,500},{45,63,1},{26,63,0},{63,45,1250},{47,62,1250},{26,63,0},{0,57,1252},{47,62,1250},{0,57,1252},{32,0,1570},{32,0,1570},{32,0,1570},{32,0,1570},{26,63,20}, |
| {26,63,20},{26,63,20},{25,46,0},{11,53,1},{11,53,1},{40,63,7062},{37,63,3915},{37,63,2690},{34,63,1579},{37,63,7765},{30,63,2178},{28,63,77},{26,56,1437},{18,63,5499},{11,57,918},{48,63,2504},{44,63,945},{43,63,225},{40,62,89},{63,31,4056},{35,63,1656},{30,63,9},{6,58,885},{63,47,4056},{6,58,885},{37,63,2690},{37,63,2690},{37,63,2690},{34,62,1570},{33,63,2227},{28,63,77},{28,63,77}, |
| {26,51,116},{11,63,1227},{15,53,12},{43,63,225},{43,63,225},{43,63,225},{41,58,2},{62,16,1152},{30,63,9},{30,63,9},{18,52,4},{62,39,1152},{18,52,4},{63,47,884},{51,63,356},{47,63,4},{32,63,0},{63,47,884},{63,55,884},{32,63,0},{0,58,884},{63,55,884},{0,58,884},{34,0,1570},{34,0,1570},{34,0,1570},{34,0,1570},{28,63,41},{28,63,41},{28,63,41},{27,48,1},{13,55,1}, |
| {13,55,1},{43,63,6493},{40,63,3882},{39,63,2880},{36,63,1584},{40,63,6982},{34,63,1966},{31,63,206},{28,57,971},{23,63,4927},{14,59,562},{50,63,2070},{46,63,842},{46,63,313},{43,62,25},{63,35,3318},{38,63,1326},{34,63,45},{11,59,545},{63,49,3318},{11,59,545},{39,63,2880},{39,63,2880},{39,63,2880},{36,63,1584},{34,63,2434},{31,63,206},{31,63,206},{29,53,114},{15,63,1329},{17,55,14},{46,63,313}, |
| {46,63,313},{46,63,313},{43,61,0},{63,21,1152},{34,63,45},{34,63,45},{19,55,1},{63,42,1152},{19,55,1},{63,51,545},{54,63,225},{51,63,1},{39,63,0},{63,51,545},{63,57,545},{39,63,0},{0,59,545},{63,57,545},{0,59,545},{36,0,1568},{36,0,1568},{36,0,1568},{36,0,1568},{31,63,85},{31,63,85},{31,63,85},{29,50,1},{15,57,1},{15,57,1},{45,63,6113},{43,63,3938},{40,63,3065}, |
| {38,63,1649},{43,63,6422},{35,63,1878},{34,63,365},{30,59,651},{26,63,4495},{16,60,318},{51,63,1698},{48,63,794},{48,63,394},{45,63,0},{63,39,2753},{41,63,1094},{38,63,106},{15,60,313},{47,59,2753},{15,60,313},{40,63,3065},{40,63,3065},{40,63,3065},{38,63,1649},{37,63,2610},{34,63,365},{34,63,365},{31,55,114},{20,63,1483},{19,57,14},{48,63,394},{48,63,394},{48,63,394},{45,63,0},{63,27,1152}, |
| {38,63,106},{38,63,106},{21,57,1},{63,45,1152},{21,57,1},{63,54,313},{55,63,130},{54,63,1},{45,63,0},{63,54,313},{62,59,313},{45,63,0},{0,60,313},{62,59,313},{0,60,313},{38,0,1568},{38,0,1568},{38,0,1568},{38,0,1568},{33,63,128},{33,63,128},{33,63,128},{31,52,1},{17,59,1},{17,59,1},{46,63,5677},{43,63,3954},{43,63,3225},{40,63,1764},{45,63,5985},{37,63,1830},{37,63,605}, |
| {32,60,410},{29,63,4159},{19,61,146},{53,63,1454},{51,63,770},{50,63,493},{47,63,25},{63,43,2273},{44,63,926},{41,63,194},{19,61,145},{63,53,2273},{19,61,145},{43,63,3225},{43,63,3225},{43,63,3225},{40,63,1764},{40,63,2818},{37,63,605},{37,63,605},{33,57,113},{23,63,1659},{21,59,14},{50,63,493},{50,63,493},{50,63,493},{47,63,25},{63,33,1152},{41,63,194},{41,63,194},{23,59,1},{47,56,1152}, |
| {23,59,1},{63,57,145},{58,63,58},{57,63,1},{50,63,1},{63,57,145},{63,60,145},{50,63,1},{0,61,145},{63,60,145},{0,61,145},{40,0,1568},{40,0,1568},{40,0,1568},{40,0,1568},{34,63,185},{34,63,185},{34,63,185},{33,54,0},{19,61,1},{19,61,1},{48,63,5379},{46,63,3978},{46,63,3449},{43,63,1924},{46,63,5542},{40,63,1870},{38,63,890},{34,61,225},{32,63,3919},{22,62,43},{54,63,1242}, |
| {53,63,809},{51,63,610},{49,63,101},{63,47,1878},{48,63,810},{44,63,314},{23,62,41},{63,55,1878},{23,62,41},{46,63,3449},{46,63,3449},{46,63,3449},{43,63,1924},{43,63,3058},{38,63,890},{38,63,890},{35,59,113},{27,63,1889},{23,61,14},{51,63,610},{51,63,610},{51,63,610},{49,63,101},{63,39,1152},{44,63,314},{44,63,314},{25,61,1},{47,59,1152},{25,61,1},{63,60,41},{60,63,17},{60,63,1}, |
| {56,63,1},{63,60,41},{62,62,41},{56,63,1},{0,62,41},{62,62,41},{0,62,41},{42,0,1568},{42,0,1568},{42,0,1568},{42,0,1568},{37,63,233},{37,63,233},{37,63,233},{35,56,0},{21,63,1},{21,63,1},{50,63,5170},{48,63,4080},{48,63,3680},{46,63,2195},{48,63,5200},{43,63,2023},{41,63,1269},{37,62,133},{35,63,3772},{25,63,17},{57,63,1088},{55,63,861},{54,63,720},{52,63,241},{63,51,1536}, |
| {51,63,768},{49,63,461},{28,63,0},{63,57,1536},{28,63,0},{48,63,3680},{48,63,3680},{48,63,3680},{46,63,2195},{46,63,3345},{41,63,1269},{41,63,1269},{37,61,114},{32,63,2200},{25,63,17},{54,63,720},{54,63,720},{54,63,720},{52,63,241},{61,49,1152},{49,63,461},{49,63,461},{28,63,0},{63,54,1152},{28,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0}, |
| {0,63,0},{63,63,0},{0,63,0},{44,0,1570},{44,0,1570},{44,0,1570},{44,0,1570},{40,63,317},{40,63,317},{40,63,317},{37,58,2},{25,63,17},{25,63,17},{51,63,4416},{50,63,3629},{48,63,3296},{47,63,2070},{50,63,4411},{46,63,1823},{43,63,1150},{39,63,50},{38,63,3132},{29,63,52},{57,63,768},{57,63,576},{56,63,505},{54,63,160},{63,53,1068},{54,63,544},{51,63,320},{33,63,1},{63,58,1068}, |
| {33,63,1},{48,63,3296},{48,63,3296},{48,63,3296},{47,63,2070},{46,63,2881},{43,63,1150},{43,63,1150},{39,62,42},{34,63,1846},{29,63,52},{56,63,505},{56,63,505},{56,63,505},{54,63,160},{63,48,800},{51,63,320},{51,63,320},{33,63,1},{62,56,800},{33,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{46,0,1570}, |
| {46,0,1570},{46,0,1570},{46,0,1570},{42,63,410},{42,63,410},{42,63,410},{39,60,2},{29,63,52},{29,63,52},{53,63,3826},{51,63,3136},{51,63,2880},{49,63,1961},{51,63,3648},{46,63,1615},{46,63,1086},{41,63,5},{41,63,2588},{32,63,116},{59,63,498},{57,63,384},{57,63,320},{56,63,116},{63,55,683},{55,63,342},{54,63,208},{39,63,1},{63,59,683},{39,63,1},{51,63,2880},{51,63,2880},{51,63,2880}, |
| {49,63,1961},{48,63,2448},{46,63,1086},{46,63,1086},{41,63,5},{37,63,1558},{32,63,116},{57,63,320},{57,63,320},{57,63,320},{56,63,116},{63,51,512},{54,63,208},{54,63,208},{39,63,1},{63,57,512},{39,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{48,0,1568},{48,0,1568},{48,0,1568},{48,0,1568},{45,63,514}, |
| {45,63,514},{45,63,514},{41,62,2},{32,63,116},{32,63,116},{54,63,3232},{53,63,2781},{53,63,2585},{51,63,1856},{53,63,3067},{48,63,1456},{48,63,1056},{43,63,10},{44,63,2140},{35,63,212},{60,63,272},{59,63,221},{59,63,185},{57,63,64},{63,57,384},{57,63,192},{55,63,125},{45,63,1},{63,60,384},{45,63,1},{53,63,2585},{53,63,2585},{53,63,2585},{51,63,1856},{51,63,2112},{48,63,1056},{48,63,1056}, |
| {43,63,10},{40,63,1334},{35,63,212},{59,63,185},{59,63,185},{59,63,185},{57,63,64},{63,54,288},{55,63,125},{55,63,125},{45,63,1},{62,59,288},{45,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{50,0,1568},{50,0,1568},{50,0,1568},{50,0,1568},{46,63,605},{46,63,605},{46,63,605},{43,63,10},{35,63,212}, |
| {35,63,212},{0,51,2665},{0,36,306},{0,26,5},{0,22,965},{0,34,5885},{0,22,3726},{0,21,1754},{0,14,4398},{0,16,6359},{0,13,4722},{0,51,2665},{0,36,306},{0,26,5},{0,22,965},{17,0,5885},{0,22,3726},{0,21,1754},{0,14,4398},{34,0,5885},{0,14,4398},{0,25,0},{0,25,0},{0,25,0},{0,12,1},{0,12,545},{0,11,212},{0,11,212},{0,6,337},{0,5,605},{0,5,374},{0,25,0}, |
| {0,25,0},{0,25,0},{0,12,1},{6,0,545},{0,11,212},{0,11,212},{0,6,337},{12,0,545},{0,6,337},{26,0,2665},{0,36,306},{0,26,5},{0,22,965},{26,0,2665},{51,0,2665},{0,22,965},{0,17,2665},{51,0,2665},{0,17,2665},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,57,2665},{0,39,202},{0,29,13}, |
| {0,24,818},{0,39,6669},{0,25,3974},{0,22,1790},{0,16,4826},{0,18,7285},{0,16,5267},{0,57,2665},{0,39,202},{0,29,13},{0,24,818},{19,1,6669},{0,25,3974},{0,22,1790},{0,16,4826},{39,0,6669},{0,16,4826},{0,31,0},{0,31,0},{0,31,0},{0,15,1},{0,15,841},{0,12,337},{0,12,337},{0,7,493},{0,7,934},{0,7,574},{0,31,0},{0,31,0},{0,31,0},{0,15,1},{8,0,841}, |
| {0,12,337},{0,12,337},{0,7,493},{15,0,841},{0,7,493},{29,0,2665},{0,39,202},{1,28,2},{0,24,818},{29,0,2665},{57,0,2665},{0,24,818},{0,19,2665},{57,0,2665},{0,19,2665},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,63,2665},{0,44,116},{1,31,66},{0,27,698},{0,42,7541},{0,28,4254},{0,25,1854}, |
| {0,18,5281},{0,19,8271},{0,16,5795},{0,63,2665},{0,44,116},{1,31,50},{0,27,698},{15,13,7538},{0,28,4254},{0,25,1854},{0,18,5281},{31,6,7538},{0,18,5281},{0,36,1},{0,36,1},{0,36,1},{0,18,1},{0,18,1201},{0,14,468},{0,14,468},{0,8,730},{0,8,1325},{0,8,830},{0,36,1},{0,36,1},{0,36,1},{0,18,1},{9,0,1201},{0,14,468},{0,14,468},{0,8,730},{18,0,1201}, |
| {0,8,730},{32,0,2665},{0,44,116},{3,30,2},{0,27,698},{32,0,2665},{63,0,2665},{0,27,698},{0,21,2665},{63,0,2665},{0,21,2665},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{1,63,2781},{0,47,52},{1,33,148},{0,29,610},{0,46,8493},{0,31,4566},{0,27,1962},{0,18,5809},{0,22,9367},{0,18,6385},{2,63,2753}, |
| {0,47,52},{2,33,129},{0,29,610},{23,0,8493},{0,31,4566},{0,27,1962},{0,18,5809},{46,0,8493},{0,18,5809},{0,42,1},{0,42,1},{0,42,1},{0,21,1},{0,21,1625},{0,16,637},{0,16,637},{0,10,965},{0,10,1806},{0,10,1134},{0,42,1},{0,42,1},{0,42,1},{0,21,1},{11,0,1625},{0,16,637},{0,16,637},{0,10,965},{21,0,1625},{0,10,965},{35,0,2665},{0,47,52},{5,32,1}, |
| {0,29,610},{35,0,2665},{63,3,2665},{0,29,610},{0,23,2665},{63,3,2665},{0,23,2665},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{2,63,3105},{0,51,10},{1,35,297},{0,32,481},{0,51,9670},{0,33,4965},{0,30,2120},{0,21,6413},{0,24,10749},{0,19,7191},{3,63,2989},{0,51,10},{2,36,257},{0,32,481},{25,1,9669}, |
| {0,33,4965},{0,30,2120},{0,21,6413},{47,2,9669},{0,21,6413},{0,49,0},{0,49,0},{0,49,0},{0,25,1},{0,25,2178},{0,19,850},{0,19,850},{0,11,1325},{0,11,2406},{0,10,1521},{0,49,0},{0,49,0},{0,49,0},{0,25,1},{12,1,2178},{0,19,850},{0,19,850},{0,11,1325},{25,0,2178},{0,11,1325},{38,0,2665},{0,51,10},{8,34,2},{0,32,481},{38,0,2665},{62,7,2665},{0,32,481}, |
| {0,25,2669},{62,7,2665},{0,25,2669},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{3,63,3437},{1,54,33},{3,37,425},{1,33,457},{0,57,9670},{0,36,4629},{0,31,1654},{0,24,6165},{0,26,11014},{0,22,7031},{6,63,3101},{2,53,10},{4,38,257},{1,33,441},{28,1,9669},{0,36,4629},{0,31,1654},{0,24,6165},{47,5,9669}, |
| {0,24,6165},{1,53,32},{1,53,32},{1,53,32},{1,27,32},{0,31,2178},{0,22,666},{0,22,666},{0,13,1160},{0,14,2534},{0,13,1449},{2,51,0},{2,51,0},{2,51,0},{2,27,1},{15,1,2178},{0,22,666},{0,22,666},{0,13,1160},{31,0,2178},{0,13,1160},{41,0,2665},{1,54,1},{10,36,2},{0,33,394},{41,0,2665},{62,10,2665},{0,33,394},{0,27,2669},{62,10,2665},{0,27,2669},{1,0,32}, |
| {1,0,32},{1,0,32},{1,0,32},{0,6,0},{0,6,0},{0,6,0},{0,3,0},{0,2,13},{0,2,13},{6,63,3917},{2,57,129},{3,40,609},{1,36,497},{0,63,9670},{0,39,4325},{0,33,1274},{0,25,5878},{0,28,11299},{0,24,6917},{8,63,3233},{4,55,10},{6,40,257},{3,35,441},{31,1,9669},{0,39,4325},{0,33,1274},{0,25,5878},{47,8,9669},{0,25,5878},{2,57,128},{2,57,128},{2,57,128}, |
| {2,30,129},{0,36,2180},{0,28,490},{0,28,490},{0,16,1018},{0,16,2691},{0,14,1441},{4,53,0},{4,53,0},{4,53,0},{4,29,1},{15,7,2178},{0,28,490},{0,28,490},{0,16,1018},{31,3,2178},{0,16,1018},{44,0,2665},{3,56,1},{12,38,2},{0,36,306},{44,0,2665},{62,13,2665},{0,36,306},{0,29,2669},{62,13,2665},{0,29,2669},{2,0,128},{2,0,128},{2,0,128},{2,0,128},{0,12,0}, |
| {0,12,0},{0,12,0},{0,6,0},{0,5,45},{0,5,45},{6,63,4541},{3,59,297},{5,42,865},{3,38,625},{2,63,9749},{0,45,4021},{0,36,914},{0,27,5581},{0,31,11611},{0,27,6877},{11,63,3377},{6,57,10},{8,42,257},{5,37,441},{34,0,9669},{0,45,4021},{0,36,914},{0,27,5581},{47,11,9669},{0,27,5581},{3,61,288},{3,61,288},{3,61,288},{3,32,288},{0,42,2180},{0,31,338},{0,31,338}, |
| {0,18,865},{0,19,2875},{0,16,1427},{6,55,0},{6,55,0},{6,55,0},{6,31,1},{15,13,2178},{0,31,338},{0,31,338},{0,18,865},{31,6,2178},{0,18,865},{47,0,2665},{5,58,1},{14,40,2},{0,38,225},{47,0,2665},{62,16,2665},{0,38,225},{0,31,2669},{62,16,2665},{0,31,2669},{3,0,288},{3,0,288},{3,0,288},{3,0,288},{0,18,0},{0,18,0},{0,18,0},{0,9,0},{0,8,109}, |
| {0,8,109},{9,63,5374},{4,62,570},{6,44,1269},{4,40,841},{3,63,10021},{0,47,3745},{0,39,593},{0,30,5294},{0,36,12029},{0,28,6810},{14,63,3558},{8,59,9},{10,44,254},{7,39,446},{37,1,9669},{0,47,3745},{0,39,593},{0,30,5294},{63,6,9669},{0,30,5294},{4,63,561},{4,63,561},{4,63,561},{4,35,546},{0,49,2178},{0,34,218},{0,34,218},{0,21,725},{0,22,3117},{0,19,1433},{8,58,1}, |
| {8,58,1},{8,58,1},{8,33,2},{24,1,2178},{0,34,218},{0,34,218},{0,21,725},{49,0,2178},{0,21,725},{50,0,2665},{7,60,1},{16,42,5},{0,41,157},{50,0,2665},{62,19,2665},{0,41,157},{0,33,2669},{62,19,2665},{0,33,2669},{4,0,545},{4,0,545},{4,0,545},{4,0,545},{0,25,0},{0,25,0},{0,25,0},{0,12,1},{0,11,212},{0,11,212},{11,63,6350},{6,63,905},{7,47,1678}, |
| {4,42,1102},{6,63,10453},{0,50,3485},{0,42,361},{0,32,5054},{0,36,12429},{0,31,6794},{15,63,3710},{10,61,9},{12,46,254},{9,41,446},{40,1,9669},{0,50,3485},{0,42,361},{0,32,5054},{63,9,9669},{0,32,5054},{6,63,901},{6,63,901},{6,63,901},{5,37,842},{0,55,2178},{0,38,125},{0,38,125},{0,24,629},{0,25,3365},{0,22,1489},{10,60,1},{10,60,1},{10,60,1},{10,35,2},{27,1,2178}, |
| {0,38,125},{0,38,125},{0,24,629},{55,0,2178},{0,24,629},{53,0,2665},{9,62,1},{18,44,5},{0,43,117},{53,0,2665},{62,22,2665},{0,43,117},{0,35,2669},{62,22,2665},{0,35,2669},{5,0,841},{5,0,841},{5,0,841},{5,0,841},{0,31,0},{0,31,0},{0,31,0},{0,15,1},{0,12,337},{0,12,337},{12,63,7350},{7,63,1450},{9,48,2190},{6,44,1422},{6,63,11045},{0,53,3293},{0,45,193}, |
| {0,35,4870},{0,39,12829},{0,32,6807},{17,63,3905},{12,63,9},{14,48,267},{11,43,446},{43,1,9669},{0,53,3293},{0,45,193},{0,35,4870},{63,12,9669},{0,35,4870},{7,63,1369},{7,63,1369},{7,63,1369},{6,40,1202},{0,61,2178},{0,42,53},{0,42,53},{0,25,520},{0,28,3645},{0,24,1573},{12,62,1},{12,62,1},{12,62,1},{12,37,2},{30,1,2178},{0,42,53},{0,42,53},{0,25,520},{61,0,2178}, |
| {0,25,520},{56,0,2665},{12,63,8},{20,46,5},{0,45,72},{56,0,2665},{62,25,2665},{0,45,72},{0,37,2669},{62,25,2665},{0,37,2669},{6,0,1201},{6,0,1201},{6,0,1201},{6,0,1201},{0,36,1},{0,36,1},{0,36,1},{0,18,1},{0,14,468},{0,14,468},{14,63,8614},{9,63,2129},{9,51,2758},{6,47,1822},{9,63,11765},{0,57,3125},{0,47,81},{0,36,4629},{0,42,13261},{0,35,6855},{20,63,4081}, |
| {15,63,49},{16,50,257},{13,45,446},{46,1,9669},{0,57,3125},{0,47,81},{0,36,4629},{63,15,9669},{0,36,4629},{9,63,1933},{9,63,1933},{9,63,1933},{7,42,1626},{1,63,2212},{0,45,13},{0,45,13},{0,27,421},{0,31,3957},{0,25,1673},{14,63,2},{14,63,2},{14,63,2},{14,39,2},{33,1,2178},{0,45,13},{0,45,13},{0,27,421},{63,2,2178},{0,27,421},{59,0,2665},{15,63,40},{22,48,2}, |
| {0,47,45},{59,0,2665},{62,28,2665},{0,47,45},{0,39,2669},{62,28,2665},{0,39,2669},{7,0,1625},{7,0,1625},{7,0,1625},{7,0,1625},{0,42,1},{0,42,1},{0,42,1},{0,21,1},{0,16,637},{0,16,637},{15,63,10085},{11,63,3185},{11,53,3481},{8,49,2337},{11,63,12845},{0,62,2958},{0,50,14},{0,38,4381},{0,45,13802},{0,36,6942},{23,63,4318},{17,63,154},{18,52,254},{14,48,456},{49,1,9669}, |
| {0,62,2958},{0,50,14},{0,38,4381},{46,27,9669},{0,38,4381},{10,63,2717},{10,63,2717},{10,63,2717},{8,45,2180},{3,63,2394},{0,49,0},{0,49,0},{0,30,317},{0,33,4314},{0,28,1811},{17,63,10},{17,63,10},{17,63,10},{16,41,1},{31,12,2178},{0,49,0},{0,49,0},{0,30,317},{62,6,2178},{0,30,317},{62,1,2665},{20,63,113},{24,50,4},{0,50,13},{62,1,2665},{63,31,2665},{0,50,13}, |
| {0,42,2669},{63,31,2665},{0,42,2669},{8,0,2180},{8,0,2180},{8,0,2180},{8,0,2180},{0,49,0},{0,49,0},{0,49,0},{0,25,1},{0,19,850},{0,19,850},{17,63,11454},{12,63,4143},{12,55,4141},{9,51,2805},{12,63,13803},{0,63,2871},{1,52,18},{0,41,4182},{0,50,14186},{0,39,6911},{26,63,4550},{20,63,306},{20,54,254},{17,49,446},{52,1,9669},{0,63,2870},{1,52,9},{0,41,4181},{46,30,9669}, |
| {0,41,4181},{12,63,3414},{12,63,3414},{12,63,3414},{9,47,2673},{3,63,2691},{1,52,14},{1,52,14},{0,32,245},{0,36,4587},{0,31,1906},{19,63,25},{19,63,25},{19,63,25},{18,43,1},{31,18,2178},{2,51,0},{2,51,0},{0,32,244},{62,9,2178},{0,32,244},{63,5,2665},{23,63,193},{26,52,4},{0,52,4},{63,5,2665},{63,34,2665},{0,52,4},{0,44,2669},{63,34,2665},{0,44,2669},{9,0,2669}, |
| {9,0,2669},{9,0,2669},{9,0,2669},{0,55,1},{0,55,1},{0,55,1},{0,28,2},{0,22,1009},{0,22,1009},{20,63,11990},{15,63,4575},{14,57,4141},{11,53,2805},{15,63,14195},{3,63,3015},{3,54,18},{0,43,4122},{0,53,13674},{0,41,6249},{29,63,4814},{23,63,522},{22,56,254},{19,51,446},{55,1,9669},{3,63,3006},{3,54,9},{0,43,4041},{47,32,9669},{0,43,4041},{14,63,3561},{14,63,3561},{14,63,3561}, |
| {11,49,2670},{6,63,2795},{3,54,14},{3,54,14},{2,34,245},{0,39,4227},{0,33,1470},{21,63,58},{21,63,58},{21,63,58},{20,45,1},{34,17,2178},{4,53,0},{4,53,0},{0,35,180},{62,12,2178},{0,35,180},{63,11,2665},{26,63,305},{28,54,4},{2,54,4},{63,11,2665},{63,37,2665},{2,54,4},{0,46,2669},{63,37,2665},{0,46,2669},{11,0,2669},{11,0,2669},{11,0,2669},{11,0,2669},{2,57,1}, |
| {2,57,1},{2,57,1},{2,30,2},{0,25,801},{0,25,801},{22,63,12554},{17,63,5066},{16,59,4118},{13,55,2805},{17,63,14614},{6,63,3255},{5,56,18},{1,45,4078},{0,56,13194},{0,44,5633},{31,63,5090},{26,63,802},{24,58,254},{21,53,446},{58,1,9669},{7,63,3198},{5,56,9},{0,45,3846},{53,32,9669},{0,45,3846},{15,63,3710},{15,63,3710},{15,63,3710},{13,51,2670},{9,63,2931},{5,56,14},{5,56,14}, |
| {4,36,245},{0,42,3899},{0,36,1110},{23,63,90},{23,63,90},{23,63,90},{22,47,1},{37,17,2178},{6,55,0},{6,55,0},{0,37,136},{62,15,2178},{0,37,136},{63,17,2665},{30,63,442},{30,56,4},{4,56,4},{63,17,2665},{63,40,2665},{4,56,4},{0,47,2677},{63,40,2665},{0,47,2677},{13,0,2669},{13,0,2669},{13,0,2669},{13,0,2669},{4,59,1},{4,59,1},{4,59,1},{4,31,5},{0,28,625}, |
| {0,28,625},{23,63,13130},{20,63,5706},{18,61,4122},{15,57,2807},{20,63,15102},{9,63,3625},{7,59,15},{3,47,4086},{0,59,12686},{0,47,5027},{34,63,5386},{29,63,1169},{26,60,257},{23,56,446},{62,0,9669},{12,63,3469},{7,59,11},{0,47,3658},{62,31,9669},{0,47,3658},{17,63,3905},{17,63,3905},{17,63,3905},{16,53,2677},{12,63,3112},{7,58,9},{7,58,9},{6,38,246},{0,45,3576},{0,38,755},{26,63,136}, |
| {26,63,136},{26,63,136},{24,49,4},{49,0,2178},{8,57,2},{8,57,2},{0,39,85},{62,18,2178},{0,39,85},{63,23,2665},{34,63,628},{32,59,2},{4,59,2},{63,23,2665},{63,43,2665},{4,59,2},{0,50,2669},{63,43,2665},{0,50,2669},{15,0,2677},{15,0,2677},{15,0,2677},{15,0,2677},{7,60,4},{7,60,4},{7,60,4},{7,33,5},{0,33,424},{0,33,424},{26,63,13650},{23,63,6378},{20,63,4122}, |
| {17,59,2799},{23,63,15558},{12,63,4065},{9,61,15},{6,49,4074},{0,62,12278},{0,49,4534},{36,63,5698},{30,63,1556},{28,62,257},{25,58,446},{63,4,9669},{15,63,3749},{9,61,11},{0,49,3510},{62,34,9669},{0,49,3510},{20,63,4041},{20,63,4041},{20,63,4041},{17,56,2670},{15,63,3304},{9,60,9},{9,60,9},{8,40,246},{0,50,3317},{0,41,499},{29,63,200},{29,63,200},{29,63,200},{26,51,4},{52,0,2178}, |
| {10,59,2},{10,59,2},{0,42,45},{62,21,2178},{0,42,45},{63,29,2665},{37,63,820},{34,61,2},{6,61,2},{63,29,2665},{63,46,2665},{6,61,2},{0,52,2669},{63,46,2665},{0,52,2669},{17,0,2669},{17,0,2669},{17,0,2669},{17,0,2669},{9,62,4},{9,62,4},{9,62,4},{9,35,5},{0,36,296},{0,36,296},{29,63,14234},{23,63,7050},{23,63,4242},{19,61,2799},{26,63,16046},{15,63,4601},{11,63,15}, |
| {8,51,4074},{0,63,12051},{0,50,4110},{37,63,6002},{34,63,1989},{31,63,270},{27,60,446},{63,10,9669},{20,63,4081},{11,63,11},{0,52,3374},{62,37,9669},{0,52,3374},{23,63,4241},{23,63,4241},{23,63,4241},{19,58,2670},{17,63,3485},{11,62,9},{11,62,9},{10,42,246},{0,53,3069},{0,43,306},{31,63,269},{31,63,269},{31,63,269},{28,53,4},{55,0,2178},{12,61,2},{12,61,2},{0,44,18},{62,24,2178}, |
| {0,44,18},{63,35,2665},{41,63,1037},{36,63,2},{8,63,2},{63,35,2665},{63,49,2665},{8,63,2},{0,54,2669},{63,49,2665},{0,54,2669},{19,0,2669},{19,0,2669},{19,0,2669},{19,0,2669},{11,63,5},{11,63,5},{11,63,5},{11,37,5},{0,40,193},{0,40,193},{31,63,13639},{26,63,7005},{25,63,4454},{21,62,2721},{28,63,15204},{17,63,4285},{13,63,24},{9,52,3457},{0,63,11020},{0,52,3109},{40,63,5381}, |
| {34,63,1890},{33,63,346},{29,61,296},{62,16,8712},{23,63,3636},{14,63,2},{0,53,2676},{62,39,8712},{0,53,2676},{25,63,4454},{25,63,4454},{25,63,4454},{21,60,2670},{19,63,3707},{13,63,24},{13,63,24},{12,44,246},{0,56,2853},{0,45,153},{33,63,346},{33,63,346},{33,63,346},{30,55,4},{58,0,2178},{14,63,2},{14,63,2},{0,46,10},{62,27,2178},{0,46,10},{63,39,2178},{44,63,872},{39,63,1}, |
| {14,63,1},{63,39,2178},{47,59,2178},{14,63,1},{0,55,2180},{47,59,2178},{0,55,2180},{21,0,2669},{21,0,2669},{21,0,2669},{21,0,2669},{13,63,20},{13,63,20},{13,63,20},{13,39,5},{0,45,104},{0,45,104},{33,63,12766},{29,63,6930},{26,63,4694},{24,63,2685},{29,63,14014},{20,63,3898},{16,63,101},{13,53,2722},{3,63,10057},{0,54,2129},{43,63,4689},{37,63,1718},{36,63,452},{32,62,164},{63,19,7578}, |
| {26,63,3078},{18,63,17},{0,55,1905},{63,41,7578},{0,55,1905},{26,63,4694},{26,63,4694},{26,63,4694},{24,61,2670},{22,63,3960},{16,63,101},{16,63,101},{14,47,242},{0,59,2650},{0,48,49},{36,63,452},{36,63,452},{36,63,452},{33,57,4},{53,16,2178},{18,63,17},{18,63,17},{0,49,1},{63,30,2178},{0,49,1},{63,42,1625},{46,63,650},{42,63,0},{21,63,0},{63,42,1625},{62,53,1625},{21,63,0}, |
| {0,56,1625},{62,53,1625},{0,56,1625},{24,0,2669},{24,0,2669},{24,0,2669},{24,0,2669},{15,63,50},{15,63,50},{15,63,50},{15,42,2},{0,48,40},{0,48,40},{34,63,11970},{31,63,6969},{29,63,4878},{26,63,2670},{31,63,13161},{21,63,3638},{18,63,229},{15,55,2146},{6,63,9313},{0,56,1410},{43,63,4097},{40,63,1614},{37,63,541},{34,62,69},{58,32,6661},{29,63,2654},{21,63,65},{0,56,1346},{52,48,6661}, |
| {0,56,1346},{29,63,4878},{29,63,4878},{29,63,4878},{26,63,2670},{23,63,4206},{18,63,229},{18,63,229},{15,49,242},{0,62,2506},{0,51,9},{37,63,541},{37,63,541},{37,63,541},{35,59,4},{56,16,2178},{21,63,65},{21,63,65},{2,51,1},{62,33,2178},{2,51,1},{63,45,1201},{48,63,481},{45,63,0},{27,63,0},{63,45,1201},{63,54,1201},{27,63,0},{0,57,1201},{63,54,1201},{0,57,1201},{26,0,2669}, |
| {26,0,2669},{26,0,2669},{26,0,2669},{17,63,85},{17,63,85},{17,63,85},{16,44,4},{0,51,8},{0,51,8},{37,63,11370},{33,63,6958},{31,63,5145},{28,63,2718},{34,63,12263},{23,63,3410},{21,63,405},{17,56,1665},{9,63,8665},{0,57,905},{46,63,3585},{43,63,1574},{40,63,637},{36,63,20},{63,27,5829},{32,63,2294},{26,63,130},{0,57,901},{63,45,5829},{0,57,901},{31,63,5145},{31,63,5145},{31,63,5145}, |
| {28,63,2718},{26,63,4430},{21,63,405},{21,63,405},{18,50,246},{0,63,2520},{2,53,9},{40,63,637},{40,63,637},{40,63,637},{37,61,4},{59,16,2178},{26,63,130},{26,63,130},{4,53,1},{62,36,2178},{4,53,1},{63,48,841},{51,63,337},{48,63,1},{33,63,0},{63,48,841},{62,56,841},{33,63,0},{0,58,841},{62,56,841},{0,58,841},{28,0,2669},{28,0,2669},{28,0,2669},{28,0,2669},{20,63,117}, |
| {20,63,117},{20,63,117},{18,46,4},{1,54,1},{1,54,1},{37,63,10794},{34,63,6895},{34,63,5374},{30,63,2813},{36,63,11574},{26,63,3274},{23,63,622},{19,57,1222},{13,63,8106},{1,59,562},{48,63,3170},{43,63,1494},{43,63,765},{39,63,4},{63,31,5082},{34,63,1998},{29,63,218},{0,59,554},{63,47,5082},{0,59,554},{34,63,5374},{34,63,5374},{34,63,5374},{30,63,2813},{29,63,4686},{23,63,622},{23,63,622}, |
| {20,52,246},{4,63,2714},{4,55,9},{43,63,765},{43,63,765},{43,63,765},{39,63,4},{62,16,2178},{29,63,218},{29,63,218},{6,55,1},{62,39,2178},{6,55,1},{63,51,545},{54,63,225},{51,63,1},{39,63,0},{63,51,545},{63,57,545},{39,63,0},{0,59,545},{63,57,545},{0,59,545},{30,0,2669},{30,0,2669},{30,0,2669},{30,0,2669},{22,63,180},{22,63,180},{22,63,180},{21,47,5},{3,56,1}, |
| {3,56,1},{40,63,10197},{37,63,6930},{36,63,5678},{32,63,2993},{37,63,10780},{29,63,3229},{26,63,945},{21,59,853},{17,63,7593},{4,60,293},{48,63,2756},{46,63,1454},{45,63,914},{41,63,37},{63,35,4344},{38,63,1740},{32,63,360},{2,60,289},{63,49,4344},{2,60,289},{36,63,5678},{36,63,5678},{36,63,5678},{32,63,2993},{31,63,5067},{26,63,945},{26,63,945},{22,55,242},{9,63,2979},{6,57,10},{45,63,914}, |
| {45,63,914},{45,63,914},{41,63,37},{63,21,2178},{32,63,360},{32,63,360},{8,57,1},{63,42,2178},{8,57,1},{63,54,288},{55,63,125},{54,63,0},{45,63,1},{63,54,288},{62,59,288},{45,63,1},{0,60,288},{62,59,288},{0,60,288},{32,0,2669},{32,0,2669},{32,0,2669},{32,0,2669},{25,63,250},{25,63,250},{25,63,250},{23,50,2},{5,59,2},{5,59,2},{43,63,9837},{40,63,7042},{37,63,5945}, |
| {34,63,3198},{40,63,10204},{32,63,3344},{29,63,1289},{24,59,589},{20,63,7225},{7,61,130},{51,63,2436},{48,63,1460},{48,63,1060},{43,63,122},{63,39,3779},{41,63,1580},{37,63,505},{6,61,129},{47,59,3779},{6,61,129},{37,63,5945},{37,63,5945},{37,63,5945},{34,63,3198},{34,63,5304},{29,63,1289},{29,63,1289},{24,57,242},{13,63,3261},{8,59,10},{48,63,1060},{48,63,1060},{48,63,1060},{43,63,122},{63,27,2178}, |
| {37,63,505},{37,63,505},{10,59,1},{63,45,2178},{10,59,1},{63,57,128},{58,63,53},{57,63,0},{51,63,0},{63,57,128},{63,60,128},{51,63,0},{0,61,128},{63,60,128},{0,61,128},{34,0,2669},{34,0,2669},{34,0,2669},{34,0,2669},{27,63,337},{27,63,337},{27,63,337},{25,52,2},{7,61,2},{7,61,2},{43,63,9437},{40,63,7154},{40,63,6193},{37,63,3454},{42,63,9783},{34,63,3398},{32,63,1740}, |
| {26,61,397},{23,63,6953},{9,62,37},{53,63,2246},{51,63,1508},{50,63,1213},{46,63,250},{63,43,3299},{44,63,1484},{40,63,673},{10,62,33},{63,53,3299},{10,62,33},{40,63,6193},{40,63,6193},{40,63,6193},{37,63,3454},{37,63,5624},{32,63,1740},{32,63,1740},{26,59,242},{17,63,3589},{10,61,10},{50,63,1213},{50,63,1213},{50,63,1213},{46,63,250},{63,33,2178},{40,63,673},{40,63,673},{12,61,1},{47,56,2178}, |
| {12,61,1},{63,60,32},{61,63,13},{60,63,0},{57,63,0},{63,60,32},{62,62,32},{57,63,0},{0,62,32},{62,62,32},{0,62,32},{36,0,2669},{36,0,2669},{36,0,2669},{36,0,2669},{29,63,405},{29,63,405},{29,63,405},{27,54,2},{9,63,2},{9,63,2},{46,63,9141},{43,63,7234},{43,63,6505},{40,63,3806},{43,63,9340},{37,63,3622},{34,63,2149},{27,62,277},{27,63,6772},{12,63,10},{54,63,2052}, |
| {53,63,1601},{51,63,1348},{48,63,436},{63,47,2904},{47,63,1452},{44,63,872},{14,63,1},{63,55,2904},{14,63,1},{43,63,6505},{43,63,6505},{43,63,6505},{40,63,3806},{40,63,5976},{34,63,2149},{34,63,2149},{28,61,242},{21,63,3955},{12,63,10},{51,63,1348},{51,63,1348},{51,63,1348},{48,63,436},{63,39,2178},{44,63,872},{44,63,872},{14,63,1},{47,59,2178},{14,63,1},{63,63,0},{63,63,0},{63,63,0}, |
| {63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{38,0,2669},{38,0,2669},{38,0,2669},{38,0,2669},{32,63,520},{32,63,520},{32,63,520},{29,56,2},{12,63,10},{12,63,10},{46,63,8097},{46,63,6510},{43,63,5893},{41,63,3605},{46,63,8074},{37,63,3244},{37,63,2019},{30,62,129},{30,63,5794},{16,63,58},{56,63,1563},{54,63,1161},{54,63,1017},{51,63,337},{63,49,2166}, |
| {49,63,1083},{46,63,650},{21,63,0},{63,56,2166},{21,63,0},{43,63,5893},{43,63,5893},{43,63,5893},{41,63,3605},{40,63,5238},{37,63,2019},{37,63,2019},{30,62,113},{24,63,3401},{16,63,58},{54,63,1017},{54,63,1017},{54,63,1017},{51,63,337},{63,42,1625},{46,63,650},{46,63,650},{21,63,0},{62,53,1625},{21,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0}, |
| {0,63,0},{63,63,0},{0,63,0},{40,0,2665},{40,0,2665},{40,0,2665},{40,0,2665},{34,63,610},{34,63,610},{34,63,610},{31,58,0},{16,63,58},{16,63,58},{48,63,7165},{46,63,5854},{46,63,5325},{43,63,3434},{46,63,7050},{40,63,2932},{37,63,1955},{32,62,57},{32,63,5021},{20,63,117},{57,63,1137},{54,63,889},{54,63,745},{52,63,250},{63,51,1601},{51,63,801},{48,63,481},{27,63,0},{63,57,1601}, |
| {27,63,0},{46,63,5325},{46,63,5325},{46,63,5325},{43,63,3434},{43,63,4622},{37,63,1955},{37,63,1955},{32,62,41},{27,63,2977},{20,63,117},{54,63,745},{54,63,745},{54,63,745},{52,63,250},{63,45,1201},{48,63,481},{48,63,481},{27,63,0},{63,54,1201},{27,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{42,0,2665}, |
| {42,0,2665},{42,0,2665},{42,0,2665},{37,63,730},{37,63,730},{37,63,730},{33,60,1},{20,63,117},{20,63,117},{50,63,6415},{48,63,5277},{48,63,4877},{45,63,3330},{48,63,6117},{43,63,2716},{40,63,1843},{35,63,10},{35,63,4341},{23,63,205},{57,63,801},{57,63,609},{56,63,530},{54,63,169},{63,53,1121},{52,63,571},{51,63,337},{33,63,0},{63,58,1121},{33,63,0},{48,63,4877},{48,63,4877},{48,63,4877}, |
| {45,63,3330},{45,63,4146},{40,63,1843},{40,63,1843},{35,63,10},{30,63,2617},{23,63,205},{56,63,530},{56,63,530},{56,63,530},{54,63,169},{63,48,841},{51,63,337},{51,63,337},{33,63,0},{62,56,841},{33,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{44,0,2665},{44,0,2665},{44,0,2665},{44,0,2665},{39,63,865}, |
| {39,63,865},{39,63,865},{35,62,1},{23,63,205},{23,63,205},{51,63,5637},{50,63,4826},{48,63,4445},{47,63,3189},{48,63,5365},{43,63,2524},{43,63,1795},{37,63,5},{37,63,3750},{27,63,320},{59,63,531},{57,63,401},{57,63,337},{55,63,122},{63,55,726},{55,63,363},{54,63,225},{39,63,0},{63,59,726},{39,63,0},{48,63,4445},{48,63,4445},{48,63,4445},{47,63,3189},{46,63,3654},{43,63,1795},{43,63,1795}, |
| {37,63,5},{32,63,2329},{27,63,320},{57,63,337},{57,63,337},{57,63,337},{55,63,122},{63,51,545},{54,63,225},{54,63,225},{39,63,0},{63,57,545},{39,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{46,0,2665},{46,0,2665},{46,0,2665},{46,0,2665},{40,63,1010},{40,63,1010},{40,63,1010},{37,63,5},{27,63,320}, |
| {27,63,320},{3,63,10504},{0,62,1552},{0,44,169},{0,38,3866},{0,57,18065},{0,39,12152},{0,35,6099},{0,24,13992},{0,26,19423},{0,22,14922},{6,63,10216},{0,62,1552},{0,44,169},{0,38,3866},{20,17,18065},{0,39,12152},{0,35,6099},{0,24,13992},{57,0,18065},{0,24,13992},{0,35,0},{0,35,0},{0,35,0},{0,17,1},{0,17,1105},{0,14,424},{0,14,424},{0,8,666},{0,8,1217},{0,7,766},{0,35,0}, |
| {0,35,0},{0,35,0},{0,17,1},{9,0,1105},{0,14,424},{0,14,424},{0,8,666},{17,0,1105},{0,8,666},{34,17,9248},{0,62,1552},{0,44,169},{0,38,3866},{34,17,9248},{62,12,9248},{0,38,3866},{0,28,9256},{62,12,9248},{0,28,9256},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{5,63,11298},{0,63,1341},{0,47,65}, |
| {0,38,3578},{0,61,19334},{0,42,12584},{0,36,6093},{0,24,14696},{0,28,20850},{0,24,15720},{6,63,10792},{0,63,1341},{0,47,65},{0,38,3578},{30,1,19334},{0,42,12584},{0,36,6093},{0,24,14696},{61,0,19334},{0,24,14696},{0,41,0},{0,41,0},{0,41,0},{0,20,1},{0,20,1513},{0,16,585},{0,16,585},{0,10,901},{0,9,1681},{0,8,1070},{0,41,0},{0,41,0},{0,41,0},{0,20,1},{10,1,1513}, |
| {0,16,585},{0,16,585},{0,10,901},{20,0,1513},{0,10,901},{37,17,9248},{0,63,1341},{0,47,65},{0,38,3578},{37,17,9248},{62,15,9248},{0,38,3578},{0,30,9256},{62,15,9248},{0,30,9256},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{6,63,12200},{0,63,1325},{0,49,9},{0,41,3298},{0,63,20705},{0,42,13032},{0,38,6147}, |
| {0,27,15400},{0,31,22426},{0,25,16626},{9,63,11512},{0,63,1325},{0,49,9},{0,41,3298},{31,3,20689},{0,42,13032},{0,38,6147},{0,27,15400},{63,1,20689},{0,27,15400},{0,47,0},{0,47,0},{0,47,0},{0,23,1},{0,23,1985},{0,19,769},{0,19,769},{0,11,1202},{0,11,2193},{0,10,1374},{0,47,0},{0,47,0},{0,47,0},{0,23,1},{12,0,1985},{0,19,769},{0,19,769},{0,11,1202},{23,0,1985}, |
| {0,11,1202},{48,1,9248},{0,63,1325},{0,49,9},{0,41,3298},{48,1,9248},{63,17,9248},{0,41,3298},{0,32,9250},{63,17,9248},{0,32,9250},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{6,63,13288},{0,63,1565},{0,51,4},{0,44,3050},{2,63,22214},{0,45,13496},{0,41,6227},{0,28,16225},{0,31,24090},{0,27,17528},{9,63,12344}, |
| {0,63,1565},{0,51,4},{0,44,3050},{34,1,22129},{0,45,13496},{0,41,6227},{0,28,16225},{63,3,22129},{0,28,16225},{0,53,0},{0,53,0},{0,53,0},{0,26,1},{0,26,2521},{0,22,985},{0,22,985},{0,13,1517},{0,11,2801},{0,11,1766},{0,53,0},{0,53,0},{0,53,0},{0,26,1},{13,1,2521},{0,22,985},{0,22,985},{0,13,1517},{26,0,2521},{0,13,1517},{51,1,9248},{1,63,1552},{1,51,0}, |
| {0,44,3050},{51,1,9248},{63,20,9248},{0,44,3050},{0,34,9250},{63,20,9248},{0,34,9250},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{6,63,14818},{1,63,2106},{0,54,58},{0,47,2792},{3,63,24091},{0,50,14075},{0,42,6341},{0,30,17106},{0,33,26067},{0,28,18692},{12,63,13474},{3,63,2077},{1,54,50},{0,47,2792},{31,12,23851}, |
| {0,50,14075},{0,42,6341},{0,30,17106},{62,6,23851},{0,30,17106},{0,59,1},{0,59,1},{0,59,1},{0,30,0},{0,30,3200},{0,25,1258},{0,25,1258},{0,13,1940},{0,14,3542},{0,13,2229},{0,59,1},{0,59,1},{0,59,1},{0,30,0},{15,0,3200},{0,25,1258},{0,25,1258},{0,13,1940},{30,0,3200},{0,13,1940},{55,0,9248},{6,63,1885},{3,53,2},{0,47,2792},{55,0,9248},{62,24,9248},{0,47,2792}, |
| {0,36,9256},{62,24,9248},{0,36,9256},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{9,63,16258},{3,63,2813},{1,56,141},{0,49,2561},{4,63,25971},{0,50,14619},{0,45,6453},{0,32,17996},{0,36,27923},{0,30,19698},{12,63,14594},{3,63,2669},{2,56,122},{0,49,2561},{38,1,25472},{0,50,14619},{0,45,6453},{0,32,17996},{45,16,25472}, |
| {0,32,17996},{0,63,9},{0,63,9},{0,63,9},{0,33,1},{0,33,3872},{0,25,1530},{0,25,1530},{0,16,2378},{0,14,4294},{0,14,2717},{0,63,9},{0,63,9},{0,63,9},{0,33,1},{16,1,3872},{0,25,1530},{0,25,1530},{0,16,2378},{33,0,3872},{0,16,2378},{58,0,9248},{9,63,2205},{5,55,2},{0,49,2561},{58,0,9248},{62,27,9248},{0,49,2561},{0,38,9256},{62,27,9248},{0,38,9256},{0,0,0}, |
| {0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{9,63,17750},{3,63,3617},{1,58,254},{0,50,2366},{6,63,27563},{0,53,14891},{0,47,6385},{0,32,18616},{0,39,29523},{0,32,20465},{15,63,15654},{6,63,3425},{2,59,206},{0,50,2366},{41,0,26744},{0,53,14891},{0,47,6385},{0,32,18616},{62,10,26744},{0,32,18616},{1,63,101},{1,63,101},{1,63,101}, |
| {0,36,5},{0,36,4420},{0,28,1666},{0,28,1666},{0,16,2642},{0,16,4931},{0,16,3083},{2,63,72},{2,63,72},{2,63,72},{1,35,4},{15,7,4418},{0,28,1666},{0,28,1666},{0,16,2642},{31,3,4418},{0,16,2642},{61,0,9248},{13,63,2554},{7,57,2},{0,50,2362},{61,0,9248},{62,30,9248},{0,50,2362},{0,40,9256},{62,30,9248},{0,40,9256},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,2,0}, |
| {0,2,0},{0,2,0},{0,1,0},{0,1,1},{0,1,1},{12,63,19046},{4,63,4598},{3,60,382},{0,52,2237},{6,63,28187},{0,59,14347},{0,50,5579},{0,35,18104},{0,39,29955},{0,33,20313},{17,63,16091},{7,63,4046},{4,61,206},{0,52,2237},{44,0,26744},{0,59,14347},{0,50,5579},{0,35,18104},{62,13,26744},{0,35,18104},{2,63,264},{2,63,264},{2,63,264},{1,38,52},{0,42,4420},{0,33,1381},{0,33,1381}, |
| {0,18,2405},{0,19,5115},{0,18,2981},{4,63,117},{4,63,117},{4,63,117},{3,37,4},{15,13,4418},{0,33,1381},{0,33,1381},{0,18,2405},{31,6,4418},{0,18,2405},{63,2,9248},{17,63,2938},{9,59,2},{0,52,2137},{63,2,9248},{46,41,9248},{0,52,2137},{0,42,9256},{46,41,9248},{0,42,9256},{1,0,52},{1,0,52},{1,0,52},{1,0,52},{0,8,0},{0,8,0},{0,8,0},{0,4,0},{0,3,20}, |
| {0,3,20},{12,63,20585},{6,63,5786},{4,63,625},{1,56,2246},{9,63,29012},{0,62,13736},{0,53,4760},{0,38,17595},{0,45,30452},{0,36,20086},{20,63,16620},{9,63,4794},{6,63,205},{1,56,2230},{39,16,26744},{0,62,13736},{0,53,4760},{0,38,17595},{62,16,26744},{0,38,17595},{4,63,589},{4,63,589},{4,63,589},{2,41,185},{0,49,4418},{0,36,1097},{0,36,1097},{0,21,2153},{0,22,5357},{0,21,2937},{6,63,169}, |
| {6,63,169},{6,63,169},{5,39,2},{24,1,4418},{0,36,1097},{0,36,1097},{0,21,2153},{49,0,4418},{0,21,2153},{59,16,9248},{20,63,3380},{11,62,4},{0,55,1901},{59,16,9248},{62,36,9248},{0,55,1901},{0,45,9250},{62,36,9248},{0,45,9250},{2,0,185},{2,0,185},{2,0,185},{2,0,185},{0,14,1},{0,14,1},{0,14,1},{0,7,1},{0,5,72},{0,5,72},{15,63,21605},{9,63,6850},{5,63,978}, |
| {2,57,2226},{11,63,29435},{0,63,12990},{0,55,3962},{0,41,16835},{0,45,30392},{0,38,19516},{22,63,16694},{12,63,5218},{9,63,225},{4,56,2130},{49,1,26259},{0,63,12990},{0,55,3962},{0,41,16835},{46,27,26259},{0,41,16835},{5,63,978},{5,63,978},{5,63,978},{3,43,370},{0,55,4418},{0,39,881},{0,39,881},{0,24,1945},{0,25,5605},{0,22,2889},{9,63,225},{9,63,225},{9,63,225},{7,41,2},{27,1,4418}, |
| {0,39,881},{0,39,881},{0,24,1945},{55,0,4418},{0,24,1945},{63,14,8978},{23,63,3592},{14,63,1},{0,58,1625},{63,14,8978},{46,47,8978},{0,58,1625},{0,46,8986},{46,47,8978},{0,46,8986},{3,0,369},{3,0,369},{3,0,369},{3,0,369},{0,20,0},{0,20,0},{0,20,0},{0,10,1},{0,8,136},{0,8,136},{15,63,21141},{9,63,7026},{6,63,1481},{3,58,2034},{12,63,28216},{0,63,11406},{0,56,2868}, |
| {0,41,14915},{0,48,28876},{0,39,17854},{23,63,15352},{15,63,4866},{11,63,306},{6,58,1746},{52,0,24371},{0,63,11406},{0,56,2868},{0,41,14915},{62,21,24371},{0,41,14915},{6,63,1481},{6,63,1481},{6,63,1481},{4,46,617},{0,61,4418},{0,45,689},{0,45,689},{0,27,1769},{0,28,5885},{0,24,2889},{11,63,306},{11,63,306},{11,63,306},{9,43,2},{30,1,4418},{0,45,689},{0,45,689},{0,27,1769},{61,0,4418}, |
| {0,27,1769},{55,32,7938},{26,63,3176},{16,63,1},{0,58,1129},{55,32,7938},{46,48,7938},{0,58,1129},{0,47,7946},{46,48,7938},{0,47,7946},{4,0,617},{4,0,617},{4,0,617},{4,0,617},{0,26,0},{0,26,0},{0,26,0},{0,13,1},{0,11,232},{0,11,232},{17,63,20849},{9,63,7458},{8,63,2106},{4,59,1970},{12,63,27224},{0,63,10078},{0,58,1986},{0,42,13214},{0,50,27357},{0,41,16276},{26,63,14168}, |
| {17,63,4556},{14,63,394},{9,58,1410},{47,14,22568},{0,63,10078},{0,58,1986},{0,42,13214},{62,23,22568},{0,42,13214},{8,63,2106},{8,63,2106},{8,63,2106},{5,48,930},{1,63,4452},{0,47,521},{0,47,521},{0,28,1600},{0,31,6197},{0,27,2921},{14,63,394},{14,63,394},{14,63,394},{11,45,2},{33,1,4418},{0,47,521},{0,47,521},{0,28,1600},{63,2,4418},{0,28,1600},{56,33,6962},{29,63,2792},{19,63,1}, |
| {0,59,740},{56,33,6962},{49,48,6962},{0,59,740},{0,48,6964},{49,48,6962},{0,48,6964},{5,0,929},{5,0,929},{5,0,929},{5,0,929},{0,32,0},{0,32,0},{0,32,0},{0,16,0},{0,14,360},{0,14,360},{17,63,20651},{12,63,7922},{9,63,2921},{5,60,2052},{15,63,26270},{0,63,8890},{0,59,1154},{0,44,11309},{0,53,25875},{0,42,14658},{26,63,12890},{20,63,4254},{16,63,493},{10,59,1076},{56,0,20642}, |
| {0,63,8890},{0,59,1154},{0,44,11309},{62,25,20642},{0,44,11309},{9,63,2921},{9,63,2921},{9,63,2921},{6,51,1360},{3,63,4634},{0,50,346},{0,50,346},{0,31,1402},{0,33,6554},{0,28,2987},{16,63,493},{16,63,493},{16,63,493},{13,48,1},{31,12,4418},{0,50,346},{0,50,346},{0,31,1402},{62,6,4418},{0,31,1402},{63,23,5941},{30,63,2386},{23,63,1},{0,61,388},{63,23,5941},{63,43,5941},{0,61,388}, |
| {0,49,5945},{63,43,5941},{0,49,5945},{6,0,1360},{6,0,1360},{6,0,1360},{6,0,1360},{0,39,0},{0,39,0},{0,39,0},{0,19,1},{0,16,522},{0,16,522},{20,63,20683},{12,63,8578},{11,63,3792},{7,60,2241},{15,63,25566},{1,63,8090},{0,59,642},{0,45,9834},{0,53,24595},{0,44,13350},{29,63,11794},{20,63,4030},{17,63,610},{13,59,804},{58,0,19021},{3,63,8050},{0,59,642},{0,45,9834},{62,27,19021}, |
| {0,45,9834},{11,63,3792},{11,63,3792},{11,63,3792},{8,53,1808},{3,63,4954},{0,55,232},{0,55,232},{0,33,1241},{0,36,6922},{0,31,3051},{17,63,610},{17,63,610},{17,63,610},{15,50,1},{31,18,4418},{0,55,232},{0,55,232},{0,33,1241},{62,9,4418},{0,33,1241},{63,26,5101},{34,63,2050},{26,63,1},{0,61,164},{63,26,5101},{62,45,5101},{0,61,164},{0,50,5105},{62,45,5101},{0,50,5105},{7,0,1808}, |
| {7,0,1808},{7,0,1808},{7,0,1808},{0,45,0},{0,45,0},{0,45,0},{0,22,1},{0,19,706},{0,19,706},{20,63,20715},{15,63,9258},{12,63,4729},{8,61,2553},{17,63,25067},{3,63,7474},{0,61,264},{0,47,8373},{0,56,23451},{0,45,12138},{31,63,10854},{23,63,3766},{20,63,698},{16,60,594},{60,0,17485},{6,63,7274},{0,61,264},{0,47,8373},{56,32,17485},{0,47,8373},{12,63,4729},{12,63,4729},{12,63,4729}, |
| {8,56,2320},{6,63,5386},{0,59,130},{0,59,130},{0,35,1076},{0,39,7322},{0,33,3161},{20,63,698},{20,63,698},{20,63,698},{17,51,2},{34,17,4418},{0,59,130},{0,59,130},{0,35,1076},{62,12,4418},{0,35,1076},{63,29,4325},{35,63,1733},{29,63,1},{0,62,41},{63,29,4325},{63,46,4325},{0,62,41},{0,51,4329},{63,46,4325},{0,51,4329},{8,0,2320},{8,0,2320},{8,0,2320},{8,0,2320},{0,50,1}, |
| {0,50,1},{0,50,1},{0,25,1},{0,19,914},{0,19,914},{20,63,21003},{15,63,10106},{14,63,5840},{9,62,2993},{17,63,24683},{3,63,7010},{0,62,74},{0,49,7113},{0,56,22427},{0,47,11094},{33,63,9941},{26,63,3566},{23,63,818},{17,61,402},{62,0,16034},{9,63,6562},{0,62,74},{0,49,7113},{62,31,16034},{0,49,7113},{14,63,5840},{14,63,5840},{14,63,5840},{10,58,2896},{6,63,5962},{0,62,58},{0,62,58}, |
| {0,38,932},{0,42,7754},{0,35,3317},{23,63,818},{23,63,818},{23,63,818},{19,53,2},{37,17,4418},{0,62,58},{0,62,58},{0,38,932},{62,15,4418},{0,38,932},{63,32,3613},{38,63,1445},{32,63,1},{0,63,0},{63,32,3613},{61,48,3613},{0,63,0},{0,52,3617},{61,48,3613},{0,52,3617},{9,0,2896},{9,0,2896},{9,0,2896},{9,0,2896},{0,56,1},{0,56,1},{0,56,1},{0,28,1},{0,22,1130}, |
| {0,22,1130},{23,63,21401},{17,63,11165},{15,63,7141},{10,63,3641},{20,63,24533},{6,63,6762},{0,63,81},{0,49,5745},{0,59,21333},{0,47,9996},{34,63,8897},{29,63,3396},{26,63,976},{20,61,224},{56,16,14504},{12,63,5834},{1,63,68},{0,49,5745},{62,33,14504},{0,49,5745},{15,63,7141},{15,63,7141},{15,63,7141},{11,61,3617},{9,63,6772},{0,63,81},{0,63,81},{0,41,794},{0,45,8260},{0,38,3515},{26,63,976}, |
| {26,63,976},{26,63,976},{21,56,0},{49,0,4418},{1,63,68},{1,63,68},{0,41,794},{62,18,4418},{0,41,794},{63,35,2888},{41,63,1156},{35,63,0},{7,63,0},{63,35,2888},{63,49,2888},{7,63,0},{0,53,2896},{63,49,2888},{0,53,2896},{11,0,3617},{11,0,3617},{11,0,3617},{11,0,3617},{0,63,0},{0,63,0},{0,63,0},{0,32,1},{0,25,1413},{0,25,1413},{23,63,21913},{17,63,12317},{17,63,8473}, |
| {12,63,4330},{20,63,24437},{6,63,6650},{2,63,298},{0,52,4721},{0,62,20509},{0,49,9157},{37,63,8153},{29,63,3268},{28,63,1129},{23,61,128},{63,6,13235},{15,63,5258},{6,63,145},{0,52,4721},{62,35,13235},{0,52,4721},{17,63,8473},{17,63,8473},{17,63,8473},{12,63,4330},{9,63,7636},{2,63,298},{2,63,298},{0,42,689},{0,45,8740},{0,39,3689},{28,63,1129},{28,63,1129},{28,63,1129},{23,58,0},{52,0,4418}, |
| {6,63,145},{6,63,145},{0,42,689},{62,21,4418},{0,42,689},{63,38,2312},{43,63,925},{38,63,0},{13,63,0},{63,38,2312},{62,51,2312},{13,63,0},{0,54,2320},{62,51,2312},{0,54,2320},{12,0,4329},{12,0,4329},{12,0,4329},{12,0,4329},{1,63,52},{1,63,52},{1,63,52},{0,34,1},{0,28,1693},{0,28,1693},{26,63,22641},{20,63,13461},{17,63,9881},{13,63,5169},{20,63,24597},{6,63,6794},{3,63,649}, |
| {0,52,3713},{0,62,19773},{0,50,8413},{37,63,7401},{32,63,3181},{29,63,1280},{24,62,48},{63,11,12051},{18,63,4746},{9,63,233},{0,52,3713},{47,45,12051},{0,52,3713},{17,63,9881},{17,63,9881},{17,63,9881},{13,63,5169},{12,63,8644},{3,63,649},{3,63,649},{0,45,569},{0,50,9245},{0,42,3905},{29,63,1280},{29,63,1280},{29,63,1280},{25,60,0},{55,0,4418},{9,63,233},{9,63,233},{0,45,569},{62,24,4418}, |
| {0,45,569},{63,41,1800},{46,63,725},{41,63,0},{19,63,0},{63,41,1800},{63,52,1800},{19,63,0},{0,55,1808},{63,52,1800},{0,55,1808},{13,0,5105},{13,0,5105},{13,0,5105},{13,0,5105},{2,63,185},{2,63,185},{2,63,185},{0,37,1},{0,31,2005},{0,31,2005},{26,63,23345},{20,63,14805},{20,63,11441},{14,63,6170},{23,63,24893},{9,63,7066},{4,63,1236},{0,53,2900},{0,63,19260},{0,52,7861},{40,63,6753}, |
| {34,63,3038},{32,63,1465},{27,63,9},{62,16,10952},{21,63,4298},{12,63,353},{0,53,2900},{62,39,10952},{0,53,2900},{20,63,11441},{20,63,11441},{20,63,11441},{14,63,6170},{12,63,9764},{4,63,1236},{4,63,1236},{0,47,458},{0,50,9789},{0,45,4185},{32,63,1465},{32,63,1465},{32,63,1465},{27,62,0},{58,0,4418},{12,63,353},{12,63,353},{0,47,458},{62,27,4418},{0,47,458},{63,44,1352},{48,63,544},{44,63,0}, |
| {25,63,0},{63,44,1352},{62,54,1352},{25,63,0},{0,56,1360},{62,54,1352},{0,56,1360},{14,0,5945},{14,0,5945},{14,0,5945},{14,0,5945},{3,63,400},{3,63,400},{3,63,400},{0,40,1},{0,33,2336},{0,33,2336},{26,63,24443},{23,63,16415},{20,63,13259},{15,63,7448},{23,63,25379},{9,63,7606},{6,63,2021},{0,55,2045},{0,63,18918},{0,53,7275},{40,63,6141},{37,63,2978},{34,63,1625},{29,63,10},{63,19,9818}, |
| {24,63,3870},{17,63,530},{0,55,2045},{63,41,9818},{0,55,2045},{20,63,13259},{20,63,13259},{20,63,13259},{15,63,7448},{15,63,11218},{6,63,2021},{6,63,2021},{0,49,365},{0,53,10427},{0,45,4509},{34,63,1625},{34,63,1625},{34,63,1625},{29,63,10},{53,16,4418},{17,63,530},{17,63,530},{0,49,365},{63,30,4418},{0,49,365},{63,47,925},{51,63,377},{47,63,1},{31,63,1},{63,47,925},{63,55,925},{31,63,1}, |
| {0,58,929},{63,55,925},{0,58,929},{15,0,6964},{15,0,6964},{15,0,6964},{15,0,6964},{3,63,769},{3,63,769},{3,63,769},{0,44,0},{0,36,2745},{0,36,2745},{29,63,25483},{23,63,17983},{22,63,15066},{17,63,8739},{23,63,26083},{12,63,8302},{6,63,2965},{0,56,1458},{0,63,18886},{0,53,6955},{43,63,5581},{40,63,2986},{37,63,1801},{32,63,65},{58,32,8901},{27,63,3558},{20,63,698},{0,56,1458},{52,48,8901}, |
| {0,56,1458},{22,63,15066},{22,63,15066},{22,63,15066},{17,63,8739},{15,63,12626},{6,63,2965},{6,63,2965},{0,52,277},{0,56,11011},{0,49,4833},{37,63,1801},{37,63,1801},{37,63,1801},{32,63,65},{56,16,4418},{20,63,698},{20,63,698},{0,52,277},{62,33,4418},{0,52,277},{63,50,613},{52,63,250},{50,63,0},{37,63,0},{63,50,613},{62,57,613},{37,63,0},{0,59,617},{62,57,613},{0,59,617},{16,0,7946}, |
| {16,0,7946},{16,0,7946},{16,0,7946},{5,63,1184},{5,63,1184},{5,63,1184},{0,47,0},{0,36,3145},{0,36,3145},{29,63,26667},{26,63,19695},{23,63,16891},{18,63,10206},{26,63,26795},{12,63,9118},{9,63,4037},{0,58,933},{0,63,19110},{0,56,6699},{46,63,5181},{40,63,2970},{40,63,2009},{34,63,160},{63,27,8069},{30,63,3310},{23,63,898},{0,58,933},{63,45,8069},{0,58,933},{23,63,16891},{23,63,16891},{23,63,16891}, |
| {18,63,10206},{17,63,14179},{9,63,4037},{9,63,4037},{0,55,221},{0,59,11627},{0,50,5115},{40,63,2009},{40,63,2009},{40,63,2009},{34,63,160},{59,16,4418},{23,63,898},{23,63,898},{0,55,221},{62,36,4418},{0,55,221},{63,53,365},{55,63,146},{53,63,0},{43,63,0},{63,53,365},{63,58,365},{43,63,0},{0,60,369},{63,58,365},{0,60,369},{16,0,8986},{16,0,8986},{16,0,8986},{16,0,8986},{6,63,1665}, |
| {6,63,1665},{6,63,1665},{0,50,1},{0,39,3545},{0,39,3545},{31,63,26643},{26,63,20231},{26,63,17731},{20,63,10867},{26,63,26531},{15,63,9546},{12,63,4889},{0,59,590},{0,63,18606},{0,56,5707},{46,63,4781},{43,63,2978},{42,63,2228},{37,63,320},{63,31,7322},{32,63,3134},{27,63,1125},{0,59,554},{63,47,7322},{0,59,554},{26,63,17731},{26,63,17731},{26,63,17731},{20,63,10867},{20,63,15043},{12,63,4889},{12,63,4889}, |
| {1,56,185},{0,62,11315},{0,53,4667},{42,63,2228},{42,63,2228},{42,63,2228},{37,63,320},{62,16,4418},{27,63,1125},{27,63,1125},{0,56,162},{62,39,4418},{0,56,162},{63,56,181},{57,63,73},{56,63,0},{49,63,0},{63,56,181},{62,60,181},{49,63,0},{0,61,185},{62,60,181},{0,61,185},{18,0,9250},{18,0,9250},{18,0,9250},{18,0,9250},{8,63,1972},{8,63,1972},{8,63,1972},{1,52,4},{0,42,3341}, |
| {0,42,3341},{34,63,26006},{29,63,20400},{28,63,18273},{23,63,11384},{29,63,25736},{17,63,9864},{12,63,5726},{2,60,366},{0,63,18111},{0,59,4452},{48,63,4436},{46,63,3050},{43,63,2465},{40,63,562},{63,35,6584},{37,63,3006},{30,63,1421},{0,61,237},{63,49,6584},{0,61,237},{28,63,18273},{28,63,18273},{28,63,18273},{23,63,11384},{23,63,15704},{12,63,5726},{12,63,5726},{3,59,189},{0,63,10886},{0,56,3924},{43,63,2465}, |
| {43,63,2465},{43,63,2465},{40,63,562},{63,21,4418},{30,63,1421},{30,63,1421},{0,59,100},{63,42,4418},{0,59,100},{63,59,52},{60,63,20},{59,63,1},{56,63,0},{63,59,52},{63,61,52},{56,63,0},{0,62,52},{63,61,52},{0,62,52},{20,0,9256},{20,0,9256},{20,0,9256},{20,0,9256},{9,63,2205},{9,63,2205},{9,63,2205},{4,54,1},{0,45,2925},{0,45,2925},{34,63,25526},{31,63,20721},{29,63,18700}, |
| {24,63,11921},{31,63,25279},{20,63,10264},{15,63,6494},{4,62,238},{4,63,17924},{0,59,3588},{51,63,4228},{48,63,3140},{46,63,2665},{41,63,833},{63,39,6019},{40,63,2958},{34,63,1693},{0,62,84},{47,59,6019},{0,62,84},{29,63,18700},{29,63,18700},{29,63,18700},{24,63,11921},{23,63,16280},{15,63,6494},{15,63,6494},{5,61,189},{0,63,10854},{0,59,3332},{46,63,2665},{46,63,2665},{46,63,2665},{41,63,833},{63,27,4418}, |
| {34,63,1693},{34,63,1693},{0,61,61},{63,45,4418},{0,61,61},{63,62,4},{63,63,4},{62,63,1},{62,63,0},{63,62,4},{62,63,4},{62,63,0},{0,63,4},{62,63,4},{0,63,4},{22,0,9256},{22,0,9256},{22,0,9256},{22,0,9256},{12,63,2389},{12,63,2389},{12,63,2389},{6,56,1},{0,50,2512},{0,50,2512},{37,63,24250},{34,63,19895},{31,63,18169},{26,63,11820},{34,63,23717},{20,63,10012},{17,63,6584}, |
| {7,62,122},{6,63,16879},{0,62,2736},{51,63,3648},{48,63,2784},{48,63,2384},{43,63,778},{63,42,5163},{41,63,2584},{37,63,1549},{0,63,9},{46,61,5163},{0,63,9},{31,63,18169},{31,63,18169},{31,63,18169},{26,63,11820},{26,63,15620},{17,63,6584},{17,63,6584},{7,62,106},{0,63,10150},{0,59,2624},{48,63,2384},{48,63,2384},{48,63,2384},{43,63,778},{63,31,3872},{37,63,1549},{37,63,1549},{0,63,9},{63,47,3872}, |
| {0,63,9},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{24,0,9256},{24,0,9256},{24,0,9256},{24,0,9256},{15,63,2605},{15,63,2605},{15,63,2605},{8,58,1},{0,53,2176},{0,53,2176},{37,63,22746},{34,63,18775},{34,63,17254},{29,63,11564},{34,63,21973},{23,63,9532},{20,63,6424},{9,62,57},{9,63,15607},{0,62,2032},{53,63,3058}, |
| {51,63,2304},{48,63,2000},{46,63,650},{63,43,4267},{43,63,2134},{40,63,1285},{4,63,0},{63,53,4267},{4,63,0},{34,63,17254},{34,63,17254},{34,63,17254},{29,63,11564},{29,63,14692},{20,63,6424},{20,63,6424},{9,62,41},{0,63,9366},{0,62,2016},{48,63,2000},{48,63,2000},{48,63,2000},{46,63,650},{55,49,3200},{40,63,1285},{40,63,1285},{4,63,0},{63,48,3200},{4,63,0},{63,63,0},{63,63,0},{63,63,0}, |
| {63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{26,0,9256},{26,0,9256},{26,0,9256},{26,0,9256},{17,63,2836},{17,63,2836},{17,63,2836},{10,60,1},{0,59,1856},{0,59,1856},{40,63,21168},{37,63,17685},{34,63,16300},{30,63,11323},{37,63,20205},{26,63,9090},{23,63,6310},{12,63,4},{12,63,14287},{0,62,1546},{54,63,2377},{51,63,1809},{51,63,1553},{47,63,520},{61,49,3361}, |
| {46,63,1683},{43,63,1018},{11,63,0},{63,54,3361},{11,63,0},{34,63,16300},{34,63,16300},{34,63,16300},{30,63,11323},{29,63,13666},{23,63,6310},{23,63,6310},{12,63,4},{3,63,8686},{0,62,1530},{51,63,1553},{51,63,1553},{51,63,1553},{47,63,520},{63,37,2521},{43,63,1018},{43,63,1018},{11,63,0},{62,50,2521},{11,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0}, |
| {0,63,0},{63,63,0},{0,63,0},{29,0,9250},{29,0,9250},{29,0,9250},{29,0,9250},{20,63,3114},{20,63,3114},{20,63,3114},{12,62,1},{0,62,1514},{0,62,1514},{40,63,19824},{37,63,16725},{37,63,15500},{32,63,11084},{37,63,18685},{26,63,8770},{26,63,6270},{14,63,16},{15,63,13215},{0,63,1325},{54,63,1881},{54,63,1449},{51,63,1249},{48,63,409},{63,47,2649},{47,63,1329},{44,63,797},{16,63,1},{63,55,2649}, |
| {16,63,1},{37,63,15500},{37,63,15500},{37,63,15500},{32,63,11084},{31,63,12906},{26,63,6270},{26,63,6270},{14,63,16},{6,63,8150},{0,63,1325},{51,63,1249},{51,63,1249},{51,63,1249},{48,63,409},{63,40,1985},{44,63,797},{44,63,797},{16,63,1},{63,51,1985},{16,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{31,0,9250}, |
| {31,0,9250},{31,0,9250},{31,0,9250},{22,63,3393},{22,63,3393},{22,63,3393},{14,63,16},{0,63,1325},{0,63,1325},{43,63,18608},{40,63,15853},{37,63,14796},{34,63,10841},{40,63,17341},{29,63,8410},{26,63,6206},{17,63,74},{17,63,12226},{0,63,1341},{56,63,1451},{54,63,1081},{54,63,937},{51,63,305},{63,50,2017},{49,63,1011},{47,63,605},{22,63,1},{62,57,2017},{22,63,1},{37,63,14796},{37,63,14796},{37,63,14796}, |
| {34,63,10841},{34,63,12089},{26,63,6206},{26,63,6206},{17,63,74},{9,63,7678},{0,63,1341},{54,63,937},{54,63,937},{54,63,937},{51,63,305},{63,43,1513},{47,63,605},{47,63,605},{22,63,1},{62,53,1513},{22,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{32,0,9256},{32,0,9256},{32,0,9256},{32,0,9256},{23,63,3650}, |
| {23,63,3650},{23,63,3650},{17,63,74},{0,63,1341},{0,63,1341},{43,63,17392},{40,63,15021},{40,63,14060},{37,63,10673},{40,63,16013},{32,63,8261},{29,63,6166},{19,63,194},{20,63,11338},{1,63,1594},{57,63,1041},{56,63,822},{54,63,697},{52,63,234},{63,51,1473},{51,63,737},{49,63,442},{28,63,1},{63,57,1473},{28,63,1},{40,63,14060},{40,63,14060},{40,63,14060},{37,63,10673},{34,63,11401},{29,63,6166},{29,63,6166}, |
| {19,63,194},{12,63,7270},{1,63,1594},{54,63,697},{54,63,697},{54,63,697},{52,63,234},{63,46,1105},{49,63,442},{49,63,442},{28,63,1},{63,54,1105},{28,63,1},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{63,63,0},{0,63,0},{63,63,0},{0,63,0},{34,0,9256},{34,0,9256},{34,0,9256},{34,0,9256},{26,63,3898},{26,63,3898},{26,63,3898},{19,63,194},{1,63,1594}, |
| {1,63,1594}, |
| /**** ended inlining basisu_transcoder_tables_dxt1_6.inc ****/ |
| }; |
| |
| static const etc1_to_dxt1_56_solution g_etc1_to_dxt_5[32 * 8 * NUM_ETC1_TO_DXT1_SELECTOR_MAPPINGS * NUM_ETC1_TO_DXT1_SELECTOR_RANGES] = { |
| /**** start inlining basisu_transcoder_tables_dxt1_5.inc ****/ |
| // Copyright (C) 2017-2019 Binomial LLC. All Rights Reserved. |
| // |
| // Licensed 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. |
| {0,2,18},{0,1,9},{0,1,0},{0,1,9},{0,1,40},{0,1,22},{0,1,13},{0,1,61},{0,1,47},{0,1,65},{0,2,18},{0,1,9},{0,1,0},{0,1,9},{0,1,40},{0,1,22},{0,1,13},{0,1,61},{1,0,40},{0,1,61},{0,1,0},{0,1,0},{0,1,0},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,1,0}, |
| {0,1,0},{0,1,0},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{0,0,4},{1,0,18},{0,1,9},{0,1,0},{0,1,9},{1,0,18},{2,0,18},{0,1,9},{0,1,36},{2,0,18},{0,1,36},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,5,54},{0,3,40},{0,2,61}, |
| {0,2,36},{0,4,51},{0,2,37},{0,2,1},{0,2,52},{0,2,77},{0,1,73},{1,3,22},{1,2,13},{1,2,4},{1,2,13},{0,4,51},{1,2,34},{0,2,1},{0,2,52},{4,0,51},{0,2,52},{0,4,37},{0,4,37},{0,4,37},{0,2,36},{0,3,8},{0,2,1},{0,2,1},{0,1,5},{0,1,30},{0,1,9},{1,2,4},{1,2,4},{1,2,4},{1,1,8},{1,1,8}, |
| {0,2,1},{0,2,1},{0,1,5},{3,0,8},{0,1,5},{2,1,18},{0,3,4},{1,2,0},{0,2,0},{2,1,18},{5,0,18},{0,2,0},{0,2,36},{5,0,18},{0,2,36},{0,0,36},{0,0,36},{0,0,36},{0,0,36},{0,2,1},{0,2,1},{0,2,1},{0,1,1},{0,1,5},{0,1,5},{1,6,54},{1,4,40},{1,3,61},{1,3,36},{1,5,51},{1,3,37},{1,3,1}, |
| {1,3,52},{0,3,72},{0,3,40},{2,4,22},{2,3,13},{2,3,4},{2,3,13},{1,5,51},{0,4,29},{1,3,1},{0,3,40},{7,0,51},{0,3,40},{1,5,37},{1,5,37},{1,5,37},{1,3,36},{1,4,8},{1,3,1},{1,3,1},{1,2,5},{0,3,8},{1,2,9},{2,3,4},{2,3,4},{2,3,4},{2,2,8},{3,0,8},{1,3,1},{1,3,1},{1,2,5},{6,0,8}, |
| {1,2,5},{3,2,18},{1,4,4},{2,3,0},{1,3,0},{3,2,18},{6,1,18},{1,3,0},{0,3,36},{6,1,18},{0,3,36},{1,0,36},{1,0,36},{1,0,36},{1,0,36},{1,3,1},{1,3,1},{1,3,1},{1,2,1},{0,3,4},{0,3,4},{2,7,54},{2,5,40},{2,4,62},{2,4,38},{2,6,51},{2,4,27},{2,4,3},{2,3,69},{0,5,60},{1,4,54},{3,5,22}, |
| {3,4,9},{3,4,6},{3,4,21},{5,0,51},{2,4,27},{2,4,3},{0,4,50},{10,0,51},{0,4,50},{2,6,37},{2,6,37},{2,6,37},{2,4,37},{2,5,8},{2,4,2},{2,4,2},{2,3,5},{1,4,8},{2,3,9},{3,4,5},{3,4,5},{3,4,5},{3,3,8},{4,1,8},{2,4,2},{2,4,2},{2,3,5},{9,0,8},{2,3,5},{3,5,18},{2,5,4},{3,4,2}, |
| {2,4,2},{3,5,18},{7,2,18},{2,4,2},{0,4,50},{7,2,18},{0,4,50},{2,0,36},{2,0,36},{2,0,36},{2,0,36},{2,4,1},{2,4,1},{2,4,1},{2,3,1},{1,4,4},{1,4,4},{3,8,68},{3,6,60},{4,5,68},{3,5,50},{3,7,53},{3,6,28},{3,5,5},{3,5,53},{3,5,68},{2,5,38},{4,6,22},{4,5,13},{4,5,4},{4,5,13},{6,1,52}, |
| {3,6,27},{3,5,4},{1,5,37},{13,0,52},{1,5,37},{3,7,50},{3,7,50},{3,7,50},{3,5,50},{3,6,11},{3,5,5},{3,5,5},{3,4,6},{2,5,11},{3,4,9},{4,5,4},{4,5,4},{4,5,4},{4,4,8},{4,4,8},{3,5,4},{3,5,4},{3,4,5},{12,0,8},{3,4,5},{7,0,18},{4,5,9},{4,5,0},{3,5,0},{7,0,18},{14,0,18},{3,5,0}, |
| {0,5,36},{14,0,18},{0,5,36},{3,0,50},{3,0,50},{3,0,50},{3,0,50},{3,6,2},{3,6,2},{3,6,2},{3,4,2},{2,5,2},{2,5,2},{4,9,54},{4,7,40},{4,6,61},{4,6,36},{4,8,51},{4,6,37},{4,6,1},{4,6,52},{2,7,68},{3,6,38},{5,7,22},{5,6,13},{5,6,4},{5,6,13},{8,0,51},{5,6,34},{4,6,1},{2,6,37},{16,0,51}, |
| {2,6,37},{4,8,37},{4,8,37},{4,8,37},{4,6,36},{4,7,8},{4,6,1},{4,6,1},{4,5,5},{3,6,11},{4,5,9},{5,6,4},{5,6,4},{5,6,4},{5,5,8},{5,5,8},{4,6,1},{4,6,1},{4,5,5},{15,0,8},{4,5,5},{8,1,18},{4,7,4},{5,6,0},{4,6,0},{8,1,18},{17,0,18},{4,6,0},{0,6,36},{17,0,18},{0,6,36},{4,0,36}, |
| {4,0,36},{4,0,36},{4,0,36},{4,6,1},{4,6,1},{4,6,1},{4,5,1},{3,6,2},{3,6,2},{5,10,54},{5,8,40},{5,7,61},{5,7,36},{5,9,51},{5,7,37},{5,7,1},{5,7,52},{3,8,60},{4,7,40},{6,8,22},{6,7,13},{6,7,4},{6,7,13},{9,1,51},{4,8,29},{5,7,1},{3,7,37},{19,0,51},{3,7,37},{5,9,37},{5,9,37},{5,9,37}, |
| {5,7,36},{5,8,8},{5,7,1},{5,7,1},{5,6,5},{4,7,8},{5,6,9},{6,7,4},{6,7,4},{6,7,4},{6,6,8},{9,0,8},{5,7,1},{5,7,1},{5,6,5},{18,0,8},{5,6,5},{10,0,18},{5,8,4},{6,7,0},{5,7,0},{10,0,18},{18,1,18},{5,7,0},{0,7,36},{18,1,18},{0,7,36},{5,0,36},{5,0,36},{5,0,36},{5,0,36},{5,7,1}, |
| {5,7,1},{5,7,1},{5,6,1},{4,7,4},{4,7,4},{6,11,54},{6,9,40},{6,8,62},{6,8,38},{6,10,51},{6,8,27},{6,8,3},{6,7,69},{4,9,60},{5,8,54},{7,9,22},{7,8,9},{7,8,6},{7,8,21},{11,0,51},{6,8,27},{6,8,3},{4,8,50},{22,0,51},{4,8,50},{6,10,37},{6,10,37},{6,10,37},{6,8,37},{6,9,8},{6,8,2},{6,8,2}, |
| {6,7,5},{5,8,8},{6,7,9},{7,8,5},{7,8,5},{7,8,5},{7,7,8},{10,1,8},{6,8,2},{6,8,2},{6,7,5},{21,0,8},{6,7,5},{11,1,18},{6,9,4},{7,8,2},{6,8,2},{11,1,18},{19,2,18},{6,8,2},{0,8,50},{19,2,18},{0,8,50},{6,0,36},{6,0,36},{6,0,36},{6,0,36},{6,8,1},{6,8,1},{6,8,1},{6,7,1},{5,8,4}, |
| {5,8,4},{7,12,68},{7,10,60},{8,9,68},{7,9,50},{7,11,53},{7,10,28},{7,9,5},{7,9,53},{7,9,68},{6,9,38},{8,10,22},{8,9,13},{8,9,4},{8,9,13},{12,1,52},{7,10,27},{7,9,4},{5,9,37},{25,0,52},{5,9,37},{7,11,50},{7,11,50},{7,11,50},{7,9,50},{7,10,11},{7,9,5},{7,9,5},{7,8,6},{6,9,11},{7,8,9},{8,9,4}, |
| {8,9,4},{8,9,4},{8,8,8},{12,0,8},{7,9,4},{7,9,4},{7,8,5},{24,0,8},{7,8,5},{13,0,18},{8,9,9},{8,9,0},{7,9,0},{13,0,18},{26,0,18},{7,9,0},{0,9,36},{26,0,18},{0,9,36},{7,0,50},{7,0,50},{7,0,50},{7,0,50},{7,10,2},{7,10,2},{7,10,2},{7,8,2},{6,9,2},{6,9,2},{8,13,54},{8,11,40},{8,10,61}, |
| {8,10,36},{8,12,51},{8,10,37},{8,10,1},{8,10,52},{6,11,68},{7,10,38},{9,11,22},{9,10,13},{9,10,4},{9,10,13},{12,4,51},{9,10,34},{8,10,1},{6,10,37},{28,0,51},{6,10,37},{8,12,37},{8,12,37},{8,12,37},{8,10,36},{8,11,8},{8,10,1},{8,10,1},{8,9,5},{7,10,11},{8,9,9},{9,10,4},{9,10,4},{9,10,4},{9,9,8},{13,1,8}, |
| {8,10,1},{8,10,1},{8,9,5},{27,0,8},{8,9,5},{14,1,18},{8,11,4},{9,10,0},{8,10,0},{14,1,18},{29,0,18},{8,10,0},{0,10,36},{29,0,18},{0,10,36},{8,0,36},{8,0,36},{8,0,36},{8,0,36},{8,10,1},{8,10,1},{8,10,1},{8,9,1},{7,10,2},{7,10,2},{9,14,54},{9,12,40},{9,11,61},{9,11,36},{9,13,51},{9,11,37},{9,11,1}, |
| {9,11,52},{7,12,60},{8,11,40},{10,12,22},{10,11,13},{10,11,4},{10,11,13},{13,5,51},{8,12,29},{9,11,1},{7,11,37},{31,0,51},{7,11,37},{9,13,37},{9,13,37},{9,13,37},{9,11,36},{9,12,8},{9,11,1},{9,11,1},{9,10,5},{8,11,8},{9,10,9},{10,11,4},{10,11,4},{10,11,4},{10,10,8},{15,0,8},{9,11,1},{9,11,1},{9,10,5},{30,0,8}, |
| {9,10,5},{15,2,18},{9,12,4},{10,11,0},{9,11,0},{15,2,18},{30,1,18},{9,11,0},{0,11,36},{30,1,18},{0,11,36},{9,0,36},{9,0,36},{9,0,36},{9,0,36},{9,11,1},{9,11,1},{9,11,1},{9,10,1},{8,11,4},{8,11,4},{10,15,54},{10,13,40},{10,12,62},{10,12,38},{10,14,51},{10,12,27},{10,12,3},{10,11,69},{8,13,60},{9,12,54},{11,13,22}, |
| {11,12,9},{11,12,6},{11,12,21},{17,0,51},{10,12,27},{10,12,3},{8,12,50},{30,2,51},{8,12,50},{10,14,37},{10,14,37},{10,14,37},{10,12,37},{10,13,8},{10,12,2},{10,12,2},{10,11,5},{9,12,8},{10,11,9},{11,12,5},{11,12,5},{11,12,5},{11,11,8},{16,1,8},{10,12,2},{10,12,2},{10,11,5},{31,1,8},{10,11,5},{15,5,18},{10,13,4},{11,12,2}, |
| {10,12,2},{15,5,18},{31,2,18},{10,12,2},{0,12,50},{31,2,18},{0,12,50},{10,0,36},{10,0,36},{10,0,36},{10,0,36},{10,12,1},{10,12,1},{10,12,1},{10,11,1},{9,12,4},{9,12,4},{11,16,68},{11,14,60},{12,13,68},{11,13,50},{11,15,53},{11,14,28},{11,13,5},{11,13,53},{11,13,68},{10,13,38},{12,14,22},{12,13,13},{12,13,4},{12,13,13},{18,1,52}, |
| {11,14,27},{11,13,4},{9,13,37},{31,3,52},{9,13,37},{11,15,50},{11,15,50},{11,15,50},{11,13,50},{11,14,11},{11,13,5},{11,13,5},{11,12,6},{10,13,11},{11,12,9},{12,13,4},{12,13,4},{12,13,4},{12,12,8},{16,4,8},{11,13,4},{11,13,4},{11,12,5},{28,4,8},{11,12,5},{19,0,18},{12,13,9},{12,13,0},{11,13,0},{19,0,18},{30,4,18},{11,13,0}, |
| {0,13,36},{30,4,18},{0,13,36},{11,0,50},{11,0,50},{11,0,50},{11,0,50},{11,14,2},{11,14,2},{11,14,2},{11,12,2},{10,13,2},{10,13,2},{12,17,54},{12,15,40},{12,14,61},{12,14,36},{12,16,51},{12,14,37},{12,14,1},{12,14,52},{10,15,68},{11,14,38},{13,15,22},{13,14,13},{13,14,4},{13,14,13},{20,0,51},{13,14,34},{12,14,1},{10,14,37},{24,8,51}, |
| {10,14,37},{12,16,37},{12,16,37},{12,16,37},{12,14,36},{12,15,8},{12,14,1},{12,14,1},{12,13,5},{11,14,11},{12,13,9},{13,14,4},{13,14,4},{13,14,4},{13,13,8},{17,5,8},{12,14,1},{12,14,1},{12,13,5},{31,4,8},{12,13,5},{20,1,18},{12,15,4},{13,14,0},{12,14,0},{20,1,18},{31,5,18},{12,14,0},{0,14,36},{31,5,18},{0,14,36},{12,0,36}, |
| {12,0,36},{12,0,36},{12,0,36},{12,14,1},{12,14,1},{12,14,1},{12,13,1},{11,14,2},{11,14,2},{13,18,54},{13,16,40},{13,15,61},{13,15,36},{13,17,51},{13,15,37},{13,15,1},{13,15,52},{11,16,60},{12,15,40},{14,16,22},{14,15,13},{14,15,4},{14,15,13},{21,1,51},{12,16,29},{13,15,1},{11,15,37},{27,8,51},{11,15,37},{13,17,37},{13,17,37},{13,17,37}, |
| {13,15,36},{13,16,8},{13,15,1},{13,15,1},{13,14,5},{12,15,8},{13,14,9},{14,15,4},{14,15,4},{14,15,4},{14,14,8},{21,0,8},{13,15,1},{13,15,1},{13,14,5},{30,6,8},{13,14,5},{22,0,18},{13,16,4},{14,15,0},{13,15,0},{22,0,18},{30,7,18},{13,15,0},{0,15,36},{30,7,18},{0,15,36},{13,0,36},{13,0,36},{13,0,36},{13,0,36},{13,15,1}, |
| {13,15,1},{13,15,1},{13,14,1},{12,15,4},{12,15,4},{14,19,54},{14,17,40},{14,16,62},{14,16,38},{14,18,51},{14,16,27},{14,16,3},{14,15,69},{12,17,60},{13,16,54},{15,17,22},{15,16,9},{15,16,6},{15,16,21},{23,0,51},{14,16,27},{14,16,3},{12,16,50},{30,8,51},{12,16,50},{14,18,37},{14,18,37},{14,18,37},{14,16,37},{14,17,8},{14,16,2},{14,16,2}, |
| {14,15,5},{13,16,8},{14,15,9},{15,16,5},{15,16,5},{15,16,5},{15,15,8},{22,1,8},{14,16,2},{14,16,2},{14,15,5},{31,7,8},{14,15,5},{23,1,18},{14,17,4},{15,16,2},{14,16,2},{23,1,18},{27,10,18},{14,16,2},{0,16,50},{27,10,18},{0,16,50},{14,0,36},{14,0,36},{14,0,36},{14,0,36},{14,16,1},{14,16,1},{14,16,1},{14,15,1},{13,16,4}, |
| {13,16,4},{15,20,68},{15,18,60},{16,17,68},{15,17,50},{15,19,53},{15,18,28},{15,17,5},{15,17,53},{15,17,68},{14,17,38},{16,18,22},{16,17,13},{16,17,4},{16,17,13},{24,1,52},{15,18,27},{15,17,4},{13,17,37},{31,9,52},{13,17,37},{15,19,50},{15,19,50},{15,19,50},{15,17,50},{15,18,11},{15,17,5},{15,17,5},{15,16,6},{14,17,11},{15,16,9},{16,17,4}, |
| {16,17,4},{16,17,4},{16,16,8},{24,0,8},{15,17,4},{15,17,4},{15,16,5},{24,12,8},{15,16,5},{25,0,18},{16,17,9},{16,17,0},{15,17,0},{25,0,18},{30,10,18},{15,17,0},{0,17,36},{30,10,18},{0,17,36},{15,0,50},{15,0,50},{15,0,50},{15,0,50},{15,18,2},{15,18,2},{15,18,2},{15,16,2},{14,17,2},{14,17,2},{16,21,54},{16,19,40},{16,18,61}, |
| {16,18,36},{16,20,51},{16,18,37},{16,18,1},{16,18,52},{14,19,68},{15,18,38},{17,19,22},{17,18,13},{17,18,4},{17,18,13},{24,4,51},{17,18,34},{16,18,1},{14,18,37},{28,12,51},{14,18,37},{16,20,37},{16,20,37},{16,20,37},{16,18,36},{16,19,8},{16,18,1},{16,18,1},{16,17,5},{15,18,11},{16,17,9},{17,18,4},{17,18,4},{17,18,4},{17,17,8},{25,1,8}, |
| {16,18,1},{16,18,1},{16,17,5},{27,12,8},{16,17,5},{26,1,18},{16,19,4},{17,18,0},{16,18,0},{26,1,18},{31,11,18},{16,18,0},{0,18,36},{31,11,18},{0,18,36},{16,0,36},{16,0,36},{16,0,36},{16,0,36},{16,18,1},{16,18,1},{16,18,1},{16,17,1},{15,18,2},{15,18,2},{17,22,54},{17,20,40},{17,19,61},{17,19,36},{17,21,51},{17,19,37},{17,19,1}, |
| {17,19,52},{15,20,60},{16,19,40},{18,20,22},{18,19,13},{18,19,4},{18,19,13},{25,5,51},{16,20,29},{17,19,1},{15,19,37},{31,12,51},{15,19,37},{17,21,37},{17,21,37},{17,21,37},{17,19,36},{17,20,8},{17,19,1},{17,19,1},{17,18,5},{16,19,8},{17,18,9},{18,19,4},{18,19,4},{18,19,4},{18,18,8},{27,0,8},{17,19,1},{17,19,1},{17,18,5},{30,12,8}, |
| {17,18,5},{27,2,18},{17,20,4},{18,19,0},{17,19,0},{27,2,18},{30,13,18},{17,19,0},{0,19,36},{30,13,18},{0,19,36},{17,0,36},{17,0,36},{17,0,36},{17,0,36},{17,19,1},{17,19,1},{17,19,1},{17,18,1},{16,19,4},{16,19,4},{18,23,54},{18,21,40},{18,20,62},{18,20,38},{18,22,51},{18,20,27},{18,20,3},{18,19,69},{16,21,60},{17,20,54},{19,21,22}, |
| {19,20,9},{19,20,6},{19,20,21},{29,0,51},{18,20,27},{18,20,3},{16,20,50},{30,14,51},{16,20,50},{18,22,37},{18,22,37},{18,22,37},{18,20,37},{18,21,8},{18,20,2},{18,20,2},{18,19,5},{17,20,8},{18,19,9},{19,20,5},{19,20,5},{19,20,5},{19,19,8},{28,1,8},{18,20,2},{18,20,2},{18,19,5},{31,13,8},{18,19,5},{27,5,18},{18,21,4},{19,20,2}, |
| {18,20,2},{27,5,18},{31,14,18},{18,20,2},{0,20,50},{31,14,18},{0,20,50},{18,0,36},{18,0,36},{18,0,36},{18,0,36},{18,20,1},{18,20,1},{18,20,1},{18,19,1},{17,20,4},{17,20,4},{19,24,68},{19,22,60},{20,21,68},{19,21,50},{19,23,53},{19,22,28},{19,21,5},{19,21,53},{19,21,68},{18,21,38},{20,22,22},{20,21,13},{20,21,4},{20,21,13},{30,1,52}, |
| {19,22,27},{19,21,4},{17,21,37},{31,15,52},{17,21,37},{19,23,50},{19,23,50},{19,23,50},{19,21,50},{19,22,11},{19,21,5},{19,21,5},{19,20,6},{18,21,11},{19,20,9},{20,21,4},{20,21,4},{20,21,4},{20,20,8},{28,4,8},{19,21,4},{19,21,4},{19,20,5},{28,16,8},{19,20,5},{31,0,18},{20,21,9},{20,21,0},{19,21,0},{31,0,18},{30,16,18},{19,21,0}, |
| {0,21,36},{30,16,18},{0,21,36},{19,0,50},{19,0,50},{19,0,50},{19,0,50},{19,22,2},{19,22,2},{19,22,2},{19,20,2},{18,21,2},{18,21,2},{20,25,54},{20,23,40},{20,22,61},{20,22,36},{20,24,51},{20,22,37},{20,22,1},{20,22,52},{18,23,68},{19,22,38},{21,23,22},{21,22,13},{21,22,4},{21,22,13},{28,8,51},{21,22,34},{20,22,1},{18,22,37},{24,20,51}, |
| {18,22,37},{20,24,37},{20,24,37},{20,24,37},{20,22,36},{20,23,8},{20,22,1},{20,22,1},{20,21,5},{19,22,11},{20,21,9},{21,22,4},{21,22,4},{21,22,4},{21,21,8},{29,5,8},{20,22,1},{20,22,1},{20,21,5},{31,16,8},{20,21,5},{31,3,18},{20,23,4},{21,22,0},{20,22,0},{31,3,18},{31,17,18},{20,22,0},{0,22,36},{31,17,18},{0,22,36},{20,0,36}, |
| {20,0,36},{20,0,36},{20,0,36},{20,22,1},{20,22,1},{20,22,1},{20,21,1},{19,22,2},{19,22,2},{21,26,54},{21,24,40},{21,23,61},{21,23,36},{21,25,51},{21,23,37},{21,23,1},{21,23,52},{19,24,60},{20,23,40},{22,24,22},{22,23,13},{22,23,4},{22,23,13},{29,9,51},{20,24,29},{21,23,1},{19,23,37},{27,20,51},{19,23,37},{21,25,37},{21,25,37},{21,25,37}, |
| {21,23,36},{21,24,8},{21,23,1},{21,23,1},{21,22,5},{20,23,8},{21,22,9},{22,23,4},{22,23,4},{22,23,4},{22,22,8},{31,4,8},{21,23,1},{21,23,1},{21,22,5},{30,18,8},{21,22,5},{31,6,18},{21,24,4},{22,23,0},{21,23,0},{31,6,18},{30,19,18},{21,23,0},{0,23,36},{30,19,18},{0,23,36},{21,0,36},{21,0,36},{21,0,36},{21,0,36},{21,23,1}, |
| {21,23,1},{21,23,1},{21,22,1},{20,23,4},{20,23,4},{22,27,54},{22,25,40},{22,24,62},{22,24,38},{22,26,51},{22,24,27},{22,24,3},{22,23,69},{20,25,60},{21,24,54},{23,25,22},{23,24,9},{23,24,6},{23,24,21},{31,8,51},{22,24,27},{22,24,3},{20,24,50},{30,20,51},{20,24,50},{22,26,37},{22,26,37},{22,26,37},{22,24,37},{22,25,8},{22,24,2},{22,24,2}, |
| {22,23,5},{21,24,8},{22,23,9},{23,24,5},{23,24,5},{23,24,5},{23,23,8},{31,7,8},{22,24,2},{22,24,2},{22,23,5},{31,19,8},{22,23,5},{31,9,18},{22,25,4},{23,24,2},{22,24,2},{31,9,18},{27,22,18},{22,24,2},{0,24,50},{27,22,18},{0,24,50},{22,0,36},{22,0,36},{22,0,36},{22,0,36},{22,24,1},{22,24,1},{22,24,1},{22,23,1},{21,24,4}, |
| {21,24,4},{23,28,68},{23,26,60},{24,25,68},{23,25,50},{23,27,53},{23,26,28},{23,25,5},{23,25,53},{23,25,68},{22,25,38},{24,26,22},{24,25,13},{24,25,4},{24,25,13},{31,11,52},{23,26,27},{23,25,4},{21,25,37},{31,21,52},{21,25,37},{23,27,50},{23,27,50},{23,27,50},{23,25,50},{23,26,11},{23,25,5},{23,25,5},{23,24,6},{22,25,11},{23,24,9},{24,25,4}, |
| {24,25,4},{24,25,4},{24,24,8},{28,16,8},{23,25,4},{23,25,4},{23,24,5},{24,24,8},{23,24,5},{31,12,18},{24,25,9},{24,25,0},{23,25,0},{31,12,18},{30,22,18},{23,25,0},{0,25,36},{30,22,18},{0,25,36},{23,0,50},{23,0,50},{23,0,50},{23,0,50},{23,26,2},{23,26,2},{23,26,2},{23,24,2},{22,25,2},{22,25,2},{24,29,54},{24,27,40},{24,26,61}, |
| {24,26,36},{24,28,51},{24,26,37},{24,26,1},{24,26,52},{22,27,68},{23,26,38},{25,27,22},{25,26,13},{25,26,4},{25,26,13},{28,20,51},{25,26,34},{24,26,1},{22,26,37},{28,24,51},{22,26,37},{24,28,37},{24,28,37},{24,28,37},{24,26,36},{24,27,8},{24,26,1},{24,26,1},{24,25,5},{23,26,11},{24,25,9},{25,26,4},{25,26,4},{25,26,4},{25,25,8},{29,17,8}, |
| {24,26,1},{24,26,1},{24,25,5},{27,24,8},{24,25,5},{31,15,18},{24,27,4},{25,26,0},{24,26,0},{31,15,18},{31,23,18},{24,26,0},{0,26,36},{31,23,18},{0,26,36},{24,0,36},{24,0,36},{24,0,36},{24,0,36},{24,26,1},{24,26,1},{24,26,1},{24,25,1},{23,26,2},{23,26,2},{25,30,54},{25,28,40},{25,27,61},{25,27,36},{25,29,51},{25,27,37},{25,27,1}, |
| {25,27,52},{23,28,60},{24,27,40},{26,28,22},{26,27,13},{26,27,4},{26,27,13},{29,21,51},{24,28,29},{25,27,1},{23,27,37},{31,24,51},{23,27,37},{25,29,37},{25,29,37},{25,29,37},{25,27,36},{25,28,8},{25,27,1},{25,27,1},{25,26,5},{24,27,8},{25,26,9},{26,27,4},{26,27,4},{26,27,4},{26,26,8},{31,16,8},{25,27,1},{25,27,1},{25,26,5},{30,24,8}, |
| {25,26,5},{31,18,18},{25,28,4},{26,27,0},{25,27,0},{31,18,18},{30,25,18},{25,27,0},{0,27,36},{30,25,18},{0,27,36},{25,0,36},{25,0,36},{25,0,36},{25,0,36},{25,27,1},{25,27,1},{25,27,1},{25,26,1},{24,27,4},{24,27,4},{26,31,54},{26,29,40},{26,28,62},{26,28,38},{26,30,51},{26,28,27},{26,28,3},{26,27,69},{24,29,60},{25,28,54},{27,29,22}, |
| {27,28,9},{27,28,6},{27,28,21},{31,20,51},{26,28,27},{26,28,3},{24,28,50},{30,26,51},{24,28,50},{26,30,37},{26,30,37},{26,30,37},{26,28,37},{26,29,8},{26,28,2},{26,28,2},{26,27,5},{25,28,8},{26,27,9},{27,28,5},{27,28,5},{27,28,5},{27,27,8},{31,19,8},{26,28,2},{26,28,2},{26,27,5},{31,25,8},{26,27,5},{31,21,18},{26,29,4},{27,28,2}, |
| {26,28,2},{31,21,18},{31,26,18},{26,28,2},{0,28,50},{31,26,18},{0,28,50},{26,0,36},{26,0,36},{26,0,36},{26,0,36},{26,28,1},{26,28,1},{26,28,1},{26,27,1},{25,28,4},{25,28,4},{28,30,86},{27,30,60},{28,29,68},{27,29,50},{27,31,53},{27,30,28},{27,29,5},{27,29,53},{27,29,68},{26,29,38},{28,30,22},{28,29,13},{28,29,4},{28,29,13},{31,23,52}, |
| {27,30,27},{27,29,4},{25,29,37},{31,27,52},{25,29,37},{27,31,50},{27,31,50},{27,31,50},{27,29,50},{27,30,11},{27,29,5},{27,29,5},{27,28,6},{26,29,11},{27,28,9},{28,29,4},{28,29,4},{28,29,4},{28,28,8},{28,28,8},{27,29,4},{27,29,4},{27,28,5},{28,28,8},{27,28,5},{31,24,18},{28,29,9},{28,29,0},{27,29,0},{31,24,18},{30,28,18},{27,29,0}, |
| {0,29,36},{30,28,18},{0,29,36},{27,0,50},{27,0,50},{27,0,50},{27,0,50},{27,30,2},{27,30,2},{27,30,2},{27,28,2},{26,29,2},{26,29,2},{29,31,86},{28,31,40},{28,30,61},{28,30,36},{28,31,72},{28,30,37},{28,30,1},{28,30,52},{26,31,68},{27,30,38},{29,31,22},{29,30,13},{29,30,4},{29,30,13},{31,26,52},{29,30,34},{28,30,1},{26,30,37},{30,29,52}, |
| {26,30,37},{28,31,40},{28,31,40},{28,31,40},{28,30,36},{28,31,8},{28,30,1},{28,30,1},{28,29,5},{27,30,11},{28,29,9},{29,30,4},{29,30,4},{29,30,4},{29,29,8},{29,29,8},{28,30,1},{28,30,1},{28,29,5},{31,28,8},{28,29,5},{31,27,18},{28,31,4},{29,30,0},{28,30,0},{31,27,18},{31,29,18},{28,30,0},{0,30,36},{31,29,18},{0,30,36},{28,0,36}, |
| {28,0,36},{28,0,36},{28,0,36},{28,30,1},{28,30,1},{28,30,1},{28,29,1},{27,30,2},{27,30,2},{30,31,104},{30,31,77},{29,31,61},{29,31,36},{30,31,116},{29,31,37},{29,31,1},{29,31,52},{28,31,72},{28,31,40},{30,31,40},{30,31,13},{30,31,4},{30,31,13},{31,29,52},{30,31,34},{29,31,1},{27,31,37},{31,30,52},{27,31,37},{29,31,61},{29,31,61},{29,31,61}, |
| {29,31,36},{29,31,26},{29,31,1},{29,31,1},{29,30,5},{28,31,8},{29,30,9},{30,31,4},{30,31,4},{30,31,4},{30,30,8},{31,28,8},{29,31,1},{29,31,1},{29,30,5},{30,30,8},{29,30,5},{31,30,18},{30,31,9},{30,31,0},{29,31,0},{31,30,18},{30,31,18},{29,31,0},{0,31,36},{30,31,18},{0,31,36},{29,0,36},{29,0,36},{29,0,36},{29,0,36},{29,31,1}, |
| {29,31,1},{29,31,1},{29,30,1},{28,31,4},{28,31,4},{31,31,68},{31,31,68},{31,31,68},{30,31,45},{31,31,68},{30,31,34},{30,31,25},{30,31,1},{30,31,23},{30,31,5},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{30,31,1},{31,31,4},{30,31,1},{31,31,68},{31,31,68},{31,31,68},{30,31,45},{30,31,52},{30,31,25},{30,31,25}, |
| {30,31,1},{30,31,14},{30,31,5},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{31,31,4},{30,31,1},{31,31,4},{30,31,1},{31,31,0},{31,31,0},{31,31,0},{31,31,0},{31,31,0},{31,31,0},{31,31,0},{0,31,0},{31,31,0},{0,31,0},{30,0,36},{30,0,36},{30,0,36},{30,0,36},{30,31,16},{30,31,16},{30,31,16},{30,31,1},{30,31,5}, |
| {30,31,5},{0,4,72},{0,3,10},{0,2,1},{0,2,26},{0,3,154},{0,2,99},{0,2,51},{0,1,115},{0,1,173},{0,1,119},{0,4,72},{0,3,10},{0,2,1},{0,2,26},{1,1,154},{0,2,99},{0,2,51},{0,1,115},{3,0,154},{0,1,115},{0,2,0},{0,2,0},{0,2,0},{0,1,0},{0,1,13},{0,1,4},{0,1,4},{0,0,25},{0,0,25},{0,0,25},{0,2,0}, |
| {0,2,0},{0,2,0},{0,1,0},{0,1,13},{0,1,4},{0,1,4},{0,0,25},{1,0,13},{0,0,25},{0,4,72},{0,3,10},{0,2,1},{0,2,26},{0,4,72},{4,0,72},{0,2,26},{0,1,90},{4,0,72},{0,1,90},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,7,81},{0,5,13},{0,3,35}, |
| {0,3,19},{0,5,244},{0,3,115},{0,3,35},{0,2,139},{0,2,308},{0,2,164},{0,7,81},{0,5,13},{1,3,26},{0,3,19},{2,1,244},{0,3,115},{0,3,35},{0,2,139},{5,0,244},{0,2,139},{0,5,9},{0,5,9},{0,5,9},{0,2,18},{0,3,50},{0,2,13},{0,2,13},{0,1,29},{0,1,72},{0,1,33},{0,5,9},{0,5,9},{0,5,9},{0,2,18},{1,1,50}, |
| {0,2,13},{0,2,13},{0,1,29},{3,0,50},{0,1,29},{1,5,72},{0,5,4},{1,3,1},{0,3,10},{1,5,72},{7,0,72},{0,3,10},{0,2,90},{7,0,72},{0,2,90},{0,0,9},{0,0,9},{0,0,9},{0,0,9},{0,1,1},{0,1,1},{0,1,1},{0,1,4},{0,1,8},{0,1,8},{1,8,145},{1,6,77},{1,4,98},{1,4,82},{0,8,243},{0,5,76},{0,4,1}, |
| {0,3,115},{0,4,364},{0,3,179},{1,8,81},{1,6,13},{2,4,25},{1,4,18},{4,0,243},{0,5,76},{0,4,1},{0,3,115},{8,0,243},{0,3,115},{1,6,73},{1,6,73},{1,6,73},{1,3,82},{0,6,50},{0,4,1},{0,4,1},{0,2,26},{0,3,114},{0,2,51},{1,6,9},{1,6,9},{1,6,9},{1,3,18},{3,0,50},{0,4,1},{0,4,1},{0,2,26},{6,0,50}, |
| {0,2,26},{5,0,72},{1,6,4},{2,4,0},{0,4,1},{5,0,72},{10,0,72},{0,4,1},{0,3,90},{10,0,72},{0,3,90},{1,0,73},{1,0,73},{1,0,73},{1,0,73},{0,4,0},{0,4,0},{0,4,0},{0,2,1},{0,2,26},{0,2,26},{2,9,162},{2,7,94},{2,5,115},{2,5,99},{1,9,244},{1,6,77},{1,5,2},{1,4,106},{0,5,300},{0,4,105},{2,9,81}, |
| {2,7,13},{3,5,25},{2,5,18},{5,1,243},{1,6,76},{1,5,1},{0,4,89},{11,0,243},{0,4,89},{2,7,90},{2,7,90},{2,7,90},{2,4,94},{1,7,51},{1,5,2},{1,5,2},{1,3,27},{0,4,74},{0,3,35},{2,7,9},{2,7,9},{2,7,9},{2,4,13},{4,1,50},{1,5,1},{1,5,1},{0,4,25},{9,0,50},{0,4,25},{6,1,72},{2,7,4},{3<
|