diff --git a/opennurbs_3dm_settings.cpp b/opennurbs_3dm_settings.cpp index 860cf2fb..1eaaca66 100644 --- a/opennurbs_3dm_settings.cpp +++ b/opennurbs_3dm_settings.cpp @@ -3409,8 +3409,11 @@ bool ON_EarthAnchorPoint::ModelLocationIsSet() const { return ( m_model_point.IsValid() - && m_model_north.IsValid() - && m_model_east.IsValid() + && m_model_north.IsNotZero() + && m_model_east.IsNotZero() + && m_model_north.Length() > ON_ZERO_TOLERANCE + && m_model_east.Length() > ON_ZERO_TOLERANCE + && fabs(m_model_north.UnitVector()* m_model_east.UnitVector()) <= 1e-8 ); } @@ -3800,6 +3803,134 @@ void ON_EarthAnchorPoint::SetModelLocation( SetModelEast(model_east); } +const ON_Xform ON_EarthAnchorPoint::Internal_KMLOrientationXform() const +{ + if (false == this->ModelLocationIsSet()) + { + ON_ERROR("Corrupt model location."); + return ON_Xform::Nan; + } + + ON_Plane model_directions; + if (false == model_directions.CreateFromFrame(ON_3dPoint::Origin, ModelEast(), ModelNorth())) + return ON_Xform::Nan; + if (false == model_directions.IsValid()) + return ON_Xform::Nan; + + // The KML orientation moves the model so that + // east = x-axis + // north = Y-axis + // up = Z-axis + // https://developers.google.com/kml/documentation/kmlreference#orientation + // "Describes rotation of a 3D model's coordinate system to position the object in Google Earth." + + ON_Xform KMLorientation; + KMLorientation.Rotation(model_directions, ON_Plane::World_xy); + + const ON_3dPoint M[4] = { + ON_3dPoint::Origin, + ON_3dPoint::Origin + ModelEast().UnitVector(), + ON_3dPoint::Origin + ModelNorth().UnitVector(), + ON_3dPoint::Origin + ON_CrossProduct(ModelEast().UnitVector(), ModelNorth().UnitVector()) + }; + const ON_3dPoint E[sizeof(M)/sizeof(M[0])] = { + ON_3dPoint::Origin, + ON_3dPoint::Origin + ON_3dVector::XAxis, + ON_3dPoint::Origin + ON_3dVector::YAxis, + ON_3dPoint::Origin + ON_3dVector::ZAxis + }; + ON_3dPoint rM[sizeof(M) / sizeof(M[0])] = {}; + double err[sizeof(M) / sizeof(M[0])] = {}; + double maxerr = 0.0; + for (size_t i = 0; i < sizeof(M) / sizeof(M[0]); ++i) + { + rM[i] = KMLorientation * M[i]; + double d = E[i].DistanceTo(rM[i]); + if (d != d || d > err[i]) + err[i] = d; + if (err[i] != err[i] || err[i] > maxerr) + maxerr = err[i]; + } + + if (false == maxerr <= ON_ZERO_TOLERANCE) + { + ON_ERROR("Sloppy rotation matrix."); + } + + return KMLorientation; +} + +bool ON_EarthAnchorPoint::GetKMLOrientationAnglesRadians(double& heading_radians, double& tilt_radians, double& roll_radians) const +{ + heading_radians = ON_DBL_QNAN; + tilt_radians = ON_DBL_QNAN; + roll_radians = ON_DBL_QNAN; + const ON_Xform rot = Internal_KMLOrientationXform(); + return rot.GetKMLOrientationAnglesRadians(heading_radians, tilt_radians, roll_radians); +} + +bool ON_EarthAnchorPoint::GetKMLOrientationAnglesDegrees(double& heading_degrees, double& tilt_degrees, double& roll_degrees) const +{ + heading_degrees = ON_DBL_QNAN; + tilt_degrees = ON_DBL_QNAN; + roll_degrees = ON_DBL_QNAN; + const ON_Xform rot = Internal_KMLOrientationXform(); + return rot.GetKMLOrientationAnglesDegrees(heading_degrees, tilt_degrees, roll_degrees); +} + +const double ON_EarthAnchorPoint::KMLOrientationHeadingAngleRadians() const +{ + double heading_radians = ON_DBL_QNAN; + double tilt_radians = ON_DBL_QNAN; + double roll_radians = ON_DBL_QNAN; + const bool rc = GetKMLOrientationAnglesRadians(heading_radians, tilt_radians, roll_radians); + return rc ? heading_radians : ON_DBL_QNAN; +} + +const double ON_EarthAnchorPoint::KMLOrientationTiltAngleRadians() const +{ + double heading_radians = ON_DBL_QNAN; + double tilt_radians = ON_DBL_QNAN; + double roll_radians = ON_DBL_QNAN; + const bool rc = GetKMLOrientationAnglesRadians(heading_radians, tilt_radians, roll_radians); + return rc ? tilt_radians : ON_DBL_QNAN; +} + +const double ON_EarthAnchorPoint::KMLOrientationRollAngleRadians() const +{ + double heading_radians = ON_DBL_QNAN; + double tilt_radians = ON_DBL_QNAN; + double roll_radians = ON_DBL_QNAN; + const bool rc = GetKMLOrientationAnglesRadians(heading_radians, tilt_radians, roll_radians); + return rc ? roll_radians : ON_DBL_QNAN; +} + +const double ON_EarthAnchorPoint::KMLOrientationHeadingAngleDegrees() const +{ + double heading_degrees = ON_DBL_QNAN; + double tilt_degrees = ON_DBL_QNAN; + double roll_degrees = ON_DBL_QNAN; + const bool rc = GetKMLOrientationAnglesDegrees(heading_degrees, tilt_degrees, roll_degrees); + return rc ? heading_degrees : ON_DBL_QNAN; +} + +const double ON_EarthAnchorPoint::KMLOrientationTiltAngleDegrees() const +{ + double heading_degrees = ON_DBL_QNAN; + double tilt_degrees = ON_DBL_QNAN; + double roll_degrees = ON_DBL_QNAN; + const bool rc = GetKMLOrientationAnglesDegrees(heading_degrees, tilt_degrees, roll_degrees); + return rc ? tilt_degrees : ON_DBL_QNAN; +} + +const double ON_EarthAnchorPoint::KMLOrientationRollAngleDegrees() const +{ + double heading_degrees = ON_DBL_QNAN; + double tilt_degrees = ON_DBL_QNAN; + double roll_degrees = ON_DBL_QNAN; + const bool rc = GetKMLOrientationAnglesDegrees(heading_degrees, tilt_degrees, roll_degrees); + return rc ? roll_degrees : ON_DBL_QNAN; +} ////////////////////////////////////////////////////////////////////////////////////////// // diff --git a/opennurbs_3dm_settings.h b/opennurbs_3dm_settings.h index 8f33490f..2687ac1b 100644 --- a/opennurbs_3dm_settings.h +++ b/opennurbs_3dm_settings.h @@ -1122,6 +1122,138 @@ public: ON_3dVector model_east ); + /* + Description: + Find the Keyhole Markup Language (KML) orientation angles (in radians) of a rotation + transformation that maps model (east,north,up) to ((1,0,0),(0,1,0),(0,0,1)). + KML Earth Z axis = up, KML Earth X axis = east, KML Earth Y axis = north. + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Parameters: + heading_radians - [out] + angle (in radians) of rotation around KML Earth Z axis (Earth up). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + tilt_radians - [out] + angle (in radians) of rotation around KML Earth X axis (Earth east). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + roll_radians - [out] + angle (in radians) of rotation around KML Earth Y axis (Earth north). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Returns: + True if the model location is set (this->ModelLocationIsSet() is true) + and the KML orientation angles are returned. + Otherwise false is returned and all of the angle values are ON_DLB_QNAN. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + bool GetKMLOrientationAnglesRadians( + double& heading_radians, + double& tilt_radians, + double& roll_radians + ) const; + + /* + If the model location is set (this->ModelLocationIsSet() is true), then the + Keyhole Markup Language orientation heading angle in radians is returned. + Otherwise ON_DBL_QNAN is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + const double KMLOrientationHeadingAngleRadians() const; + + /* + Returns: + If the model location is set (this->ModelLocationIsSet() is true), then the + Keyhole Markup Language orientation tilt angle in radians is returned. + Otherwise ON_DBL_QNAN is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + const double KMLOrientationTiltAngleRadians() const; + + /* + Returns: + If the model location is set (this->ModelLocationIsSet() is true), then the + Keyhole Markup Language orientation roll angle in radians is returned. + Otherwise ON_DBL_QNAN is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + const double KMLOrientationRollAngleRadians() const; + + /* + Description: + Find the Keyhole Markup Language (KML) orientation angles (in degrees) of a rotation + transformation that maps model (east,north,up) to ((1,0,0),(0,1,0),(0,0,1)). + KML Earth Z axis = up, KML Earth X axis = east, KML Earth Y axis = north. + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Parameters: + heading_degrees - [out] + angle (in degrees) of rotation around KML Earth Z axis (Earth up). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + tilt_degrees - [out] + angle (in degrees) of rotation around KML Earth X axis (Earth east). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + roll_degrees - [out] + angle (in degrees) of rotation around KML Earth Y axis (Earth north). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Returns: + True if the model location is set (this->ModelLocationIsSet() is true) + and the KML orientation angles are returned. + Otherwise false is returned and all of the angle values are ON_DLB_QNAN. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + bool GetKMLOrientationAnglesDegrees( + double& heading_degrees, + double& tilt_degrees, + double& roll_degrees + ) const; + + /* + Returns: + If the model location is set (this->ModelLocationIsSet() is true), then the + Keyhole Markup Language orientation heading angle in degrees is returned. + Otherwise ON_DBL_QNAN is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + const double KMLOrientationHeadingAngleDegrees() const; + + /* + Returns: + If the model location is set (this->ModelLocationIsSet() is true), then the + Keyhole Markup Language orientation tilt angle in degrees is returned. + Otherwise ON_DBL_QNAN is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + const double KMLOrientationTiltAngleDegrees() const; + + /* + If the model location is set (this->ModelLocationIsSet() is true), then the + Keyhole Markup Language orientation roll angle in degrees is returned. + Otherwise ON_DBL_QNAN is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + const double KMLOrientationRollAngleDegrees() const; + private: // Point on the Earth // Latitude (degrees): +90 = north pole, 0 = equator, -90 = south pole @@ -1203,6 +1335,9 @@ public: const ON_UnitSystem& model_unit_system, ON_Xform& model_to_earth ) const; + +private: + const ON_Xform Internal_KMLOrientationXform() const; }; diff --git a/opennurbs_archive.h b/opennurbs_archive.h index 2bcc47a6..852a8284 100644 --- a/opennurbs_archive.h +++ b/opennurbs_archive.h @@ -2004,7 +2004,7 @@ public: Returns: Endian-ness of the cpu reading this file. Remarks: - 3dm files are alwasy saved with little endian byte order. + 3dm files are always saved with little endian byte order. */ ON::endian Endian() const; // endian-ness of cpu @@ -4801,7 +4801,7 @@ private: private: // endian-ness of the cpu reading this file. - // 3dm files are alwasy saved with little endian byte order. + // 3dm files are always saved with little endian byte order. const ON::endian m_endian = ON::Endian(); const ON::archive_mode m_mode = ON::archive_mode::unset_archive_mode; diff --git a/opennurbs_archive_manifest.cpp b/opennurbs_archive_manifest.cpp index a66f24f3..a3942aad 100644 --- a/opennurbs_archive_manifest.cpp +++ b/opennurbs_archive_manifest.cpp @@ -3190,7 +3190,7 @@ const ON_ComponentManifestItem_PRIVATE* ON_ComponentManifestTableIndex::SystemIt { if (m_bIndexedComponent && sytem_item_index < 0 && sytem_item_index > ON_UNSET_INT_INDEX ) { - // The linked list of system items is alwasy short - hash tables and sorting are a waste of time + // The linked list of system items is always short - hash tables and sorting are a waste of time for (const ON_ComponentManifestItem_PRIVATE* system_item = m_first_system_item; nullptr != system_item; system_item = system_item->m_next) { if ( system_item->Index() == sytem_item_index ) diff --git a/opennurbs_array.h b/opennurbs_array.h index 63ad5677..ec3e5864 100644 --- a/opennurbs_array.h +++ b/opennurbs_array.h @@ -1633,5 +1633,162 @@ void ON_SHA1_Accumulate3dVectorArray( // will work on the template functions. #include "opennurbs_array_defs.h" +class ON_CLASS ON_Big5UnicodePair +{ +public: + ON_Big5UnicodePair() = default; + ~ON_Big5UnicodePair() = default; + ON_Big5UnicodePair(const ON_Big5UnicodePair&) = default; + ON_Big5UnicodePair& operator=(const ON_Big5UnicodePair&) = default; + +public: + /// + /// An array sorted by BIG5 code points and useful for converting BIG5 code points to Unicode code points. + /// + /// Returns an array sorted by ON_Big5UnicodePair::CompareBig5AndUnicodeCodePoints() + static const ON_SimpleArray< ON_Big5UnicodePair >& Big5ToUnicode(); + + /// + /// An array sorted by Unicode code points and useful for converting Unicode code points to BIG5 code points. + /// + /// Returns an array sorted by ON_Big5UnicodePair::CompareUnicodeAndBig5CodePoints() + static const ON_SimpleArray< ON_Big5UnicodePair >& UnicodeToBig5(); + +public: + static const ON_Big5UnicodePair Null; + + /// + /// ON_Big5UnicodePair::Error.Big5() = ON_Big5CodePoint::Error and ON_Big5UnicodePair::Error.Unicode() = ON_UnicodeShortCodePoint::Error. + /// + static const ON_Big5UnicodePair Error; + + /// + /// Create a BIG5 - Unicode code point pair. + /// + /// + /// BIG5 code point. + /// + /// + /// Unicode code point. + /// + /// + static const ON_Big5UnicodePair Create( + ON_Big5CodePoint big5_code_point, + ON_UnicodeShortCodePoint unicode_code_point + ); + + static const ON_Big5UnicodePair Create( + unsigned int big5_code_point, + unsigned int unicode_code_point + ); + + /// + /// Determine if both code points in this pair are 0. + /// + /// True if both code points are 0. + bool IsNull() const; + + /// + /// Determing if the values stored as the BIG5 and Unicode code points are equal nonzero ASCII code points. + /// ASCII code point are in the range 0-0x7F (127 decimal). + /// Unicode extends ASCII. Strictly speaking, BIG5 does not extend ASCII, but it is common to mix + /// single bytes ASCII and double byte BIG5 encodings in the same char string. + /// BIG5 is a double byte string encoding with the first byte in the range 0x81 to 0xFE, the + /// minimum BIG5 code point is 0x8140 and the maximum BIG5 code point is 0xFEFE. + /// Thus it is possible to mix ASCII and BIG5 encodings in the same char string. + /// + /// + /// Value to return if both code points are 0. + /// + /// True if both code points are equal and ASCII code points (0 to 0x7F). + bool IsASCII(bool bNullIsASCII) const; + + /// + /// Determine if the pair of code points is valid. + /// If the values for BIG5 and Unicode code point values are < 0xFF and equal, the pair is considered valid. + /// Use IsASCII() if you need to treat nonzero ASCII code points differently. + /// + /// + /// Value to return if this pair is null. + /// + /// + /// Value to return if this pair is an ASCII code point. + /// + /// True if the BIG5 and Unicode code points are both valid or IsASCII() is true. + bool IsValid(bool bNullIsValid, bool bASCIICodePointIsValid) const; + + const ON_Big5CodePoint Big5() const; + const ON_UnicodeShortCodePoint Unicode() const; + + unsigned int Big5CodePoint() const; + unsigned int UnicodeCodePoint() const; + + /// + /// + /// + /// + /// + /// Value to return if this pair is null. + /// + /// + /// Value to return if this pair is an ASCII code point. + /// + /// + bool IsStandard(bool bNullIsValid, bool bASCIICodePointIsStandard) const; + + /// + /// + /// + /// Returns true if this pair is valid and at least one of the code points is a private use code point. + /// + bool IsPrivateUse() const; + + /// + /// Compares the BIG5 code point. + /// + /// + /// + /// + static int CompareBig5CodePoint(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs); + + /// + /// Compares the Unicode code point. + /// + /// + /// + /// + static int CompareUnicodeCodePoint(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs); + + /// + /// Dictionary compare (BIG5 code point first, Unicode code point second). + /// + /// + /// + /// + static int CompareBig5AndUnicodeCodePoints(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs); + + /// + /// Dictionary compare (Unicode code point first, BIG5 code point second). + /// + /// + /// + /// + static int CompareUnicodeAndBig5CodePoints(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs); + +private: + ON_Big5CodePoint m_big5; + ON_UnicodeShortCodePoint m_unicode; +}; + +ON_DECL bool operator==(ON_Big5UnicodePair lhs, ON_Big5UnicodePair rhs); +ON_DECL bool operator!=(ON_Big5UnicodePair lhs, ON_Big5UnicodePair rhs); + +#if defined(ON_DLL_TEMPLATE) + +ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; +ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; +ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; + +#endif #endif diff --git a/opennurbs_brep.cpp b/opennurbs_brep.cpp index 985f6471..87810754 100644 --- a/opennurbs_brep.cpp +++ b/opennurbs_brep.cpp @@ -1665,7 +1665,9 @@ bool ON_Brep::Transform( const ON_Xform& xform ) if ( 1 != tmp.IsSimilarity() ) bEvAnalysisMesh = true; } - if ( bEvAnalysisMesh && face.m_analysis_mesh->EvaluateMeshGeometry(*srf) ) + // 1 Sept 2021, Mikko, RH-65468: + // Added null check to prevent a crash. + if ( bEvAnalysisMesh && nullptr != srf && face.m_analysis_mesh->EvaluateMeshGeometry(*srf) ) { // 28 Sept 2012, Mikko: // Apply the "29 September 2003 Dale Lear" fix above also to analysis meshes. @@ -1688,10 +1690,12 @@ bool ON_Brep::Transform( const ON_Xform& xform ) { if ( face.m_bRev ) { - int ni, ncnt = face.m_analysis_mesh->m_N.Count(); + // 10 June 2021, Mikko, RH-64582: + // Fixed typo that caused a crash, changed "m_analysis_mesh" to "m_preview_mesh". + int ni, ncnt = face.m_preview_mesh->m_N.Count(); for ( ni = 0; ni < ncnt; ni++ ) { - face.m_analysis_mesh->m_N[ni] = -face.m_analysis_mesh->m_N[ni]; + face.m_preview_mesh->m_N[ni] = -face.m_preview_mesh->m_N[ni]; } } } @@ -5468,47 +5472,75 @@ bool ON_Brep::IsValid( ON_TextLog* text_log ) const } - // GBA 28-Aug-20 RH-60112 and RH-58462 - // Adding bounding box (m_bbox) validation tests. - // Brep bounding box is cached and persists across sessions (since at least Rhino 6). - // In Rhino6 and earlier, the bounding box included entire underlying surface. - // Rhino7 bounding box calculation now uses "shrinked" surfaces. - // A bounding box is now reported as invalid if it could be significantly - // reduced by being recalculated. - if (!m_bbox.IsEmpty()) + // Dale Lear Fix https://mcneel.myjetbrains.com/youtrack/issue/RH-64277 + // The commented out tests might have helped in debugging make2d, but they are making a mess of things now. + // In my view, destroying/remaking a box is beyond the scope of an appropriate IsValid() test. + // In addintion to replacing the test below with a warning Greg can use while debugging + // make2d, I've fixed the IO code in ON_Brep::Read() so old boxes are now reliably updated + // to their smaller versions. + + //////// GBA 28-Aug-20 RH-60112 and RH-58462 + //////// Adding bounding box (m_bbox) validation tests. + //////// Brep bounding box is cached and persists across sessions (since at least Rhino 6). + //////// In Rhino6 and earlier, the bounding box included entire underlying surface. + //////// Rhino7 bounding box calculation now uses "shrinked" surfaces. + //////// A bounding box is now reported as invalid if it could be significantly + //////// reduced by being recalculated. + //////if (!m_bbox.IsEmpty()) + //////{ + ////// if (!m_bbox.IsValid()) + ////// { + ////// if (text_log) + ////// text_log->Print("Bounding Box is not valid.\n"); + ////// return ON_BrepIsNotValid(); + ////// } + ////// else + ////// { + ////// ON_BoundingBox orig_box = m_bbox; + ////// ON_BoundingBox computed_box; + ////// { + ////// ON_Brep* this_nonconst = const_cast(this); + ////// this_nonconst->ClearBoundingBox(); + ////// computed_box = BoundingBox(); + ////// this_nonconst->m_bbox = orig_box; // restore box as it as it was. + ////// } + ////// // expand the computed_box before we do the incusion test + ////// // I'm trying to avoid making a lot of objects created in Rhino 6 and earlier + ////// // reporting as Invalid objects in Rhino 7. + ////// computed_box.Expand(computed_box.Diagonal() + ON_3dVector(1.0, 1.0, 1.0)); + + ////// if (!computed_box.Includes(orig_box)) + ////// { + ////// if (text_log) + ////// text_log->Print("Stored Bounding Box extends far outside of computed bounding box.\n"); + ////// return ON_BrepIsNotValid(); + + ////// } + + ////// } + //////} + + if (m_bbox.IsNotEmpty()) { - if (!m_bbox.IsValid()) + + // new_brep_bbox is calculated from scratch WITHOUT changing existing values on ON_BrepFace.m_bbox and ON_Brep.m_bbox. + const ON_BoundingBox new_brep_bbox = this->InternalBrepBoundingBox(false, false); + if (new_brep_bbox.IsNotEmpty()) { - if (text_log) - text_log->Print("Bounding Box is not valid.\n"); - return ON_BrepIsNotValid(); - } - else - { - ON_BoundingBox orig_box = m_bbox; - ON_BoundingBox computed_box; + ON_BoundingBox triple_size_new_brep_bbox = new_brep_bbox; + triple_size_new_brep_bbox.Expand(new_brep_bbox.Diagonal() + ON_3dVector(1.0, 1.0, 1.0)); + const ON_BoundingBox cached_brep_bbox = m_bbox; + if (false == triple_size_new_brep_bbox.Includes(cached_brep_bbox, false)) { - ON_Brep* this_nonconst = const_cast(this); - this_nonconst->ClearBoundingBox(); - computed_box = BoundingBox(); - this_nonconst->m_bbox = orig_box; // restore box as it as it was. + if (nullptr != text_log) + text_log->Print("WARNING: The cached ON_Brep.m_bbox is much larger than one cacluated from current ON_BrepFace extents.\n"); + ON_WARNING("The cached ON_Brep.m_bbox is much larger than one cacluated from current ON_BrepFace extents. This might effect make2d performance."); + // DO NOT RETURN FALSE HERE! } - // expand the computed_box before we do the incusion test - // I'm trying to avoid making a lot of objects created in Rhino 6 and earlier - // reporting as Invalid objects in Rhino 7. - computed_box.Expand(computed_box.Diagonal() + ON_3dVector(1.0, 1.0, 1.0)); - - if (!computed_box.Includes(orig_box)) - { - if (text_log) - text_log->Print("Stored Bounding Box extends far outside of computed bounding box.\n"); - return ON_BrepIsNotValid(); - - } - } } + #if 0 // validate ON_BrepTrim.m_pline for ( ti = 0; ti < trim_count; ti++ ) @@ -6428,7 +6460,133 @@ void ON_BrepFace::ClearBoundingBox() } -// ON_BrepFace::GetBBox performs lazy evaluation. Namely, if m_bbox is invalid then the bounding box is +const ON_BoundingBox ON_BrepFace::InternalFaceBoundingBox(bool bLazy, bool bUpdateCachedBBox) const +{ + if (bLazy && m_bbox.IsNotEmpty()) + return m_bbox; + + for (;;) + { + // Make sure this face is valid enough to query the trims and proxy surface + if (nullptr == m_brep) + break; + if (m_face_index < 0) + break; + if (m_face_index >= m_brep->m_F.Count()) + break; + if (&m_brep->m_F[m_face_index] != this) + break; + + const ON_Surface* proxy_srf = ProxySurface(); + if (nullptr == proxy_srf) + break; + if (proxy_srf == this) + break; + + ON_BoundingBox pbox = ON_BoundingBox::NanBoundingBox; + for (int li = 0; li < LoopCount(); li++) + { + ON_BrepLoop* loop = Loop(li); + if (loop && loop->m_type == ON_BrepLoop::outer) + { + m_brep->SetTrimBoundingBoxes(*loop, true); // sets loop->m_pbox + if (false == loop->GetBoundingBox(pbox, pbox.IsValid())) + pbox = ON_BoundingBox::UnsetBoundingBox; + break; + } + } + + + ON_BoundingBox face_bbox = ON_BoundingBox::NanBoundingBox; + if (pbox.IsNotEmpty()) + { + ON_Interval pudom(pbox[0].x, pbox[1].x); + ON_Interval pvdom(pbox[0].y, pbox[1].y); + // fatten up invervals to get slightly larger boxes... + pudom.Expand(0.1 * pudom.Length()); + pvdom.Expand(0.1 * pvdom.Length()); + ON_Interval Sdom[] = { Domain(0), Domain(1) }; + // but don't let the fattened intervals extend beyond Sdom + pudom.Intersection(Sdom[0]); + pvdom.Intersection(Sdom[1]); + if (pbox.IsValid() && + (Sdom[0].Includes(pudom, true) || Sdom[1].Includes(pvdom, true)) + ) + { + ON_Surface* temp_srf = DuplicateSurface(); + if (nullptr != temp_srf) + { + if (Sdom[0].Includes(pudom, true)) + temp_srf->Trim(0, pudom); + if (Sdom[1].Includes(pvdom, true)) + temp_srf->Trim(1, pvdom); + if (false == temp_srf->GetBoundingBox(face_bbox, false)) + face_bbox = ON_BoundingBox::NanBoundingBox; + delete temp_srf; + temp_srf = nullptr; + } + } + } + + if (false == face_bbox.IsNotEmpty()) + { + if (false == proxy_srf->GetBoundingBox(face_bbox, false)) + break; + if (false == face_bbox.IsNotEmpty()) + break; + } + + if (bUpdateCachedBBox) + const_cast(this)->m_bbox = face_bbox; + return face_bbox; + } + + // ON_Brep code has always used ON_BoundingBox::EmptyBoundingBox + // to indicate a bounding box is not set. If it were to be written + // in modern times, it would have used Nans. + return ON_BoundingBox::EmptyBoundingBox; +} + +const ON_BoundingBox ON_Brep::InternalBrepBoundingBox(bool bLazy, bool bUpdateCachedBBox) const +{ + if (bLazy && m_bbox.IsNotEmpty()) + return m_bbox; + + ON_BoundingBox brep_bbox; + const int face_count = m_F.Count(); + int fi; + for (fi = 0; fi < face_count; fi++) + { + if (m_F[fi].m_face_index == -1) + continue; + + //GBA 20 May 2020. RH-58462. Brep box now computed from face boxes, instead of surface boxes. + const ON_BrepFace* f = Face(fi); + if (nullptr == f) + continue; + + const ON_BoundingBox face_bbox = f->InternalFaceBoundingBox(bLazy, bUpdateCachedBBox); + if (false == face_bbox.IsNotEmpty()) + continue; + + brep_bbox.Union(face_bbox); + } + + if (false == brep_bbox.IsNotEmpty()) + { + // ON_Brep code has always used ON_BoundingBox::EmptyBoundingBox + // to indicate a bounding box is not set. If it were to be written + // in modern times, it would have used Nans. + return ON_BoundingBox::EmptyBoundingBox; + } + + if (bUpdateCachedBBox) + const_cast(this)->m_bbox = brep_bbox; + return brep_bbox; +} + +// ON_BrepFace::GetBBox performs lazy evaluation. +// Namely, if m_bbox is invalid then the bounding box is // computed and the value is stored in m_bbox to speed future calls. bool ON_BrepFace::GetBBox( double* box_min, // [3], @@ -6436,65 +6594,11 @@ bool ON_BrepFace::GetBBox( bool bGrowBox // = false ) const { - if ( !m_bbox.IsValid() - && 0 != m_brep - && m_face_index >= 0 - && m_face_index < m_brep->m_F.Count() - && &m_brep->m_F[m_face_index] == this - ) - { - ON_BoundingBox pbox; - - for (int li = 0; li < LoopCount(); li++) - { - ON_BrepLoop* loop = Loop(li); - if (loop && loop->m_type==ON_BrepLoop::outer) - { - m_brep->SetTrimBoundingBoxes( *loop, true); // sets loop->m_pbox - loop->GetBoundingBox(pbox, pbox.IsValid()); - break; - } - } - - ON_Interval pudom(pbox[0].x, pbox[1].x); - ON_Interval pvdom(pbox[0].y, pbox[1].y); - // fatten up invervals to get slightly larger boxes... - pudom.Expand(.1 * pudom.Length()); - pvdom.Expand(.1 * pvdom.Length()); - ON_Interval Sdom[]= { Domain(0), Domain(1) }; - // but don't let the fattened intervals extend beyond Sdom - pudom.Intersection(Sdom[0]); - pvdom.Intersection(Sdom[1]); - bool Used_pbox = false; - if (pbox.IsValid() && - (Sdom[0].Includes(pudom, true) || Sdom[1].Includes(pvdom, true))) - { - ON_Surface* temp_srf = DuplicateSurface(); - if (temp_srf) - { - if (Sdom[0].Includes(pudom, true)) - temp_srf->Trim(0, pudom); - if (Sdom[1].Includes(pvdom, true)) - temp_srf->Trim(1, pvdom); - temp_srf->GetBoundingBox(const_cast(this)->m_bbox, false); - delete temp_srf; - temp_srf = nullptr; - Used_pbox = true; - } - } - if (!Used_pbox) - { - const ON_Surface* srf = ProxySurface(); - if(srf) - srf->GetBoundingBox(const_cast(this)->m_bbox, false); - } - - } - - bool rc = m_bbox.IsValid(); + ON_BoundingBox bbox = this->InternalFaceBoundingBox(true, true); + + bool rc = bbox.IsValid(); if (rc) { - ON_BoundingBox bbox = m_bbox; if ( bGrowBox && box_min && box_max && box_min[0] <= box_max[0] ) { bbox.Union( ON_BoundingBox( ON_3dPoint(box_min), ON_3dPoint(box_max) ) ); @@ -6522,26 +6626,9 @@ bool ON_Brep::GetBBox( bool bGrowBox // = false ) const { - ON_BoundingBox bbox; - if ( !m_bbox.IsValid() ) - { - const int face_count = m_F.Count(); - int fi; - for ( fi = 0; fi < face_count; fi++ ) - { - if ( m_F[fi].m_face_index == -1 ) - continue; + ON_BoundingBox bbox = this->InternalBrepBoundingBox(true, true); - //GBA 20 May 2020. RH-58462. Brep box now computed from face boxes, instead of surface boxes. - const ON_BrepFace* f = Face(fi); - if(f) - f->GetBoundingBox( bbox, bbox.IsValid() ); - } - ON_Brep* ptr = const_cast(this); - ptr->m_bbox = bbox; - } - - bool rc = m_bbox.IsValid(); + bool rc = bbox.IsValid(); if (rc) { bbox = m_bbox; diff --git a/opennurbs_brep.h b/opennurbs_brep.h index 4419e721..4e7cd095 100644 --- a/opennurbs_brep.h +++ b/opennurbs_brep.h @@ -1319,7 +1319,7 @@ private: mutable ON_Color m_per_face_color = ON_Color::UnsetColor; private: - ON_BoundingBox m_bbox; // 3d bounding box + ON_BoundingBox m_bbox; // 3d bounding box (should be declared mutable and const_cast<> is used to make it fake mutable) ON_Interval m_domain[2]; // rectangular bounds of 2d curves ON_Mesh* m_render_mesh = nullptr; ON_Mesh* m_analysis_mesh = nullptr; @@ -1330,6 +1330,18 @@ private: friend class ON_Brep; ON_Brep* m_brep = nullptr; ON_BrepFace( const ON_BrepFace& ) = delete; + +private: + /* + Parameters: + bLazy - [in] + If true and if ON_BrepFace.m_bbox is not empty, then ON_BrepFace.m_bbox is returned. + In all other cases the bbox is calculated from scratch. + bUpdateCachedBBox - [in] + If true and the bounding box is calculated, then the value is saved in ON_BrepFace.m_bbox + so future lazy evaluations can use the value. + */ + const ON_BoundingBox InternalFaceBoundingBox(bool bLazy, bool bUpdateCachedBBox) const; }; class ON_CLASS ON_BrepFaceSide : public ON_Object @@ -4128,6 +4140,18 @@ public: // The ON_Brep code increments ON_Brep::ErrorCount everytime something // unexpected happens. This is useful for debugging. static unsigned int ErrorCount; + +private: + /* + Parameters: + bLazy - [in] + If true and if ON_BrepFace.m_bbox is not empty, then ON_BrepFace.m_bbox is returned. + In all other cases the bbox is calculated from scratch. + bUpdateCachedBBox - [in] + If true and the bounding box is calculated, then the value is saved in ON_BrepFace.m_bbox + so future lazy evaluations can use the value. + */ + const ON_BoundingBox InternalBrepBoundingBox(bool bLazy, bool bUpdateCachedBBox) const; }; /////////////////////////////////////////////////////////////////////////////// diff --git a/opennurbs_brep_io.cpp b/opennurbs_brep_io.cpp index 41894ea6..68f7305a 100644 --- a/opennurbs_brep_io.cpp +++ b/opennurbs_brep_io.cpp @@ -861,6 +861,28 @@ void ReadFillInMissingBoxes( ON_Brep& brep ) } } +static const ON_BoundingBox Internal_BestBoundingBox( + const ON_BoundingBox archive_bbox, + const ON_BoundingBox new_bbox +) +{ + if (false == new_bbox.IsNotEmpty()) + return archive_bbox; // don't have a new bbox + + if (false == archive_bbox.IsValid()) + return new_bbox; + + if (archive_bbox.Includes(new_bbox, false)) + return new_bbox; + + // The best code currently available calculated new_box. + // I should be good enough. If it is different + // from archive then you need to understand WHY it is different + // and fix the problem at the source - not mask it at read time. + return new_bbox; // <- Good place to debug bbox reading bugs + +} + bool ON_Brep::Read( ON_BinaryArchive& file ) { int i; @@ -1105,16 +1127,41 @@ bool ON_Brep::Read( ON_BinaryArchive& file ) // In V6 and earlier bounding boxes of faces were bounding box of underlying surface. // This can result in enourmous boxes which mess up make2d // In V7 bounding boxes use the trim pbox resulting in resonable boxes. - if (file.Archive3dmVersion() < 70 || file.ArchiveOpenNURBSVersion() < 2382395020) + ////if (file.Archive3dmVersion() < 70 || file.ArchiveOpenNURBSVersion() < 2382395020) + ////{ + //// if (!m_bbox.IsEmpty()) + //// { + //// ON_BoundingBox orig_box = m_bbox; + //// ClearBoundingBox(); + //// BoundingBox(); // compute bounding box + //// m_bbox.Intersection(orig_box); + //// } + ////} + + // Dale Lear https://mcneel.myjetbrains.com/youtrack/issue/RH-64277 + // The test used to fix RH-60112 was not adequate and now the set of + // active v7 3dm files has lots of cases with breps that have + // oversized bounding boxes by the new standard avter Greg's RH-60112 changes. + // We have already started writing V8 files and those versions of V8 + // have been used by some of our Discourse early adopters. + // At this point, I'm going to assume a bounding box read from a V7 or V8 file + // can be too big. By the time V9 rolls around, the boxes should be cleaned up. + if (file.Archive3dmVersion() < 90 && m_bbox.IsNotEmpty() ) { - if (!m_bbox.IsEmpty()) + const ON_BoundingBox archive_brep_bbox = m_bbox; + ON_BoundingBox new_brep_bbox = ON_BoundingBox::EmptyBoundingBox; + const unsigned int face_count = m_F.UnsignedCount(); + for (unsigned fi = 0; fi < face_count; ++fi) { - ON_BoundingBox orig_box = m_bbox; - ClearBoundingBox(); - BoundingBox(); // compute bounding box - m_bbox.Intersection(orig_box); + ON_BrepFace& f = this->m_F[fi]; + const ON_BoundingBox archive_face_bbox = f.m_bbox; + ON_BoundingBox new_face_bbox = f.InternalFaceBoundingBox(false, false); + f.m_bbox = Internal_BestBoundingBox(archive_face_bbox, new_face_bbox); + new_brep_bbox.Union(f.m_bbox); } + m_bbox = Internal_BestBoundingBox(archive_brep_bbox, new_brep_bbox); } + return rc; } diff --git a/opennurbs_color.h b/opennurbs_color.h index a3d68386..8f5af218 100644 --- a/opennurbs_color.h +++ b/opennurbs_color.h @@ -38,6 +38,7 @@ public: static const ON_Color SaturatedYellow; // 0x0000FFFFu on little endan, 0xFFFF0000u on big endian static const ON_Color SaturatedCyan; // 0x00FFFF00u on little endan, 0x00FFFF00u on big endian static const ON_Color SaturatedMagenta; // 0x00FF00FFu on little endan, 0xFF00FF00u on big endian + static const ON_Color SaturatedGold; // 0x0000BFFFu on little endan, 0xFFBF0000u on big endian static const ON_Color Gray105; // R = G = B = 105 (medium dark) static const ON_Color Gray126; // R = G = B = 128 (medium) static const ON_Color Gray160; // R = G = B = 160 (medium light) diff --git a/opennurbs_defines.h b/opennurbs_defines.h index 5f646f20..fa156bae 100644 --- a/opennurbs_defines.h +++ b/opennurbs_defines.h @@ -273,7 +273,7 @@ double ON_RadiansFromDegrees( #define ON_UNSET_POSITIVE_FLOAT 1.234321e+38f #define ON_UNSET_FLOAT -ON_UNSET_POSITIVE_FLOAT -// When unsinged int values are used in a context where +// When unsigned int values are used in a context where // 0 is a valid index and there needs to be a value that // indicates the index is not set, use ON_UNSET_UINT_INDEX. #define ON_UNSET_UINT_INDEX 0xFFFFFFFFU @@ -2707,6 +2707,65 @@ public: int m_index; }; +class ON_CLASS ON_ComponentIndexAndNumber +{ +public: + ON_ComponentIndexAndNumber() = default; + ~ON_ComponentIndexAndNumber() = default; + ON_ComponentIndexAndNumber(const ON_ComponentIndexAndNumber&) = default; + ON_ComponentIndexAndNumber& operator=(const ON_ComponentIndexAndNumber&) = default; + +public: + static const ON_ComponentIndexAndNumber UnsetAndNan; + static const ON_ComponentIndexAndNumber UnsetAndZero; + static const ON_ComponentIndexAndNumber Create( + ON_COMPONENT_INDEX ci, + double x + ); + +public: + + /* + Description: + Compare Component() using ON_COMPONENT_INDEX::Compare(). + */ + static int CompareComponent( + const ON_ComponentIndexAndNumber* a, + const ON_ComponentIndexAndNumber* b + ); + + + /* + Description: + Compare Number() nans are treated as equal and sort last. + */ + static int CompareNumber( + const ON_ComponentIndexAndNumber* a, + const ON_ComponentIndexAndNumber* b + ); + + /* + Description: + Dictionary compare Component() 1st and Number() 2nd. + */ + static int CompareComponentAndNumber( + const ON_ComponentIndexAndNumber* a, + const ON_ComponentIndexAndNumber* b + ); + + +public: + const ON_COMPONENT_INDEX Component() const; + void SetComponent(ON_COMPONENT_INDEX ci); + + double Number() const; + void SetNumber(double x); + +public: + ON_COMPONENT_INDEX m_ci = ON_COMPONENT_INDEX::UnsetComponentIndex; + double m_x = ON_DBL_QNAN; +}; + #endif ON_BEGIN_EXTERNC diff --git a/opennurbs_dimension.cpp b/opennurbs_dimension.cpp index ce8be3be..47252177 100644 --- a/opennurbs_dimension.cpp +++ b/opennurbs_dimension.cpp @@ -3526,6 +3526,7 @@ bool ON_DimAngular::GetDisplayLines( isline[0] = isline[1] = isarc[0] = isarc[1] = false; double eo = style->ExtOffset() * dimscale; double ee = style->ExtExtension() * dimscale; + double el = style->FixedExtensionLen() * dimscale; double radius = Radius(); if (1.0e-8 > radius) return false; @@ -3542,14 +3543,24 @@ bool ON_DimAngular::GetDisplayLines( { double eo0 = eo; double ee0 = ee; + double el0 = el; if (m_ext_offset_1 > radius) { eo0 = -eo0; ee0 = -ee0; + el0 = -el0; + } + ON_2dPoint lpt0, lpt1; + if (style->FixedExtensionLenOn()) + { + lpt1 = m_vec_1 * (radius + ee0); + lpt0 = lpt1 + (-m_vec_1 * (el0 + ee0)); + } + else + { + lpt0 = m_vec_1 * (m_ext_offset_1 + eo0); + lpt1 = m_vec_1 * (radius + ee0); } - ON_2dPoint lpt0 = m_vec_1 * (m_ext_offset_1 + eo0); - ON_2dPoint lpt1 = m_vec_1 * (radius + ee0); - lines[0].from = m_plane.PointAt(lpt0.x, lpt0.y); lines[0].to = m_plane.PointAt(lpt1.x, lpt1.y); isline[0] = true; @@ -3559,13 +3570,24 @@ bool ON_DimAngular::GetDisplayLines( { double eo1 = eo; double ee1 = ee; + double el1 = el; if (m_ext_offset_2 > radius) { eo1 = -eo1; ee1 = -ee1; + el1 = -el1; + } + ON_2dPoint lpt0, lpt1; + if (style->FixedExtensionLenOn()) + { + lpt1 = m_vec_2 * (radius + ee1); + lpt0 = lpt1 + (-m_vec_2 * (el1 + ee1)); + } + else + { + lpt0 = m_vec_2 * (m_ext_offset_2 + eo1); + lpt1 = m_vec_2 * (radius + ee1); } - ON_2dPoint lpt0 = m_vec_2 * (m_ext_offset_2 + eo1); - ON_2dPoint lpt1 = m_vec_2 * (radius + ee1); lines[1].from = m_plane.PointAt(lpt0.x, lpt0.y); lines[1].to = m_plane.PointAt(lpt1.x, lpt1.y); isline[1] = true; diff --git a/opennurbs_dimensionstyle.cpp b/opennurbs_dimensionstyle.cpp index 80f202e4..ef04b7bc 100644 --- a/opennurbs_dimensionstyle.cpp +++ b/opennurbs_dimensionstyle.cpp @@ -4342,10 +4342,10 @@ void ON_DimStyle::SetZeroSuppress(ON_DimStyle::suppress_zero s) m_zero_suppress = s; Internal_ContentChange(); } - else - { - ON_ERROR("Attempting to set zero suppression to a value that doesn't match length display."); - } + //else + //{ + // ON_ERROR("Attempting to set zero suppression to a value that doesn't match length display."); + //} } Internal_SetOverrideDimStyleCandidateFieldOverride(ON_DimStyle::field::ZeroSuppress); } diff --git a/opennurbs_extensions.cpp b/opennurbs_extensions.cpp index bc3f6f7b..3867fa59 100644 --- a/opennurbs_extensions.cpp +++ b/opennurbs_extensions.cpp @@ -1204,6 +1204,8 @@ int ONX_Model::AddDefaultDimensionStyle( { system_dimstyle = &ON_DimStyle::Default; } + + source_dimstyle = system_dimstyle; } ON_DimStyle* default_dimstyle = new ON_DimStyle(*source_dimstyle); diff --git a/opennurbs_instance.cpp b/opennurbs_instance.cpp index 19cfdf67..cd0308c5 100644 --- a/opennurbs_instance.cpp +++ b/opennurbs_instance.cpp @@ -852,6 +852,9 @@ void ON_InstanceDefinition::Internal_Copy(const ON_InstanceDefinition& src) m_linked_component_appearance = src.m_linked_component_appearance; if (nullptr != src.m_linked_idef_component_settings) m_linked_idef_component_settings = new ON_ReferencedComponentSettings(*src.m_linked_idef_component_settings); + + //This omission was causing part of https://mcneel.myjetbrains.com/youtrack/issue/RH-47128 + m_object_uuid = src.m_object_uuid; } diff --git a/opennurbs_internal_Vx_annotation.cpp b/opennurbs_internal_Vx_annotation.cpp index a3c5ecac..28bab459 100644 --- a/opennurbs_internal_Vx_annotation.cpp +++ b/opennurbs_internal_Vx_annotation.cpp @@ -596,8 +596,10 @@ ON_OBSOLETE_V5_TextObject* ON_OBSOLETE_V5_TextObject::CreateFromV6TextObject( if (textgeom->HasWrappedRuns()) { - const ON_wString plaintextFields = textgeom->WrappedPlainTextWithFields(); - V5_text_object->SetTextFormula(plaintextFields); + // RH-64471 - WrappedPlainTextWithFields() adds multiple copies of the entire + // text string for each wrapped run. + //const ON_wString plaintextFields = textgeom->WrappedPlainTextWithFields(); + //V5_text_object->SetTextFormula(plaintextFields); const ON_wString plaintext = textgeom->WrappedPlainText(); V5_text_object->SetTextValue(plaintext); } diff --git a/opennurbs_layer.cpp b/opennurbs_layer.cpp index 171ba841..65453db2 100644 --- a/opennurbs_layer.cpp +++ b/opennurbs_layer.cpp @@ -375,6 +375,16 @@ bool ON_Layer::Read( if ( rc ) rc = file.ReadInt( &obsolete_value1 ); if ( rc ) rc = file.ReadColor( m_color ); + // 25 Aug 2021 S. Baer (RH-65410) + // Pre-V7 files ignored alpha on layer colors and in some cases + // alpha was being set to completely transparent. In this case, + // make the color opaque. Even V7 files with completely transparent + // color is strange, but it can be intentionally set for some reason + if (rc && m_color.Alpha() == 255 && m_color != ON_Color::UnsetColor && file.Archive3dmVersion() < 70) + { + m_color.SetAlpha(0); + } + { // OBSOLETE line style was never used - read and discard the next 20 bytes short s; diff --git a/opennurbs_lookup.h b/opennurbs_lookup.h index ef019a04..c3c70744 100644 --- a/opennurbs_lookup.h +++ b/opennurbs_lookup.h @@ -359,7 +359,7 @@ private: ON__UINT64 m_sn_count = 0; // total number of elements ON__UINT64 m_sn_purged = 0; // total number of purged elements - // The blocks in m_sn_list[] are alwasy sorted, disjoint, + // The blocks in m_sn_list[] are always sorted, disjoint, // and in increasing order. m_sn_list is used when // m_sn_block0.m_sn[] is not large enough. // The sn list is partitioned into blocks to avoid diff --git a/opennurbs_material.cpp b/opennurbs_material.cpp index b1099f86..4c78dab2 100644 --- a/opennurbs_material.cpp +++ b/opennurbs_material.cpp @@ -2256,6 +2256,7 @@ ON_Texture::MAPPING_CHANNEL ON_Texture::BuiltInMappingChannelFromUnsigned( const ON_SHA1_Hash ON_Texture::ContentHash() const { ON_SHA1 sha1; + sha1.AccumulateUnsigned32(m_mapping_channel_id); sha1.AccumulateSubHash(m_image_file_reference.FullPathHash()); sha1.AccumulateBool(m_bOn); sha1.AccumulateUnsigned32(static_cast(m_type)); @@ -3761,7 +3762,7 @@ bool ON_TextureMapping::HasMatchingTextureCoordinates( // values are independent of the 3d location // of the mesh. The ON_TextureMapping::TYPE::srfp_mapping != m_type // check is used because these mappings are - // alwasy independent of 3d location but + // always independent of 3d location but // the transformations are often set. if ( ON_TextureMapping::TYPE::srfp_mapping != m_type && mesh_xform diff --git a/opennurbs_math.cpp b/opennurbs_math.cpp index babb5422..43d3cb89 100644 --- a/opennurbs_math.cpp +++ b/opennurbs_math.cpp @@ -168,7 +168,7 @@ bool ON_PassesNanTest() const double zero = 0.0; const double one = 1.0; - // nan != * and * != nan should alwasy be true + // nan != * and * != nan should always be true const bool b_NE_test = nan1 != nan1 && nan1 != nan2 @@ -2566,7 +2566,7 @@ double ON_SolveNxN(bool bFullPivot, bool bNormalize, int n, double* M[], double // The Xdex_buffer[] hoo haa is here to avoid an potentially time // consuming call to heap services when the matrix is small. // When n > 64 the numerical portion of the computation is - // long enough that the time to call onmalloc() is negligable. + // long enough that the time to call onmalloc() is negligible. // (When n > 10-ish, this calculation is likely to return junk // unless you have a special case matrix, in which case this // function will be much slower than one that is designed to diff --git a/opennurbs_mesh.h b/opennurbs_mesh.h index 31121f5d..40d902aa 100644 --- a/opennurbs_mesh.h +++ b/opennurbs_mesh.h @@ -4029,7 +4029,7 @@ Returns: array of vertex indices bNoDuplicates - [in] If true, then only one edges[] is added for each edge, - the first vertex index will alwasy be less than the + the first vertex index will always be less than the second, and the returned elements are sorted in dictionary order. If false and an edge is shared by multiple faces, then @@ -5492,7 +5492,7 @@ public: Returns: True if no ON_Mesh is being managed by this ON_MeshRef. Remarks: - It is alwasy the case that exactly one of IsEmpty() and IsNotEmpty() is true. + It is always the case that exactly one of IsEmpty() and IsNotEmpty() is true. Both are provided so code using ON_MeshRef can be clean and easily read. */ bool IsEmpty() const; @@ -5501,7 +5501,7 @@ public: Returns: True if an ON_Mesh is being managed by this ON_MeshRef. Remarks: - It is alwasy the case that exactly one of IsEmpty() and IsNotEmpty() is true. + It is always the case that exactly one of IsEmpty() and IsNotEmpty() is true. Both are provided so code using ON_MeshRef can be clean and easily read. */ bool IsNotEmpty() const; diff --git a/opennurbs_mesh_ngon.cpp b/opennurbs_mesh_ngon.cpp index ad8ae61c..ac80123b 100644 --- a/opennurbs_mesh_ngon.cpp +++ b/opennurbs_mesh_ngon.cpp @@ -516,7 +516,7 @@ static char* ToStringHelper( const char* src_str, char* dst_str, const char* dst static char* ToStringHelper( unsigned int u, char* dst_str, const char* dst_str_end ) { - char ubuffer[32]; // unsinged int to string storage buffer + char ubuffer[32]; // unsigned int to string storage buffer unsigned int i, j; if ( ON_UNSET_UINT_INDEX == u ) diff --git a/opennurbs_object_history.cpp b/opennurbs_object_history.cpp index e05a7438..a3d06de4 100644 --- a/opennurbs_object_history.cpp +++ b/opennurbs_object_history.cpp @@ -2921,6 +2921,22 @@ void ON_HistoryRecord::RemapObjectIds( const ON_SimpleArray& id_rem objrev_v->m_value[j].RemapObjectId(id_remap); } } + // 24 May 2021, Mikko, RH-56171: + // Some commands like Offset use an UUID list to map inputs and outputs. + // Similar to remapping the objref ids, the uuid lists also need to be + // updated to use new ids. + // Other commands that currently use UUID lists are Divide, Slab, Ribbon, + // FilletSrf, ChamferSrf, ArrayCrv, Hatch. + else if (v && ON_Value::uuid_value == v->m_value_type) + { + ON_UuidValue* uuid_v = static_cast(v); + for (j = 0; j < uuid_v->m_value.Count(); j++) + { + int index = id_remap.BinarySearch((const ON_UuidPair*)&uuid_v->m_value[j], ON_UuidPair::CompareFirstUuid); + if (index >= 0) + uuid_v->m_value[j] = id_remap[index].m_uuid[1]; + } + } } } } diff --git a/opennurbs_objref.cpp b/opennurbs_objref.cpp index ca348b4f..b653c4d6 100644 --- a/opennurbs_objref.cpp +++ b/opennurbs_objref.cpp @@ -558,6 +558,75 @@ bool ON_COMPONENT_INDEX::operator>=(const ON_COMPONENT_INDEX& other) const return (ON_COMPONENT_INDEX::Compare(this,&other) >= 0); } +const ON_ComponentIndexAndNumber ON_ComponentIndexAndNumber::Create( + ON_COMPONENT_INDEX ci, + double x +) +{ + ON_ComponentIndexAndNumber cx; + cx.m_ci = ci; + cx.m_x = x; + return cx; +} + +int ON_ComponentIndexAndNumber::CompareComponent( + const ON_ComponentIndexAndNumber* a, + const ON_ComponentIndexAndNumber* b +) +{ + if (a == b) + return 0; + if (nullptr == a) + return -1; // nulls sort last + if (nullptr == b) + return -1; // nulls sort last + return ON_COMPONENT_INDEX::Compare(&a->m_ci, &b->m_ci); +} + +int ON_ComponentIndexAndNumber::CompareNumber( + const ON_ComponentIndexAndNumber* a, + const ON_ComponentIndexAndNumber* b +) +{ + if (a == b) + return 0; + if (nullptr == a) + return -1; // nulls sort last + if (nullptr == b) + return -1; // nulls sort last + return ON_CompareDouble(a->m_x, b->m_x); +} + +int ON_ComponentIndexAndNumber::CompareComponentAndNumber( + const ON_ComponentIndexAndNumber* a, + const ON_ComponentIndexAndNumber* b +) +{ + const int rc = ON_ComponentIndexAndNumber::CompareComponent(a, b); + return (0 == rc) ? ON_ComponentIndexAndNumber::CompareNumber(a,b) : rc; +} + + +const ON_COMPONENT_INDEX ON_ComponentIndexAndNumber::Component() const +{ + return m_ci; +} + +void ON_ComponentIndexAndNumber::SetComponent(ON_COMPONENT_INDEX ci) +{ + m_ci = ci; +} + +double ON_ComponentIndexAndNumber::Number() const +{ + return m_x; +} + +void ON_ComponentIndexAndNumber::SetNumber(double x) +{ + m_x = x; +} + ON_ObjRefEvaluationParameter::ON_ObjRefEvaluationParameter() : m_t_type(0) , m_reserved(0) diff --git a/opennurbs_parse_number.cpp b/opennurbs_parse_number.cpp index 461ba077..6372b3cf 100644 --- a/opennurbs_parse_number.cpp +++ b/opennurbs_parse_number.cpp @@ -988,7 +988,7 @@ static int ON_ParseFunctionHelper( if ( f_parameter_capacity < f->m_function_parameter_count ) break; - // The angle parameters passed to trig functions alwasy have + // The angle parameters passed to trig functions always have // an "implicit" angle system of radians. It is intentional that // this cannot be changed by parse settings. The reason is // to insure that the same script will create the same values diff --git a/opennurbs_point.cpp b/opennurbs_point.cpp index 70f0234d..b4423387 100644 --- a/opennurbs_point.cpp +++ b/opennurbs_point.cpp @@ -362,7 +362,7 @@ int ON_4dPoint::ProjectiveCompare( if (0.0 != lhs.w && 0.0 != rhs.w) { // neither lhs.w nor rhs.w is a nan - return ON_3dPoint::Compare(ON_3dPoint(lhs), ON_3dPoint(lhs)); + return ON_3dPoint::Compare(ON_3dPoint(lhs), ON_3dPoint(rhs)); } if (0.0 != lhs.w && 0.0 == rhs.w) diff --git a/opennurbs_pointcloud.cpp b/opennurbs_pointcloud.cpp index 1077109d..922d2d42 100644 --- a/opennurbs_pointcloud.cpp +++ b/opennurbs_pointcloud.cpp @@ -634,15 +634,15 @@ ON_PointCloud* ON_PointCloud::RandomSubsample( // For (min <= r < max): min + RandomNumber() % (max-min) const int point_index = gen.RandomNumber() % last_point_count; - destination_point_cloud->m_P.Swap(point_index, last_point_count); + destination_point_cloud->m_P.Swap(point_index, last_point_count - 1); if (bHaveNormals) - destination_point_cloud->m_N.Swap(point_index, last_point_count); + destination_point_cloud->m_N.Swap(point_index, last_point_count - 1); if (bHaveColors) - destination_point_cloud->m_C.Swap(point_index, last_point_count); + destination_point_cloud->m_C.Swap(point_index, last_point_count - 1); if (bHaveValues) - destination_point_cloud->m_V.Swap(point_index, last_point_count); + destination_point_cloud->m_V.Swap(point_index, last_point_count - 1); if (bHaveHidden) - destination_point_cloud->m_H.Swap(point_index, last_point_count); + destination_point_cloud->m_H.Swap(point_index, last_point_count - 1); last_point_count--; if (last_point_count <= 0) diff --git a/opennurbs_polycurve.cpp b/opennurbs_polycurve.cpp index 3e258f5c..2ff9f437 100644 --- a/opennurbs_polycurve.cpp +++ b/opennurbs_polycurve.cpp @@ -3719,7 +3719,23 @@ bool ON_PolyCurve::SynchronizeSegmentDomains() return rc; } +ON_Curve* ON_PolyCurve::ExplodeSingleSegmentCurve() const +{ + if (Count() != 1) + return 0; + ON_Curve* pSeg = SegmentCurve(0)->DuplicateCurve(); + if (!pSeg) + return 0; + ON_PolyCurve* pSegPly = ON_PolyCurve::Cast(pSeg); + if (pSegPly){ + delete pSeg; + return 0; + } + pSeg->SetDomain(Domain()); + pSeg->CopyUserData(*this,ON_nil_uuid,ON_Object::UserDataConflictResolution::source_object); + return pSeg; +} bool ON_PolyCurve::RemoveNesting( ) { diff --git a/opennurbs_polycurve.h b/opennurbs_polycurve.h index 1e48e48a..39db2a91 100644 --- a/opennurbs_polycurve.h +++ b/opennurbs_polycurve.h @@ -693,6 +693,19 @@ public: */ bool IsNested() const; + /* + Description: + If this has a single segment, return that single segment with user_data copied, + reversed if necessary so the sense of the result is the same as this, + and domain adjusted to match this->Domain. If the single segment is a polycurve, + RemoveNesting should be called before calling ExplodeSingleSegmentCurve. + Returns: + NULL if not a single span polycurve + The single span, adjusted as described above; + */ + + ON_Curve* ExplodeSingleSegmentCurve() const; + /* Description: Removes the nested of polycurves. The result will have not diff --git a/opennurbs_public_version.h b/opennurbs_public_version.h index c365e1e0..f0462c07 100644 --- a/opennurbs_public_version.h +++ b/opennurbs_public_version.h @@ -6,7 +6,7 @@ // To update version numbers, edit ..\build\build_dates.msbuild #define RMA_VERSION_MAJOR 7 -#define RMA_VERSION_MINOR 6 +#define RMA_VERSION_MINOR 11 //////////////////////////////////////////////////////////////// // @@ -14,9 +14,9 @@ // first step in each build. // #define RMA_VERSION_YEAR 2021 -#define RMA_VERSION_MONTH 5 -#define RMA_VERSION_DATE 7 -#define RMA_VERSION_HOUR 19 +#define RMA_VERSION_MONTH 10 +#define RMA_VERSION_DATE 12 +#define RMA_VERSION_HOUR 13 #define RMA_VERSION_MINUTE 0 //////////////////////////////////////////////////////////////// @@ -35,8 +35,8 @@ // 3 = build system release build #define RMA_VERSION_BRANCH 0 -#define VERSION_WITH_COMMAS 7,6,21127,19000 -#define VERSION_WITH_PERIODS 7.6.21127.19000 +#define VERSION_WITH_COMMAS 7,11,21285,13000 +#define VERSION_WITH_PERIODS 7.11.21285.13000 #define COPYRIGHT "Copyright (C) 1993-2021, Robert McNeel & Associates. All Rights Reserved." #define SPECIAL_BUILD_DESCRIPTION "Public OpenNURBS C++ 3dm file IO library." @@ -44,11 +44,11 @@ #define RMA_VERSION_NUMBER_MAJOR_WSTRING L"7" #define RMA_PREVIOUS_VERSION_NUMBER_MAJOR_WSTRING L"6" -#define RMA_VERSION_NUMBER_SR_STRING "SR6" -#define RMA_VERSION_NUMBER_SR_WSTRING L"SR6" +#define RMA_VERSION_NUMBER_SR_STRING "SR11" +#define RMA_VERSION_NUMBER_SR_WSTRING L"SR11" -#define RMA_VERSION_WITH_PERIODS_STRING "7.6.21127.19000" -#define RMA_VERSION_WITH_PERIODS_WSTRING L"7.6.21127.19000" +#define RMA_VERSION_WITH_PERIODS_STRING "7.11.21285.13000" +#define RMA_VERSION_WITH_PERIODS_WSTRING L"7.11.21285.13000" diff --git a/opennurbs_rtree.cpp b/opennurbs_rtree.cpp index 412b6db9..45d5437f 100644 --- a/opennurbs_rtree.cpp +++ b/opennurbs_rtree.cpp @@ -672,17 +672,25 @@ bool ON_RTree::CreateMeshFaceTree( const ON_Mesh* mesh ) return (0 != m_root); } -bool ON_SubDRTree::CreateSubDVertexRTree( - const ON_SubD& subd, - ON_SubDComponentLocation vertex_location + +bool ON_SubDRTree::CreateSubDEmptyRTree( + const ON_SubD& subd ) { // ShareContentsFrom() increments the reference count on m_subdimple_sp // so vertex pointers one this RTree's nodes will be valid for the duration // of the rtree's existence. m_subd.ShareContentsFrom(const_cast(subd)); - this->RemoveAll(); + return true; +} + +bool ON_SubDRTree::CreateSubDVertexRTree( + const ON_SubD& subd, + ON_SubDComponentLocation vertex_location +) +{ + CreateSubDEmptyRTree(subd); ON_SubDVertexIterator vit(m_subd); @@ -698,6 +706,17 @@ bool ON_SubDRTree::CreateSubDVertexRTree( return (nullptr != this->Root()); } +bool ON_SubDRTree::AddVertex( + const ON_SubDVertex* v, + ON_SubDComponentLocation vertex_location +) +{ + const ON_3dPoint P = (nullptr != v) ? v->Point(vertex_location) : ON_3dPoint::NanPoint; + return P.IsValid() ? this->Insert(&P.x, &P.x, (void*)v) : false; +} + + + const ON_SubDVertex* ON_SubDRTree::FindVertexAtPoint( const ON_3dPoint P, const double distance_tolerance @@ -760,6 +779,30 @@ const ON_SubDVertex* ON_SubDRTree::FindUnmarkedVertexAtPoint( return vf.m_v; } +const ON_SubDVertex* ON_SubDRTree::FindVertex( + const class ON_SubDRTreeVertexFinder& vertex_finder, + const double distance_tolerance +) const +{ + ON_SubDRTreeVertexFinder vf(vertex_finder); + if (false == vf.m_P.IsValid()) + return nullptr; + + vf.m_distance = ON_SubDRTreeVertexFinder::Unset.m_distance; + vf.m_v = ON_SubDRTreeVertexFinder::Unset.m_v; + + ON_BoundingBox rbox; + const ON_3dVector rtol(distance_tolerance, distance_tolerance, distance_tolerance); + + rbox.m_min = vf.m_P - rtol; + rbox.m_max = vf.m_P + rtol; + // vtree.Search() can return true (found nearby) and false (found exact) because + // ON_SubDRTreeVertexFinder::Callback() cancels the search when a vertex at the exact location + // is found. + this->Search(&rbox.m_min.x, &rbox.m_max.x, ON_SubDRTreeVertexFinder::Callback, &vf); + return vf.m_v; +} + void ON_SubDRTree::Clear() { RemoveAll(); // clear the rtree @@ -786,14 +829,63 @@ const ON_SubDRTreeVertexFinder ON_SubDRTreeVertexFinder::Create(const ON_3dPoint return vf; } +const ON_SubDRTreeVertexFinder ON_SubDRTreeVertexFinder::Create( + const ON_3dPoint P, + ON_SubDRTreeVertexFinder::MarkBitsFilter mark_bits_filter, + ON__UINT8 mark_bits +) +{ + ON_SubDRTreeVertexFinder vf = ON_SubDRTreeVertexFinder::Create(P); + vf.m_mark_bits_filter = mark_bits_filter; + vf.m_mark_bits = mark_bits; + return vf; +} + + bool ON_SubDRTreeVertexFinder::Callback(void* a_context, ON__INT_PTR a_id) { for (;;) { ON_SubDRTreeVertexFinder* vf = (ON_SubDRTreeVertexFinder*)a_context; const ON_SubDVertex* v = (const ON_SubDVertex*)a_id; - if (nullptr == v || (vf->m_bMarkFilterEnabled && vf->m_bMarkFilter != v->Mark())) - break; // when m_bMarkFilterEnabled is true, only vertices with v->Mark() == m_bMarkFilter can be found. + if (nullptr == v ) + break; + + if (vf->m_bMarkFilterEnabled && vf->m_bMarkFilter != v->Mark()) + { + // v is not eligable. + // Returning true means continue searching for other vertices + return true; + } + + if (ON_SubDRTreeVertexFinder::MarkBitsFilter::None != vf->m_mark_bits_filter) + { + const ON__UINT8 v_mark_bits = v->MarkBits(); + switch(vf->m_mark_bits_filter) + { + case ON_SubDRTreeVertexFinder::MarkBitsFilter::Equal: + if (vf->m_mark_bits != v_mark_bits) + { + // v is not eligable. + // Returning true means continue searching for other vertices + return true; + } + break; + + case ON_SubDRTreeVertexFinder::MarkBitsFilter::NotEqual: + if (vf->m_mark_bits == v_mark_bits) + { + // v is not eligable. + // Returning true means continue searching for other vertices + return true; + } + break; + + default: + break; + } + } + const double d = (vf->m_P - v->ControlNetPoint()).MaximumCoordinate(); if (d >= 0.0) { diff --git a/opennurbs_statics.cpp b/opennurbs_statics.cpp index b80801ec..bc23eb8f 100644 --- a/opennurbs_statics.cpp +++ b/opennurbs_statics.cpp @@ -29,7 +29,6 @@ static unsigned int ON_LibraryStatusInit() unsigned int ON::m_opennurbs_library_status = ON_LibraryStatusInit(); - unsigned int ON_MemoryAllocationTracking::m_g_stack_depth = 0; int ON_MemoryAllocationTracking::m_g_crt_dbg_flag0 = 0; @@ -110,6 +109,20 @@ std::atomic ON_ModelComponent::Internal_RuntimeSerialNumberGenerator std::atomic ON_SubDimple::Internal_RuntimeSerialNumberGenerator; +const double ON_SubDExpandEdgesParameters::OffsetTolerance = 0.001; + +const double ON_SubDExpandEdgesParameters::MinimumOffset = 0.05; + +const double ON_SubDExpandEdgesParameters::MaximumOffset = 0.95; + +const double ON_SubDExpandEdgesParameters::SmallOffset = 0.125; + +const double ON_SubDExpandEdgesParameters::MediumOffset = 0.25; + +const double ON_SubDExpandEdgesParameters::LargeOffset = 0.5; + +const ON_SubDExpandEdgesParameters ON_SubDExpandEdgesParameters::Default ON_CLANG_CONSTRUCTOR_BUG_INIT(ON_SubDExpandEdgesParameters); + const ON_SubDComponentLocation ON_SubD::DefaultSubDAppearance = ON_SubDComponentLocation::Surface; // The default type must be packed, unpacked, zero, or nan and should be packed or upacked. @@ -152,6 +165,9 @@ const ON_SubDToBrepParameters ON_SubDToBrepParameters::DefaultUnpacked = Interna const ON_SubDToBrepParameters ON_SubDToBrepParameters::DefaultPacked = Internal_SubDToBrepParameters(true); +const ON_SubDRTreeVertexFinder ON_SubDRTreeVertexFinder::Unset ON_CLANG_CONSTRUCTOR_BUG_INIT(ON_SubDRTreeVertexFinder); + + ON_ClassId* ON_ClassId::m_p0 = 0; // static pointer to first id in list ON_ClassId* ON_ClassId::m_p1 = 0; // static pointer to last id in list int ON_ClassId::m_mark0 = 0; @@ -265,6 +281,8 @@ const ON_UUID ON_opennurbs_id = ON_opennurbs7_id; const ON_UuidPairList ON_UuidPairList::EmptyList; const ON_COMPONENT_INDEX ON_COMPONENT_INDEX::UnsetComponentIndex; +const ON_ComponentIndexAndNumber ON_ComponentIndexAndNumber::UnsetAndNan = ON_ComponentIndexAndNumber::Create(ON_COMPONENT_INDEX::UnsetComponentIndex, ON_DBL_QNAN); +const ON_ComponentIndexAndNumber ON_ComponentIndexAndNumber::UnsetAndZero = ON_ComponentIndexAndNumber::Create(ON_COMPONENT_INDEX::UnsetComponentIndex, 0.0); // All opennurbs static members are initialized here so that initialization happens in a predictable order. /* @@ -515,11 +533,24 @@ static struct ON_UnicodeErrorParameters ON_Internal_UnicodeErrorParameters_Defau const struct ON_UnicodeErrorParameters ON_UnicodeErrorParameters::MaskErrors = ON_Internal_UnicodeErrorParameters_Default(0xFFFFFFFF); const struct ON_UnicodeErrorParameters ON_UnicodeErrorParameters::FailOnErrors = ON_Internal_UnicodeErrorParameters_Default(0); + +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::Null = ON_UnicodeShortCodePoint::Create(0); +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::ReplacementCharacter = ON_UnicodeShortCodePoint::Create(0xFFFD); +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::ByteOrderMark = ON_UnicodeShortCodePoint::Create(0xFFFE); +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::Error = ON_UnicodeShortCodePoint::Create(0xFFFF); + +const ON_Big5CodePoint ON_Big5CodePoint::Null = ON_Big5CodePoint::Create(0); +const ON_Big5CodePoint ON_Big5CodePoint::WindowsEuro = ON_Big5CodePoint::Create(0xA3E1); +const ON_Big5CodePoint ON_Big5CodePoint::Error = ON_Big5CodePoint::Create(0xFFFF); + +const ON_Big5UnicodePair ON_Big5UnicodePair::Null = ON_Big5UnicodePair::Create(ON_Big5CodePoint::Null, ON_UnicodeShortCodePoint::Null); +const ON_Big5UnicodePair ON_Big5UnicodePair::Error = ON_Big5UnicodePair::Create(ON_Big5CodePoint::Error, ON_UnicodeShortCodePoint::Error); + const ON_String ON_String::EmptyString; static const ON_String ON_Internal_ByteOrderMark() { // UTF-8 encoded byte order mark. - const unsigned char bom[3] = {0xEFU,0xBBU,0xBFU}; + const unsigned char bom[4] = {0xEFU,0xBBU,0xBFU,0x00U}; return ON_String((const char*)bom); } const ON_String ON_String::ByteOrderMark(ON_Internal_ByteOrderMark()); @@ -843,6 +874,7 @@ const ON_Color ON_Color::SaturatedBlue(0, 0, 255); const ON_Color ON_Color::SaturatedYellow(255, 255, 0); const ON_Color ON_Color::SaturatedCyan(0, 255, 255); const ON_Color ON_Color::SaturatedMagenta(255, 0, 255); +const ON_Color ON_Color::SaturatedGold(255, 191, 0); const ON_Color ON_Color::Gray105(105, 105, 105); const ON_Color ON_Color::Gray126(126, 126, 126); const ON_Color ON_Color::Gray160(160, 160, 160); @@ -2657,6 +2689,13 @@ const ON_SubDEdgePtr ON_SubDEdgePtr::Null = { 0 }; const ON_SubDFacePtr ON_SubDFacePtr::Null = { 0 }; const ON_SubDComponentPtr ON_SubDComponentPtr::Null = { 0 }; const ON_SubDComponentPtrPair ON_SubDComponentPtrPair::Null = ON_SubDComponentPtrPair::Create(ON_SubDComponentPtr::Null,ON_SubDComponentPtr::Null); + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::NullAndNan = ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Null, ON_DBL_QNAN); +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::NullAndZero = ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Null, 0.0); + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::NullAndNan = ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Null, ON_3dPoint::NanPoint); +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::NullAndOrigin = ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Null, ON_3dPoint::Origin); + const ON_SubDComponentList ON_SubDComponentList::Empty ON_CLANG_CONSTRUCTOR_BUG_INIT(ON_SubDComponentList); const ON_SubD_ComponentIdTypeAndTag ON_SubD_ComponentIdTypeAndTag::Unset ON_CLANG_CONSTRUCTOR_BUG_INIT(ON_SubD_ComponentIdTypeAndTag); diff --git a/opennurbs_string.cpp b/opennurbs_string.cpp index 7d771da8..f41051b7 100644 --- a/opennurbs_string.cpp +++ b/opennurbs_string.cpp @@ -1658,6 +1658,437 @@ ON_String ON_String::Right(int count) const } +static bool ON_IsBig5Encoded(const char* buffer, int buffer_length) +{ + if (nullptr == buffer) + return false; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (buffer_length <= 0 || buffer_length > ON_String::MaximumStringLength) + return false; + + int db_count = 0; + + int delta_i = 0; + for (int i = 0; i < buffer_length; i += (delta_i > 0) ? delta_i : 1) + { + delta_i = 1; + const char c = buffer[i]; + if (c >= 0 && c <= 0x7F) + continue; // ASCII single byte + if (i + 2 <= buffer_length) + { + ON_Big5CodePoint big5_cp = ON_Big5CodePoint::Error; + const char* b2 = ON_Big5CodePoint::Decode( + buffer + i, + 2, + false, false, + &big5_cp + ); + if (b2 == buffer + i + 2 && big5_cp.IsValid(false, false)) + { + delta_i = 2; + ++db_count; + continue; + } + } + return false; + } + + return (db_count > 0); +} + + + +static unsigned Internal_Big5ToUTF32( + const char* buffer, + int buffer_length, + ON_SimpleArray& utf32 +) +{ + unsigned replacement_count = 0; + + utf32.SetCount(0); + + if (nullptr == buffer) + return false; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (buffer_length <= 0 || buffer_length > ON_String::MaximumStringLength) + return false; + + utf32.Reserve(buffer_length); + + int db_count = 0; + + int delta_i = 0; + for (int i = 0; i < buffer_length; i += (delta_i > 0) ? delta_i : 1) + { + delta_i = 1; + const char c = buffer[i]; + if (c >= 0 && c <= 0x7F) + { + // ASCII single byte + utf32.Append((unsigned char)c); + continue; + } + if (i + 2 <= buffer_length) + { + ON_Big5CodePoint big5_cp = ON_Big5CodePoint::Error; + const char* b2 = ON_Big5CodePoint::Decode( + buffer + i, + 2, + false, false, + &big5_cp + ); + if (b2 == buffer + i + 2 && big5_cp.IsValid(false, false)) + { + const ON_UnicodeShortCodePoint u = ON_UnicodeShortCodePoint::CreateFromBig5(big5_cp, ON_UnicodeShortCodePoint::ReplacementCharacter); + if (u.IsReplacementCharacter()) + ++replacement_count; + utf32.Append(u.UnicodeCodePoint()); + delta_i = 2; + ++db_count; + continue; + } + } + utf32.Append(ON_UnicodeCodePoint::ON_ReplacementCharacter); + ++replacement_count; + } + + return replacement_count; +} + +static bool ON_IsUTF8Encoded(bool bSloppy, const char* buffer, int buffer_length) +{ + if (nullptr == buffer) + return false; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (buffer_length <= 0 || buffer_length > ON_String::MaximumStringLength) + return false; + + struct ON_UnicodeErrorParameters e0 + = bSloppy + ? ON_UnicodeErrorParameters::FailOnErrors + : ON_UnicodeErrorParameters::MaskErrors; + e0.m_error_code_point = ON_UnicodeCodePoint::ON_InvalidCodePoint; + ON__UINT32 unicode_code_point; + int delta_i = 0; + for (int i = 0; i < buffer_length; i += (delta_i > 0) ? delta_i : 1) + { + struct ON_UnicodeErrorParameters e = e0; + unicode_code_point = ON_UnicodeCodePoint::ON_InvalidCodePoint; + delta_i = ON_DecodeUTF8(buffer + i, buffer_length - i, &e, &unicode_code_point); + if (delta_i > 0 && ON_IsValidUnicodeCodePoint(unicode_code_point) && i + delta_i <= buffer_length) + continue; + return false; + } + + return true; +} + + +static bool ON_IsASCIIEncoded(const char* buffer, int buffer_length) +{ + if (nullptr == buffer) + return false; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (buffer_length <= 0 || buffer_length > ON_String::MaximumStringLength) + return false; + + if (buffer_length <= 0 || buffer_length > ON_String::MaximumStringLength) + return false; + + for (int i = 0; i < buffer_length; ++i) + { + char c = buffer[i]; + if (c >= 0 && c <= 127) + continue; + return false; + } + + return true; +} + + +bool ON_String::IsPossibleEncoding( + ON_String::Encoding encoding, + const char* buffer, + int buffer_length +) +{ + // In practice, this is used to choose between BIG5 and UTF when parsing strings that + // are names of components. + // + // If you need something more clever like NOTPOAD++ encoding detection, then you need + // to find a library that uses some sampling and linguistic analysis. + if (ON_String::Encoding::Unset == encoding) + return false; + if (ON_String::Encoding::Unknown == encoding) + return false; + if (nullptr == buffer) + return false; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (0 == buffer_length) + return true; + if (buffer_length < 0) + return false; + + switch (encoding) + { + case ON_String::Encoding::ASCII: + return ON_IsASCIIEncoded(buffer, buffer_length); + case ON_String::Encoding::UTF8: + return ON_IsUTF8Encoded(false, buffer, buffer_length); + case ON_String::Encoding::BIG5andASCII: + return ON_IsBig5Encoded(buffer, buffer_length); + case ON_String::Encoding::SloppyUTF8: + return ON_IsUTF8Encoded(false, buffer, buffer_length); + default: + break; + } + + return false; +} + +bool ON_String::IsPossibleEncoding( + ON_String::Encoding encoding +) const +{ + return ON_String::IsPossibleEncoding(encoding, this->Array(), this->Length()); +} + +ON_String::Encoding ON_String::ProbableEncoding() const +{ + return ON_String::ProbableEncoding(this->Array(), this->Length()); +} + +ON_String::Encoding ON_String::ProbableEncoding( + const char* buffer, + int buffer_length +) +{ + if (nullptr == buffer) + return ON_String::Encoding::Unknown; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + + if (buffer_length <= 0) + return ON_String::Encoding::Unknown; + + if (ON_String::IsPossibleEncoding(ON_String::Encoding::ASCII, buffer, buffer_length)) + return ON_String::Encoding::ASCII; + if (ON_String::IsPossibleEncoding(ON_String::Encoding::UTF8, buffer, buffer_length)) + return ON_String::Encoding::UTF8; + if (ON_String::IsPossibleEncoding(ON_String::Encoding::BIG5andASCII, buffer, buffer_length)) + return ON_String::Encoding::BIG5andASCII; + if (ON_String::IsPossibleEncoding(ON_String::Encoding::SloppyUTF8, buffer, buffer_length)) + return ON_String::Encoding::SloppyUTF8; + + return ON_String::Encoding::Unknown; +} + +const ON_String ON_String::ToUTF8( + const char* buffer, + int buffer_length +) +{ + if (nullptr == buffer) + return ON_String::EmptyString; + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (buffer_length <= 0) + return ON_String::EmptyString; + + unsigned bad_utf32_count = 0; + ON_SimpleArray utf32; + + const ON_String::Encoding e = ON_String::ProbableEncoding(buffer, buffer_length); + switch (e) + { + case ON_String::Encoding::ASCII: + case ON_String::Encoding::UTF8: + return ON_String(buffer, buffer_length); + break; + + case ON_String::Encoding::SloppyUTF8: + // ON_String -> ON_wString cleans up the slop. + // ON_wString -> ON_String converts the wchar_t UTF-X encoding to UTF-8. + return ON_String(ON_wString(ON_String(buffer, buffer_length))); + break; + + case ON_String::Encoding::BIG5andASCII: + bad_utf32_count = Internal_Big5ToUTF32(buffer, buffer_length, utf32); + break; + } + + const unsigned utf32_count = utf32.UnsignedCount(); + if (utf32_count > 0 && utf32_count >= 2* bad_utf32_count) + { + unsigned int error_status = 0; + const unsigned int error_mask = 0xFFFFFFFFu; + const int utf8_count = ON_ConvertUTF32ToUTF8( + false, // bTestByteOrder, + utf32.Array(), + utf32.Count(), + nullptr, // char* sUTF8, + 0, // int sUTF8_count, + &error_status, + error_mask, + ON_UnicodeCodePoint::ON_ReplacementCharacter, + nullptr //const ON__UINT32 * *sNextUTF32 + ); + if (utf8_count > 0) + { + error_status = 0; + ON_String utf8; + utf8.ReserveArray(utf8_count); + utf8.SetLength(utf8_count); + ON_ConvertUTF32ToUTF8( + false, // bTestByteOrder, + utf32.Array(), + utf32.Count(), + utf8.Array(), + utf8_count, + &error_status, + error_mask, + ON_UnicodeCodePoint::ON_ReplacementCharacter, + nullptr //const ON__UINT32 * *sNextUTF32 + ); + return utf8; + } + } + + return ON_String::EmptyString; +} + +const ON_String ON_String::ToUTF8() const +{ + if (IsPossibleEncoding(ON_String::Encoding::UTF8)) + return *this; + return ON_String::ToUTF8( this->Array(), this->Length() ); +} + + +const ON_String ON_String::ToBIG5( + const char* buffer, + int buffer_length, + int* error_count +) +{ + if (nullptr != error_count) + *error_count = 0; + + if (nullptr == buffer) + return ON_String::EmptyString; + + if (-1 == buffer_length) + buffer_length = ON_String::Length(buffer); + if (buffer_length <= 0 || buffer_length > ON_String::MaximumStringLength) + return ON_String::EmptyString; + + switch (ON_String::ProbableEncoding(buffer,buffer_length)) + { + case ON_String::Encoding::ASCII: + case ON_String::Encoding::BIG5andASCII: + return ON_String(buffer,buffer_length); + break; + + case ON_String::Encoding::UTF8: + case ON_String::Encoding::SloppyUTF8: + { + const ON_SimpleArray< ON_Big5UnicodePair>& unicode_to_big5 = ON_Big5UnicodePair::UnicodeToBig5(); + + const int big5_capacity = 2 * buffer_length; + int big5_len = 0; + ON_String big5; + char* big5_buffer = big5.ReserveArray(big5_capacity + 1); + + int code_point_count = 0; + int big5_code_point_count = 0; + int fail_count = 0; + int delta_i = 0; + for (int i = 0; i < buffer_length; i += (delta_i > 0 ? delta_i : 1)) + { + ON_UnicodeErrorParameters e = ON_UnicodeErrorParameters::MaskErrors; + e.m_error_code_point = ON_UnicodeCodePoint::ON_InvalidCodePoint; + ON__UINT32 unicode_code_point = e.m_error_code_point; + delta_i = ON_DecodeUTF8( + buffer + i, + buffer_length - i, + &e, + &unicode_code_point + ); + ++code_point_count; + + ON_Big5UnicodePair pair = ON_Big5UnicodePair::Error; + for (;;) + { + if (delta_i <= 0) + break; + if (false == ON_IsStandardUnicodeCodePoint(unicode_code_point)) + break; + + if (unicode_code_point >= 0 && unicode_code_point <= 0x7F) + { + // ASCII code point. + pair = ON_Big5UnicodePair::Create(unicode_code_point, unicode_code_point); + break; + } + + const ON_Big5UnicodePair key = ON_Big5UnicodePair::Create(0, unicode_code_point); + if (unicode_code_point != key.UnicodeCodePoint()) + break; + const int k = unicode_to_big5.BinarySearch(&key, ON_Big5UnicodePair::CompareUnicodeCodePoint); + if (k < 0) + break; + + // BIG5 code point + pair = unicode_to_big5[k]; + break; + } + + const int big5_delta = pair.IsValid(true, true) ? pair.Big5().Encode(big5_buffer + big5_len, big5_capacity - big5_len) : 0; + if (1 == big5_delta || 2 == big5_delta) + { + if (2 == big5_delta) + ++big5_code_point_count; + big5_len += big5_delta; + } + else + { + big5_buffer[big5_len++] = '?'; + ++fail_count; + } + } + if (big5_code_point_count > 0 && 2 * fail_count < code_point_count) + { + big5.SetLength(big5_len); + return big5; + } + } + break; + + default: + break; + } + return ON_String::EmptyString; +} + +const ON_String ON_String::ToBIG5( + int* error_count +) const +{ + const ON_String::Encoding e = this->ProbableEncoding(); + if (ON_String::Encoding::ASCII == e || ON_String::Encoding::BIG5andASCII == e) + return *this; + + return ON_String::ToBIG5(this->Array(), this->Length(), error_count); +} + ON_CheckSum::ON_CheckSum() { Zero(); diff --git a/opennurbs_string.h b/opennurbs_string.h index 3a83b09e..cafc2a7a 100644 --- a/opennurbs_string.h +++ b/opennurbs_string.h @@ -1016,7 +1016,21 @@ public: True if c is '0', '1', ..., or '9'. */ static bool IsDecimalDigit(char c); - + + /* + Description: + Decode this char string using the encoding specified by windows_code_page + to a UTF encoded wide character string. + Parameters: + windows_code_page - [in] + WIndows code page. For example, big5 = 950. + Returns: + A UTF encoded wide charater string. + See Also: + ON_wString::MultiByteEncode() + */ + const ON_wString MultiByteDecode(int windows_code_page) const; + private: // Use IsEmpty() or IsNotEmpty() when you want a bool // to test for the empty string. @@ -1090,13 +1104,13 @@ public: /* Returns: - number of nonzero elements in string. + number of char elements in string not including the null terminator. */ int Length() const; /* Returns: - number of nonzero elements in the string. + number of char elements in string not including the null terminator. */ unsigned int UnsignedLength() const; @@ -2082,6 +2096,122 @@ public: ON_String* ext ); +public: + + enum class Encoding : unsigned int + { + /// + /// Encoding not set. + /// + Unset = 0, + + /// + /// Encoding not known or cannot be determined. + /// + Unknown = 1, + + /// + /// All byte values are in the range 0 to 0x7F (127) + /// + ASCII = 2, + + /// + /// The sequence of byte values could be a UTF-8 encode string. + /// UTF-8 extends ASCII encoding. + /// + UTF8 = 3, + + /// + /// The sequence of byte values could be a UTF-8 encoding with oversized + /// encodings or surrogate pair code points. + /// + SloppyUTF8 = 4, + + /// + /// The sequence of byte values could be a BIG5 encode string + /// that may also contain single byte ASCII code points. + /// BIG5 is a double byte encoding and the first byte + /// always has the high bit set. + /// + BIG5andASCII = 5, + }; + + /* + Description: + Determine if the string's buffer can be parsed using the specified encoding. + */ + bool IsPossibleEncoding( + ON_String::Encoding encoding + ) const; + + /* + Description: + Determine if the buffer can be parsed using the specified encoding. + */ + static bool IsPossibleEncoding( + ON_String::Encoding encoding, + const char* buffer, + int buffer_length + ); + + ON_String::Encoding ProbableEncoding() const; + + static ON_String::Encoding ProbableEncoding( + const char* buffer, + int buffer_length + ); + + /* + Description: + Make an educated guess at the encoding and convert the string to UTF-8 encoding. + Returns: + If the string encoding could be determined and parsed, a UTF-8 encoded string is returned. + Otherwise EmptyString is returned. + */ + static const ON_String ToUTF8( + const char* buffer, + int buffer_length + ); + + /* + Description: + Make an educated guess at the encoding and convert the string to UTF-8 encoding. + Returns: + If the string encoding could be determined and parsed, a UTF-8 encoded string is returned. + Otherwise EmptyString is returned. + */ + const ON_String ToUTF8() const; + + /* + Description: + Make an educated guess at the encoding and convert the string to BIG5 encoding. + Parameters: + error_count - [out] + number of errors in encoding (question mark is used as a replacement character). + Returns: + If the string encoding could be determined and parsed, a BIG5 encoded string is returned. + Otherwise EmptyString is returned. + */ + static const ON_String ToBIG5( + const char* buffer, + int buffer_length, + int* error_count + ); + + /* + Description: + Make an educated guess at the encoding and convert the string to BIG5 encoding. + Parameters: + error_count - [out] + number of errors in encoding (question mark is used as a replacement character). + Returns: + If the string encoding could be determined and parsed, a BIG5 encoded string is returned. + Otherwise EmptyString is returned. + */ + const ON_String ToBIG5( + int* error_count + ) const; + public: ~ON_String(); @@ -2250,6 +2380,25 @@ public: /// static const ON_wString ByteOrderMark; + /* + Parameters: + bom_candidate - [in] + Returns; + 1: bom_candidate = ON_UnicodeCodePoint::ON_ByteOrderMark + -1: After swapping bytes, bom_candidate = ON_UnicodeCodePoint::ON_ByteOrderMark + 0: otherwise + */ + static int ByteOrder(wchar_t bom_candidate); + + /* + Parameters: + w - [in] + wchar_t value to swap bytes + Returns: + w with swapped byte order + */ + static wchar_t SwapByteOrder(wchar_t w); + /// /// Identifies a built in string that can be used for testing. /// @@ -2699,6 +2848,21 @@ public: */ static bool IsHorizontalSpace(wchar_t c); + /* + Description: + Encode this UTF encoded wide charater string to a char string + using the multibyte character set (MBCS) specified by windows_code_page. + Parameters: + windows_code_page - [in] + WIndows code page. For example, big5 = 950. + Returns: + A char string with the specified MBCS encoding. + Carefully control the scope and use of the returned string. Lacking context, + opennurbs assumes ON_Strings use the UTF-8 encoded. + See Also: + ON_String::MultiByteDecode() + */ + const ON_String MultiByteEncode(int windows_code_page) const; private: // Use IsEmpty() or IsNotEmpty() when you want a bool diff --git a/opennurbs_subd.cpp b/opennurbs_subd.cpp index adbb9e10..6db57394 100644 --- a/opennurbs_subd.cpp +++ b/opennurbs_subd.cpp @@ -574,6 +574,22 @@ ON__UINT_PTR ON_SubDVertexPtr::VertexDirection() const return ON_SUBD_VERTEX_DIRECTION(m_ptr); } +void ON_SubDVertexPtr::ClearSavedSubdivisionPoints() const +{ + const ON_SubDVertex* v = ON_SUBD_VERTEX_POINTER(m_ptr); + if (nullptr != v) + v->ClearSavedSubdivisionPoints(); +} + +void ON_SubDVertexPtr::ClearSavedSubdivisionPoints( + bool bClearNeighborhood +) const +{ + const ON_SubDVertex* v = ON_SUBD_VERTEX_POINTER(m_ptr); + if (nullptr != v) + v->ClearSavedSubdivisionPoints(bClearNeighborhood); +} + const ON_ComponentStatus ON_SubDVertexPtr::Status() const { const ON_SubDVertex* vertex = ON_SUBD_VERTEX_POINTER(m_ptr); @@ -667,11 +683,36 @@ bool ON_SubDEdgePtr::EdgeIsDartCrease() const return (nullptr != e) ? e->IsDartCrease() : false; } +bool ON_SubDEdgePtr::HasInteriorEdgeTopology( + bool bRequireOppositeFaceDirections +) const +{ + const ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(m_ptr); + return (nullptr != e) ? e->HasInteriorEdgeTopology(bRequireOppositeFaceDirections) : false; +} + + ON__UINT_PTR ON_SubDEdgePtr::EdgeDirection() const { return ON_SUBD_EDGE_DIRECTION(m_ptr); } +void ON_SubDEdgePtr::ClearSavedSubdivisionPoints() const +{ + const ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(m_ptr); + if (nullptr != e) + e->ClearSavedSubdivisionPoints(); +} + +void ON_SubDEdgePtr::ClearSavedSubdivisionPoints( + bool bClearNeighborhood +) const +{ + const ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(m_ptr); + if (nullptr != e) + e->ClearSavedSubdivisionPoints(bClearNeighborhood); +} + const class ON_SubDVertex* ON_SubDEdgePtr::RelativeVertex( int relative_vertex_index ) const @@ -690,6 +731,13 @@ const class ON_SubDVertex* ON_SubDEdgePtr::RelativeVertex( return nullptr; } + +unsigned ON_SubDEdgePtr::RelativeVertexId(int relative_vertex_index) const +{ + const ON_SubDVertex* v = this->RelativeVertex(relative_vertex_index); + return (nullptr != v) ? v->m_id : 0U; +} + bool ON_SubDEdgePtr::RelativeVertexMark( int relative_vertex_index, bool missing_vertex_return_value @@ -762,6 +810,64 @@ const ON_3dVector ON_SubDEdgePtr::RelativeDirection() const return ON_3dVector::NanVector; } +const class ON_SubDFace* ON_SubDEdgePtr::RelativeFace( + int relative_face_index +) const +{ + if (relative_face_index < 0 || relative_face_index > 1) + return nullptr; // invalid input + + const ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(m_ptr); + if (nullptr == e ) + return nullptr; // null input + + if (nullptr == e || e->m_face_count > 2) + return nullptr; // nonmanifold edge + + const ON_SubDFace* LR[2] = {}; + for (unsigned short efi = 0; efi < e->m_face_count; ++efi) + { + const ON__UINT_PTR ptr = e->m_face2[efi].m_ptr; + const ON_SubDFace* f = ON_SUBD_FACE_POINTER(ptr); + if (nullptr == f) + continue; + if (0 == ON_SUBD_FACE_DIRECTION(ptr)) + { + if (nullptr != LR[0]) + return nullptr; // not an oriented manifold interior edge + LR[0] = f; + } + else + { + if (nullptr != LR[1]) + return nullptr; // not an oriented manifold interior edge + LR[1] = f; + } + } + + if (0 != ON_SUBD_EDGE_DIRECTION(m_ptr)) + relative_face_index = 1 - relative_face_index; + return LR[relative_face_index]; +} + +bool ON_SubDEdgePtr::RelativeFaceMark( + int relative_face_index, + bool missing_face_return_value +) const +{ + const ON_SubDFace* f = this->RelativeFace(relative_face_index); + return (nullptr != f) ? f->Mark() : missing_face_return_value; +} + +ON__UINT8 ON_SubDEdgePtr::RelativeFaceMarkBits( + int relative_face_index, + ON__UINT8 missing_face_return_value +) const +{ + const ON_SubDFace* f = this->RelativeFace(relative_face_index); + return (nullptr != f) ? f->MarkBits() : missing_face_return_value; +} + const ON_ComponentStatus ON_SubDEdgePtr::Status() const { const ON_SubDEdge* edge = ON_SUBD_EDGE_POINTER(m_ptr); @@ -849,6 +955,23 @@ ON_SubDFace* ON_SubDFacePtr::Face() const return ON_SUBD_FACE_POINTER(m_ptr); } +void ON_SubDFacePtr::ClearSavedSubdivisionPoints() const +{ + const ON_SubDFace* f = ON_SUBD_FACE_POINTER(m_ptr); + if (nullptr != f) + f->ClearSavedSubdivisionPoints(); +} + +void ON_SubDFacePtr::ClearSavedSubdivisionPoints( + bool bClearNeighborhood +) const +{ + const ON_SubDFace* f = ON_SUBD_FACE_POINTER(m_ptr); + if (nullptr != f) + f->ClearSavedSubdivisionPoints(bClearNeighborhood); +} + + unsigned int ON_SubDFacePtr::FaceId() const { const ON_SubDFace* f = ON_SUBD_FACE_POINTER(m_ptr); @@ -954,6 +1077,64 @@ unsigned int ON_SubDComponentPtr::ComponentId() const return (nullptr != c) ? c->m_id : 0U; } +void ON_SubDComponentPtr::ClearSavedSubdivisionPoints() const +{ + switch (ON_SUBD_COMPONENT_TYPE_MASK & m_ptr) + { + case ON_SUBD_COMPONENT_TYPE_VERTEX: + { + const ON_SubDVertex* v = Vertex(); + if (nullptr != v) + v->ClearSavedSubdivisionPoints(); + } + break; + case ON_SUBD_COMPONENT_TYPE_EDGE: + { + const ON_SubDEdge* e = Edge(); + if (nullptr != e) + e->ClearSavedSubdivisionPoints(); + } + break; + case ON_SUBD_COMPONENT_TYPE_FACE: + { + const ON_SubDFace* f = Face(); + if (nullptr != f) + f->ClearSavedSubdivisionPoints(); + } + break; + } +} + +void ON_SubDComponentPtr::ClearSavedSubdivisionPoints( + bool bClearNeighborhood +) const +{ + switch (ON_SUBD_COMPONENT_TYPE_MASK & m_ptr) + { + case ON_SUBD_COMPONENT_TYPE_VERTEX: + { + const ON_SubDVertex* v = Vertex(); + if (nullptr != v) + v->ClearSavedSubdivisionPoints(bClearNeighborhood); + } + break; + case ON_SUBD_COMPONENT_TYPE_EDGE: + { + const ON_SubDEdge* e = Edge(); + if (nullptr != e) + e->ClearSavedSubdivisionPoints(bClearNeighborhood); + } + break; + case ON_SUBD_COMPONENT_TYPE_FACE: + { + const ON_SubDFace* f = Face(); + if (nullptr != f) + f->ClearSavedSubdivisionPoints(bClearNeighborhood); + } + break; + } +} + const ON_3dPoint ON_SubDComponentPtr::ControlNetCenterPoint() const { switch (ON_SUBD_COMPONENT_TYPE_MASK & m_ptr) @@ -1657,11 +1838,7 @@ const ON_SubDVertexPtr ON_SubDComponentPtr::VertexPtr() const ON__UINT_PTR element_type = ON_SUBD_COMPONENT_TYPE(m_ptr); if ( ON_SUBD_COMPONENT_TYPE_VERTEX == element_type) return ON_SubDVertexPtr::Create(Vertex(), ComponentDirection()); - - if ( 0 == element_type ) - return ON_SubDVertexPtr::Null; - - return ON_SUBD_RETURN_ERROR(ON_SubDVertexPtr::Null); + return ON_SubDVertexPtr::Null; } const ON_SubDEdgePtr ON_SubDComponentPtr::EdgePtr() const @@ -1669,11 +1846,7 @@ const ON_SubDEdgePtr ON_SubDComponentPtr::EdgePtr() const ON__UINT_PTR element_type = ON_SUBD_COMPONENT_TYPE(m_ptr); if ( ON_SUBD_COMPONENT_TYPE_EDGE == element_type) return ON_SubDEdgePtr::Create(Edge(), ComponentDirection()); - - if ( 0 == element_type ) - return ON_SubDEdgePtr::Null; - - return ON_SUBD_RETURN_ERROR(ON_SubDEdgePtr::Null); + return ON_SubDEdgePtr::Null; } const ON_SubDFacePtr ON_SubDComponentPtr::FacePtr() const @@ -1681,11 +1854,22 @@ const ON_SubDFacePtr ON_SubDComponentPtr::FacePtr() const ON__UINT_PTR element_type = ON_SUBD_COMPONENT_TYPE(m_ptr); if ( ON_SUBD_COMPONENT_TYPE_FACE == element_type) return ON_SubDFacePtr::Create(Face(), ComponentDirection()); + return ON_SubDFacePtr::Null; +} - if ( 0 == element_type ) - return ON_SubDFacePtr::Null; +const bool ON_SubDComponentPtr::IsVertex() const +{ + return (ON_SUBD_COMPONENT_TYPE_VERTEX == (ON_SUBD_COMPONENT_TYPE_MASK & m_ptr)); +} - return ON_SUBD_RETURN_ERROR(ON_SubDFacePtr::Null); +const bool ON_SubDComponentPtr::IsEdge() const +{ + return (ON_SUBD_COMPONENT_TYPE_EDGE == (ON_SUBD_COMPONENT_TYPE_MASK & m_ptr)); +} + +const bool ON_SubDComponentPtr::IsFace() const +{ + return (ON_SUBD_COMPONENT_TYPE_FACE == (ON_SUBD_COMPONENT_TYPE_MASK & m_ptr)); } const ON_SubDComponentPtr ON_SubDComponentPtr::Create( @@ -1864,6 +2048,291 @@ int ON_SubDComponentPtr::CompareComponentAndDirection( return rc; } +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + ON_SubDComponentPtr cptr, + double x +) +{ + ON_SubDComponentAndNumber cx; + cx.m_cptr = cptr; + cx.m_x = x; + return cx; +} + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + const ON_SubDVertex* v, + double x +) +{ + return ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Create(v), x); +} + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + const ON_SubDEdge* e, + double x +) +{ + return ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Create(e), x); +} + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + const ON_SubDFace* f, + double x +) +{ + return ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Create(f), x); +} + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + const ON_SubDVertexPtr vptr, + double x +) +{ + return ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Create(vptr), x); +} + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + const ON_SubDEdgePtr eptr, + double x +) +{ + return ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Create(eptr), x); +} + +const ON_SubDComponentAndNumber ON_SubDComponentAndNumber::Create( + const ON_SubDFacePtr fptr, + double x +) +{ + return ON_SubDComponentAndNumber::Create(ON_SubDComponentPtr::Create(fptr), x); +} + + +const ON_SubDComponentPtr ON_SubDComponentAndNumber::Component() const +{ + return m_cptr; +} + +void ON_SubDComponentAndNumber::SetComponent(ON_SubDComponentPtr cptr) +{ + m_cptr = cptr; +} + +double ON_SubDComponentAndNumber::Number() const +{ + return m_x; +} + +void ON_SubDComponentAndNumber::SetNumber(double x) +{ + m_x = x; +} + +int ON_SubDComponentAndNumber::CompareComponent( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b +) +{ + if (a == b) + return 0; + if (nullptr == a) + return -1; + if (nullptr == b) + return 1; + return ON_SubDComponentPtr::CompareComponent(&a->m_cptr, &b->m_cptr); +} + +// +int ON_SubDComponentAndNumber::CompareComponentAndDirection( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b +) +{ + if (a == b) + return 0; + if (nullptr == a) + return -1; + if (nullptr == b) + return 1; + return ON_SubDComponentPtr::CompareComponentAndDirection(&a->m_cptr, &b->m_cptr); +} + +int ON_SubDComponentAndNumber::CompareNumber( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b +) +{ + if (a == b) + return 0; + if (nullptr == a) + return -1; + if (nullptr == b) + return 1; + return ON_CompareDouble(a->m_x, b->m_x); +} + +int ON_SubDComponentAndNumber::CompareComponentAndNumber( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b +) +{ + const int rc = ON_SubDComponentAndNumber::CompareComponent(a, b); + return (0 != rc) ? rc : ON_SubDComponentAndNumber::CompareNumber(a, b); +} + +int ON_SubDComponentAndNumber::CompareComponentAndDirectionAndNumber( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b +) +{ + const int rc = ON_SubDComponentAndNumber::CompareComponentAndDirection(a, b); + return (0 != rc) ? rc : ON_SubDComponentAndNumber::CompareNumber(a, b); +} + + + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + ON_SubDComponentPtr cptr, + ON_3dPoint P +) +{ + ON_SubDComponentAndPoint cx; + cx.m_cptr = cptr; + cx.m_P = P; + return cx; +} + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + const ON_SubDVertex* v, + ON_3dPoint P +) +{ + return ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Create(v), P); +} + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + const ON_SubDEdge* e, + ON_3dPoint P +) +{ + return ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Create(e), P); +} + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + const ON_SubDFace* f, + ON_3dPoint P +) +{ + return ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Create(f), P); +} + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + const ON_SubDVertexPtr vptr, + ON_3dPoint P +) +{ + return ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Create(vptr), P); +} + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + const ON_SubDEdgePtr eptr, + ON_3dPoint P +) +{ + return ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Create(eptr), P); +} + +const ON_SubDComponentAndPoint ON_SubDComponentAndPoint::Create( + const ON_SubDFacePtr fptr, + ON_3dPoint P +) +{ + return ON_SubDComponentAndPoint::Create(ON_SubDComponentPtr::Create(fptr), P); +} + + +const ON_SubDComponentPtr ON_SubDComponentAndPoint::Component() const +{ + return m_cptr; +} + +void ON_SubDComponentAndPoint::SetComponent(ON_SubDComponentPtr cptr) +{ + m_cptr = cptr; +} + +const ON_3dPoint ON_SubDComponentAndPoint::Point() const +{ + return m_P; +} + +void ON_SubDComponentAndPoint::SetPoint(ON_3dPoint P) +{ + m_P = P; +} + +int ON_SubDComponentAndPoint::CompareComponent( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs +) +{ + if (lhs == rhs) + return 0; + if (nullptr == lhs) + return -1; + if (nullptr == rhs) + return 1; + return ON_SubDComponentPtr::CompareComponent(&lhs->m_cptr, &rhs->m_cptr); +} + +// +int ON_SubDComponentAndPoint::CompareComponentAndDirection( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs +) +{ + if (lhs == rhs) + return 0; + if (nullptr == lhs) + return -1; + if (nullptr == rhs) + return 1; + return ON_SubDComponentPtr::CompareComponentAndDirection(&lhs->m_cptr, &rhs->m_cptr); +} + +int ON_SubDComponentAndPoint::ComparePoint( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs +) +{ + if (lhs == rhs) + return 0; + if (nullptr == lhs) + return -1; + if (nullptr == rhs) + return 1; + return ON_3dPoint::Compare(lhs->m_P, rhs->m_P); +} + +int ON_SubDComponentAndPoint::CompareComponentAndPoint( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs +) +{ + const int rc = ON_SubDComponentAndPoint::CompareComponent(lhs, rhs); + return (0 != rc) ? rc : ON_SubDComponentAndPoint::ComparePoint(lhs, rhs); +} + +int ON_SubDComponentAndPoint::CompareComponentAndDirectionAndPoint( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs +) +{ + const int rc = ON_SubDComponentAndPoint::CompareComponentAndDirection(lhs, rhs); + return (0 != rc) ? rc : ON_SubDComponentAndPoint::ComparePoint(lhs, rhs); +} + + static const bool Internal_FirstIsPartOfSecond( const ON_SubDComponentPoint& first, const ON_SubDComponentPoint& second @@ -6975,8 +7444,6 @@ static void Internal_AccumulateVertexHash( { sha1.AccumulateBytes(&v->m_vertex_tag, sizeof(v->m_vertex_tag)); sha1.AccumulateDoubleArray(3, v->m_P); - if (v->SubdivisionDisplacementIsNonzero()) - sha1.Accumulate3dVector(v->SubdivisionDisplacement()); } } @@ -7034,12 +7501,6 @@ static void Internal_AccumulateEdgeHash( // Changing edge crease/smooth attributes often changes the regions used in face packing and exploding. sha1.AccumulateBool(e->IsCrease()); } - - if (ON_SubDHashType::Geometry == hash_type) - { - if (e->SubdivisionDisplacementIsNonzero()) - sha1.Accumulate3dVector(e->SubdivisionDisplacement()); - } } @@ -7103,11 +7564,6 @@ static void Internal_AccumulateFaceHash( sha1.AccumulateInteger32(eptr->EdgeId()); if (0 != ON_SUBD_EDGE_DIRECTION(eptr->m_ptr)) sha1.AccumulateBool(true); - if (ON_SubDHashType::Geometry == hash_type) - { - if (f->SubdivisionDisplacementIsNonzero()) - sha1.Accumulate3dVector(f->SubdivisionDisplacement()); - } } } @@ -7942,10 +8398,6 @@ unsigned int ON_SubDLevel::DumpTopology( text_log.PushIndent(); - ON_3dVector D(ON_3dVector::NanVector); - if (v->GetSubdivisionDisplacement(&D.x) && D.IsValid()) - text_log.Print( "v.SubdivisionDisplacement: (%g, %g, %g)\n", D.x, D.y, D.z ); - ON_3dPoint P1(ON_3dPoint::NanPoint); if (v->GetSavedSubdivisionPoint(&P1.x) && P1.IsValid()) text_log.Print( "v.SubdivisionPoint: (%g, %g, %g)\n", P1.x, P1.y, P1.z ); @@ -8171,10 +8623,6 @@ unsigned int ON_SubDLevel::DumpTopology( text_log.PushIndent(); - ON_3dVector D(ON_3dVector::NanVector); - if (e->GetSubdivisionDisplacement(&D.x) && D.IsValid()) - text_log.Print( "e.SubdivisionDisplacement: (%g, %g, %g)\n", D.x, D.y, D.z ); - ON_3dPoint P1(ON_3dPoint::NanPoint); if (e->GetSavedSubdivisionPoint(&P1.x) && P1.IsValid()) text_log.Print( "e.SubdivisionPoint: (%g, %g, %g)\n", P1.x, P1.y, P1.z ); @@ -8324,10 +8772,6 @@ unsigned int ON_SubDLevel::DumpTopology( text_log.PushIndent(); - ON_3dVector D(ON_3dVector::NanVector); - if (f->GetSubdivisionDisplacement(&D.x) && D.IsValid()) - text_log.Print( "f.SubdivisionDisplacement: (%g, %g, %g)\n", D.x, D.y, D.z ); - ON_3dPoint P1(ON_3dPoint::NanPoint); if (f->GetSavedSubdivisionPoint(&P1.x) && P1.IsValid()) text_log.Print( "f.SubdivisionPoint: (%g, %g, %g)\n", P1.x, P1.y, P1.z ); @@ -10155,9 +10599,6 @@ bool ON_SubDFace::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ if (count < 3) return ON_SubDFace_GetSubdivisionPointError(this, subdivision_point, true); - double displacementV[3] = { 0 }; - const bool bApplyDisplacement = GetSubdivisionDisplacement(displacementV); - const class ON_SubDEdgePtr* edge_ptr = m_edge4; ON__UINT_PTR e_ptr; @@ -10191,14 +10632,6 @@ bool ON_SubDFace::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = (vertexP[0][0] + vertexP[1][0] + vertexP[2][0] + vertexP[3][0])*0.25; subdivision_point[1] = (vertexP[0][1] + vertexP[1][1] + vertexP[2][1] + vertexP[3][1])*0.25; subdivision_point[2] = (vertexP[0][2] + vertexP[1][2] + vertexP[2][2] + vertexP[3][2])*0.25; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -10208,14 +10641,6 @@ bool ON_SubDFace::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = (vertexP[0][0] + vertexP[1][0] + vertexP[2][0]) / 3.0; subdivision_point[1] = (vertexP[0][1] + vertexP[1][1] + vertexP[2][1]) / 3.0; subdivision_point[2] = (vertexP[0][2] + vertexP[1][2] + vertexP[2][2]) / 3.0; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -10272,13 +10697,6 @@ bool ON_SubDFace::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = faceP[0] / n; subdivision_point[1] = faceP[1] / n; subdivision_point[2] = faceP[2] / n; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } return true; } @@ -10960,77 +11378,31 @@ bool ON_SubDEdge::EdgeSurfaceCurveIsSet() const bool ON_SubDComponentBase::SubdivisionDisplacementIsNonzero() const { - return (0 != ON_SUBD_CACHE_DISPLACEMENT_FLAG(m_saved_points_flags)) - ? ( - (0.0 != m_displacement_V[0] || 0.0 != m_displacement_V[1] || 0.0 != m_displacement_V[2]) - && ON_IS_VALID(m_displacement_V[0]) && ON_IS_VALID(m_displacement_V[1]) && ON_IS_VALID(m_displacement_V[2]) - ) - : false; + // deprecated - never used. + return false; } -bool ON_SubDComponentBase::SetSubdivisionDisplacement( - const double displacement[3] - ) +bool ON_SubDComponentBase::SetSubdivisionDisplacement(const double*) { - if ( - nullptr == displacement - || (0.0 == displacement[0] && 0.0 == displacement[1] && 0.0 == displacement[2]) - ) - { - ClearSubdivisionDisplacement(); - return true; - } - - if ( ON_IsValid(displacement[0]) && ON_IsValid(displacement[1]) && ON_IsValid(displacement[2]) ) - { - m_saved_points_flags |= ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT; - m_displacement_V[0] = displacement[0]; - m_displacement_V[1] = displacement[1]; - m_displacement_V[2] = displacement[2]; - return true; - } - - ClearSubdivisionDisplacement(); - - return ON_SUBD_RETURN_ERROR(false); + // deprecated - never used. + return false; } void ON_SubDComponentBase::ClearSubdivisionDisplacement() const { - if (0 != (m_saved_points_flags & ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT)) - { - ON_SUBD_CACHE_CLEAR_POINT_FLAG(m_saved_points_flags); - ON_SUBD_CACHE_CLEAR_DISPLACEMENT_FLAG(m_saved_points_flags); - } + // deprecated - never used. } -bool ON_SubDComponentBase::GetSubdivisionDisplacement( - double displacement[3] - ) const +bool ON_SubDComponentBase::GetSubdivisionDisplacement(double*) const { - const bool rc = (0 != (ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT & m_saved_points_flags)); - if (nullptr != displacement) - { - if (rc) - { - displacement[0] = m_displacement_V[0]; - displacement[1] = m_displacement_V[1]; - displacement[2] = m_displacement_V[2]; - } - else - { - displacement[0] = 0.0; - displacement[1] = 0.0; - displacement[2] = 0.0; - } - } - return rc; + // deprecated - never used. + return false; } const ON_3dVector ON_SubDComponentBase::SubdivisionDisplacement() const { - ON_3dVector v(ON_3dVector::ZeroVector); - return GetSubdivisionDisplacement(&v.x) ? v : ON_3dVector::ZeroVector; + // deprecated - never used. + return ON_3dVector::ZeroVector; } void ON_SubDComponentBase::Internal_SetSavedSurfacePointFlag(bool bSavedSurfacePointFlag) const @@ -11316,9 +11688,6 @@ bool ON_SubDEdge::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ if (nullptr == edge_vertex[0] || nullptr == edge_vertex[1]) return ON_SubDEdge_GetSubdivisionPointError(this, subdivision_point, nullptr, true); - double displacementV[3] = { 0 }; - const bool bApplyDisplacement = GetSubdivisionDisplacement(displacementV); - const double* edgeP[2] = { edge_vertex[0]->m_P, edge_vertex[1]->m_P }; const double edgePsum[3] = { edgeP[0][0] + edgeP[1][0], edgeP[0][1] + edgeP[1][1], edgeP[0][2] + edgeP[1][2] }; @@ -11386,14 +11755,6 @@ bool ON_SubDEdge::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = EP[0] + 0.0625*(facePsum[0][0] + facePsum[1][0]); subdivision_point[1] = EP[1] + 0.0625*(facePsum[0][1] + facePsum[1][1]); subdivision_point[2] = EP[2] + 0.0625*(facePsum[0][2] + facePsum[1][2]); - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -11408,14 +11769,6 @@ bool ON_SubDEdge::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = EP[0] + (0.5*edgePsum[0] + facePsum[0][0] + facePsum[1][0]) / 12.0; subdivision_point[1] = EP[1] + (0.5*edgePsum[1] + facePsum[0][1] + facePsum[1][1]) / 12.0; subdivision_point[2] = EP[2] + (0.5*edgePsum[2] + facePsum[0][2] + facePsum[1][2]) / 12.0; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -11433,14 +11786,6 @@ bool ON_SubDEdge::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = EP[0] + x * edgePsum[0] + facePsum[0][0] / f0 + facePsum[1][0] / f1; subdivision_point[1] = EP[1] + x * edgePsum[1] + facePsum[0][1] / f0 + facePsum[1][1] / f1; subdivision_point[2] = EP[2] + x * edgePsum[2] + facePsum[0][2] / f0 + facePsum[1][2] / f1; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -11449,14 +11794,6 @@ bool ON_SubDEdge::EvaluateCatmullClarkSubdivisionPoint(double subdivision_point[ subdivision_point[0] = 0.5*edgePsum[0]; subdivision_point[1] = 0.5*edgePsum[1]; subdivision_point[2] = 0.5*edgePsum[2]; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -12062,9 +12399,6 @@ bool ON_SubDVertex::EvaluateCatmullClarkSubdivisionPoint(double subdivision_poin if (nullptr == subdivision_point ) return ON_SubDVertex_GetSubdivisionPointError(this, subdivision_point, nullptr, false); - double displacementV[3] = { 0 }; - const bool bApplyDisplacement = GetSubdivisionDisplacement(displacementV); - const double* vertexP = m_P; const unsigned int n = (nullptr != m_edges ? m_edge_count : 0); @@ -12120,14 +12454,6 @@ bool ON_SubDVertex::EvaluateCatmullClarkSubdivisionPoint(double subdivision_poin subdivision_point[0] = (vertexP[0] * 6.0 + (edgeP[0][0] + edgeP[1][0]))*0.125; subdivision_point[1] = (vertexP[1] * 6.0 + (edgeP[0][1] + edgeP[1][1]))*0.125; subdivision_point[2] = (vertexP[2] * 6.0 + (edgeP[0][2] + edgeP[1][2]))*0.125; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -12140,14 +12466,6 @@ bool ON_SubDVertex::EvaluateCatmullClarkSubdivisionPoint(double subdivision_poin subdivision_point[0] = vertexP[0]; subdivision_point[1] = vertexP[1]; subdivision_point[2] = vertexP[2]; - - if (bApplyDisplacement) - { - subdivision_point[0] += displacementV[0]; - subdivision_point[1] += displacementV[1]; - subdivision_point[2] += displacementV[2]; - } - return true; } @@ -14190,6 +14508,104 @@ const ON_SubDEdge* ON_SubD::SplitEdge( return subdimple->SplitEdge(edge,vertex_location); } +const ON_SubDEdgePtr ON_SubD::SplitEdge( + ON_SubDEdgePtr eptr, + ON_3dPoint vertex_location, + unsigned new_edge_end +) +{ + if ( 0 != new_edge_end && 1 != new_edge_end) + return ON_SubDEdgePtr::Null; + ON_SubDEdge* e = eptr.Edge(); + if (nullptr == e) + return ON_SubDEdgePtr::Null; + const ON_SubDVertex* v[3] = { e->m_vertex[0],nullptr,e->m_vertex[1] }; + ON_SubDEdge* e1 = const_cast(this->SplitEdge(e, vertex_location)); + if ( nullptr == e1) + return ON_SubDEdgePtr::Null; + + const ON__UINT_PTR eptr_dir = eptr.EdgeDirection(); + const ON_SubDEdgePtr e1ptr = ON_SubDEdgePtr::Create(e1, eptr_dir); + + if (v[0] != e->m_vertex[0] || v[2] != e1->m_vertex[1]) + { + ON_SUBD_ERROR("Error in SplitEdge(ON_SubDEdge*,...)."); + return e1ptr; + } + + v[1] = e->m_vertex[1]; + if ( nullptr == v[1] || v[1] != e1->m_vertex[0] || 2 != v[1]->m_edge_count) + { + ON_SUBD_ERROR("Error in SplitEdge(ON_SubDEdge*,...)."); + return e1ptr; + } + + if (e->m_face_count != e1->m_face_count) + { + ON_SUBD_ERROR("Error in SplitEdge(ON_SubDEdge*,...)."); + return e1ptr; + } + + const unsigned v0edex = v[0]->EdgeArrayIndex(e); + const unsigned v2edex = v[2]->EdgeArrayIndex(e1); + if (v0edex >= v[0]->EdgeCount() || v2edex >= v[2]->EdgeCount()) + { + ON_SUBD_ERROR("Error in SplitEdge(ON_SubDEdge*,...)."); + return e1ptr; + } + + if (0 == eptr_dir && 1 == new_edge_end) + { + return e1ptr; + } + + if (1 == eptr_dir && 0 == new_edge_end) + { + return e1ptr; + } + + // swap e and e1 topology connections to put the "new edge" where the caller wants it. + + for (unsigned short efi = 0; efi < e->m_face_count; ++efi) + { + ON_SubDFace* f = const_cast(e->Face(efi)); + if (nullptr == f) + continue; + const unsigned edge_count = f->EdgeCount(); + const unsigned fei = f->EdgeArrayIndex(e); + const unsigned fe1i = f->EdgeArrayIndex(e1); + if (fei >= edge_count || fe1i >= edge_count) + continue; + + const ON_SubDEdgePtr feptr = ON_SubDEdgePtr::Create(e1, f->EdgePtr(fei).EdgeDirection()); // e1 is correct - we are swapping + if (fei < 4) + f->m_edge4[fei] = feptr; + else + f->m_edgex[fei - 4] = feptr; + + const ON_SubDEdgePtr fe1ptr = ON_SubDEdgePtr::Create(e, f->EdgePtr(fe1i).EdgeDirection()); // e is correct - we are swapping + if (fe1i < 4) + f->m_edge4[fe1i] = fe1ptr; + else + f->m_edgex[fe1i - 4] = fe1ptr; + } + + const ON_SubDEdgePtr new_v0eptr = ON_SubDEdgePtr::Create(e1, v[0]->EdgePtr(v0edex).EdgeDirection()); + const ON_SubDEdgePtr new_v2eptr = ON_SubDEdgePtr::Create(e, v[2]->EdgePtr(v2edex).EdgeDirection()); + v[0]->m_edges[v0edex] = new_v0eptr; + v[1]->m_edges[0] = new_v0eptr.Reversed(); + v[1]->m_edges[1] = new_v2eptr.Reversed(); + v[2]->m_edges[v2edex] = new_v2eptr; + e1->m_vertex[0] = v[0]; + e1->m_vertex[1] = v[1]; + e->m_vertex[0] = v[1]; + e->m_vertex[1] = v[2]; + + + return e1ptr; +} + + const ON_SubDEdge * ON_SubD::SplitFace( ON_SubDFace * face, const ON_SubDVertex * v0, @@ -14240,6 +14656,351 @@ const ON_SubDEdge* ON_SubD::SplitFace( return subdimple->SplitFace(face,fvi0,fvi1); } +static void Internal_SplitFaceSwapFacePtr( + ON_SubDFace* f, + ON__UINT_PTR pairA[2], + ON__UINT_PTR pairB[2] + ) +{ + if (nullptr == f) + return; + + if (pairA[0] == pairB[0] || pairA[1] == pairB[0] || pairA[0] == pairB[1] || pairA[1] == pairB[1]) + { + ON_SUBD_ERROR("pairA[] and pairB[] must be disjoint sets of values."); + return; + } + + ON_SubDEdgePtr* feptr = f->m_edge4; + for (unsigned short fei = 0; fei < f->m_edge_count; ++fei, ++feptr) + { + if (4 == fei) + { + feptr = f->m_edgex; + if (nullptr == feptr) + break; + } + + ON_SubDEdge* fe = ON_SUBD_EDGE_POINTER(feptr->m_ptr); + if (nullptr == fe) + continue; + + ON_SubDFacePtr* efptr = fe->m_face2; + for (unsigned short efi = 0; efi < fe->m_face_count; ++efi, ++efptr) + { + if (2 == efi) + { + efptr = fe->m_facex; + if (nullptr == efptr) + break; + } + const ON__UINT_PTR x = (efptr->m_ptr & ON_SUBD_COMPONENT_POINTER_MASK); + const ON__UINT_PTR d = (efptr->m_ptr & ON_SUBD_COMPONENT_DIRECTION_MASK); + if (x == pairA[0]) + efptr->m_ptr = (pairA[1] | d); + else if (x == pairB[0]) + efptr->m_ptr = (pairB[1] | d); + } + + + ON_SubDVertex* v = const_cast(feptr->RelativeVertex(0)); + if (nullptr != v && nullptr != v->m_faces) + { + for (unsigned short vfi = 0; vfi < v->m_face_count; ++vfi) + { + const ON__UINT_PTR x = (ON__UINT_PTR)v->m_faces[vfi]; + if (x == pairA[0]) + v->m_faces[vfi] = (ON_SubDFace*)pairA[1]; + else if (x == pairB[0]) + v->m_faces[vfi] = (ON_SubDFace*)pairB[1]; + } + } + } +} + +static bool Internal_ValidateFaceTopology( + const ON_SubDFace* f +) +{ + if (nullptr == f) + return false; + + if (f->m_edge_count < 3 || 0 == f->m_id) + return ON_SUBD_RETURN_ERROR(false); + + const ON_SubDVertex* firstv = nullptr; + const ON_SubDVertex* ev[2] = {}; + bool rc = true; + unsigned short fdex; + const ON_SubDEdgePtr* feptr = f->m_edge4; + for (unsigned short fei = 0; fei < f->m_edge_count; ++fei, ++feptr) + { + if (4 == fei) + { + feptr = f->m_edgex; + if (nullptr == feptr) + { + ON_SUBD_ERROR("face m_edge_count > 4 and m_edgex is nullptr."); + rc = false; + break; + } + } + + ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(feptr->m_ptr); + if (nullptr == e || 0 == e->m_id) + { + ON_SUBD_ERROR("null edge in face."); + rc = false; + continue; + } + + if (e != f->Edge(fei)) + { + ON_SUBD_ERROR("face->Edge(fei) != e"); + rc = false; + } + + for (unsigned short k = fei + 1; k < f->m_edge_count; ++k) + { + if (e == f->Edge(k)) + { + ON_SUBD_ERROR("face references e 2 or more times."); + rc = false; + } + } + + const ON__UINT_PTR fedir = ON_SUBD_FACE_DIRECTION(feptr->m_ptr); + + if (0 == fei) + { + firstv = e->m_vertex[fedir]; + ev[1] = firstv; + } + + if (ev[1] != e->m_vertex[fedir]) + { + ON_SUBD_ERROR("consecutive edge pointers do not have the same vertex at the end/start."); + rc = false; + } + + ev[0] = e->m_vertex[fedir]; + ev[1] = e->m_vertex[1-fedir]; + if (nullptr == ev[0] || nullptr == ev[1]) + { + ON_SUBD_ERROR("edge has null vertex pointers."); + rc = false; + } + else if (ev[0] == ev[1]) + { + ON_SUBD_ERROR("edge begins and ends at the same vertex."); + rc = false; + } + + fdex = e->m_face_count; + const ON_SubDFacePtr* efptr = e->m_face2; + for (unsigned short efi = 0; efi < e->m_face_count; ++efi, ++efptr) + { + if (2 == efi) + { + efptr = e->m_facex; + if (nullptr == efptr) + { + ON_SUBD_ERROR("null edge in face."); + rc = false; + break; + } + } + + const ON_SubDFace* ef = ON_SUBD_FACE_POINTER(efptr->m_ptr); + if (f == ef) + { + if (fdex < e->m_face_count) + { + ON_SUBD_ERROR("ef references face 2 or more times."); + rc = false; + break; + } + fdex = efi; + ON__UINT_PTR efdir = ON_SUBD_FACE_DIRECTION(efptr->m_ptr); + if (efdir != fedir) + { + ON_SUBD_ERROR("face and edge have inconsistent direction settings."); + rc = false; + break; + } + } + } + if (fdex >= e->m_face_count) + { + ON_SUBD_ERROR("The face references and edge that does not reference the face."); + rc = false; + } + + const ON_SubDVertex* v = ev[0]; + if (nullptr != v ) + { + if (v != f->Vertex(fei)) + { + ON_SUBD_ERROR("face->Vertex(fei) != v"); + rc = false; + } + + fdex = v->m_face_count; + for (unsigned short vfi = 0; vfi < v->m_face_count; ++vfi) + { + const ON_SubDFace* vf = v->m_faces[vfi]; + if (f == vf) + { + if (fdex < v->m_face_count) + { + ON_SUBD_ERROR("ef references face 2 or more times."); + rc = false; + break; + } + fdex = vfi; + } + } + if (fdex >= v->m_face_count) + { + ON_SUBD_ERROR("The face references a vertex that does not reference the face."); + rc = false; + } + + for (unsigned short k = fei + 1; k < f->m_edge_count; ++k) + { + if (v == f->Vertex(k)) + { + ON_SUBD_ERROR("face references v 2 or more times."); + rc = false; + } + } + } + } + + if (firstv != ev[1]) + { + ON_SUBD_ERROR("The vertices at the end ofthe final edge and start of the initial edges are different."); + rc = false; + } + + return rc; +} + +const ON_SubDEdgePtr ON_SubD::SplitFace( + class ON_SubDFace* face, + unsigned int fvi0, + unsigned int fvi1, + unsigned new_face_side +) +{ + if (new_face_side != 0 && new_face_side != 1) + return ON_SUBD_RETURN_ERROR(ON_SubDEdgePtr::Null); + face->ClearSavedSubdivisionPoints(true); + ON_SubDEdge* e = const_cast(this->SplitFace(face, fvi0, fvi1)); + if (nullptr == e) + return ON_SubDEdgePtr::Null; + + const ON_SubDEdgePtr eptr = ON_SubDEdgePtr::Create(e, 0); + + ON_SubDFace* f2[2] = { const_cast(eptr.RelativeFace(0)), const_cast(eptr.RelativeFace(1)) }; + if (nullptr == f2[0] || nullptr == f2[1] || f2[0] == f2[1]) + return ON_SUBD_RETURN_ERROR(eptr); + if (face != f2[0] && face != f2[1]) + return ON_SUBD_RETURN_ERROR(eptr); + + if ( face == f2[new_face_side]) + { + + // swap faces + + // markA and markB need to be different, must be values no valid heap pointer will + // ever have, and need to be chosen so that debug runtime pointer checking code will not + // throw exceptions. Values like 1 and 2 would work just fine except debug runtime + // pointer checking code is mindlessly diligent. the addresses of marking_faces[0] + // and marking_faces[1] "tricks" the debug runtime pointer checking code and + // are values no valid app heap will ever have (they point to stack + // used by this call). + const ON_SubDFace marking_faces[2] = {}; + const ON__UINT_PTR markA = (ON__UINT_PTR)(&marking_faces[0]); + const ON__UINT_PTR markB = (ON__UINT_PTR)(&marking_faces[1]); + + // The mark first, then change approach must be used because f2[0] and f2[1] + // have multiple vertex and edge references and we must avoid swapping twice. + + // First change face references f2[0] to markA and f2[1] to markB. + ON__UINT_PTR pairA[2] = { (ON__UINT_PTR)f2[0], markA }; + ON__UINT_PTR pairB[2] = { (ON__UINT_PTR)f2[1], markB }; + for (unsigned fdex = 0; fdex < 2; ++fdex) + Internal_SplitFaceSwapFacePtr(f2[fdex], pairA, pairB); + + // ... then change markA to f2[1] and markB to f2[0]. + pairA[0] = markA; pairA[1] = (ON__UINT_PTR)f2[1]; + pairB[0] = markB; pairB[1] = (ON__UINT_PTR)f2[0]; + for (unsigned fdex = 0; fdex < 2; ++fdex) + Internal_SplitFaceSwapFacePtr(f2[fdex], pairA, pairB); + + // At this point, all the vertex and edge references to f2[0] and f2[1] have been swapped. + + // All that is left is to wwap edge references on f2[0] and f2[1]. + const unsigned short edge_count[2] = { f2[1]->m_edge_count, f2[0]->m_edge_count }; + const unsigned short edgex_capacity[2] = { f2[1]->m_edgex_capacity, f2[0]->m_edgex_capacity }; + ON_SubDEdgePtr edge4[2][4] = { + {f2[1]->m_edge4[0],f2[1]->m_edge4[1],f2[1]->m_edge4[2],f2[1]->m_edge4[3]}, + {f2[0]->m_edge4[0],f2[0]->m_edge4[1],f2[0]->m_edge4[2],f2[0]->m_edge4[3]} + }; + ON_SubDEdgePtr* edgex[2] = { f2[1]->m_edgex, f2[0]->m_edgex }; + for (unsigned i = 0; i < 2; ++i) + { + f2[i]->m_edge_count = edge_count[i]; + f2[i]->m_edgex_capacity = edgex_capacity[i]; + f2[i]->m_edge4[0] = edge4[i][0]; + f2[i]->m_edge4[1] = edge4[i][1]; + f2[i]->m_edge4[2] = edge4[i][2]; + f2[i]->m_edge4[3] = edge4[i][3]; + f2[i]->m_edgex = edgex[i]; + } + + //// The Internal_SplitFaceSwapFacePtr() calls above have switched the + //// ON_SubDFace pointer values in e->m_face2[]. Because the faces + //// are switching sides, we need to swap the directions in e->m_face2[]. + //// + //e->m_face2[0] = e->m_face2[0].Reversed(); + //e->m_face2[1] = e->m_face2[1].Reversed(); + } + + + if (2 == e->m_face_count && face == e->m_face2[new_face_side].Face()) + { + // Adjust the e->m_face2[] so it jibes with the relative face values exactly. + ON_SubDFacePtr tmp = e->m_face2[0]; + e->m_face2[0] = e->m_face2[1]; + e->m_face2[1] = tmp; + } + + if (false == Internal_ValidateFaceTopology(f2[0]) + || false == Internal_ValidateFaceTopology(f2[1]) + || f2[0] == f2[1] + ) + { + ON_SUBD_ERROR("Invalid faces."); + } + + + return eptr; // new face is on the requested side +} + +const ON_SubDEdgePtr ON_SubD::SplitFace( + class ON_SubDFace* face, + const class ON_SubDVertex* v0, + const class ON_SubDVertex* v1, + unsigned new_face_side +) +{ + if (nullptr == face) + return ON_SubDEdgePtr::Null; + return this->SplitFace(face, face->VertexIndex(v0), face->VertexIndex(v1), new_face_side); +} + void ON_SubD::MarkAggregateComponentStatusAsNotCurrent() const { const ON_SubDLevel* level = ActiveLevelConstPointer(); @@ -19046,6 +19807,260 @@ unsigned int ON_UniqueTester::Count() const return (unsigned int)count; } +bool ON_SubDEdgeChain::GetSideComponents( + unsigned relative_side, + ON_SimpleArray& side_components +) const +{ + return ON_SubDEdgeChain::GetSideComponents(EdgeChain(), relative_side, side_components); +} + +bool ON_SubDEdgeChain::GetSideComponents( + const ON_SimpleArray& edge_chain, + unsigned relative_side, + ON_SimpleArray& side_components +) +{ + side_components.SetCount(0); + if (relative_side > 1U) + return false; + + const unsigned edge_count = edge_chain.UnsignedCount(); + if (edge_count < 1) + return false; + + if (false == ON_SubDEdgeChain::IsValidEdgeChain(edge_chain, true)) + return false; // bozo vaccine + + const bool bClosedLoop = edge_count >= 3 && edge_chain[0].RelativeVertex(0) == edge_chain[edge_count - 1].RelativeVertex(1); + + ON_SubDSectorIterator sit; + const ON__INT_PTR sitdir = ((unsigned)1 - relative_side); + + ON_SubDEdgePtr chain_eptr1 = ON_SubDEdgePtr::Null; + const ON_SubDFace* f1 = nullptr; + const ON_SubDVertex* v = nullptr; + if (false == bClosedLoop) + { + // first edge/face pair at the chain's initial vertex + chain_eptr1 = edge_chain[0]; + f1 = chain_eptr1.RelativeFace(relative_side); + if (nullptr != f1) + { + v = chain_eptr1.RelativeVertex(0); + if (nullptr != v && v == sit.Initialize(f1, sitdir, v)) + { + ON_SubDEdgePtr e = sit.CurrentEdgePtr(0); + if (e.IsNotNull()) + { + side_components.Append(ON_SubDComponentPtr::Create(e)); + side_components.Append(ON_SubDComponentPtr::Create(f1)); + } + } + } + } + else + { + chain_eptr1 = edge_chain[edge_count-1]; + f1 = chain_eptr1.RelativeFace(relative_side); + } + + // first_side_components_edge is needed for closed loops. + ON_SubDComponentPtr first_side_components_edge = ON_SubDComponentPtr::Null; + for (unsigned j = bClosedLoop ? 0 : 1; j < edge_count; ++j) + { + const ON_SubDEdgePtr chain_eptr0 = chain_eptr1; + chain_eptr1 = edge_chain[j]; + v = chain_eptr1.RelativeVertex(0); + const ON_SubDFace* f0 = f1; + f1 = chain_eptr1.RelativeFace(relative_side); + if (nullptr != f0 && f0 == f1) + { + // side_components[] = ...f0,v,f1. + unsigned n = side_components.UnsignedCount(); + if (0 == n || f0 != side_components[n-1].Face()) + side_components.Append(ON_SubDComponentPtr::Create(f0)); + side_components.Append(ON_SubDComponentPtr::Create(v)); + side_components.Append(ON_SubDComponentPtr::Create(f1)); + continue; + } + + // sit_dex < sit_max prevents possiblity of an infinite loop if the chain or subd is corrupt + const unsigned sit_max = v->FaceCount(); + unsigned sit_dex = 1; + + const ON_SubDFace* f = nullptr; + for (;;) + { + if (nullptr == f0) + break; + + if (nullptr == v || v != sit.Initialize(f0, sitdir, v)) + break; + + ON_SubDEdgePtr eptr = sit.CurrentEdgePtr(1); + if (eptr.IsNull()) + break; + + unsigned n = side_components.UnsignedCount(); + if (0 == n || f0 != side_components[n - 1].Face()) + side_components.Append(ON_SubDComponentPtr::Create(f0)); + side_components.Append(ON_SubDComponentPtr::Create(eptr)); + if (first_side_components_edge.IsNull()) + first_side_components_edge = ON_SubDComponentPtr::Create(eptr); // needed for closed loops + + // The HasInteriorEdgeTopology() checks prevent getting garbage from + // non-oriented SubDs. If people complain, they need to orient + // their SubDs before asking "side" questions. + // Some math nerd yokel is sure to stuff the boundary of + // a mobius strip boundary into this function and then complain. + // Too bad for them. [Dale Lear 2021] + if (eptr.HasInteriorEdgeTopology(true)) + { + for (f = sit.NextFace(ON_SubDSectorIterator::StopAt::Boundary), sit_dex = 1; nullptr != f && sit_dex < sit_max; f = sit.NextFace(ON_SubDSectorIterator::StopAt::Boundary), ++sit_dex) + { + if (f == f0) + break; + eptr = sit.CurrentEdgePtr(1); + side_components.Append(ON_SubDComponentPtr::Create(f)); + if (f == f1) + break; + side_components.Append(ON_SubDComponentPtr::Create(eptr)); + if (false == eptr.HasInteriorEdgeTopology(true)) + break; + } + } + break; + } + + if (f == f1) + continue; + + for (;;) + { + if (nullptr == f1) + break; + if (nullptr == v || v != sit.Initialize(f1, 1-sitdir, v)) + break; + const ON_SubDEdgePtr eptr1 = sit.CurrentEdgePtr(1); + const unsigned count0 = side_components.UnsignedCount(); + if (eptr1.HasInteriorEdgeTopology(true)) + { + const ON_SubDFace* f2 = nullptr; + for (f = sit.NextFace(ON_SubDSectorIterator::StopAt::Boundary), sit_dex = 1; nullptr != f && sit_dex < sit_max; f = sit.NextFace(ON_SubDSectorIterator::StopAt::Boundary), ++sit_dex) + { + if (f == f0 || f == f1) + { + f = nullptr; + break; + } + f2 = f; + if (false == sit.CurrentEdgePtr(1).HasInteriorEdgeTopology(true)) + break; + } + if (nullptr == f2) + break; + if (v != sit.Initialize(f2, sitdir, v)) + break; + for (f = sit.CurrentFace(), sit_dex = 1; nullptr != f && sit_dex < sit_max; f = sit.NextFace(ON_SubDSectorIterator::StopAt::Boundary), ++sit_dex) + { + ON_SubDEdgePtr eptr = sit.CurrentEdgePtr(0); + if (f == f0 || eptr.IsNull()) + { + f = nullptr; + break; + } + side_components.Append(ON_SubDComponentPtr::Create(eptr)); + side_components.Append(ON_SubDComponentPtr::Create(f)); + if (f == f1) + break; + eptr = sit.CurrentEdgePtr(1); + if (false == eptr.HasInteriorEdgeTopology(true)) + { + f = nullptr; + break; + } + } + if (f != f1) + { + side_components.SetCount(count0); + } + } + if ( count0 == side_components.UnsignedCount() && eptr1.IsNotNull() ) + { + side_components.Append(ON_SubDComponentPtr::Create(eptr1)); + side_components.Append(ON_SubDComponentPtr::Create(f1)); + } + break; + } + } + + if (bClosedLoop) + { + const unsigned side_components_count = side_components.UnsignedCount(); + if (side_components_count >= 6 + && first_side_components_edge.IsEdge() + && side_components[0].IsFace() + && side_components[0].Face() == side_components[side_components_count-1].Face() + ) + { + // rearrange side_components[] so it begins with first_side_components_eptr. + // This elimnates the complexity of having to begin/end a SubD fillet + // at a ... f,v,f ... location. + const ON_SubDFace* f = side_components[0].Face(); + if (nullptr == f) + { + ON_SUBD_ERROR("f should be non-null."); + } + else + { + // set j0 = current side_components[] index of the first edge + unsigned j0 = side_components_count; + for (unsigned j = 0; j < side_components_count; ++j) + { + if (first_side_components_edge.m_ptr == side_components[j].m_ptr) + { + j0 = j; + break; + } + } + if (j0 > 0 && j0 < side_components_count) + { + ON_SimpleArray tail; + tail.Append((int)(j0-1), side_components.Array() + 1); + for (unsigned k = 0; k + j0 < side_components_count; ++k) + side_components[k] = side_components[j0 + k]; + side_components.SetCount(side_components_count - j0); + side_components.Append(tail.Count(), tail.Array()); + side_components.Append(first_side_components_edge); + } + } + } + } + else + { + // last edge at the chain's final vertex + chain_eptr1 = edge_chain[edge_count - 1]; + f1 = chain_eptr1.RelativeFace(relative_side); + if (nullptr != f1) + { + v = chain_eptr1.RelativeVertex(1); + if (nullptr != v && v == sit.Initialize(f1, sitdir, v)) + { + ON_SubDEdgePtr eptr = sit.CurrentEdgePtr(1); + if (eptr.IsNotNull()) + { + unsigned n = side_components.UnsignedCount(); + if (0 == n || f1 != side_components[n - 1].Face()) + side_components.Append(ON_SubDComponentPtr::Create(f1)); + side_components.Append(ON_SubDComponentPtr::Create(eptr)); + } + } + } + } + + return side_components.UnsignedCount() > 0; +} const ON_SimpleArray& ON_SubDEdgeChain::EdgeChain() const { @@ -19588,6 +20603,25 @@ const ON_SubDVertex* ON_SubDEdgeChain::Vertex(int vertex_index) const return nullptr; } +const ON_3dPoint ON_SubDEdgeChain::FirstControlNetPoint() const +{ + const ON_SubDVertex* v = FirstVertex(); + return (nullptr != v) ? v->ControlNetPoint() : ON_3dPoint::NanPoint; +} + +const ON_3dPoint ON_SubDEdgeChain::LastControlNetPoint() const +{ + const ON_SubDVertex* v = LastVertex(); + return (nullptr != v) ? v->ControlNetPoint() : ON_3dPoint::NanPoint; +} + +const ON_3dPoint ON_SubDEdgeChain::ControlNetPoint(int vertex_index) const +{ + const ON_SubDVertex* v = Vertex(vertex_index); + return (nullptr != v) ? v->ControlNetPoint() : ON_3dPoint::NanPoint; +} + + unsigned int ON_SubDEdgeChain::AddOneNeighbor( ON_ChainDirection direction, @@ -19896,6 +20930,527 @@ bool ON_SubD::IsManifold() const return IsManifold(bIsOriented, bHasBoundary); } +#ifdef ON_DEBUG +static bool Internal_UnrollChain(const ON_SimpleArray& chain) { + const unsigned imax{chain.UnsignedCount()}; + ON_SimpleArray reversed_dirs{(size_t)imax}; + ON_SimpleArray edges{(size_t)imax}; + ON_SimpleArray vertices{(size_t)2 * (size_t)imax}; + ON_SimpleArray edge_ids{(size_t)imax}; + ON_SimpleArray vertice_ids{(size_t)2 * (size_t)imax}; + const unsigned int max_id = 0xFFFFFFFFU; + for (unsigned i = 0; i < imax; ++i) { + ON_SubDEdgePtr eptr = chain[i]; + const ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(eptr.m_ptr); + if (nullptr == e) { + reversed_dirs.Append(false); + edges.Append(nullptr); + vertices.Append(nullptr); + vertices.Append(nullptr); + edge_ids.Append(max_id); + vertice_ids.Append(max_id); + vertice_ids.Append(max_id); + continue; + } + edges.Append(e); + edge_ids.Append(e->m_id); + ON__UINT_PTR edir = ON_SUBD_EDGE_DIRECTION(eptr.m_ptr); + reversed_dirs.Append(edir == 0 ? false : true); + const ON_SubDVertex* v[2] = {e->m_vertex[edir], e->m_vertex[1 - edir]}; + vertices.Append(v[0]); + vertices.Append(v[1]); + vertice_ids.Append(v[0] == nullptr ? max_id : v[0]->m_id); + vertice_ids.Append(v[1] == nullptr ? max_id : v[1]->m_id); + } + return true; +} + +static bool Internal_VerifyEdgeChain( + const ON_SimpleArray& chain, ON_2udex& chaindex, + unsigned* edge_count = nullptr) { + bool valid_chain{true}; + unsigned valid_edge_count{0}; + const unsigned jmax{chain.UnsignedCount()}; + ON_SubDEdgePtr eptr = chain[chaindex.i]; + const ON_SubDEdge* e = ON_SUBD_EDGE_POINTER(eptr.m_ptr); + if (nullptr == e) { + if (edge_count != nullptr) *edge_count = 0; + return false; + } + ON__UINT_PTR edir = ON_SUBD_EDGE_DIRECTION(eptr.m_ptr); + const ON_SubDVertex* v[2] = {e->m_vertex[edir], e->m_vertex[1 - edir]}; + if (nullptr == v[0] || nullptr == v[1] || v[0] == v[1]) { + if (edge_count != nullptr) *edge_count = 0; + return false; + } + ++valid_edge_count; + for (chaindex.j = chaindex.i + 1; chaindex.j < jmax; ++chaindex.j) { + valid_chain = false; + eptr = chain[chaindex.j]; + e = ON_SUBD_EDGE_POINTER(eptr.m_ptr); + if (nullptr == e) { + // End of chain marker + valid_chain = true; + if (chaindex.j < jmax) ++chaindex.j; + break; + } + if (nullptr == e->m_vertex[0] || nullptr == e->m_vertex[1] || + e->m_vertex[0] == e->m_vertex[1]) { + break; + } + edir = ON_SUBD_EDGE_DIRECTION(eptr.m_ptr); + if (v[1] != e->m_vertex[edir]) { + if (edge_count == nullptr) valid_chain = true; + break; + } + v[1] = e->m_vertex[1 - edir]; + ++valid_edge_count; + valid_chain = true; + } + if (edge_count != nullptr && *edge_count != valid_edge_count) { + *edge_count = valid_edge_count; + return false; + } + return valid_edge_count > 0 && valid_chain; +} + +static bool Internal_CountAndVerifyEdgeChains( + const ON_SimpleArray& sorted_edges, + unsigned* chain_count = nullptr) { + if (chain_count != nullptr && chain_count == 0) return false; + unsigned valid_chain_count{0}; + bool valid_chains{false}; + const unsigned edge_count{sorted_edges.UnsignedCount()}; + ON_2udex chaindex{0, edge_count}; + for (chaindex = {0, edge_count}; chaindex.i < edge_count; + chaindex.i = (chaindex.j > chaindex.i) ? chaindex.j : (chaindex.i + 1)) { + valid_chains = false; + if (!Internal_VerifyEdgeChain(sorted_edges, chaindex)) break; + ++valid_chain_count; + valid_chains = true; + } + if (chain_count != nullptr && + (*chain_count != valid_chain_count || chaindex.j != edge_count)) { + *chain_count = valid_chain_count; + return false; + } + return valid_chain_count > 0 && valid_chains; +} +#endif + +////////////////////////// +// +// Better edge sorter +// + + +static unsigned Internal_MuchImprovedSortEdgesIntoChains( + const ON__UINT_PTR* unsorted_edges, + size_t unsorted_edges_count, + ON_SimpleArray& sorted_edges +) +{ + // NOTE: sorted_edges and unsorted_edges should not point to the same array by this point + sorted_edges.SetCount(0); + sorted_edges.Reserve(unsorted_edges_count + 128U); + + if (unsorted_edges_count < 1 || nullptr == unsorted_edges) + return 0; + + const unsigned unsorted_count = (unsigned)unsorted_edges_count; + unsigned chain_count = 0; + + // Set MarkBits = 0 for every vertex and for every edge attached to a vertex in the edge chain. + for (unsigned i = 0; i < unsorted_count; ++i) + { + const ON_SubDEdge* e = (const ON_SubDEdge*)(ON_SUBD_COMPONENT_POINTER_MASK & unsorted_edges[i]); + if (nullptr == e) + continue; + e->ClearMarkBits(); + if (nullptr == e->m_vertex[0] || nullptr == e->m_vertex[1]) + continue; + if (e->m_vertex[0] == e->m_vertex[1]) + continue; + for (unsigned evi = 0; evi < 2; ++evi) + { + const ON_SubDVertex* v = e->m_vertex[evi]; + v->ClearMarkBits(); + for (unsigned short vei = 0; vei < v->m_edge_count; ++vei) + { + const ON_SubDEdge* ve = ON_SUBD_EDGE_POINTER(v->m_edges[vei].m_ptr); + if (nullptr != ve) + ve->ClearMarkBits(); + } + } + } + + // Set e->MarkBits = 1 for every valid edge in the edge chain. + for (unsigned i = 0; i < unsorted_count; ++i) + { + const ON_SubDEdge* e = (const ON_SubDEdge*)(ON_SUBD_COMPONENT_POINTER_MASK & unsorted_edges[i]); + if (nullptr == e) + continue; + if (nullptr == e->m_vertex[0] || nullptr == e->m_vertex[1]) + continue; + if (e->m_vertex[0] == e->m_vertex[1]) + continue; + e->SetMarkBits(1); + } + + // Set v->MarkBits() = number of unsorted_edges[] that have v as a vertex with 3 meaning 3 or more. + for (unsigned i = 0; i < unsorted_count; ++i) + { + const ON_SubDEdge* e = (const ON_SubDEdge*)(ON_SUBD_COMPONENT_POINTER_MASK & unsorted_edges[i]); + if (nullptr == e) + continue; + if (0 == e->MarkBits()) + continue; + for (unsigned evi = 0; evi < 2; ++evi) + { + const ON_SubDVertex* v = e->m_vertex[evi]; + const ON__UINT8 ecount = v->MarkBits(); + if (ecount < 3) + v->SetMarkBits(ecount + 1); + } + } + + // Go through the unsorted edges and use the MarkBits values to quickly build the edge chains. + ON_SimpleArray chain((int)unsorted_edges_count); + + for (unsigned i = 0; i < unsorted_edges_count; ++i) + { + const ON_SubDEdge* seed_edge = (const ON_SubDEdge*)(ON_SUBD_COMPONENT_POINTER_MASK & unsorted_edges[i]); + if (nullptr == seed_edge || 1 != seed_edge->MarkBits()) + continue; // seed_edge is invalid or already assigned to an edge chain + + // this edge pointer direcion will be reversed when the for loop evi = 1. + chain.SetCount(0); + chain.Append(ON_SubDEdgePtr::Create(seed_edge, 1)); // dir=1 is correct. The direcion will be reversed in the for loop below when evi = 1. + seed_edge->ClearMarkBits(); // seed_edge is now in a chain + + for (unsigned evi = 0; evi < 2; ++evi) + { + if (1 == evi) + { + ON_SubDEdgeChain::ReverseEdgeChain(chain); + if (chain[0].RelativeVertex(0) == chain[chain.UnsignedCount() - 1].RelativeVertex(1)) + break; // we found a closed loop + } + + const ON_SubDVertex* v = chain[chain.UnsignedCount() - 1].RelativeVertex(1); + if (nullptr == v || 2 != v->MarkBits()) + continue; // edge chain cannot continue through v + + for (const ON_SubDVertex* v1 = nullptr; nullptr != v && 2 == v->MarkBits(); v = v1) + { + v->ClearMarkBits(); // clearing v->MarkBits indicates this v has been used. + v1 = nullptr; + for (unsigned short vei = 0; vei < v->m_edge_count; ++vei) + { + const ON_SubDEdge* ve = ON_SUBD_EDGE_POINTER(v->m_edges[vei].m_ptr); + if (nullptr == ve) + continue; + if (1 != ve->MarkBits()) + continue; // this ve was not in unsorted_edges[] or has already been assigned to a chain. + if (v == ve->m_vertex[0]) + { + ve->SetMarkBits(0); // MarkBits() = 0 indicates ve is now in a chain + chain.Append(ON_SubDEdgePtr::Create(ve, 0)); + v1 = ve->m_vertex[1]; + } + else if (v == ve->m_vertex[1]) + { + ve->SetMarkBits(0); // MarkBits() = 0 indicates ve is now in a chain + chain.Append(ON_SubDEdgePtr::Create(ve, 1)); + v1 = ve->m_vertex[0]; + } + else + { + ON_SUBD_ERROR("Corrupt edge/vertex topology."); + } + } + v = v1; + } + } + +#ifdef ON_DEBUG + unsigned temp_chain_edge_count{chain.UnsignedCount()}; + ON_2udex temp_udex{0U, (unsigned)(chain.UnsignedCount() - 1)}; + if (!Internal_VerifyEdgeChain(chain, temp_udex, &temp_chain_edge_count)) { + temp_chain_edge_count = 0; + } + Internal_UnrollChain(chain); +#endif + sorted_edges.Append(chain.Count(), chain.Array()); + sorted_edges.Append(ON_SubDEdgePtr::Null); // end of chain marker + ++chain_count; + } + + // clear all the mark bits that may still be set when the input is corrupt. + for (size_t i = 0; i < unsorted_edges_count; ++i) + { + const ON_SubDEdge* e = (const ON_SubDEdge*)(ON_SUBD_COMPONENT_POINTER_MASK & unsorted_edges[i]); + if (nullptr == e) + continue; + e->ClearMarkBits(); + if (nullptr != e->m_vertex[0]) + e->m_vertex[0]->ClearMarkBits(); + if (nullptr != e->m_vertex[1]) + e->m_vertex[1]->ClearMarkBits(); + } + +#ifdef ON_DEBUG + Internal_UnrollChain(sorted_edges); + if (!Internal_CountAndVerifyEdgeChains(sorted_edges, &chain_count)) { + return chain_count; + } +#endif + return chain_count; +} + +unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( + const ON_SimpleArray< ON_SubDEdgePtr >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges +) +{ + unsigned int chain_count = 0; + if (unsorted_edges.Array() == sorted_edges.Array()) + { + const ON_SimpleArray< ON_SubDEdgePtr > local_unsorted_edges(unsorted_edges); + chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR * )local_unsorted_edges.Array(), + local_unsorted_edges.UnsignedCount(), + sorted_edges + ); + } + else + { + chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)unsorted_edges.Array(), + unsorted_edges.UnsignedCount(), + sorted_edges + ); + } + return chain_count; +} + +unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( + const ON_SimpleArray< const ON_SubDEdge* >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges +) +{ + unsigned int chain_count = 0; + if ((const void*)unsorted_edges.Array() == (const void*)sorted_edges.Array()) + { + const ON_SimpleArray< const ON_SubDEdge* > local_unsorted_edges(unsorted_edges); + chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)local_unsorted_edges.Array(), + local_unsorted_edges.UnsignedCount(), + sorted_edges + ); + } + else + { + chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)unsorted_edges.Array(), + unsorted_edges.UnsignedCount(), + sorted_edges + ); + } + return chain_count; +} + +unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( + const ON_SimpleArray< ON_SubDComponentPtr >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges +) +{ + unsigned int chain_count = 0; + if ((const void*)unsorted_edges.Array() == (const void*)sorted_edges.Array()) + { + const ON_SimpleArray< ON_SubDComponentPtr > local_unsorted_edges(unsorted_edges); + chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)local_unsorted_edges.Array(), + local_unsorted_edges.UnsignedCount(), + sorted_edges + ); + } + else + { + chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)unsorted_edges.Array(), + unsorted_edges.UnsignedCount(), + sorted_edges + ); + } + return chain_count; +} + +unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( + const ON_SubD& subd, + const ON_SimpleArray< ON_COMPONENT_INDEX >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges +) +{ + const unsigned unsorted_count = unsorted_edges.UnsignedCount(); + ON_SimpleArray< const ON_SubDEdge* > local_unsorted_edges(unsorted_count); + for (unsigned i = 0; i < unsorted_count; ++i) + { + const ON_COMPONENT_INDEX ci = unsorted_edges[i]; + if (ON_COMPONENT_INDEX::TYPE::subd_edge != ci.m_type) + continue; + if (0 == ci.m_index || -1 == ci.m_index) + continue; + const ON_SubDEdge* e = subd.EdgeFromId((unsigned)ci.m_index); + if (nullptr == e) + continue; + local_unsorted_edges.Append(e); + } + + return Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)local_unsorted_edges.Array(), + unsorted_edges.UnsignedCount(), + sorted_edges + ); +} + +bool ON_SubDEdgeChain::IsSingleEdgeChain( + const ON_SimpleArray& edges, + bool& bIsClosed, + bool& bIsSorted +) +{ + bIsSorted = false; + bIsClosed = false; + + const unsigned count = edges.UnsignedCount(); + if (count <= 1U) + { + const ON_SubDEdge* e = (1U == count) ? edges[0].Edge() : nullptr; + if ( + nullptr != e + && nullptr != e->m_vertex[0] + && nullptr != e->m_vertex[1] + && e->m_vertex[0] != e->m_vertex[1] + ) + { + // 1 valid edge + bIsSorted = true; + return true; + } + return false; + } + + // save MarkBits() values on edges[] components so they can be restored after testing. + // Internal_MuchImprovedSortEdgesIntoChains() uses MarkBits(). + union + { + ON__UINT32 u32; + ON__UINT8 u8[4]; + } u; + ON_SimpleArray saved_markbits(count); + for (unsigned i = 0; i < count; ++i) + { + u.u32 = 0; + const ON_SubDEdge* e = edges[i].Edge(); + if (nullptr != e) + { + u.u8[0] = e->MarkBits(); + if (e->m_vertex[0]) + u.u8[1] = e->m_vertex[0]->MarkBits(); + if (e->m_vertex[1]) + u.u8[2] = e->m_vertex[1]->MarkBits(); + } + saved_markbits.Append(u.u32); + } + + bool bIsSingleEdgeChain = false; + for (;;) + { + ON_SimpleArray sorted_edges; + const unsigned chain_count = Internal_MuchImprovedSortEdgesIntoChains( + (const ON__UINT_PTR*)edges.Array(), + count, + sorted_edges + ); + + if (1U != chain_count) + break; // edges[] is not a contiguouse set of edges or it self intersects. + if (count + 1U != sorted_edges.UnsignedCount()) + break; // edges[] contained null edges + + // determine edges[] sorts into a closed edge chain. + if (count >= 3 && sorted_edges[0].RelativeVertex(0) == sorted_edges[count - 1].RelativeVertex(1)) + bIsClosed = true; + + // Determine edges[] is was already sorted. + // Note that this test does not detect self interections and that's + // why ON_SubDEdgeChain::SortEdgesIntoEdgeChains() is called above. + const ON_SubDVertex* v0 = edges[0].RelativeVertex(0); + if (nullptr != v0) + { + const ON_SubDVertex* edges_ends[2] = { edges[0].RelativeVertex(0), edges[count - 1].RelativeVertex(1) }; + const ON_SubDVertex* sorted_ends[2] = { sorted_edges[0].RelativeVertex(0), sorted_edges[count - 1].RelativeVertex(1) }; + if (bIsClosed) + { + if (edges_ends[0] == edges_ends[1] && sorted_ends[0] == sorted_ends[1]) + bIsSorted = true; + } + else + { + // sorted_eges[] may be reversed. + if (edges_ends[0] == sorted_ends[0] && edges_ends[1] == sorted_ends[1]) + bIsSorted = true; + else if (edges_ends[0] == sorted_ends[1] && edges_ends[1] == sorted_ends[0]) + bIsSorted = true; + } + + for (unsigned i = 0; bIsSorted && i < count; ++i) + { + const ON_SubDVertex* ev[2] = { edges[i].RelativeVertex(0), edges[i].RelativeVertex(1) }; + if (v0 != ev[0] || nullptr == ev[1] || ev[0] == ev[1]) + { + bIsSorted = false; + break; + } + v0 = ev[1]; + } + } + + + bIsSingleEdgeChain = true; + break; + } + + + // restore MarkBits() values on edges[] components. + for (unsigned i = 0; i < count; ++i) + { + u.u32 = saved_markbits[i]; + const ON_SubDEdge* e = edges[i].Edge(); + if (nullptr != e) + { + e->SetMarkBits(u.u8[0]); + if (e->m_vertex[0]) + e->m_vertex[0]->SetMarkBits(u.u8[1]); + if (e->m_vertex[1]) + e->m_vertex[1]->SetMarkBits(u.u8[2]); + } + } + + return bIsSingleEdgeChain; +} + +bool ON_SubDEdgeChain::IsSingleEdgeChain( + const ON_SimpleArray& edges +) +{ + bool bIsClosed = false; + bool bIsSorted = false; + return ON_SubDEdgeChain::IsSingleEdgeChain(edges, bIsClosed, bIsSorted); +} + + class ON_SubDEdgePtrLink { public: @@ -20319,11 +21874,12 @@ unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( chain.Append(epl.m_ep); } - const bool bClosedChain = (epl.m_index == epl1.m_index); - const bool bReverseFinalChain - = false == bClosedChain - && unset_nbr1_index == epl.m_nbr_index - && (0 == (epl.m_index % 2)); + const bool bClosedChain = + chain.UnsignedCount() > 0 && (epl.m_index == epl1.m_index); + const bool bFirstEdgeIsReversed = !bClosedChain && + unset_nbr1_index <= epl.m_nbr_index && + (0 == (epl.m_index % 2)); + bool bLastEdgeIsReversed{false}; if (false == bClosedChain) { chain.Reverse(); @@ -20365,8 +21921,15 @@ unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( chain.Append(epl.m_ep.Reversed()); } - if (bReverseFinalChain) - chain.Reverse(); + // No need to update bClosedChain here: if it was closed, then the circle + // was found with the edges "before" edges[i/2] + + // First and last edge are reversed: reverse chain direction to keep first + // edge direction the same as in unsorted_edges + bLastEdgeIsReversed = epl.m_index % 2 == 0; + if (bFirstEdgeIsReversed && bLastEdgeIsReversed) { + ReverseEdgeChain(chain); + } } const unsigned int chain_edge_count = chain.UnsignedCount(); @@ -20421,20 +21984,97 @@ unsigned int ON_SubDEdgeChain::SortEdgesIntoEdgeChains( } break; } - if (chain.UnsignedCount() >= minimum_chain_length) - { - ++chain_count; - sorted_edges.Append(chain.Count(), chain.Array()); +#ifdef ON_DEBUG + unsigned temp_chain_edge_count{chain_edge_count}; + ON_2udex temp_udex{0U, (unsigned)(chain_edge_count - 1)}; + if (!Internal_VerifyEdgeChain(chain, temp_udex, &temp_chain_edge_count)) { + temp_chain_edge_count = 0; + } + Internal_UnrollChain(chain); +#endif + if (chain.UnsignedCount() >= minimum_chain_length) { + const ON_SubDVertex* c0{chain[0].RelativeVertex(0)}; + const ON_SubDVertex* s1{sorted_edges.Last() == nullptr + ? nullptr + : sorted_edges.Last()->RelativeVertex(1)}; + if (c0 != nullptr && c0 == s1) { + // If the first vertex of the chain is a corner, or a vertex with more + // than 2 edges referencing it, we might have artificially split the + // chain at that vertex and the last vertex of the previous chain is + // the same as ours. Try a few tricks to put a gap between these two + // vertices. + const ON_SubDVertex* c1{ + chain[chain_edge_count - 1].RelativeVertex(1)}; + const ON_SubDVertex* s0{ + sorted_edges.First() == nullptr + ? nullptr + : sorted_edges.First()->RelativeVertex(0)}; + // By order of importance, try to: + // - Keep the orientation of the first edge the same as in unsorted_edges + // - Not use ReverseEdgeChain() + // - Append rather than Prepend to sorted_edges + if (c1 != s0) { + ++chain_count; + sorted_edges.Prepend(chain.Count(), chain.Array()); + } else if (c1 != s1 && !bClosedChain && + ((bFirstEdgeIsReversed && !bLastEdgeIsReversed) || + (!bFirstEdgeIsReversed && bLastEdgeIsReversed))) { + ReverseEdgeChain(chain); + ++chain_count; + sorted_edges.Append(chain.Count(), chain.Array()); + } else if (c0 != s0 && !bClosedChain && + ((bFirstEdgeIsReversed && !bLastEdgeIsReversed) || + (!bFirstEdgeIsReversed && bLastEdgeIsReversed))) { + ReverseEdgeChain(chain); + ++chain_count; + sorted_edges.Prepend(chain.Count(), chain.Array()); + } else if (c1 != s1 && !bClosedChain) { + ReverseEdgeChain(chain); + ++chain_count; + sorted_edges.Append(chain.Count(), chain.Array()); + } else if (c0 != s0 && !bClosedChain) { + ReverseEdgeChain(chain); + ++chain_count; + sorted_edges.Prepend(chain.Count(), chain.Array()); + } else { + // We tried, but nothing works easily enough: append the chain as + // usual, this means the two chains are merged and chain_count does + // not increase. + sorted_edges.Append(chain.Count(), chain.Array()); + } + } else { + ++chain_count; + sorted_edges.Append(chain.Count(), chain.Array()); + } } } if ( link_count == 2*sorted_edges.UnsignedCount() ) break; // we've used all the links - no need to "skip over the rest". } - +#ifdef ON_DEBUG + Internal_UnrollChain(sorted_edges); + if (!Internal_CountAndVerifyEdgeChains(sorted_edges, &chain_count)) { + return chain_count; + } +#endif return chain_count; } +const ON_SHA1_Hash ON_SubDEdgeChain::Hash() const +{ + ON_SHA1 sha1; + const unsigned edge_count = this->EdgeCount(); + for (unsigned i = 0; i < edge_count; ++i) + { + const ON_SubDEdgePtr eptr = EdgePtr(i); + sha1.AccumulateInteger32(eptr.EdgeId()); + sha1.AccumulateInteger32(eptr.RelativeVertexId(0)); + sha1.AccumulateInteger32(eptr.RelativeVertexId(1)); + } + return sha1.Hash(); +} + unsigned int ON_SubDEdgeChain::OrientEdgesIntoEdgeChains( const ON_SubD& subd, const ON_SimpleArray< ON_COMPONENT_INDEX >& edges, @@ -21744,6 +23384,207 @@ bool ON_Symmetry::SetSymmetricObject(const ON_SubDimple* subdimple) const return rc; } +double ON_SubDExpandEdgesParameters::ConstantOffset() const +{ + return this->m_constant_offset; +} + +void ON_SubDExpandEdgesParameters::SetConstantOffset(double offset) +{ + offset = ON_SubDExpandEdgesParameters::CleanupOffset(offset); + if (ON_SubDExpandEdgesParameters::IsValidConstantOffset(offset)) + this->m_constant_offset = offset; +} + + +bool ON_SubDExpandEdgesParameters::IsValidForHalfOffset( + const ON_SimpleArray& edge_chain +) +{ + const unsigned count = edge_chain.UnsignedCount(); + for (unsigned i = 0; i < count; ++i) + { + if (false == edge_chain[i].HasInteriorEdgeTopology(true)) + return false; + } + return ON_SubDEdgeChain::IsSingleEdgeChain(edge_chain); +} + + +bool ON_SubDExpandEdgesParameters::IsValidForVariableOffset( + const ON_SimpleArray& edge_chain +) +{ + bool bIsClosed = false; + bool bIsSorted = false; + const bool IsSingleEdgeChain = ON_SubDEdgeChain::IsSingleEdgeChain(edge_chain, bIsClosed, bIsSorted); + return IsSingleEdgeChain && false == bIsClosed; +} + +const ON_Interval ON_SubDExpandEdgesParameters::VariableOffset() const +{ + return this->m_variable_offsets; +} + +void ON_SubDExpandEdgesParameters::SetVariableOffset(ON_Interval variable_offsets) +{ + variable_offsets[0] = ON_SubDExpandEdgesParameters::CleanupOffset(variable_offsets[0]); + variable_offsets[1] = ON_SubDExpandEdgesParameters::CleanupOffset(variable_offsets[1]); + if (ON_SubDExpandEdgesParameters::IsValidVariableOffset(variable_offsets)) + { + this->m_variable_offsets = variable_offsets; + } + else + { + // invalid input + ClearVariableOffset(); + if (ON_SubDExpandEdgesParameters::IsValidConstantOffset(variable_offsets[0]) + && fabs(variable_offsets[0] - variable_offsets[1]) <= ON_SubDExpandEdgesParameters::OffsetTolerance + ) + { + SetConstantOffset(variable_offsets[0]); + } + } +} + +void ON_SubDExpandEdgesParameters::ClearVariableOffset() +{ + this->m_variable_offsets = ON_Interval::Nan; +} + +bool ON_SubDExpandEdgesParameters::IsVariableOffset() const +{ + return ON_SubDExpandEdgesParameters::IsValidVariableOffset(this->m_variable_offsets); +} + +bool ON_SubDExpandEdgesParameters::IsValidConstantOffset( + double constant_offset_candidate +) +{ + return constant_offset_candidate >= ON_SubDExpandEdgesParameters::MinimumOffset && constant_offset_candidate <= ON_SubDExpandEdgesParameters::MaximumOffset; +} + +bool ON_SubDExpandEdgesParameters::IsValidVariableOffset( + ON_Interval variable_offset_candidate +) +{ + for (int i = 0; i < 2; i++) + { + const double x[2] = { variable_offset_candidate[i], variable_offset_candidate[1 - i] }; + if (false == ON_SubDExpandEdgesParameters::IsValidConstantOffset(x[0])) + { + if (0.0 == x[0]) + return (x[1] >= ON_SubDExpandEdgesParameters::MinimumOffset && x[1] <= 1.0); + if (1.0 == x[0]) + return (x[1] >= 0.0 && x[1] <= ON_SubDExpandEdgesParameters::MaximumOffset); + return false; + } + } + return fabs(variable_offset_candidate[0] - variable_offset_candidate[1]) > ON_SubDExpandEdgesParameters::OffsetTolerance; +} + + +ON_SubDExpandEdgesParameters::Style ON_SubDExpandEdgesParameters::FaceStyle() const +{ + return this->m_face_style; +} + +void ON_SubDExpandEdgesParameters::SetFaceStyle(ON_SubDExpandEdgesParameters::Style face_style) +{ + this->m_face_style = face_style; +} + +bool ON_SubDExpandEdgesParameters::IsHalfFaceStyle() const +{ + return + ON_SubDExpandEdgesParameters::Style::HalfLeft == this->m_face_style + || ON_SubDExpandEdgesParameters::Style::HalfRight == this->m_face_style + ; +} + +const ON_Color ON_SubDExpandEdgesParameters::FaceColor() const +{ + return this->m_face_color; +} + +void ON_SubDExpandEdgesParameters::SetFaceColor(ON_Color face_color) +{ + this->m_face_color = face_color; +} + +const ON_ComponentStatus ON_SubDExpandEdgesParameters::FaceStatus() const +{ + return this->m_face_status; +} + +void ON_SubDExpandEdgesParameters::SetFaceStatus(ON_ComponentStatus face_status) +{ + this->m_face_status = ON_ComponentStatus::NoneSet; + this->m_face_status.SetRuntimeMark(face_status.SetRuntimeMark()); + this->m_face_status.SetMarkBits(face_status.MarkBits()); + if (face_status.IsSelectedPersistent()) + this->m_face_status.SetSelectedState(ON_ComponentState::SelectedPersistent, face_status.IsHighlighted()); + else if (face_status.IsSelected()) + this->m_face_status.SetSelectedState(ON_ComponentState::Selected, face_status.IsHighlighted()); + else if (face_status.IsHighlighted()) + this->m_face_status.SetHighlightedState(true); +} + +const ON_SHA1_Hash ON_SubDExpandEdgesParameters::Hash() const +{ + ON_SHA1 sha1; + sha1.AccumulateDouble(ConstantOffset()); + sha1.AccumulateDouble(VariableOffset().m_t[0]); + sha1.AccumulateDouble(VariableOffset().m_t[1]); + sha1.AccumulateInteger32((unsigned int)FaceColor()); + sha1.AccumulateBytes(&m_face_status, sizeof(m_face_status)); + sha1.AccumulateInteger32((unsigned int)FaceStyle()); + return sha1.Hash(); +} + +bool operator==(const ON_SubDExpandEdgesParameters& lhs, const ON_SubDExpandEdgesParameters& rhs) +{ + return lhs.Hash() == rhs.Hash(); +} + +bool operator!=(const ON_SubDExpandEdgesParameters& lhs, const ON_SubDExpandEdgesParameters& rhs) +{ + return lhs.Hash() != rhs.Hash(); +} + + +double ON_SubDExpandEdgesParameters::CleanupOffset(double x) +{ + + const double r[] = { + 0.0, + 1.0, + ON_SubDExpandEdgesParameters::SmallOffset, + ON_SubDExpandEdgesParameters::MediumOffset, + ON_SubDExpandEdgesParameters::LargeOffset, + ON_SubDExpandEdgesParameters::MinimumOffset, + ON_SubDExpandEdgesParameters::MaximumOffset + }; + + const size_t c = sizeof(r) / sizeof(r[0]); + for (size_t i = 0; i < c; ++i) + { + if (fabs(x - r[i]) <= ON_SubDExpandEdgesParameters::OffsetTolerance) + return r[i]; + } + + if (x > 0.0 && x < ON_SubDExpandEdgesParameters::MinimumOffset) + x = ON_SubDExpandEdgesParameters::MinimumOffset; + else if (x < 1.0 && x > ON_SubDExpandEdgesParameters::MaximumOffset) + x = ON_SubDExpandEdgesParameters::MaximumOffset; + + if (x >= 0.0 && x <= 1.0) + return x; + + return ON_DBL_QNAN; +} + + #if defined(ON_SUBD_CENSUS) ////////////////////////////////////////////////////////////////////////// diff --git a/opennurbs_subd.h b/opennurbs_subd.h index 0571afef..3d925d7d 100644 --- a/opennurbs_subd.h +++ b/opennurbs_subd.h @@ -768,6 +768,20 @@ public: ) const; ON__UINT8 ClearMarkBits() const; + + void ClearSavedSubdivisionPoints() const; + + /* + Description: + Clears saved subdivision and limit surface information for this component. + Parameters: + bClearNeighborhood - [in] + If true, all components attached to this component are also cleared. + */ + void ClearSavedSubdivisionPoints( + bool bClearNeighborhood + ) const; + }; @@ -863,6 +877,15 @@ public: */ bool EdgeIsDartCrease() const; + /* + Returns: + If Edge() is not nullptr, Edge()->HasInteriorEdgeTopology(bRequireOppositeFaceDirections) is returned. + Otherwise, false is returned. + */ + bool HasInteriorEdgeTopology( + bool bRequireOppositeFaceDirections + ) const; + /* Returns: 0: this ON_SubDEdgePtr is oriented from Edge()->Vertex(0) to Edge()->Vertex(1). @@ -883,6 +906,19 @@ public: int relative_vertex_index ) const; + /* + Parameters: + relative_vertex_index - [in] + 0: return Edge()->Vertex(EdgeDirection()) + 1: return Edge()->Vertex(1-EdgeDirection()) + Returns: + The requested id of the vertex with EdgeDirection() taken into account. + 0 if relative_vertex_index, Edge() is nullptr, or Edge()->Vertex() is nullptr. + */ + unsigned RelativeVertexId( + int relative_vertex_index + ) const; + /* Parameters: relative_vertex_index - [in] @@ -927,6 +963,46 @@ public: int relative_vertex_index ) const; + /* + Description: + Get the face on the left or right side of an oriented manifold or boundary edge. + A face is on the "left side" if this ON_SubDEdgePtr is oriented so it + points in the same direction as the face's oriented boundary. + A face is on the "right side" if this ON_SubDEdgePtr is oriented so it + points in the opposite direction as the face's oriented boundary. + If an edge is nonmanifold (3 or more faces), then nullptr is always returned. + If an edge has two faces that do not attach to this edge with opposite orientations + (nonoriented manifold edge), then nullptr is returned. + Parameters: + relative_face_index - [in] + 0: return face on the left side of the edge with respect to EdgeOrientation(). + 1: return face on the right side of the edge with respect to EdgeOrientation(). + Returns: + The requested face. + */ + const class ON_SubDFace* RelativeFace( + int relative_face_index + ) const; + + /* + Returns: + this->RelativeFace(relative_face_index)->Mark(); + */ + bool RelativeFaceMark( + int relative_face_index, + bool missing_face_return_value + ) const; + + + /* + Returns: + this->RelativeFace(relative_face_index)->MarkBits(); + */ + ON__UINT8 RelativeFaceMarkBits( + int relative_face_index, + ON__UINT8 missing_face_return_value + ) const; + /* Returns: The vector from RelativeVertex(0)->ControlNetPoint() to RelativeVertex(1)->ControlNetPoint(), @@ -946,6 +1022,20 @@ public: */ const ON_SubDEdgePtr Reversed() const; + void ClearSavedSubdivisionPoints() const; + + /* + Description: + Clears saved subdivision and limit surface information for this component. + Parameters: + bClearNeighborhood - [in] + If true, all components attached to this component are also cleared. + */ + void ClearSavedSubdivisionPoints( + bool bClearNeighborhood + ) const; + + /* Parameters: @@ -1200,6 +1290,20 @@ public: ) const; ON__UINT8 ClearMarkBits() const; + + void ClearSavedSubdivisionPoints() const; + + /* + Description: + Clears saved subdivision and limit surface information for this component. + Parameters: + bClearNeighborhood - [in] + If true, all components attached to this component are also cleared. + */ + void ClearSavedSubdivisionPoints( + bool bClearNeighborhood + ) const; + }; #if defined(ON_DLL_TEMPLATE) @@ -1328,6 +1432,23 @@ public: const ON_SubDEdgePtr EdgePtr() const; const ON_SubDFacePtr FacePtr() const; + const bool IsVertex() const; + const bool IsEdge() const; + const bool IsFace() const; + + void ClearSavedSubdivisionPoints() const; + + /* + Description: + Clears saved subdivision and limit surface information for this component. + Parameters: + bClearNeighborhood - [in] + If true, all components attached to this component are also cleared. + */ + void ClearSavedSubdivisionPoints( + bool bClearNeighborhood + ) const; + unsigned int ComponentId() const; const ON_COMPONENT_INDEX ComponentIndex() const; @@ -1575,6 +1696,239 @@ public: ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; #endif +////////////////////////////////////////////////////////////////////////// +// +// ON_SubDComponentPtrAndNumber +// + +class ON_CLASS ON_SubDComponentAndNumber +{ +public: + ON_SubDComponentAndNumber() = default; + ~ON_SubDComponentAndNumber() = default; + ON_SubDComponentAndNumber(const ON_SubDComponentAndNumber&) = default; + ON_SubDComponentAndNumber& operator=(const ON_SubDComponentAndNumber&) = default; + +public: + static const ON_SubDComponentAndNumber NullAndNan; + static const ON_SubDComponentAndNumber NullAndZero; + static const ON_SubDComponentAndNumber Create( + ON_SubDComponentPtr cptr, + double x + ); + + static const ON_SubDComponentAndNumber Create( + const ON_SubDVertex* v, + double x + ); + static const ON_SubDComponentAndNumber Create( + const ON_SubDEdge* e, + double x + ); + static const ON_SubDComponentAndNumber Create( + const ON_SubDFace* f, + double x + ); + + static const ON_SubDComponentAndNumber Create( + const ON_SubDVertexPtr vptr, + double x + ); + + static const ON_SubDComponentAndNumber Create( + const ON_SubDEdgePtr eptr, + double x + ); + + static const ON_SubDComponentAndNumber Create( + const ON_SubDFacePtr fptr, + double x + ); + +public: + + /* + Description: + Compare Component() using ON_SubDComponentPtr::CompareComponent(). + */ + static int CompareComponent( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b + ); + + /* + Description: + Compare Component() using ON_SubDComponentPtr::CompareComponentAndDirection(). + */ + static int CompareComponentAndDirection( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b + ); + + + /* + Description: + Compare Number() nans are treated as equal and sort last. + */ + static int CompareNumber( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b + ); + + /* + Description: + Dictionary compare Component() and Number() in that order. + */ + static int CompareComponentAndNumber( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b + ); + + /* + Description: + Dictionary compare using ON_SubDComponentAndNumber::CompareComponentAndDirection() and ON_SubDComponentAndNumber::Number() in that order. + */ + static int CompareComponentAndDirectionAndNumber( + const ON_SubDComponentAndNumber* a, + const ON_SubDComponentAndNumber* b + ); + + +public: + const ON_SubDComponentPtr Component() const; + void SetComponent(ON_SubDComponentPtr cptr); + + double Number() const; + void SetNumber(double x); + +public: + ON_SubDComponentPtr m_cptr = ON_SubDComponentPtr::Null; + double m_x = ON_DBL_QNAN; +}; + +#if defined(ON_DLL_TEMPLATE) +ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; +#endif + +////////////////////////////////////////////////////////////////////////// +// +// ON_SubDComponentAndPoint +// + +class ON_CLASS ON_SubDComponentAndPoint +{ +public: + ON_SubDComponentAndPoint() = default; + ~ON_SubDComponentAndPoint() = default; + ON_SubDComponentAndPoint(const ON_SubDComponentAndPoint&) = default; + ON_SubDComponentAndPoint& operator=(const ON_SubDComponentAndPoint&) = default; + +public: + static const ON_SubDComponentAndPoint NullAndNan; + static const ON_SubDComponentAndPoint NullAndOrigin; + static const ON_SubDComponentAndPoint Create( + ON_SubDComponentPtr cptr, + ON_3dPoint P + ); + + static const ON_SubDComponentAndPoint Create( + const ON_SubDVertex* v, + ON_3dPoint P + ); + static const ON_SubDComponentAndPoint Create( + const ON_SubDEdge* e, + ON_3dPoint P + ); + static const ON_SubDComponentAndPoint Create( + const ON_SubDFace* f, + ON_3dPoint P + ); + + static const ON_SubDComponentAndPoint Create( + const ON_SubDVertexPtr vptr, + ON_3dPoint P + ); + + static const ON_SubDComponentAndPoint Create( + const ON_SubDEdgePtr eptr, + ON_3dPoint P + ); + + static const ON_SubDComponentAndPoint Create( + const ON_SubDFacePtr fptr, + ON_3dPoint P + ); + +public: + + /* + Description: + Compare Component() using ON_SubDComponentPtr::CompareComponent(). + */ + static int CompareComponent( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs + ); + + /* + Description: + Compare Component() using ON_SubDComponentPtr::CompareComponentAndDirection(). + */ + static int CompareComponentAndDirection( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs + ); + + + /* + Description: + Compare Point() uses ON_3dPoint::Compare() to compare lhs and rhs Point() values. + */ + static int ComparePoint( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs + ); + + /* + Description: + Dictionary compare Component() and Point() in that order. + */ + static int CompareComponentAndPoint( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs + ); + + /* + Description: + Dictionary compare using ON_SubDComponentAndPoint::CompareComponentAndDirection() and ON_SubDComponentAndPoint::Point() in that order. + */ + static int CompareComponentAndDirectionAndPoint( + const ON_SubDComponentAndPoint* lhs, + const ON_SubDComponentAndPoint* rhs + ); + + +public: + const ON_SubDComponentPtr Component() const; + void SetComponent(ON_SubDComponentPtr cptr); + + const ON_3dPoint Point() const; + void SetPoint(ON_3dPoint P); + +public: + ON_SubDComponentPtr m_cptr = ON_SubDComponentPtr::Null; + ON_3dPoint m_P = ON_3dPoint::NanPoint; +}; + +#if defined(ON_DLL_TEMPLATE) +ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; +#endif + +////////////////////////////////////////////////////////////////////////// +// +// ON_SubDComponentTest +// + /* Description: ON_SubDComponentTest is used in contexts where custom testing or filtering of @@ -2928,6 +3282,221 @@ const ON_wString ON_SubDEndCapStyleToString( ON_SubDEndCapStyle subd_cap_style ); +////////////////////////////////////////////////////////////////////////// +// +// ON_SubD +// +//// ON_WIP_SDK +//// This class is in the WIP SDK but the [[deprecated]] tag is +//// failing to compile in tl_precompiledheader.cpp +class ON_CLASS ON_SubDExpandEdgesParameters +{ +public: + ON_SubDExpandEdgesParameters() = default; + ~ON_SubDExpandEdgesParameters() = default; + ON_SubDExpandEdgesParameters(const ON_SubDExpandEdgesParameters&) = default; + ON_SubDExpandEdgesParameters& operator=(const ON_SubDExpandEdgesParameters&) = default; + + static const ON_SubDExpandEdgesParameters Default; + + /// + /// ON_SubDExpandEdgesParameters::Style specifies options for how faces are inserted along input edges. + /// + enum class Style : unsigned char + { + /// + /// Indicates the variable has not be initialized. + /// + Unset = 0, + + /// + /// One quad replaces each input manifold edge. Corner cases where three or more edges meet + /// receive special handling. + /// + Single = 1, + + /// + /// Two quads are added for each input manifold edge. Corner cases where three or more edges meet + /// receive special handling. + /// + Double = 2, + + /// + /// This option applies only when the the input is an array of ON_SubDEdgePtrs + /// that form a single oriented edge chain of manifold interior edges. + /// A single quad is added to the left of the input edges. + /// (The left side of of an oriented interior manifold edge is the face + /// whose natural boundary orientation is the same as with the ON_SubDEdgePtr direction.) + /// + HalfLeft = 3, + + /// + /// This option applies only when the the input is an array of ON_SubDEdgePtrs + /// that form a single oriented edge chain of manifold interior edges. + /// A single quad is added to the right of the input edges. + /// (The right side of of an oriented interior manifold edge is the face + /// whose natural boundary orientation is opposite the ON_SubDEdgePtr direction.) + /// + HalfRight = 4, + }; + +public: + /// OffsetTolerance = 0.001 + static const double OffsetTolerance; + + /// Minimum permitted offset value (0.05) + static const double MinimumOffset; + + /// Maximum permitted offset value (0.95) + static const double MaximumOffset; + + /// Small offset value (0.125) + static const double SmallOffset; + + /// Medium offset value (0.25) + static const double MediumOffset; + + /// Large offset value (0.5) + static const double LargeOffset; + +public: + /// + /// This SHA1 hash can be used to determine if sets of parameters are the same. + /// + /// A SHA1 hash of all parameter values. + const ON_SHA1_Hash Hash() const; + +public: + static double CleanupOffset(double x); + + + /// + /// Normalized constant offset parameter for inserting edges parallel to an input edge. + /// Smaller values create narrower offsets. + /// + /// Offset value in the range ON_SubDExpandEdgesParameters::MinimumOffset to ON_SubDExpandEdgesParameters::MaximumOffset. + double ConstantOffset() const; + + /// + /// Set the constant offset value. Values within OffsetTolerance of a + /// predefined offset value are set to the predefined offset value. + /// + /// + /// ON_SubDExpandEdgesParameters::MinimumOffset <= offset <= ON_SubDExpandEdgesParameters::MaximumOffset; + /// + /// + void SetConstantOffset(double offset); + + + /// + /// Determine if the set of ON_SubDEdgePtrs can be sorted into a + /// single edge chain that supports half side offsets. + /// + /// + /// True if variable offsets can be applied to edge_chain. + static bool IsValidForHalfOffset( + const ON_SimpleArray& edges + ); + + /// + /// Determine if the set of ON_SubDEdgePtrs can be sorted into a + /// single open edge chain supports variable offsets. + /// + /// + /// True if variable offsets can be applied to edge_chain. + static bool IsValidForVariableOffset( + const ON_SimpleArray& edges + ); + + /// This option applies only when the the input is an array of ON_SubDEdgePtrs + /// that form a single oriented edge chain. You may use + /// ON_SubDExpandEdgesParameters::IsValidForVariableOffset() to determine if an + /// array of ON_SubDEdgePtrs meets the variable offset requirements. + /// In all other cases, the constant Offset() is used. + /// To apply variable offsets to several edge chains, expand them one at a time. + const ON_Interval VariableOffset() const; + + /* + Description: + This option applies only when the the input is an array of ON_SubDEdgePtrs + that form a single oriented edge chain. You may use + ON_SubDExpandEdgesParameters::IsValidForVariableOffset() to determine if an + array of ON_SubDEdgePtrs meets the variable offset requirements. + In all other cases, the constant Offset() is used. + To apply variable offsets to several edge chains, expand them one at a time. + + Parameters: + variable_offsets - [in] + The two values must be between 0 and 1 and differ by more than ON_SubDExpandEdgesParameters::OffsetTolerance. + */ + void SetVariableOffset(ON_Interval variable_offsets); + + void ClearVariableOffset(); + + static bool IsValidConstantOffset( + double constant_offset_candidate + ); + + static bool IsValidVariableOffset( + ON_Interval variable_offset_candidate + ); + + /* + Returns: + True if variable offsets are set. + */ + bool IsVariableOffset() const; + + + ON_SubDExpandEdgesParameters::Style FaceStyle() const; + + /// + /// Set the style for new faces. + /// + /// + /// Style for new faces. + void SetFaceStyle(ON_SubDExpandEdgesParameters::Style face_style); + + /// True if the FaceStyle() is HalfLeft of HalfRight. + bool IsHalfFaceStyle() const; + + /// Per face color for new faces. + const ON_Color FaceColor() const; + + /// + /// Set the perf face color for new faces. + /// + /// Color for new face. Pass ON_Color::Unset for no per face color. + void SetFaceColor(ON_Color face_color); + + /// Status for new faces. + const ON_ComponentStatus FaceStatus() const; + + /// + /// Set the Mark(), MarkBits(), Selected(), and Highlighted() status for new faces. + /// + /// Status for new faces. + void SetFaceStatus(ON_ComponentStatus face_status); + +private: + double m_constant_offset = ON_SubDExpandEdgesParameters::MediumOffset; + ON_Interval m_variable_offsets = ON_Interval::Nan; + ON_Color m_face_color = ON_Color::UnsetColor; + ON_ComponentStatus m_face_status; + ON_SubDExpandEdgesParameters::Style m_face_style = ON_SubDExpandEdgesParameters::Style::Double; + +private: + unsigned char m_reserved1 = 0; + +private: + ON__UINT64 m_reserved2 = 0; + ON__UINT64 m_reserved3 = 0; +}; + +bool operator==(const ON_SubDExpandEdgesParameters& lhs, const ON_SubDExpandEdgesParameters& rhs); +bool operator!=(const ON_SubDExpandEdgesParameters& lhs, const ON_SubDExpandEdgesParameters& rhs); + + ////////////////////////////////////////////////////////////////////////// // // ON_SubD @@ -3030,7 +3599,7 @@ public: bForceUpdate - [in] When in doubt pass false. The SubD hashes are mutable and cached. When code properly manages GeometryContentSerialNumber(), - then SubDHash(hash_type,false) will alwasys return the correct answer. This is the expected behavior. + then SubDHash(hash_type,false) will always return the correct answer. This is the expected behavior. If code directly modifies SubD components and fails to call ChangeGeometryContentSerialNumberForExperts(), then it is possible a stale hash will be returned. Setting bForceUpdate = true forces the SHA1 values to be recalculated from scratch. For extremely large SubDs, this recalculation can be time consuming. @@ -3310,8 +3879,8 @@ public: component_ring[component_count-1] = last face Example: - unsinged int component_ring_count = GetVertexComponentRing(vit,component_ring); - unsinged int N = component_ring_count/2; // number of edges in ring + unsigned int component_ring_count = GetVertexComponentRing(vit,component_ring); + unsigned int N = component_ring_count/2; // number of edges in ring const bool bSectorHasCreaseBoundary = (0 == (component_ring_count % 2)); */ static unsigned int GetSectorComponentRing( @@ -3350,8 +3919,8 @@ public: component_ring[component_count-1] = last face Example: - unsinged int component_ring_count = GetVertexComponentRing(vit,component_ring); - unsinged int N = component_ring_count/2; // number of edges in ring + unsigned int component_ring_count = GetVertexComponentRing(vit,component_ring); + unsigned int N = component_ring_count/2; // number of edges in ring const bool bSectorHasCreaseBoundary = (0 == (component_ring_count % 2)); */ static unsigned int GetSectorComponentRing( @@ -4598,6 +5167,16 @@ public: */ bool HasPerFaceColorsFromSymmetryMotif() const; + /* + Description: + Sets ON_SubDComponent MarkBits() to + 0: component is not in a symmetry set motif + n>=1: + The component is the the n-th element in the symmetry set + with n=1 indicating the component in the primary motif. + */ + void SetComponentMarkBitsFromSymmetryMotif() const; + ///* //Description: @@ -4760,37 +5339,62 @@ public: /* Description: - Split and edge. - The input edge is modifed to terminate at the input vertex. - The new edge begins at the input vertex and ends at the final vertex - of the original input edge. + Divide an edge into two contiguous edges. + The input edge is modifed to terminate at the new vertex. + The new edge begins at the new vertex and ends at the orginal edge's m_vertex[1]. edge - [in] edge to split. vertex_location - [in] - location of inserted vertex. + location of the new vertex vertex. If vertex_location == ON_ON_3dPoint::UnsetPoint, then the edge's midpoint is used. Returns: A pointer to the new edge or nullptr if the input is not valid. - Remarks: + Remarks: After all editing operations are completed, you must call this->UpdateEdgeSectorCoefficients(true) before evaluation. */ const class ON_SubDEdge* SplitEdge( class ON_SubDEdge* edge, ON_3dPoint vertex_location - ); + ); /* Description: - Split a face into two faces by inserting and edge connecting the - specified vertices. + Divide an edge into two contiguous edges. + edge - [in] + edge to split. + vertex_location - [in] + location of the new vertex vertex. + If vertex_location == ON_ON_3dPoint::UnsetPoint, + then the edge's midpoint is used. + new_edge_end - [in] + This paratmer is 0 or 1 and dtermines where the new edge is inserted. + Below v0 = input eptr.RelativeVertex(0), v1 = new vertex, v2 = input eptr.RelativeVertex(1), + and new_eptr = returned edge pointer. + If edge_end is 0, new_eptr is first: v0 = new_eptr.RelativeVertex(0), v1 = new_eptr.RelativeVertex(1)=eptr.RelativeVertex(0), v2 = eptr.RelativeVertex(1). + If edge_end is 1, new_eptr is last: v0 = eptr.RelativeVertex(0), v1 = eptr.RelativeVertex(1)=new_eptr.RelativeVertex(0), v2 = new_eptr.RelativeVertex(1). + Returns: + A pointer to the new edge or ON_SubDEdgePtr::Null if the input is not valid. + Remarks: + After all editing operations are completed, you must clear the evaluation cache + and call this->UpdateEdgeSectorCoefficients(true). + */ + const ON_SubDEdgePtr SplitEdge( + ON_SubDEdgePtr eptr, + ON_3dPoint vertex_location, + unsigned new_edge_end + ); + + /* + Description: + Divide a face into two faces by inserting an edge connecting the specified vertices. Parameters: face - [in] A face with at least four edges. fvi0 - [in] fvi1 - [in] - Indices of the inserted edge ends. + Face vertex indices of the inserted edge's ends. Returns: A pointer to the inserted edge. The inserted edge runs from face->Vertex(fvi0) to face->Vertex(fvi1). @@ -4806,14 +5410,13 @@ public: /* Description: - Split a face into two faces by inserting and edge connecting the - specified vertices. + Divide a face into two faces by inserting an edge connecting the specified vertices. Parameters: face - [in] A face with at least four edges. v0 - [in] v1 - [in] - Vertices on the face boundary. + Face vertices of the inserted edge's ends. Returns: A pointer to the inserted edge. The inserted edge runs from v0 to v1. @@ -4828,6 +5431,55 @@ public: const class ON_SubDVertex* v1 ); + + /* + Description: + Divide a face into two faces by inserting an edge connecting the specified vertices. + Parameters: + face - [in] + A face with at least four edges. + fvi0 - [in] + fvi1 - [in] + Face vertex indices of the inserted edge's ends. + new_face_side - [in] + 0: The new face will be on the left side of the inserted edge. + 0: The new face will be on the right side of the inserted edge. + Returns: + The edge and edgeptr are both being af both oriented + The inserted edge and returned edge ptr runs from face->Vertex(fvi0) to face->Vertex(fvi1). + the new face is SplitFace(...).RelativeFace(new_face_side) and the original face is SplitFace(...).RelativeFace(new_face_side). + */ + const ON_SubDEdgePtr SplitFace( + class ON_SubDFace* face, + unsigned int fvi0, + unsigned int fvi1, + unsigned new_face_side + ); + + /* + Description: + Divide a face into two faces by inserting an edge connecting the specified vertices. + Parameters: + face - [in] + A face with at least four edges. + v0 - [in] + v1 - [in] + Face vertices of the inserted edge's ends. + new_face_side - [in] + 0: The new face will be on the left side of the inserted edge. + 0: The new face will be on the right side of the inserted edge. + Returns: + The edge and edgeptr are both being af both oriented + The inserted edge and returned edge ptr runs from face->Vertex(fvi0) to face->Vertex(fvi1). + the new face is SplitFace(...).RelativeFace(new_face_side) and the original face is SplitFace(...).RelativeFace(new_face_side). + */ + const ON_SubDEdgePtr SplitFace( + class ON_SubDFace* face, + const class ON_SubDVertex* v0, + const class ON_SubDVertex* v1, + unsigned new_face_side + ); + /* Description: Replace a face with a triangle fan by adding a single new vertex at fan_center_point @@ -6912,6 +7564,12 @@ private: #pragma ON_PRAGMA_WARNING_POP }; + +#if defined(ON_DLL_TEMPLATE) +ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray; +#endif + + ////////////////////////////////////////////////////////////////////////// // // ON_SubDComponentList @@ -7204,7 +7862,7 @@ public: // // Q = 3/8 * (A + B) = 3/4 * (1/2*A + 1/2*B) // - // A crease edge's subdivision point is alwasy the edge's midpoint. + // A crease edge's subdivision point is always the edge's midpoint. /* Description: Calculates sector weight value for the sector type @@ -10361,32 +11019,19 @@ public: */ bool SavedSubdivisionPointIsSet() const; - ////////////////////////////////////////////////////////////// - // - // displacement applied to subdivision point - // - bool SetSubdivisionDisplacement( - const double displacement[3] - ); + ON_DEPRECATED_MSG("Does nothing. Returns false.") + bool SetSubdivisionDisplacement(const double*); - bool GetSubdivisionDisplacement( - double displacement[3] - ) const; + ON_DEPRECATED_MSG("Does nothing. Returns false.") + bool GetSubdivisionDisplacement(double*) const; - /* - Returns: - subdivision displacement. If a displacement has not been set, - ON_3dPoint::ZeroVector is returned. - */ + ON_DEPRECATED_MSG("Does nothing. Returns nans.") const ON_3dVector SubdivisionDisplacement() const; - /* - Returns: - True if the subdivision displacment vector is valid and not zero. - */ + ON_DEPRECATED_MSG("Does nothing. Returns false.") bool SubdivisionDisplacementIsNonzero() const; - + ON_DEPRECATED_MSG("Does nothing.") void ClearSubdivisionDisplacement() const; protected: @@ -10394,9 +11039,6 @@ protected: friend class ON_SubDHeap; enum SavedPointsFlags : unsigned char { - // if ( 0 != (m_saved_points_flags & SubDDisplacementVIsSet), then m_displacementV is set. - SubdivisionDisplacementBit = 0x20, - // if ( 0 != (m_saved_points_flags & SubdivisionPointBit), then m_cache_subd_P is set. SubdivisionPointBit = 0x40, @@ -10407,8 +11049,8 @@ protected: // Unset means any information in the fields identified above is invalid and must be recalculated. SurfacePointBit = 0x80, - // ControlNetFragmentBit | SubdivisionPointBit | SubdivisionDisplacementBit | SurfacePointBit - CachedPointMask = 0xF0 + // SubdivisionPointBit | SurfacePointBit + CachedPointMask = 0xC0 }; enum ModifiedFlags : unsigned char @@ -10484,9 +11126,11 @@ protected: // GetSubdivisionPoint( bUseSavedSubdivisionPoint=true ) can change the value of m_cache_subd_P mutable double m_saved_subd_point1[3]; // saved subdivision point -protected: - // optional displacement applied to standard subdivision point. - double m_displacement_V[3]; +private: + // Reserved for future use for attributes that apply to allSubD components (ON_SubDVertex, ON_SubDEdge, and ON_SubDFace). + ON__UINT64 m_reserved8bytes1; + ON__UINT64 m_reserved8bytes2; + ON__UINT64 m_reserved8bytes3; public: /* @@ -14505,12 +15149,30 @@ public: /* + Description: + + CurrentEdge(1) + | + | + NextFace() | CurrentFace() + | + | + *------------- CurrentEdge(0) + PrevFace() + + The asterisk (*) marks the center vertex. + The diagram is With respect to the initial iterator orientation. + Parameters: face_side_index - [in] - 0: Return the edge entering the center vertex. - 1: Return the edge leaving the center vertex. - Returns: - The requested edge. + CurrentEdge(0) = edge on the clockwise (PrevFace) side of the current face + CurrentEdge(1) = edge on the counterclockwise (NextFace) side of the current face + The directions "counterclockwise" and "clockwise" are with respect to the + initial iterator orientation. + + Returns: + The requested edge. The edge pointer is oriented such that + RelativeVertex(0) is the center vertex. */ ON_SubDEdgePtr CurrentEdgePtr( unsigned int face_side_index @@ -16234,6 +16896,225 @@ public: // // Edge chain tools // + + /* + Description: + Unconditionally sort edges into chains. + + Parameters: + unsorted_edges - [in] + If unsorted_edges[] contains three or more edges that share a common vertex, + no edge chain will pass through that vertex. + To sort an array in place, pass the same array as both parameters. + + sorted_edges - [out] + The sorted_edges[] has the edges grouped into edge chains. + A value of ON_SubDEdgePtr::Null is at the end of every chain + including the last chain. + + In an edge chain subsequent edges share a common vertex; i.e. + sorted_edges[i].RelativeVertex(1) == sorted_edges[i+1].RelativeVertex(0). + Returns: + Number of chains in edge_chains[]. + Remarks: + This version of SortEdgesIntoEdgeChains() uses MarkBits() on the edges + and vertices in unsorted_edges[]. The output values of MarkBits() + on these components are zero. + Multiple threads may not simultaneously use any SubD tools on that rely + on markbits on the same ON_SubD. + */ + static unsigned int SortEdgesIntoEdgeChains( + const ON_SimpleArray< ON_SubDEdgePtr >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges + ); + + /* + Description: + Unconditionally sort edges into chains. + + Parameters: + unsorted_edges - [in] + If unsorted_edges[] contains three or more edges that share a common vertex, + no edge chain will pass through that vertex. + + sorted_edges - [out] + The sorted_edges[] has the edges grouped into edge chains. + A value of ON_SubDEdgePtr::Null is at the end of every chain + including the last chain. + + In an edge chain subsequent edges share a common vertex; i.e. + sorted_edges[i].RelativeVertex(1) == sorted_edges[i+1].RelativeVertex(0). + Returns: + Number of chains in edge_chains[]. + Remarks: + This version of SortEdgesIntoEdgeChains() uses MarkBits() on the edges + and vertices in unsorted_edges[]. The output values of MarkBits() + on these components are zero. + Multiple threads may not simultaneously use any SubD tools on that rely + on markbits on the same ON_SubD. + */ + static unsigned int SortEdgesIntoEdgeChains( + const ON_SimpleArray< const ON_SubDEdge* >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges + ); + + /* + Description: + Unconditionally sort edges into chains. + + Parameters: + unsorted_edges - [in] + If unsorted_edges[] contains three or more edges that share a common vertex, + no edge chain will pass through that vertex. + + sorted_edges - [out] + The sorted_edges[] has the edges grouped into edge chains. + A value of ON_SubDEdgePtr::Null is at the end of every chain + including the last chain. + + In an edge chain subsequent edges share a common vertex; i.e. + sorted_edges[i].RelativeVertex(1) == sorted_edges[i+1].RelativeVertex(0). + Returns: + Number of chains in edge_chains[]. + Remarks: + This version of SortEdgesIntoEdgeChains() uses MarkBits() on the edges + and vertices in unsorted_edges[]. The output value of MarkBits() + on these components is zero. + Multiple threads may not simultaneously use any SubD tools on that rely + on markbits on the same ON_SubD. + */ + static unsigned int SortEdgesIntoEdgeChains( + const ON_SimpleArray< ON_SubDComponentPtr >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges + ); + + /* + Description: + Unconditionally sort edges into chains. + + Parameters: + unsorted_edges - [in] + If unsorted_edges[] contains three or more edges that share a common vertex, + no edge chain will pass through that vertex. + + sorted_edges - [out] + The sorted_edges[] has the edges grouped into edge chains. + A value of ON_SubDEdgePtr::Null is at the end of every chain + including the last chain. + + In an edge chain subsequent edges share a common vertex; i.e. + sorted_edges[i].RelativeVertex(1) == sorted_edges[i+1].RelativeVertex(0). + Returns: + Number of chains in edge_chains[]. + Remarks: + This version of SortEdgesIntoEdgeChains() uses MarkBits() on the edges + and vertices in unsorted_edges[]. The output value of MarkBits() + on these components is zero. + Multiple threads may not simultaneously use any SubD tools on that rely + on markbits on the same ON_SubD. + */ + static unsigned int SortEdgesIntoEdgeChains( + const ON_SubD& subd, + const ON_SimpleArray< ON_COMPONENT_INDEX >& unsorted_edges, + ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges + ); + + /* + Description: + Determin if the array of ON_SubDEdgePtrs in edges[] can be sorted + into a single edge chain. + Parameters: + edges - [in] + Set of edges to test. + bIsClosed - [out] + If true is returned and edges[] sorts into a closed edge chain, + then bIsClosed is true. Otherwise bIsClosed is false. + bIsSorted - [out] + If true is returned and edges[] is currently sorted into an edge chain, + then bIsSorted is true. Otherwise bIsSorted is false. + Returns: + If the array of edges[] can be sorted into a single edge chain + with no self intersections, then true is returned. Otherwise false + is returned. + Remarks: + This test usesthe MarkBits() values on the edges and vertices and + restores the values to the input state. + Multiple threads may not simultaneously use any SubD tools on that rely + on markbits on the same ON_SubD. + */ + static bool IsSingleEdgeChain( + const ON_SimpleArray& edges, + bool& bIsClosed, + bool& bIsSorted + ); + + /* + Description: + Determin if the array of ON_SubDEdgePtrs in edges[] can be sorted + into a single edge chain. + Parameters: + edges - [in] + Set of edges to test. + Returns: + If the array of edges[] can be sorted into a single edge chain + with no self intersections, then true is returned. Otherwise false + is returned. + Remarks: + This test usesthe MarkBits() values on the edges and vertices and + restores the values to the input state. + Multiple threads may not simultaneously use any SubD tools on that rely + on markbits on the same ON_SubD. + */ + static bool IsSingleEdgeChain( + const ON_SimpleArray& edges + ); + + /* + Description: + Sort edges into a chains + + Parameters: + unsorted_edges - [in] + To sort an array in place, pass the same array as both parameters. + If unsorted_edges[] contains three or more edges that share a common vertex, + then all of the edges that share that vertex are ignored. + The edges can be from one or more SubDs. + + unsigned int minimum_chain_length - [in] + minimum number of edges to consider for a chain. + + edge_chains - [out] + The edge_chains[] has the edges grouped into edge chains. + + In an edge chain subsequent edges share a common vertex; i.e. + edge_chains[i].RelativeVertex(1) == edge_chains[i+1].RelativeVertex(0). + + When edge_chains[i].RelativeVertex(1) != edge_chains[i+1].RelativeVertex(0), + a chain ends at edge_chains[i] and another begins at edge_chains[i+1]. + + Reasonnable effort is made to keep the first edge in every chain with the + same orientation as the input edge from edge_chains[]. However, this is not + possible in every case, for example if the input is two edges sharing the + same starting vertex. + + NB: Reasonnable effort is made to keep the corner vertices on the exterior + of the chains, however some chains will have corners in their interior, + especially closed chains. + + Returns: + Number of chains in edge_chains[]. + + Remarks: + When the orientation of the input edges is not intentionally set, + the versions of SortEdgesIntoEdgeChains() above without a minimum_chain_length + variable are a better choice. + */ + static unsigned int SortEdgesIntoEdgeChains( + const ON_SimpleArray< ON_SubDEdgePtr >& unsorted_edges, + unsigned int minimum_chain_length, + ON_SimpleArray< ON_SubDEdgePtr >& edge_chains + ); + /* Description: Sort edges into a chains @@ -16262,25 +17143,92 @@ public: Returns: Number of chains in edge_chains[]. - */ - static unsigned int SortEdgesIntoEdgeChains( - const ON_SimpleArray< ON_SubDEdgePtr >& unsorted_edges, - unsigned int minimum_chain_length, - ON_SimpleArray< ON_SubDEdgePtr >& edge_chains - ); + Remarks: + When the orientation of the input edges is not intentionally set, + the versions of SortEdgesIntoEdgeChains() above without a minimum_chain_length + variable are a better choice. + */ static unsigned int SortEdgesIntoEdgeChains( const ON_SimpleArray< const ON_SubDEdge* >& unsorted_edges, unsigned int minimum_chain_length, ON_SimpleArray< ON_SubDEdgePtr >& edge_chains ); + /* + Description: + Sort edges into a chains + + Parameters: + unsorted_edges - [in] + To sort an array in place, pass the same array as both parameters. + If unsorted_edges[] contains three or more edges that share a common vertex, + then all of the edges that share that vertex are ignored. + The edges can be from one or more SubDs. + + unsigned int minimum_chain_length - [in] + minimum number of edges to consider for a chain. + + edge_chains - [out] + The edge_chains[] has the edges grouped into edge chains. + + In an edge chain subsequent edges share a common vertex; i.e. + edge_chains[i].RelativeVertex(1) == edge_chains[i+1].RelativeVertex(0). + + When edge_chains[i].RelativeVertex(1) != edge_chains[i+1].RelativeVertex(0), + a chain ends at edge_chains[i] and another begins at edge_chains[i+1]. + + The first edge in every chain has the same orientation as the input edge + from edge_chains[]. + + Returns: + Number of chains in edge_chains[]. + + Remarks: + When the orientation of the input edges is not intentionally set, + the versions of SortEdgesIntoEdgeChains() above without a minimum_chain_length + variable are a better choice. + */ static unsigned int SortEdgesIntoEdgeChains( const ON_SimpleArray< ON_SubDComponentPtr >& unsorted_edges, unsigned int minimum_chain_length, ON_SimpleArray< ON_SubDEdgePtr >& sorted_edges ); + /* + Description: + Sort edges into a chains + + Parameters: + unsorted_edges - [in] + To sort an array in place, pass the same array as both parameters. + If unsorted_edges[] contains three or more edges that share a common vertex, + then all of the edges that share that vertex are ignored. + The edges can be from one or more SubDs. + + unsigned int minimum_chain_length - [in] + minimum number of edges to consider for a chain. + + edge_chains - [out] + The edge_chains[] has the edges grouped into edge chains. + + In an edge chain subsequent edges share a common vertex; i.e. + edge_chains[i].RelativeVertex(1) == edge_chains[i+1].RelativeVertex(0). + + When edge_chains[i].RelativeVertex(1) != edge_chains[i+1].RelativeVertex(0), + a chain ends at edge_chains[i] and another begins at edge_chains[i+1]. + + The first edge in every chain has the same orientation as the input edge + from edge_chains[]. + + Returns: + Number of chains in edge_chains[]. + + Remarks: + When the orientation of the input edges is not intentionally set, + the versions of SortEdgesIntoEdgeChains() above without a minimum_chain_length + variable are a better choice. + */ static unsigned int SortEdgesIntoEdgeChains( const ON_SubD& subd, const ON_SimpleArray< ON_COMPONENT_INDEX >& unsorted_edges, @@ -16322,6 +17270,15 @@ public: ON_SimpleArray< ON_SubDEdgePtr >& edge_chains ); + /* + Returns: + A SHA1 hash of the edge and vertex ids. + Useful for determining when two edge chains from different + subds (one generally a modified copy) involve the same + edges and vertices. + */ + const ON_SHA1_Hash Hash() const; + ///////////////////////////////////////////////////////// // @@ -16449,6 +17406,75 @@ public: bool bCheckForDuplicateEdges ); + + /* + Description: + Get the edges and faces on a specified side of the edge chain. + Parameters: + relative_side - [in] + 0: Get edges and faces on the ON_SubDEdgePtr::RelativeFace(0) side (left). + 1: Get edges and faces on the ON_SubDEdgePtr::RelativeFace(1) side (right). + + side_components - [out] + side_components[] is a sequence of made of vertices, edges, and faces that + record the edges and faces that are on the specified side of the edge chain. + + When a vertex is in side_components[], ON_SubDComponentPtr.Vertex() is not nullptr + and the vertex is between two conscutive edges in the edge chain. + + When an edge is in side_components[], ON_SubDComponentPtr.EdgePtr() is not nullptr, + the edge is on the specified side of the edge chain (not in the edge chain), + and ON_SubDComponentPtr.EdgePtr().RelativeVertex(0) is a vertex on the edge chain. + + When a face is in side_components[], ON_SubDComponentPtr.Face() is not nullptr, + then at least one vertex of f is part of the edge chain and f is on the specified + side of the edge chain. + + If a vertex v is side_components[], then it is preceded and followed by the same + face (...f,v,f,...), there are consecutive edges in the edge chain (...e0,e1,...), + and e0 and e1 are consecutive edges in f's boundary. + + If ...eptr0,f,eptr1,... is in side_components[], + v0 = eptr0.RelativeVertex(0), + v1 = eptr0.RelativeVertex(0), + and v0 == v1, + then eptr0 and eptr1 are conecutive edges in the boundary of f + and v0==v1 is a vertex in the edge chain. + + If ...eptr0,f,eptr1,... is in side_components[], + v0 = eptr0.RelativeVertex(0), + v1 = eptr0.RelativeVertex(0), + and v0 != v1, + then there is an edge c from v0 to v1 that is in the edge chain and + eptr0,c,eptr1 are conecutive edges in the boundary of f. + + If ...eptr0,f,v,... is in side_components[] and v0 = eptr0.RelativeVertex(0), + and then v0 != v, then there is an edge c from v0 to v that is in the edge chain, + and eptr0,c are conecutive edges in the boundary of f. + + If ...v,f,eptr1,... is in side_components[] and v1 = eptr1.RelativeVertex(0), + and then v != v1, then there is an edge c from v to v1 that is in the edge chain, + and c,eptr1 conecutive edges in the boundary of f. + + Remarks: + If the SubD is not an oriented manifold along the entire side of the chain, + then there may be gaps in chain_side[]. When there are face fans at a chain + vertex, there will be faces that do not have an edge on the chain. + */ + bool GetSideComponents( + unsigned relative_side, + ON_SimpleArray& side_components + ) const; + + /* + See above. + */ + static bool GetSideComponents( + const ON_SimpleArray& edge_chain, + unsigned relative_side, + ON_SimpleArray& side_components + ); + public: /* Returns: @@ -16618,6 +17644,10 @@ public: const ON_SubDEdgePtr LastEdgePtr() const; const ON_SubDEdgePtr EdgePtr(int edge_index) const; + const ON_3dPoint FirstControlNetPoint() const; + const ON_3dPoint LastControlNetPoint() const; + const ON_3dPoint ControlNetPoint(int vertex_index) const; + const ON_SubDEdge* FirstEdge() const; const ON_SubDEdge* LastEdge() const; const ON_SubDEdge* Edge(int edge_index) const; @@ -16950,6 +17980,15 @@ public: ON_SubDComponentLocation vertex_location ); + bool CreateSubDEmptyRTree( + const ON_SubD& subd + ); + + bool AddVertex( + const ON_SubDVertex* v, + ON_SubDComponentLocation vertex_location + ); + const ON_SubDVertex* FindVertexAtPoint( const ON_3dPoint P, const double distance_tolerance @@ -16965,6 +18004,11 @@ public: const double distance_tolerance ) const; + const ON_SubDVertex* FindVertex( + const class ON_SubDRTreeVertexFinder& vertex_finder, + const double distance_tolerance + ) const; + const ON_SubD& SubD() const; /* @@ -16988,6 +18032,8 @@ public: ON_SubDRTreeVertexFinder(const ON_SubDRTreeVertexFinder&) = default; ON_SubDRTreeVertexFinder& operator=(const ON_SubDRTreeVertexFinder&) = default; + static const ON_SubDRTreeVertexFinder Unset; + public: static const ON_SubDRTreeVertexFinder Create(const ON_3dPoint P); @@ -16999,6 +18045,20 @@ public: */ static const ON_SubDRTreeVertexFinder Create(const ON_3dPoint P, bool bMarkFilter); + enum class MarkBitsFilter : unsigned char + { + None = 0, + Equal = 1, + NotEqual = 2 + }; + + static const ON_SubDRTreeVertexFinder Create( + const ON_3dPoint P, + ON_SubDRTreeVertexFinder::MarkBitsFilter mark_bits_filter, + ON__UINT8 mark_bits + ); + + public: ON_3dPoint m_P = ON_3dPoint::NanPoint; double m_distance = ON_DBL_QNAN; @@ -17008,14 +18068,17 @@ public: // to be found and vertices with Mark() != m_bMarkFilter are ignored. bool m_bMarkFilterEnabled = false; bool m_bMarkFilter = false; + +public: + ON_SubDRTreeVertexFinder::MarkBitsFilter m_mark_bits_filter = ON_SubDRTreeVertexFinder::MarkBitsFilter::None; + ON__UINT8 m_mark_bits = 0; + private: - unsigned short m_reserved1 = 0; unsigned int m_reserved2 = 0; public: static bool Callback(void* a_context, ON__INT_PTR a_id); - }; diff --git a/opennurbs_subd.natvis b/opennurbs_subd.natvis new file mode 100644 index 00000000..9451f386 --- /dev/null +++ b/opennurbs_subd.natvis @@ -0,0 +1,92 @@ + + + + + + {{vertex id={m_id}}} + + + + {{edge id={m_id}}} + + nullptr!=m_vertex[0] ? m_vertex[0]->m_id : 0 + nullptr!=m_vertex[1] ? m_vertex[1]->m_id : 0 + + + + + {{face id={m_id}}} + + + + + + null + vertex(+) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + vertex(-) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + edge(+) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + edge(-) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + face(+) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + face(-) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + + ((m_ptr>8) && (2==(m_ptr&7)))?(((ON_SubDVertex*)(m_ptr&0xFFFFFFFFFFFFFFF8))):((ON_SubDVertex*)nullptr) + ((m_ptr>8) && (4==(m_ptr&7)))?(*((ON_SubDEdgePtr*)(m_ptr&0xFFFFFFFFFFFFFFF8))):ON_SubDEdgePtr::Null + ((m_ptr>8) && (6==(m_ptr&7)))?(((ON_SubDFace*)(m_ptr&0xFFFFFFFFFFFFFFF8))):((ON_SubDFace*)nullptr) + + + + + + null + vertex(+) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + vertex(-) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + + m_ptr>=8?(((ON_SubDVertex*)(m_ptr&0xFFFFFFFFFFFFFFF8))):nullptr + + + + + + null + edge(+) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + edge(-) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + + (m_ptr>8)?(((ON_SubDEdge*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_vertex[m_ptr%2]->m_id):0 + (m_ptr>8)?(((ON_SubDEdge*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_vertex[1-(m_ptr%2)]->m_id):0 + m_ptr>=8?(((ON_SubDEdge*)(m_ptr&0xFFFFFFFFFFFFFFF8))):nullptr + + + + + + null + face(+) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + face(-) id={((ON_SubDComponentBase*)(m_ptr&0xFFFFFFFFFFFFFFF8))->m_id} + + m_ptr>=8?(((ON_SubDFace*)(m_ptr&0xFFFFFFFFFFFFFFF8))):nullptr + + + + diff --git a/opennurbs_subd_archive.cpp b/opennurbs_subd_archive.cpp index d93d8c18..68b4ea32 100644 --- a/opennurbs_subd_archive.cpp +++ b/opennurbs_subd_archive.cpp @@ -212,9 +212,8 @@ static bool WriteBase( if (archive.Archive3dmVersion() < 70) { // version 6 3dm files - double P[3], V[3]; + double P[3]; const bool bHaveP = base->GetSavedSubdivisionPoint(P); - const bool bHaveV = base->GetSubdivisionDisplacement(V); unsigned char cP = bHaveP ? 4U : 0U; if (!archive.WriteChar(cP)) @@ -225,29 +224,17 @@ static bool WriteBase( break; } - unsigned char cV = bHaveV ? 4U : 0U; - if (!archive.WriteChar(cV)) + unsigned char deprecated_and_never_used_zero = 0U; + if (!archive.WriteChar(deprecated_and_never_used_zero)) break; - if (0 != cV) - { - if (!Internal_WriteDouble3(V, archive)) - break; - } return true; } // version 7 3dm files and later - // 24 byte displacement addition - double V[3]; - const bool bWriteDisplacement = base->GetSubdivisionDisplacement(V); - if ( false == Internal_WriteComponentAdditionSize(bWriteDisplacement,archive,24) ) + // never used displacement + if ( false == Internal_WriteComponentAdditionSize(false,archive,24) ) break; - if (bWriteDisplacement) - { - if (!archive.WriteDouble(3,V)) - break; - } // 4 byte group id addition const bool bWriteGroupId = base->m_group_id > 0; @@ -300,8 +287,8 @@ static bool ReadBase( if (archive.Archive3dmVersion() < 70) { unsigned char cP = 0U; - unsigned char cV = 0U; - double P[3], V[3]; + unsigned char deprecated_and_never_used_char = 0U; + double P[3]; if (!archive.ReadChar(&cP)) break; @@ -311,26 +298,16 @@ static bool ReadBase( break; } - if (!archive.ReadChar(&cV)) + if (!archive.ReadChar(&deprecated_and_never_used_char)) break; - if (0 != cV) + if (0 != deprecated_and_never_used_char) { - if (!Internal_ReadDouble3(archive, V)) + double deprecated_and_never_used_V[3]; + if (!Internal_ReadDouble3(archive, deprecated_and_never_used_V)) break; - const unsigned int no_displacement_version = ON_VersionNumberConstruct(7, 0, 2019, 6, 12, 0); - const unsigned int archive_opennurbs_version = archive.ArchiveOpenNURBSVersion(); - if (archive_opennurbs_version <= no_displacement_version) - { - cV = 0; - V[0] = 0.0; - V[1] = 0.0; - V[2] = 0.0; - } } if (4 == cP) base.SetSavedSubdivisionPoint(P); - if (4 == cV) - base.SetSubdivisionDisplacement(V); return true; } @@ -338,6 +315,7 @@ static bool ReadBase( unsigned char sz; // 24 byte displacement addition + // This addition was a deprecated prototype that was never used in commercial Rhino. sz = 0; if (false == Internal_ReadComponentAdditionSize(archive, 24, &sz)) break; @@ -345,10 +323,9 @@ static bool ReadBase( return true; // end of additions if (0 != sz) { - double V[3] = {}; - if (!archive.ReadDouble(V)) + double deprecated_and_never_used_V[3] = {}; + if (!archive.ReadDouble(3, deprecated_and_never_used_V)) break; - base.SetSubdivisionDisplacement(V); } // 4 byte group id addition diff --git a/opennurbs_subd_data.cpp b/opennurbs_subd_data.cpp index efe4d0a9..75865874 100644 --- a/opennurbs_subd_data.cpp +++ b/opennurbs_subd_data.cpp @@ -733,9 +733,6 @@ void ON_SubDComponentBase::Internal_TransformComponentBase( const class ON_Xform& xform ) { - if (0 != ON_SUBD_CACHE_DISPLACEMENT_FLAG(m_saved_points_flags)) - TransformVector(&xform.m_xform[0][0],m_displacement_V); - if ( SavedSubdivisionPointIsSet() ) { if (bTransformationSavedSubdivisionPoint) diff --git a/opennurbs_subd_data.h b/opennurbs_subd_data.h index 351a9b0f..852d58cd 100644 --- a/opennurbs_subd_data.h +++ b/opennurbs_subd_data.h @@ -462,18 +462,15 @@ void ON_SubDIncrementErrorCount(); // defined in opennurbs_subd.cpp // m_saved_points_flags // #define ON_SUBD_CACHE_POINT_FLAG_BIT ON_SubDComponentBase::SavedPointsFlags::SubdivisionPointBit -#define ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT ON_SubDComponentBase::SavedPointsFlags::SubdivisionDisplacementBit #define ON_SUBD_CACHE_LIMITLOC_FLAG_BIT ON_SubDComponentBase::SavedPointsFlags::SurfacePointBit #define ON_SUBD_CACHE_FLAGS_MASK ON_SubDComponentBase::SavedPointsFlags::CachedPointMask #define ON_SUBD_CACHE_FLAGS(cache_subd_flags) (ON_SUBD_CACHE_FLAGS_MASK&(cache_subd_flags)) #define ON_SUBD_CACHE_POINT_FLAG(cache_subd_flags) (ON_SUBD_CACHE_POINT_FLAG_BIT&(cache_subd_flags)) -#define ON_SUBD_CACHE_DISPLACEMENT_FLAG(cache_subd_flags) (ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT&(cache_subd_flags)) #define ON_SUBD_CACHE_LIMITLOC_FLAG(cache_subd_flags) (ON_SUBD_CACHE_LIMITLOC_FLAG_BIT&(cache_subd_flags)) -#define ON_SUBD_CACHE_CLEAR_POINT_FLAG(cache_subd_flags) (cache_subd_flags &= (ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT|ON_SUBD_CACHE_LIMITLOC_FLAG_BIT|ON_SubDComponentBase::ModifiedFlags::ModifiedFlagsMask)) -#define ON_SUBD_CACHE_CLEAR_DISPLACEMENT_FLAG(cache_subd_flags) (cache_subd_flags &= (ON_SUBD_CACHE_POINT_FLAG_BIT|ON_SUBD_CACHE_LIMITLOC_FLAG_BIT|ON_SubDComponentBase::ModifiedFlags::ModifiedFlagsMask)) -#define ON_SUBD_CACHE_CLEAR_LIMITLOC_FLAG(cache_subd_flags) (cache_subd_flags &= (ON_SUBD_CACHE_POINT_FLAG_BIT|ON_SUBD_CACHE_DISPLACEMENT_FLAG_BIT|ON_SubDComponentBase::ModifiedFlags::ModifiedFlagsMask)) +#define ON_SUBD_CACHE_CLEAR_POINT_FLAG(cache_subd_flags) (cache_subd_flags &= (ON_SUBD_CACHE_LIMITLOC_FLAG_BIT|ON_SubDComponentBase::ModifiedFlags::ModifiedFlagsMask)) +#define ON_SUBD_CACHE_CLEAR_LIMITLOC_FLAG(cache_subd_flags) (cache_subd_flags &= (ON_SUBD_CACHE_POINT_FLAG_BIT|ON_SubDComponentBase::ModifiedFlags::ModifiedFlagsMask)) ////////////////////////////////////////////////////////////////////////// @@ -1651,7 +1648,7 @@ public: + m_fsp_oddball_fragments.SizeOfUnusedElements() + m_fsp_limit_curves.SizeOfUnusedElements(); - // It has alwasy been the case that count0 = count1 = ON_SubDDisplayParameters::MaximumDensity + 1. + // It has always been the case that count0 = count1 = ON_SubDDisplayParameters::MaximumDensity + 1. // But a wrong answer is better than crashing if somebody incorrectly modifies ON_SubDHeap // in the far future. const size_t count0 = sizeof(m_unused_fragments) / sizeof(m_unused_fragments[0]); diff --git a/opennurbs_subd_fragment.cpp b/opennurbs_subd_fragment.cpp index a0e8ecf9..e1d2ceef 100644 --- a/opennurbs_subd_fragment.cpp +++ b/opennurbs_subd_fragment.cpp @@ -2658,7 +2658,7 @@ public: else { // this is an inteior edge of a partial fragment and it - // is alwasy sealed with its neighbor when it is created. + // is always sealed with its neighbor when it is created. break; } } diff --git a/opennurbs_subd_frommesh.cpp b/opennurbs_subd_frommesh.cpp index 2aab9faa..459d5bf8 100644 --- a/opennurbs_subd_frommesh.cpp +++ b/opennurbs_subd_frommesh.cpp @@ -1977,7 +1977,7 @@ bool ON_NgonBoundaryChecker::IsSimpleNgon( for (ON_NgonBoundaryComponent* e = (ON_NgonBoundaryComponent * )fspit.FirstElement(); nullptr != e; e = (ON_NgonBoundaryComponent * )fspit.NextElement()) { if (1 != e->m_face_count) - continue; // vertex components alwasy have m_face_count = 0; + continue; // vertex components always have m_face_count = 0; // e is a boundary edge if (bBoundaryIsMarked) diff --git a/opennurbs_subd_texture.cpp b/opennurbs_subd_texture.cpp index 5c41c527..40a408cd 100644 --- a/opennurbs_subd_texture.cpp +++ b/opennurbs_subd_texture.cpp @@ -743,6 +743,11 @@ void ON_SubD::ClearFragmentTextureCoordinatesTextureSettingsHash() const Internal_SetFragmentTextureCoordinatesTextureSettingsHash(ON_SHA1_Hash::EmptyContentHash); } +static bool SetGridMeshMappingTCs(const unsigned int pointCount, const double* P, const size_t P_stride, const double* N, const size_t N_stride, double* T, const size_t T_stride, const ON_TextureMapping& mapping, const ON_Xform* P_xform, const ON_Xform* N_xform) +{ + return false; +} + bool ON_SubD::SetFragmentTextureCoordinates( const class ON_TextureMapping& mapping, bool bLazy @@ -771,8 +776,6 @@ bool ON_SubD::SetFragmentTextureCoordinates( if (bApplySubDXform) subd_xform.GetMappingXforms(P_xform, N_xform); - const bool bApplyUVW = ON_MappingTag::TransformTreatedIsIdentity(&mapping.m_uvw) ? false : true; - ON_3dPoint tc; ON_SubDMeshFragmentIterator frit(*this); for (const ON_SubDMeshFragment* fragment = frit.FirstFragment(); nullptr != fragment; fragment = frit.NextFragment()) @@ -797,18 +800,19 @@ bool ON_SubD::SetFragmentTextureCoordinates( const unsigned N_count = fragment->NormalCount(); const double* N = (N_count == P_count) ? fragment->m_N : &ON_3dVector::ZeroVector.x; const size_t N_stride = (N_count == P_count) ? fragment->m_N_stride : 0; - for (double* T1 = T + T_stride * T_count; T < T1; T += T_stride, P += P_stride, N += N_stride) + if (T_count != P_count || N_count != P_count || !SetGridMeshMappingTCs(P_count, P, P_stride, N, N_stride, T, T_stride, mapping, bApplySubDXform ? &P_xform : nullptr, bApplySubDXform ? &N_xform : nullptr)) { - const bool ok = bApplySubDXform ? - mapping.Evaluate(ON_3dPoint(P), ON_3dVector(N), &tc, P_xform, N_xform) : - mapping.Evaluate(ON_3dPoint(P), ON_3dVector(N), &tc); - if(!ok) - tc = ON_3dPoint::NanPoint; - else if (bApplyUVW) - tc = mapping.m_uvw * tc; - T[0] = tc.x; - T[1] = tc.y; - T[2] = tc.z; + for (double* T1 = T + T_stride * T_count; T < T1; T += T_stride, P += P_stride, N += N_stride) + { + const bool ok = bApplySubDXform ? + mapping.Evaluate(ON_3dPoint(P), ON_3dVector(N), &tc, P_xform, N_xform) : + mapping.Evaluate(ON_3dPoint(P), ON_3dVector(N), &tc); + if (!ok) + tc = ON_3dPoint::NanPoint; + T[0] = tc.x; + T[1] = tc.y; + T[2] = tc.z; + } } } @@ -1047,6 +1051,12 @@ bool ON_SubD::HasPerFaceColorsFromPackId() const + +void ON_SubD::SetComponentMarkBitsFromSymmetryMotif() const +{ + this->ClearComponentMarkBits(true, true, true); +} + void ON_SubD::SetPerFaceColorsFromSymmetryMotif() const { if (FaceCount() < 1) diff --git a/opennurbs_symmetry.cpp b/opennurbs_symmetry.cpp index a3e1e337..952650ca 100644 --- a/opennurbs_symmetry.cpp +++ b/opennurbs_symmetry.cpp @@ -51,7 +51,7 @@ const ON_wString ON_Symmetry::SymmetryTypeToString(ON_Symmetry::Type symmetry_ty case ON_Symmetry::Type::Reflect: s = L"Reflect"; break; - case ON_Symmetry::Type::Rotate: + break; case ON_Symmetry::Type::Rotate: s = L"Rotate"; break; case ON_Symmetry::Type::ReflectAndRotate: @@ -75,13 +75,17 @@ ON_Symmetry::Region ON_Symmetry::SymmetryRegionFromUnsigned(unsigned int region_ switch (region_as_unsigned) { ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::Unset); - ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::In); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::AboveReflectionPlane); ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnRotationAxis); ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnReflectionPlane); - ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnRotationZeroPlane); - ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnRotationOnePlane); - ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::InAndOut); - ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::Out); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::CrossesReflectionPlane); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::BelowReflectionPlane); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OffRotationAxis); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnReflectionHalfPlane); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnSupplementalHalfPlane); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OnRotateAndReflectHalfPlane); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::InsideRotateAndReflect); + ON_ENUM_FROM_UNSIGNED_CASE(ON_Symmetry::Region::OutsideRotateAndReflect); } ON_ERROR("Invalid region_as_unsigned parameter"); @@ -96,53 +100,53 @@ const ON_wString SymmetryRegionToString(ON_Symmetry::Region r) case ON_Symmetry::Region::Unset: return ON_wString(L"Unset"); break; - case ON_Symmetry::Region::In: - return ON_wString(L"In"); + case ON_Symmetry::Region::AboveReflectionPlane: + return ON_wString(L"AboveReflectionPlane"); break; case ON_Symmetry::Region::OnRotationAxis: return ON_wString(L"OnRotationAxis"); break; + case ON_Symmetry::Region::OffRotationAxis: + return ON_wString(L"OffRotationAxis"); + break; case ON_Symmetry::Region::OnReflectionPlane: return ON_wString(L"OnReflectionPlane"); break; - case ON_Symmetry::Region::OnRotationZeroPlane: - return ON_wString(L"OnRotationZeroPlane"); + case ON_Symmetry::Region::CrossesReflectionPlane: + return ON_wString(L"CrossesReflectionPlane"); break; - case ON_Symmetry::Region::OnRotationOnePlane: - return ON_wString(L"OnRotationOnePlane"); + case ON_Symmetry::Region::BelowReflectionPlane: + return ON_wString(L"BelowReflectionPlane"); break; - case ON_Symmetry::Region::InAndOut: - return ON_wString(L"InAndOut"); + case ON_Symmetry::Region::OnReflectionHalfPlane: + return ON_wString(L"OnReflectionHalfPlane"); break; - case ON_Symmetry::Region::Out: - return ON_wString(L"Out"); + case ON_Symmetry::Region::OnSupplementalHalfPlane: + return ON_wString(L"OnSupplementalHalfPlane"); + break; + case ON_Symmetry::Region::OnRotateAndReflectHalfPlane: + return ON_wString(L"OnRotateAndReflectHalfPlane"); + break; + case ON_Symmetry::Region::InsideRotateAndReflect: + return ON_wString(L"InsideRotateAndReflect"); + break; + case ON_Symmetry::Region::OutsideRotateAndReflect: + return ON_wString(L"OutsideRotateAndReflect"); break; } return ON_wString::EmptyString; } -bool ON_Symmetry::IsOn(ON_Symmetry::Region r, bool bInAndOutResult) -{ - const unsigned char max = bInAndOutResult ? static_cast(ON_Symmetry::Region::Out) : static_cast(ON_Symmetry::Region::InAndOut); - return static_cast(r) > static_cast(ON_Symmetry::Region::In) && static_cast(r) < max; -} - -bool ON_Symmetry::IsInOrOn(ON_Symmetry::Region r, bool bInAndOutResult) -{ - const unsigned char max = bInAndOutResult ? static_cast(ON_Symmetry::Region::Out) : static_cast(ON_Symmetry::Region::InAndOut); - return static_cast(r) >= static_cast(ON_Symmetry::Region::In) && static_cast(r) < max; -} - -bool ON_Symmetry::IsNotInOrOn(ON_Symmetry::Region r, bool bInAndOutResult) -{ - return ON_Symmetry::IsInOrOn(r,!bInAndOutResult) ? false : true; -} - ON_Symmetry::Region ON_Symmetry::PointRegion(ON_3dPoint point, bool bUseCleanupTolerance) const { - if (point.IsValid()) + for(;;) { + if (false == point.IsValid()) + break; + const double tol = bUseCleanupTolerance ? CleanupTolerance() : ON_Symmetry::ZeroTolerance; + if (false == ON_IsValid(tol)) + break; double h[2]; switch (m_type) @@ -150,44 +154,73 @@ ON_Symmetry::Region ON_Symmetry::PointRegion(ON_3dPoint point, bool bUseCleanupT case ON_Symmetry::Type::Reflect: h[0] = ReflectionPlane().ValueAt(point); if (h[0] < -tol) - return ON_Symmetry::Region::Out; + return ON_Symmetry::Region::BelowReflectionPlane; if (h[0] <= tol) return ON_Symmetry::Region::OnReflectionPlane; if (h[0] > tol) - return ON_Symmetry::Region::In; + return ON_Symmetry::Region::AboveReflectionPlane; + + // ... else nans break; case ON_Symmetry::Type::Rotate: - h[0] = RotationZeroPlane().ValueAt(point); - if (h[0] < -tol) - return ON_Symmetry::Region::Out; - h[1] = RotationOnePlane().ValueAt(point); - if (h[1] < -tol) - return ON_Symmetry::Region::Out; - if (h[0] >= -tol && h[1] >= -tol) - { - // h[0] and h[1] are not nans ... - if (h[0] <= tol) - return (h[1] <= tol) ? ON_Symmetry::Region::OnRotationAxis : ON_Symmetry::Region::OnRotationZeroPlane; - return (h[1] <= tol) ? ON_Symmetry::Region::OnRotationOnePlane : ON_Symmetry::Region::In; - } - break; + { + const ON_Line axis = RotationAxis(); + const ON_3dPoint A = axis.ClosestPointTo(point); + const double d = fabs((point - A).MaximumCoordinate()); + if (d <= tol) + return ON_Symmetry::Region::OnRotationAxis; + if (d > tol) + return ON_Symmetry::Region::OffRotationAxis; + + // ... else nans + } + break; case ON_Symmetry::Type::ReflectAndRotate: - h[0] = ReflectionPlane().ValueAt(point); - if (h[0] < -tol) - return ON_Symmetry::Region::Out; - h[1] = RotationZeroPlane().ValueAt(point); - if (h[1] < -tol) - return ON_Symmetry::Region::Out; - if (h[0] >= -tol && h[1] >= -tol) + { + const ON_Line axis = RotationAxis(); + const ON_3dPoint A = axis.ClosestPointTo(point); + const double d = fabs((point - A).MaximumCoordinate()); + if (d <= tol) + return ON_Symmetry::Region::OnRotationAxis; + + const ON_PlaneEquation M = ReflectAndRotatePlane(0); // reflection plane + const ON_PlaneEquation S = ReflectAndRotatePlane(1); // supplental plane + h[0] = M.ValueAt(point); + h[1] = S.ValueAt(point); + if (h[0] > tol && h[1] > tol) + return ON_Symmetry::Region::InsideRotateAndReflect; + if (fabs(h[0]) <= tol && fabs(h[0]) <= fabs(h[1])) { - // h[0] and h[1] are not nans ... - if (h[0] <= tol) - return (h[1] <= tol) ? ON_Symmetry::Region::OnRotationAxis : ON_Symmetry::Region::OnReflectionPlane; - return (h[1] <= tol) ? ON_Symmetry::Region::OnRotationZeroPlane : ON_Symmetry::Region::In; + return (h[1] >= 0.0) ? ON_Symmetry::Region::OnReflectionHalfPlane : ON_Symmetry::Region::OnRotateAndReflectHalfPlane; } - break; + if (fabs(h[1]) <= tol) + { + return (h[0] >= 0.0) ? ON_Symmetry::Region::OnSupplementalHalfPlane : ON_Symmetry::Region::OnRotateAndReflectHalfPlane; + } + + if (h[0] == h[0] && h[1] == h[1]) + { + const ON_Xform R = this->RotationTransformation(); + const unsigned Rcount = this->RotationCount(); + for (unsigned i = 0; i < Rcount; ++i) + { + point = R * point; + h[0] = S.ValueAt(point); + if (fabs(h[0]) <= tol) + return ON_Symmetry::Region::OnRotateAndReflectHalfPlane; + h[0] = M.ValueAt(point); + if (fabs(h[0]) <= tol) + return ON_Symmetry::Region::OnRotateAndReflectHalfPlane; + } + return ON_Symmetry::Region::OutsideRotateAndReflect; + } + + + // ... else nans + } + break; } } @@ -195,6 +228,16 @@ ON_Symmetry::Region ON_Symmetry::PointRegion(ON_3dPoint point, bool bUseCleanupT return ON_Symmetry::Region::Unset; } +bool ON_Symmetry::SymmetryRegionHasFixedPoints(ON_Symmetry::Region symmetry_region) +{ + return + ON_Symmetry::Region::OnRotationAxis == symmetry_region + || ON_Symmetry::Region::OnReflectionPlane == symmetry_region + || ON_Symmetry::Region::OnReflectionHalfPlane == symmetry_region + || ON_Symmetry::Region::OnSupplementalHalfPlane == symmetry_region + || ON_Symmetry::Region::OnRotateAndReflectHalfPlane == symmetry_region + ; +} ON_Symmetry::Coordinates ON_Symmetry::SymmetryCoordinatesFromUnsigned(unsigned int symmetry_coordinates_as_unsigned) { @@ -254,7 +297,7 @@ bool ON_Symmetry::Write(ON_BinaryArchive& archive) const if (false == archive.WriteUuid(m_id)) break; - if (archive.BeginWrite3dmAnonymousChunk(2)) + if (archive.BeginWrite3dmAnonymousChunk(3)) { switch (m_type) { @@ -264,8 +307,9 @@ bool ON_Symmetry::Write(ON_BinaryArchive& archive) const rc = archive.WritePlaneEquation(m_fixed_plane); break; case ON_Symmetry::Type::Rotate: - // fixed plane added for chunk version >= 2 - rc = archive.WriteLine(m_rotation_axis) && archive.WritePlaneEquation(m_fixed_plane); + // The plane is written but not read so the files saved afeter June 15, 2021 + // can be read by code compiled before June 15, 2021. + rc = archive.WriteLine(m_rotation_axis) && archive.WritePlaneEquation(ON_PlaneEquation::NanPlaneEquation); break; case ON_Symmetry::Type::ReflectAndRotate: rc = archive.WritePlaneEquation(m_fixed_plane) && archive.WriteLine(m_rotation_axis); @@ -424,51 +468,202 @@ bool ON_Symmetry::IsMotifBoundarySubDVertex(const class ON_SubDVertex* v, bool b return false; if (false == v->IsCreaseOrCorner()) return false; + + const ON_Symmetry::Type symmetry_type = this->SymmetryType(); if (false == v->HasBoundaryVertexTopology()) { - const ON_Symmetry::Type symmetry_type = this->SymmetryType(); - if (ON_Symmetry::Type::Reflect == symmetry_type) - return false; // easy case. - else if (ON_Symmetry::Type::Rotate == symmetry_type) + switch (symmetry_type) { + case ON_Symmetry::Type::Reflect: + return false; // easy case. + break; + + case ON_Symmetry::Type::Rotate: if (v->HasInteriorVertexTopology()) return false; if (ON_SubDVertexTag::Corner != v->m_vertex_tag) return false; - // We have to keep "funky" corners - RH-63789 - } - else if (ON_Symmetry::Type::ReflectAndRotate == symmetry_type) - { - // Probably much harder than this - future work - return false; // easy case. - } - else + // We have to keep nonmanifold corners - RH-63789 + break; + + case ON_Symmetry::Type::ReflectAndRotate: + return false; + + default: return false; + break; + } } const ON_3dPoint P = v->ControlNetPoint(); const double tol = bUseCleanupTolerance ? this->CleanupTolerance() : ON_Symmetry::ZeroTolerance; - double d; - switch (this->SymmetryType()) + + switch (symmetry_type) { case ON_Symmetry::Type::Reflect: - d = fabs(this->ReflectionPlane().ValueAt(P)); - break; + { + const double d = fabs(this->ReflectionPlane().ValueAt(P)); + return (d <= tol); + } + break; + case ON_Symmetry::Type::Rotate: // All boundary vertices must be eligable for joining. - // The pinwheel motifs in RH-63376 show why. - d = P.IsValid() ? 0.0 : ON_DBL_QNAN; + // The pinwheel motifs in RH-63376 shows why. + return true; break; + case ON_Symmetry::Type::ReflectAndRotate: - // to be determined when ReflectAndRotate support is added - d = ON_DBL_QNAN; + // The ReflectAndRotatePlane(2) test makes sure we are in the correct half space + // where the ReflectAndRotate reflection plane is active. + if ( this->ReflectAndRotatePlane(2).ValueAt(P) >= -tol ) + { + // The d0 test is correct for certain + const double d0 = fabs(this->ReflectAndRotatePlane(0).ValueAt(P)); + if (d0 <= tol) + return true; + + // The d1 test is probably correct + const double d1 = fabs(this->ReflectAndRotatePlane(1).ValueAt(P)); + if (d1 <= tol) + return true; + } break; + default: - d = ON_DBL_QNAN; break; } - return (d <= tol); + return false; +} + +bool ON_Symmetry::IsFixedSubDComponent( + const class ON_SubDComponentPtr& subd_component, + bool bUseCleanupTolerance +) const +{ + const unsigned motif_count = this->MotifCount(); + if (motif_count < 2 || motif_count > ON_Symmetry::MaximumOrder) + return false; + + const ON_SubDVertex* v = nullptr; + const ON_SubDEdge* e = nullptr; + const ON_SubDFace* f = nullptr; + ON_3dPoint C = ON_3dPoint::NanPoint; + + switch (subd_component.ComponentType()) + { + case ON_SubDComponentPtr::Type::Vertex: + v = subd_component.Vertex(); + if (nullptr != v) + C = v->ControlNetPoint(); + break; + + case ON_SubDComponentPtr::Type::Edge: + e = subd_component.Edge(); + if (nullptr != e) + C = e->ControlNetCenterPoint(); + break; + + case ON_SubDComponentPtr::Type::Face: + f = subd_component.Face(); + if (nullptr != f) + C = f->ControlNetCenterPoint(); + break; + + default: + break; + } + + if (false == C.IsValid()) + return false; + + const double dtol = bUseCleanupTolerance ? this->CleanupTolerance() : ON_Symmetry::ZeroTolerance; + // quick test of center point + double d = C.DistanceTo(this->MotifTransformation(1) * C); + if (false == (d <= dtol)) + return false; + + ON_SimpleArray P(nullptr != f ? f->EdgeCount() : 2U); + if (nullptr != f) + { + for (unsigned short fvi = 0; fvi < f->m_edge_count; ++fvi) + P.Append(f->ControlNetPoint(fvi)); + } + else if (nullptr != e) + { + P.Append(e->ControlNetPoint(0)); + P.Append(e->ControlNetPoint(1)); + } + else if (nullptr != v) + { + P.Append(C); + } + + const unsigned Pcount = P.UnsignedCount(); + ON_SimpleArray hit_array(Pcount); + hit_array.SetCount(Pcount); + bool* bHit = hit_array.Array(); + + for (unsigned j = 1; j < motif_count; ++j) + { + const ON_Xform& motif_xform = this->MotifTransformation(j); + hit_array.Zero(); + unsigned hit_count = 0; + for (unsigned i = 0; i < Pcount; ++i) + { + const ON_3dPoint Q = motif_xform * P[i]; + for (unsigned k = 0; k < Pcount; ++k) + { + if (false == bHit[k]) + { + d = Q.DistanceTo(P[k]); + if (d <= dtol) + { + bHit[k] = true; + ++hit_count; + } + } + } + } + if (hit_count != Pcount) + return false; + } + + return true; +} + +bool ON_Symmetry::IsValidRotationAxis( + ON_Line rotation_axis, + unsigned int rotation_count +) +{ + for (;;) + { + if (rotation_count < 2) + break; + if (rotation_count > ON_Symmetry::MaximumOrder) + break; + if (false == rotation_axis.IsValid()) + break; + if (false == (rotation_axis.Length() > ON_Symmetry::ZeroTolerance)) + break; + + // Make sure a unitized axis can be reliably used for evaluations. + const ON_Line unit_axis(rotation_axis.from, rotation_axis.from + rotation_axis.Tangent()); + if (false == unit_axis.IsValid()) + break; + const double d0 = unit_axis.DistanceTo(rotation_axis.to); + if (false == (d0 <= ON_Symmetry::ZeroTolerance)) + break; + const double d1 = rotation_axis.DistanceTo(unit_axis.to); + if (false == (d1 <= ON_Symmetry::ZeroTolerance)) + break; + + return true; + } + + return false; } bool ON_Symmetry::IsValidRotationAxisAndFixedPlane( @@ -680,17 +875,16 @@ static bool Internal_InventSymmetryFixedPlane(const double zero_tolerance, ON_Xf return false; } -static bool Internal_InventRotationFixedPlane(const double zero_tolerance, const ON_Line rotation_axis, unsigned cyclic_order, ON_PlaneEquation& fixed_plane) -{ - const ON_3dPoint F[2] = { rotation_axis.from, rotation_axis.to }; - const ON_3dVector N = rotation_axis.Tangent().Perpendicular(ON_3dVector::NanVector); - return Internal_CreateAndValidateFixedPlane(F[0], N, fixed_plane, zero_tolerance, 2, F); -} +////static bool Internal_InventRotationFixedPlane(const double zero_tolerance, const ON_Line rotation_axis, unsigned cyclic_order, ON_PlaneEquation& fixed_plane) +////{ +//// const ON_3dPoint F[2] = { rotation_axis.from, rotation_axis.to }; +//// const ON_3dVector N = rotation_axis.Tangent().Perpendicular(ON_3dVector::NanVector); +//// return Internal_CreateAndValidateFixedPlane(F[0], N, fixed_plane, zero_tolerance, 2, F); +////} bool ON_Symmetry::Read(ON_BinaryArchive& archive) { *this = ON_Symmetry::Unset; - int chunk_version = 0; if (false == archive.BeginRead3dmAnonymousChunk(&chunk_version)) return false; @@ -709,9 +903,21 @@ bool ON_Symmetry::Read(ON_BinaryArchive& archive) { if (chunk_version <= 0) break; + unsigned char utype = 0; if (false == archive.ReadChar(&utype)) break; + + bool bNewRotatePrototype = false; + if (113 == utype) + { + // There was a period of time in June 2021 when ON_Symmetry::Type::NewRotate = 113 + // was used to prototype a replacement for an earlier version of rotate + // that did not work well. The protyped replacement worked much better + // and became the standard rotate on June 15, 2021. + bNewRotatePrototype = true; + utype = static_cast(ON_Symmetry::Type::Rotate); + } symmetry_type = ON_Symmetry::SymmetryTypeFromUnsigned(utype); if (ON_Symmetry::Type::Unset == symmetry_type) { @@ -719,7 +925,6 @@ bool ON_Symmetry::Read(ON_BinaryArchive& archive) break; } - if (false == archive.ReadInt(&inversion_order)) break; if (false == archive.ReadInt(&cyclic_order)) @@ -727,6 +932,9 @@ bool ON_Symmetry::Read(ON_BinaryArchive& archive) if (false == archive.ReadUuid(symmetry_id)) break; + // Before June 1, 2021: Chunk verson 2 for rotations that had a rotation plane. + // June 1, 2021: Chunk version 3 for symmetry_type=113 prototyping rotations with no rotation plane + // Future: Chunk version 4 for final rotations not using a rotation plane. int inner_chunk_version = 0; if (false == archive.BeginRead3dmAnonymousChunk(&inner_chunk_version)) break; @@ -748,12 +956,13 @@ bool ON_Symmetry::Read(ON_BinaryArchive& archive) case ON_Symmetry::Type::Rotate: rc = archive.ReadLine(rotation_axis); - if (inner_chunk_version >= 2) + if (inner_chunk_version >= 2 && false == bNewRotatePrototype) rc = archive.ReadPlaneEquation(fixed_plane); - else - rc = Internal_InventRotationFixedPlane(ON_Symmetry::ZeroTolerance, rotation_axis, cyclic_order, fixed_plane); if (rc) - symmetry = ON_Symmetry::CreateRotateSymmetry(rotation_axis, cyclic_order, fixed_plane, symmetry_coordinates); + { + // the fixed plane is intentionally ignored. + symmetry = ON_Symmetry::CreateRotateSymmetry(rotation_axis, cyclic_order, symmetry_coordinates); + } break; case ON_Symmetry::Type::ReflectAndRotate: @@ -982,6 +1191,7 @@ const ON_Symmetry ON_Symmetry::TransformUnconditionally(const ON_Xform& xform) c } break; + case ON_Symmetry::Type::Rotate: { if (false == m_rotation_axis.IsValid()) @@ -990,13 +1200,7 @@ const ON_Symmetry ON_Symmetry::TransformUnconditionally(const ON_Xform& xform) c a.Transform(xform); if (false == a.IsValid()) break; - if (false == m_fixed_plane.IsValid()) - break; - ON_PlaneEquation e = m_fixed_plane; - e.Transform(xform); - if (false == e.IsValid()) - break; - return ON_Symmetry::CreateRotateSymmetry(a, RotationCount(), e, m_coordinates); + return ON_Symmetry::CreateRotateSymmetry(a, RotationCount(), m_coordinates); } break; @@ -1157,15 +1361,6 @@ int ON_Symmetry::CompareSymmetryTransformation(const ON_Symmetry* lhs, const ON_ return ON_Symmetry::Compare(lhs, rhs); } -const ON_Symmetry ON_Symmetry::CreateInversionSymmetry( - ON_UUID symmetry_id, - ON_Xform inversion_transform, - ON_Symmetry::Coordinates symmetry_coordinates -) -{ - ON_ERROR("Use CreateRotationSymmetry(axis,2,...) or CreateReflectionSymmetry()"); - return ON_Symmetry::Unset; -} const ON_PlaneEquation ON_Symmetry::Internal_UnitizePlaneEquationParameter(ON_PlaneEquation e) { @@ -1224,16 +1419,78 @@ const ON_Symmetry ON_Symmetry::Internal_CreateInversionSymmetry( return ON_Symmetry::Unset; } - - -const ON_Symmetry ON_Symmetry::CreateCyclicSymmetry( +const ON_Symmetry ON_Symmetry::Internal_CreateCyclicSymmetry( ON_UUID symmetry_id, ON_Xform cyclic_transform, unsigned int cyclic_order, + ON_Line fixed_line, ON_Symmetry::Coordinates symmetry_coordinates ) { - ON_ERROR("Use CreateRotationSymmetry() or CreateReflectionSymmetry()"); + for (;;) + { + if (false == fixed_line.IsValid()) + break; + + const ON_Line unit_axis(fixed_line.from, fixed_line.from + fixed_line.Tangent()); + if (false == unit_axis.IsValid()) + break; + + if (false == ON_Symmetry::IsValidCyclicTranformation(cyclic_transform, cyclic_order)) + break; + + const double det = cyclic_transform.Determinant(); + if (2 == cyclic_order || 1 == (cyclic_order % 2)) + { + if (false == (det > 0.0)) + break; + } + else + { + if (false == (det != 0.0)) + break; + } + + if (false == (ON_nil_uuid == symmetry_id)) + { + // prohibit using built-in ids + if (ON_Symmetry::ReflectId == symmetry_id) + break; + if (ON_Symmetry::RotateId == symmetry_id) + break; + if (ON_Symmetry::ReflectAndRotateId == symmetry_id) + break; + } + + + // Make sure cyclic_transform fixes the axis. + const ON_3dPoint P[3] = { fixed_line.from, fixed_line.to, unit_axis.to }; + const unsigned Pcount = (unsigned)(sizeof(P) / sizeof(P[0])); + ON_Xform T = cyclic_transform; + for (unsigned int i = 0; i < cyclic_order; ++i) + { + for (unsigned j = 0; j < Pcount; ++j) + { + const ON_3dPoint Q = T * P[j]; + const double d = P[j].DistanceTo(Q); + if (false == (d <= ON_Symmetry::ZeroTolerance)) + return ON_Symmetry::Unset; + } + T = T * cyclic_transform; + } + + ON_Symmetry symmetry; + symmetry.m_type = ON_Symmetry::Type::Cyclic; + symmetry.m_coordinates = symmetry_coordinates; + symmetry.m_inversion_order = 1; + symmetry.m_cyclic_order = cyclic_order; + symmetry.m_id = symmetry_id; + symmetry.m_inversion_transform = ON_Xform::IdentityTransformation; + symmetry.m_cyclic_transform = cyclic_transform; + symmetry.m_fixed_plane = ON_PlaneEquation::NanPlaneEquation; + return symmetry; + } + return ON_Symmetry::Unset; } @@ -1323,26 +1580,13 @@ const ON_Symmetry ON_Symmetry::CreateRotateSymmetry( unsigned int rotation_count, ON_Symmetry::Coordinates symmetry_coordinates ) -{ - // You must use the version that has a rotation_plane parameter. - ON_ERROR("Obsolete function."); - return ON_Symmetry::Unset; -} - -const ON_Symmetry ON_Symmetry::CreateRotateSymmetry( - ON_Line rotation_axis, - unsigned int rotation_count, - ON_PlaneEquation zero_rotation_plane, - ON_Symmetry::Coordinates symmetry_coordinates -) { for (;;) { - zero_rotation_plane = ON_Symmetry::Internal_UnitizePlaneEquationParameter(zero_rotation_plane); - if (false == ON_Symmetry::IsValidRotationAxisAndFixedPlane(rotation_axis, rotation_count, zero_rotation_plane)) + if (false == ON_Symmetry::IsValidRotationAxis(rotation_axis, rotation_count)) break; const ON_Xform R = Internal_RotationXform(rotation_axis, 1, rotation_count); - ON_Symmetry symmetry = ON_Symmetry::Internal_CreateCyclicSymmetry(ON_nil_uuid, R, rotation_count, zero_rotation_plane, symmetry_coordinates); + ON_Symmetry symmetry = ON_Symmetry::Internal_CreateCyclicSymmetry(ON_nil_uuid, R, rotation_count, rotation_axis, symmetry_coordinates); if (ON_Symmetry::Type::Cyclic != symmetry.m_type) break; symmetry.m_type = ON_Symmetry::Type::Rotate; @@ -1353,7 +1597,6 @@ const ON_Symmetry ON_Symmetry::CreateRotateSymmetry( return ON_Symmetry::Unset; } - const ON_Symmetry ON_Symmetry::CreateReflectAndRotateSymmetry( ON_PlaneEquation reflection_plane, ON_Line rotation_axis, @@ -1369,7 +1612,7 @@ const ON_Symmetry ON_Symmetry::CreateReflectAndRotateSymmetry( if (ON_Symmetry::Type::Reflect != reflection.SymmetryType()) break; - const ON_Symmetry rotation = CreateRotateSymmetry(rotation_axis,rotation_count, reflection_plane, symmetry_coordinates); + const ON_Symmetry rotation = CreateRotateSymmetry(rotation_axis,rotation_count, symmetry_coordinates); if (ON_Symmetry::Type::Rotate != rotation.SymmetryType()) break; @@ -1453,25 +1696,21 @@ int ON_Symmetry::Compare(const ON_Symmetry* lhs, const ON_Symmetry* rhs) if (0U == lhs->m_inversion_order || 0U == lhs->m_cyclic_order) return 0; - if (ON_Symmetry::Type::Unset != lhs->m_type) + if (lhs->Internal_RequiresFixedPlane() || rhs->Internal_RequiresFixedPlane()) { const int rc = ON_Symmetry::Internal_CompareDouble(&lhs->m_fixed_plane.x, &rhs->m_fixed_plane.x, 4); if (0 != rc) return rc; } - if (ON_Symmetry::Type::Rotate == lhs->m_type || ON_Symmetry::Type::ReflectAndRotate == lhs->m_type) + if (lhs->Internal_RequiresRotationAxis() || rhs->Internal_RequiresRotationAxis()) { const int rc = ON_Symmetry::Internal_CompareDouble(&lhs->m_rotation_axis.from.x, &rhs->m_rotation_axis.from.x, 6); if (0 != rc) return rc; } - if ( - ON_Symmetry::Type::Reflect == lhs->m_type - || ON_Symmetry::Type::Rotate == lhs->m_type - || ON_Symmetry::Type::ReflectAndRotate == lhs->m_type - ) + if (lhs->Internal_IsStandardType() && rhs->Internal_IsStandardType()) return 0; if (lhs->m_inversion_order > 1) @@ -1498,6 +1737,21 @@ ON_Symmetry::Type ON_Symmetry::SymmetryType() const return m_type; } +bool ON_Symmetry::IsRotate() const +{ + return ON_Symmetry::Type::Rotate == m_type; +} + +bool ON_Symmetry::IsReflect() const +{ + return ON_Symmetry::Type::Reflect == m_type; +} + +bool ON_Symmetry::IsReflectAndRotate() const +{ + return ON_Symmetry::Type::ReflectAndRotate == m_type; +} + ON_Symmetry::Coordinates ON_Symmetry::SymmetryCoordinates() const { return m_coordinates; @@ -1550,23 +1804,11 @@ const ON_Xform ON_Symmetry::InversionTransformation() const return IsSet() ? m_inversion_transform : ON_Xform::Nan; } -const ON_Xform ON_Symmetry::InversionTransform() const -{ - // OBSOLETE use ON_Symmetry::InversionTransformation() - return ON_Xform::Nan; -} - const ON_Xform ON_Symmetry::CyclicTransformation() const { return IsSet() ? m_cyclic_transform : ON_Xform::Nan; } -const ON_Xform ON_Symmetry::CyclicTransform() const -{ - // OBSOLETE use ON_Symmetry::CyclicTransformation() - return ON_Xform::Nan; -} - const ON_SHA1_Hash ON_Symmetry::Hash() const { for(;;) @@ -1585,13 +1827,13 @@ const ON_SHA1_Hash ON_Symmetry::Hash() const sha1.AccumulateInteger32(InversionOrder()); sha1.AccumulateInteger32(CyclicOrder()); - if (ON_Symmetry::Type::Unset != m_type) + if ( this->Internal_RequiresFixedPlane()) sha1.AccumulateDoubleArray(4, &m_fixed_plane.x); - if (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + if ( this->Internal_RequiresRotationAxis() ) sha1.AccumulateDoubleArray(6, &m_rotation_axis.from.x); - if (ON_Symmetry::Type::Reflect != m_type && ON_Symmetry::Type::Rotate != m_type && ON_Symmetry::Type::ReflectAndRotate != m_type) + if ( false == this->Internal_IsStandardType() ) { if (InversionOrder() > 1) sha1.AccumulateDoubleArray(16, &m_inversion_transform.m_xform[0][0]); @@ -1611,6 +1853,65 @@ const ON_PlaneEquation ON_Symmetry::ReflectionPlane() const : ON_PlaneEquation::NanPlaneEquation; } +const ON_PlaneEquation ON_Symmetry::ReflectAndRotatePlane( + unsigned int plane_index +) const +{ + if ( IsSet() && ON_Symmetry::Type::ReflectAndRotate == m_type || plane_index >= 0 && plane_index <= 2) + { + const ON_PlaneEquation fixed_plane = FixedPlane(); + if (0 == plane_index) + return fixed_plane; + + // 2nd plane + ON_Xform R; + const double a = (1 == plane_index) ? -0.5 * RotationAngleRadians() : 0.5 * ON_PI; + R.Rotation(a, RotationAxisTangent(), RotationAxisPoint()); + ON_PlaneEquation e = fixed_plane; + e.Transform(R); + return (1 == plane_index) ? e.NegatedPlaneEquation() : e; + } + + return ON_PlaneEquation::NanPlaneEquation; +} + +bool ON_Symmetry::OnReflectAndRotateFixedPlane( ON_3dPoint P, bool bUseCleanupTolerance) const +{ + if (ON_Symmetry::Type::ReflectAndRotate != m_type) + return false; + if (false == P.IsValid()) + return false; + const double tol = this->Tolerance(bUseCleanupTolerance); + + const ON_PlaneEquation M = this->ReflectAndRotatePlane(0); + double h = M.ValueAt(P); + if (fabs(h) <= tol) + return true; + + const ON_PlaneEquation S = this->ReflectAndRotatePlane(1); + h = S.ValueAt(P); + if (fabs(h) <= tol) + return true; + + const unsigned Rcount = this->RotationCount(); + if (Rcount > 2) + { + const ON_Xform R = this->RotationTransformation(); + for (unsigned i = 1; i < Rcount; ++i) + { + P = R * P; + h = S.ValueAt(P); + if (fabs(h) <= tol) + return true; + h = M.ValueAt(P); + if (fabs(h) <= tol) + return true; + } + } + + return false; +} + const ON_Xform ON_Symmetry::ReflectionTransformation() const { return (ON_Symmetry::Type::Reflect == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) @@ -1625,97 +1926,74 @@ const ON_PlaneEquation ON_Symmetry::FixedPlane() const : ON_PlaneEquation::NanPlaneEquation; } +bool ON_Symmetry::Internal_RequiresRotationAxis() const +{ + return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type); +} + +bool ON_Symmetry::Internal_RequiresFixedPlane() const +{ + return (ON_Symmetry::Type::Reflect == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type); +} + +bool ON_Symmetry::Internal_IsStandardType() const +{ + return (ON_Symmetry::Type::Reflect == m_type || ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type); +} + const ON_Line ON_Symmetry::RotationAxis() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? m_rotation_axis : ON_Line::NanLine; } const ON_3dPoint ON_Symmetry::RotationAxisPoint() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? m_rotation_axis.from : ON_3dPoint::NanPoint; } const ON_3dVector ON_Symmetry::RotationAxisDirection() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? m_rotation_axis.Direction() : ON_3dVector::NanVector; } const ON_3dVector ON_Symmetry::RotationAxisTangent() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? m_rotation_axis.Tangent() : ON_3dVector::NanVector; } unsigned int ON_Symmetry::RotationCount() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? m_cyclic_order : 0U; } double ON_Symmetry::RotationAngleDegrees() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? (360.0 / ((double)RotationCount())) : ON_DBL_QNAN; } double ON_Symmetry::RotationAngleRadians() const { - return (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) + return (Internal_RequiresRotationAxis()) ? ((2.0*ON_PI) / ((double)RotationCount())) : ON_DBL_QNAN; } -const ON_PlaneEquation ON_Symmetry::RotationZeroPlane() const -{ - if (ON_Symmetry::Type::Rotate == m_type) - { - return this->m_fixed_plane; - } - if (ON_Symmetry::Type::ReflectAndRotate == m_type) - { - const double a = RotationAngleRadians(); - if (a > 0.0 && a <= ON_PI) - { - ON_Xform rot; - rot.Rotation(-0.5*a, this->RotationAxisDirection(), this->RotationAxisPoint()); - ON_PlaneEquation e(this->m_fixed_plane); - e.Transform(rot); - return e.NegatedPlaneEquation(); - } - } - return ON_PlaneEquation::NanPlaneEquation; -} - - -const ON_PlaneEquation ON_Symmetry::RotationOnePlane() const -{ - if (ON_Symmetry::Type::Rotate == m_type || ON_Symmetry::Type::ReflectAndRotate == m_type) - { - const ON_PlaneEquation r0 = RotationZeroPlane(); - if (r0.IsSet()) - { - const ON_PlaneEquation r1 = (RotationTransformation() * r0).NegatedPlaneEquation(); - if (r1.IsSet()) - return r1; - } - } - - return ON_PlaneEquation::NanPlaneEquation; -} - const ON_Xform ON_Symmetry::RotationTransformation() const { - if (ON_Symmetry::Type::Rotate == m_type) + if ( ON_Symmetry::Type::Rotate == m_type ) { return MotifTransformation(1); } @@ -1769,6 +2047,12 @@ const ON_Xform ON_Symmetry::Internal_RotationXform( sin_angle = 0.0; cos_angle = -1.0; } + else if (3 * rotation_index == rotation_count) + { + // angle = 2pi/3 + sin_angle = 0.5*sqrt(3.0); + cos_angle = -0.5; + } else if (4 * rotation_index == rotation_count) { // angle = pi/2 @@ -1897,11 +2181,6 @@ const ON_Xform ON_Symmetry::Internal_ReflectAndRotateTransformation(unsigned ind return r; } -ON_SHA1_Hash ON_Symmetry::Sha1Hash() const -{ - return SymmetryHash(); -} - const ON_SHA1_Hash ON_Symmetry::SymmetryHash() const { ON_SHA1 sha1; @@ -1918,14 +2197,6 @@ const ON_SHA1_Hash ON_Symmetry::SymmetryHash() const return sha1.Hash(); } -void ON_Symmetry::SetSymmetricObjectContentSerialNumber(ON__UINT64 symmetric_object_content_serial_number) const -{ - // OBSOLETE - You must use SetSymmetricObject(). - ON_ERROR("Obsolete function."); - - ClearSymmetricObject(); // strongly discourage use by erasing all SymmetricContent settings. -} - void ON_Symmetry::ClearSymmetricObject() const { m_symmetric_object_content_serial_number = 0U; @@ -1933,18 +2204,6 @@ void ON_Symmetry::ClearSymmetricObject() const m_symmetric_object_topology_hash = ON_SHA1_Hash::ZeroDigest; } -void ON_Symmetry::ClearSymmetricObjectContentSerialNumber() const -{ - ClearSymmetricObject(); -} - -ON__UINT64 ON_Symmetry::SymmetricObjectContentSerialNumber() const -{ - // OBSOLETE - You must use SameSymmetricObjectGeometry(). - ON_ERROR("Obsolete function."); - return 0; -} - void ON_Symmetry::SetCleanupTolerance( double cleanup_tolerance ) @@ -1964,3 +2223,8 @@ double ON_Symmetry::CleanupTolerance() const // read from old archives. return (m_cleanup_tolerance >= ON_Symmetry::ZeroTolerance) ? m_cleanup_tolerance : ON_Symmetry::ZeroTolerance; } + +double ON_Symmetry::Tolerance(bool bUseCleanupTolerance) const +{ + return bUseCleanupTolerance ? CleanupTolerance() : ON_Symmetry::ZeroTolerance; +} diff --git a/opennurbs_symmetry.h b/opennurbs_symmetry.h index f46e259f..a988effd 100644 --- a/opennurbs_symmetry.h +++ b/opennurbs_symmetry.h @@ -37,6 +37,11 @@ public: MaximumOrder = 4096 }; + + // NOTE never use the value 113 for a new ON_Symmetry::Type. + // This value was used breifly in June 2021 for a prototype symmetry type + // and reusing it will break SHA1 hashes and 3dm archive IO. + enum class Type : unsigned char { Unset = 0, @@ -50,8 +55,8 @@ public: /// /// Rotation around an axis. - /// The symmetric object has reflection copies of the motif. - /// Points on the axis are fixed. + /// The symmetric object has rotated copies of the motif. + /// Points on the rotation axis are fixed. /// Rotate = 2, @@ -78,7 +83,7 @@ public: /// When N is even and greater than 2, Det(cyclic transformation) = 1 or -1. /// The symmetric object has N copies of the motif. /// - Cyclic = 5, + Cyclic = 5 }; static ON_Symmetry::Type SymmetryTypeFromUnsigned(unsigned int symmetry_type_as_unsigned); @@ -118,81 +123,69 @@ public: Unset = 0, /// - /// Inside the primary motif region. + /// Above the reflection plane and inside the primary reflect motif region. + /// Applies to Reflect symmetries. /// - In = 1, + AboveReflectionPlane = 1, /// - /// On the rotation axis. Applies to Reflect and ReflectAndRotate symmetries. + /// On the reflection plane. Applies to Reflect symmetries. /// - OnRotationAxis = 2, + OnReflectionPlane = 2, /// - /// On the reflection plane. Applies to Reflect and ReflectAndRotate symmetries. + /// Below the reflection plane and outside the primary reflect motif region. + /// Applies to Reflect symmetries. /// - OnReflectionPlane = 3, + BelowReflectionPlane = 3, /// - /// On the zero angle plane. Applies to Reflect and ReflectAndRotate symmetries. + /// Something like a line segment that has points above and below the reflection plane. /// - OnRotationZeroPlane = 4, + CrossesReflectionPlane = 4, /// - /// On the the rotation of the zero angle plane. Applies to Rotate symmetries. + /// On the rotation axis. Applies to Rotate and ReflectAndRotate symmetries. /// - OnRotationOnePlane = 5, + OnRotationAxis = 5, /// - /// Something like a line segment that has points both inside and outside the primary motif region. + /// Off of (not on) the rotation axis. Applies to Rotate symmetries. /// - InAndOut = 6, + OffRotationAxis = 6, /// - /// Outside the primary motif region. + /// On the reflection half plane. Applies to ReflectAndRotate symmetries. /// - Out = 7 + OnReflectionHalfPlane = 7, + + /// + /// On the supplemental half plane. Applies to ReflectAndRotate symmetries. + /// + OnSupplementalHalfPlane = 8, + + /// + /// The half planes outside the primary motif region that are rotations + /// of either the reflection half plane or the supplemental half plane. + /// Applies to ReflectAndRotate symmetries. + /// + OnRotateAndReflectHalfPlane = 10, + + /// + /// Above both the reflection plane and the supplemental plane. + /// Applies to ReflectAndRotate symmetries. + /// + InsideRotateAndReflect = 11, + + /// + /// Outside the primary motif region and and on one of the fixed point planes + /// Applies to ReflectAndRotate symmetries. + /// + OutsideRotateAndReflect = 12 }; static ON_Symmetry::Region SymmetryRegionFromUnsigned(unsigned int region_as_unsigned); - static const ON_wString SymmetryRegionToString(ON_Symmetry::Region r); - - /* - Returns: - (r == ON_Symmetry::Region::OnRotationZeroPlane || r == ON_Symmetry::Region::OnRotationOnePlane). - */ - static bool SymmetryRegionIsRotationPlane(ON_Symmetry::Region r); - - /* - Paramaters: - r - [in] - bInAndOutResult - [in] - Value to return when ON_Symmetry::Region::InandOut == r. - Returns: - True if r is OnRotationAxis, OnReflectionPlane, OnZeroAnglePlane, or OnOneAnglePlane. - */ - static bool IsOn(ON_Symmetry::Region r, bool bInAndOutResult); - - /* - Paramaters: - r - [in] - bInAndOutResult - [in] - Value to return when ON_Symmetry::Region::InandOut == r. - Returns: - ON_Symmetry::Region::In == r || IsOn(r). - */ - static bool IsInOrOn(ON_Symmetry::Region r, bool bInAndOutResult); - - /* - Paramaters: - r - [in] - bInAndOutResult - [in] - Value to return when ON_Symmetry::Region::InandOut == r. - Returns: - !ON_Symmetry::IsInOrOn(r) - */ - static bool IsNotInOrOn(ON_Symmetry::Region r, bool bInAndOutResult); - /* Parameters: point - [in] @@ -206,6 +199,22 @@ public: */ ON_Symmetry::Region PointRegion(ON_3dPoint point, bool bUseCleanupTolerance) const; + /* + Description: + A symmetry region has fixed points if one or more motif transforms of the + applicable symmetry type fixes points in the region. + Points in these regions typically need special processing when the symmetric + object is edited. + Returns: + True if symmetry_region is one of + ON_Symmetry::Region::OnRotationAxis, + ON_Symmetry::Region::OnReflectionPlane, + ON_Symmetry::Region::OnReflectionHalfPlane, + ON_Symmetry::Region::OnSupplementalHalfPlane, + or ON_Symmetry::Region::OnRotateAndReflectFixedPlane. + */ + static bool SymmetryRegionHasFixedPoints(ON_Symmetry::Region symmetry_region); + static ON_Symmetry::Coordinates SymmetryCoordinatesFromUnsigned(unsigned int coordinates_as_unsigned); static const ON_wString SymmetryCoordinatesToString( @@ -225,8 +234,23 @@ public: True if v is a vertex that might possibly be merged when transformed motifs are joined to create a symmetric SubD. */ - bool IsMotifBoundarySubDVertex(const class ON_SubDVertex* v, bool bUseCleanupTolerance) const; + bool IsMotifBoundarySubDVertex( + const class ON_SubDVertex* v, + bool bUseCleanupTolerance + ) const; + /* + Description: + Examples of fixed SubD components include vertices on a reflection plane or + rotation axis, faces and edges straddling a reflection plane, + and faces centered about a rotation axis. + Returns: + True if the component is transformed to itself by every motif transformation. + */ + bool IsFixedSubDComponent( + const class ON_SubDComponentPtr& subd_component, + bool bUseCleanupTolerance + ) const; static const ON_UUID ReflectId; static const ON_UUID RotateId; @@ -292,10 +316,11 @@ public: rotation_count - [in] fixed_plane - [in] Returns: - True if these 3 conditions are satisified. + True if these 4 conditions are satisified. 1. rotation_axis is a valid line. - 2. rotation_count > 0 - 3. fixed_plane contains the rotation axis. + 2. rotation_count >= 2 + 3. rotation_count <= ON_Symmetry::MaximumOrder + 4. fixed_plane contains the rotation axis. Remarks: The value ON_Symmetry::ZeroTolerance is used for all "zero tolerances." */ @@ -305,6 +330,24 @@ public: ON_PlaneEquation fixed_plane ); + /* + Parameters: + rotation_axis - [in] + rotation_count - [in] + fixed_plane - [in] + Returns: + True if these 3 conditions are satisified. + 1. rotation_axis is a valid line. + 2. rotation_count >= 2 + 3. rotation_count <= ON_Symmetry::MaximumOrder + Remarks: + The value ON_Symmetry::ZeroTolerance is used for all "zero tolerances." + */ + static bool IsValidRotationAxis( + ON_Line rotation_axis, + unsigned int rotation_count + ); + /* Description: Reflection about a plane. @@ -327,41 +370,29 @@ public: ON_Symmetry::Coordinates symmetry_coordinates ); - ON_DEPRECATED_MSG("Does nothing. Use ON_Symmetry::CreateRotateSymmetry(axis,count,plane,coordinates.") - static const ON_Symmetry CreateRotateSymmetry( - ON_Line rotation_axis, - unsigned int rotation_count, - ON_Symmetry::Coordinates symmetry_coordinates - ); - /* Description: Rotation around an axis. The symmetric object has reflection_count copies of the motif. - Points on the axis are fixed. + Points on the axis are fixed. Parameters: rotation_axis - [in] rotation_count - [in] rotation_count must be >= 2 and the rotation angle is (360/rotation_count) degrees. - zero_rotation_plane - [in] - zero_rotation_plane plane is used to define the primary motif region. - A point P is in the primary motif when zero_rotation_plane.ValueAt(P) >= 0 && (MotifTransformation(1)*zero_rotation_plane).ValueAt(P) <= 0. - The rotation axis must be in zero_rotation_plane (zero_rotation_plane.ValueAt(rotation_axis) <= ON_ZERO_TOLERANCE and zero_rotation_plane.ValueAt(rotation_axis) <= ON_ZERO_TOLERANCE). symmetry_coordinates - [in] object or world. Example: - If the rotation axis is the z-axis and the order is N, then the generator is + If the rotation axis is the z-axis and the order is N, then the generator is then (x,y,z) -> (r*cos(a), r*sin(a), z) -> (r*cos(2*a), r*sin(2*a), z) -> ... -> (x,y,z), where r = sqrt(x*x + y*y) and a = (360 degrees)/N. - Any plane containing the z-axis can be used as the zero_rotation_plane. Remarks: CyclicTransformation() = rotation. InversionTransformation() = identity. */ + ////ON_WIP_SDK static const ON_Symmetry CreateRotateSymmetry( ON_Line rotation_axis, unsigned int rotation_count, - ON_PlaneEquation zero_rotation_plane, ON_Symmetry::Coordinates symmetry_coordinates ); @@ -386,6 +417,7 @@ public: InversionTransformation() = reflection. CyclicTransformation() = rotation by (360/rotation_count) degrees. */ + ////ON_WIP_SDK static const ON_Symmetry CreateReflectAndRotateSymmetry( ON_PlaneEquation reflection_plane, ON_Line rotation_axis, @@ -393,21 +425,6 @@ public: ON_Symmetry::Coordinates symmetry_coordinates ); - ON_DEPRECATED_MSG("Use CreateRotationSymmetry(axis,2,...) or CreateReflectionSymmetry()") - static const ON_Symmetry CreateInversionSymmetry( - ON_UUID symmetry_id, - ON_Xform inversion_transform, - ON_Symmetry::Coordinates symmetry_coordinates - ); - - ON_DEPRECATED_MSG("Use CreateRotationSymmetry() or CreateReflectionSymmetry()") - static const ON_Symmetry CreateCyclicSymmetry( - ON_UUID symmetry_id, - ON_Xform cyclic_transform, - unsigned int cyclic_order, - ON_Symmetry::Coordinates symmetry_coordinates - ); - private: /* Description: @@ -466,6 +483,41 @@ private: ON_PlaneEquation zero_plane, ON_Symmetry::Coordinates symmetry_coordinates ); + + + /* + Description: + Create a cyclic symmetry from a transformation. + The symmetric object has order copies of the modif. + Parameters: + symmetry_id - [in] + An id you can assign to the symmetry + cyclic_transform - [in] + cyclic_transform^order = identity + cyclic_transform^i != identity when 0 < i < order + If order is even and at least 4, then Det(cyclic_transform) = 1 or -1. + Otherwise Det(cyclic_transform) = 1. + cyclic_order - [in] + cyclic_order >= 2 + fixed_line - [in] + fixed_line must contain all fixed points of cyclic_transform. + For any point P, F = P + cyclic_transform*P + ... + cyclic_transform^(cyclic_order-1)*P + is a fixed point of cyclic_transform. + symmetry_coordinates - [in] + object or world. + Remarks: + If cyclic_transform is a rotation, use CreateRotationSymmetry(). + If cyclic_transform is a reflection, use CreateReflectionSymmetry(). + If 2 = cyclic_order and Det(cyclic_transform) = -1, use CreateInversionSymmetry(). + */ + static const ON_Symmetry Internal_CreateCyclicSymmetry( + ON_UUID symmetry_id, + ON_Xform cyclic_transform, + unsigned int cyclic_order, + ON_Line fixed_line, + ON_Symmetry::Coordinates symmetry_coordinates + ); + public: /* @@ -490,6 +542,24 @@ public: */ ON_Symmetry::Type SymmetryType() const; + /* + Returns: + True if SymmetryType() is ON_Symmetry::Type::Rotate + */ + bool IsRotate() const; + + /* + Returns: + True if SymmetryType() is ON_Symmetry::Type::Reflect + */ + bool IsReflect() const; + + /* + Returns: + True if SymmetryType() is ON_Symmetry::Type::ReflectAndRotage + */ + bool IsReflectAndRotate() const; + /* Returns: Symmetry type. @@ -594,9 +664,6 @@ public: */ const ON_Xform InversionTransformation() const; - ON_DEPRECATED_MSG("Returns nans. Call InversionTransformation()") - const ON_Xform InversionTransform() const; - /* Returns: The cyclic transformation is returned. @@ -612,9 +679,6 @@ public: */ const ON_Xform CyclicTransformation() const; - ON_DEPRECATED_MSG("Return nans. Call CyclicTransformation()") - const ON_Xform CyclicTransform() const; - /* Returns: A plane containing all the fixed points of the symmetry. @@ -645,6 +709,29 @@ public: */ const ON_Xform ReflectionTransformation() const; + +private: + /* + Returns: + True if the symmetry type requires a valid rotation axis. + False otherwide + */ + bool Internal_RequiresRotationAxis() const; + + /* + Returns: + True if the symmetry type requires a valid fixed plane. + False otherwide + */ + bool Internal_RequiresFixedPlane() const; + + /* + Returns: + True if the symmetry type is Reflect, Rotate, ReflectAndRotate. + */ + bool Internal_IsStandardType() const; + +public: /* Returns: If the symmetry is type is Rotate or ReflectAndRotate, then the rotation axis is returned. @@ -707,29 +794,39 @@ public: */ double RotationAngleRadians() const; - /* - Returns: - If the symmetry is type is Rotate or ReflectAndRotate, then the plane defining the zero angle or rotation is returned. - Othewise ON_PlaneEquation::NanPlaneEquation is returned. - Remarks: - For a Rotate symmetry, the region on or above RotationZeroPlane() and above RotationOnePlane() - is the default primary motif region. - For a RotateAndReflect symmetry, the region on or above RotationZeroPlane() and on or above ReflectionPlane() - is the default primary motif region. - */ - const ON_PlaneEquation RotationZeroPlane() const; /* + Description: + A reflect and rotate symmetry has three important planes. + * The reflection plane. + This plane is returned by ReflectAndRotatePlane(0). + * The supplemental plane. This plane is the reflection plane rotated + around the rotation axis by angle = -0.5*RotationAngle() and then reversed. + This plane is returned by ReflectAndRotatePlane(1). + * The reflection plane rotated around the rotation axis by pi/2. + This plane is returned by ReflectAndRotatePlane(2). + + The primary motif region for a reflect and rotate symmetry is region above both + the reflection plane and the supplemental plane. + + The normals of all planes point into the primary motif region. + + Parameters: + plane_index - [in] + Selects the plane. + 0: returns the reflection plane. + 1: returns the supplemental plane. + 2: returns the half space bounding plane. + Returns: - If the symmetry is type is Rotate or ReflectAndRotate, then (RotationTransformation() * RotationOnePlane()).NegatedPlaneEquation() is returned. - Othewise ON_PlaneEquation::NanPlaneEquation is returned. - Remarks: - For a Rotate symmetry, the region on or above RotationZeroPlane() and above RotationOnePlane() - is the default primary motif region. - For a RotateAndReflect symmetry, the region on or above RotationZeroPlane() and on or above ReflectionPlane() - is the default primary motif region. + If the symmetry type is ReflectAndRotate and plane_index is valid, the requested plane is returned. + Otherwise ON_PlaneEquation::Nan is returned. */ - const ON_PlaneEquation RotationOnePlane() const; + const ON_PlaneEquation ReflectAndRotatePlane( + unsigned int plane_index + ) const; + + bool OnReflectAndRotateFixedPlane( ON_3dPoint P, bool bUseCleanupTolerance) const; public: bool Write(class ON_BinaryArchive&) const; @@ -763,9 +860,6 @@ public: */ const ON_SHA1_Hash SymmetryHash() const; - ON_DEPRECATED_MSG("Use SymmetryHash()") - ON_SHA1_Hash Sha1Hash() const; - /* Description: If the SubD is known to have the symmetry specified by this ON_Symmetry, @@ -828,15 +922,6 @@ public: bool SameSymmetricObjectTopology(const class ON_SubDimple* subdimple) const; - ON_DEPRECATED_MSG("OBSOLETE AND DESTROYS SYMMETRIC OBJECT INFORMATION. Use SetSymmetricObject()") - void SetSymmetricObjectContentSerialNumber(ON__UINT64 symmetric_object_content_serial_number) const; - - ON_DEPRECATED_MSG("Use ClearSymmetricObject()") - void ClearSymmetricObjectContentSerialNumber() const; - - ON_DEPRECATED_MSG("ALWAYS RETURNS ZERO. Use SameSymmetricObjectGeometry(...)") - ON__UINT64 SymmetricObjectContentSerialNumber() const; - public: // ON_Symmetry::ZeroTolerance is a 3d tolerance use to validate // transformations, rotation axis locations, and plane equations. @@ -878,6 +963,12 @@ public: */ double CleanupTolerance() const; + /* + Returns: + bUseCleanupTolerance ? this->CleanupTolerance() : ON_Symmetry::ZeroTolerance; + */ + double Tolerance(bool bUseCleanupTolerance) const; + private: ON_Symmetry::Type m_type = ON_Symmetry::Type::Unset; @@ -910,7 +1001,7 @@ private: // m_rotation_axis always lies in m_plane. ON_Line m_rotation_axis = ON_Line::NanLine; - // Using 0.0 insures the default returned by CleanupTolerance() is alwasy ON_Symmetry::ZeroTolerance. + // Using 0.0 insures the default returned by CleanupTolerance() is always ON_Symmetry::ZeroTolerance. double m_cleanup_tolerance = 0.0; private: diff --git a/opennurbs_text.h b/opennurbs_text.h index bc41cd34..e978ab44 100644 --- a/opennurbs_text.h +++ b/opennurbs_text.h @@ -198,7 +198,7 @@ public: /* Returns: Rich text suitable for initializing SDK controls on the current platform (Windows or Apple OS X). - The returned string is alwasy rich text (never plain text). + The returned string is always rich text (never plain text). The returned rich text is always generated directly from the runs. This text is typically different from the Rhino clean rich text returned by the RichText() command. */ @@ -210,7 +210,7 @@ public: rich_text_style - [in] Type of rich text to return. Returns: - The returned string is alwasy rich text (never plain text). + The returned string is always rich text (never plain text). The returned rich text is always generated directly from the runs. This text is typically different from the Rhino clean rich text returned by the RichText() command. */ diff --git a/opennurbs_textiterator.cpp b/opennurbs_textiterator.cpp index a1309b36..1284bf38 100644 --- a/opennurbs_textiterator.cpp +++ b/opennurbs_textiterator.cpp @@ -3291,8 +3291,9 @@ bool RtfComposer::Compose( run_strings += L" "; } - if (run->IsStacked() == ON_TextRun::Stacked::kStacked && run->m_stacked_text != 0) + if (ON_TextRun::RunType::kField != run->Type() && run->IsStacked() == ON_TextRun::Stacked::kStacked && run->m_stacked_text != 0) { + // RH-64720 - Only do this if the stack isn't from a field run_strings += L"[["; run_strings += run->m_stacked_text->m_separator; GetRunText(run->m_stacked_text->m_top_run, run_strings, make_rtf); @@ -3302,9 +3303,9 @@ bool RtfComposer::Compose( } else if (ON_TextRun::RunType::kField == run->Type()) { - run_strings += L"%<"; - GetRunText(run, run_strings, make_rtf); - run_strings += L">%"; + //run_strings += L"%<"; + //GetRunText(run, run_strings, make_rtf); + //run_strings += L">%"; } else { diff --git a/opennurbs_unicode.cpp b/opennurbs_unicode.cpp index 2deebfb1..82edc5d6 100644 --- a/opennurbs_unicode.cpp +++ b/opennurbs_unicode.cpp @@ -26,7 +26,88 @@ int ON_IsValidUnicodeCodePoint(ON__UINT32 u) { - return (u < 0xD800 || (u >= 0xE000 && u <= 0x10FFFF)); + if (u < 0xD800) + return true; + + if (u < 0xE000) + { + // 0xD800 <= u < 0xDC00 is used for the first value in a UTF-16 surrogate pair. + // 0xDC00 <= u < 0xE000 is used for the second value in a UTF-16 surrogate pair. + return false; + } + + if (u < 0xFFFE) + return true; + + if (u == 0xFFFE || u == 0xFFFF) + { + // The Unicode specification states these values are . + // 0xFFFE is a swapped Unicode byte order mark (U+FEFF). + // https://www.unicode.org/charts/PDF/UFFF0.pdf + return false; + } + + if (u < 0xFFFFE) + return true; + + if (u == 0xFFFFE || u == 0xFFFFF) + { + // The Unicode specification states these values are . + // https://www.unicode.org/charts/PDF/UFFF80.pdf + return false; + } + + if (u < 0x10FFFE) + return true; + + if (u == 0x10FFFE || u == 0x10FFFF) + { + // The Unicode specification states these values are . + // https://www.unicode.org/charts/PDF/U10FF80.pdf + return false; + } + + // All valid Unicode code points are < 0x110000 + return false; +} + +bool ON_IsPrivateUseUnicodeCodePoint(ON__UINT32 unicode_code_point) +{ + // Unicode code points in the ranges U+E000–U+F8FF, U+F0000–U+FFFFD, + // and U+100000–U+10FFFD are for private use (user defined characters). + + if (unicode_code_point < 0xE000U) + return false; + + if (unicode_code_point <= 0xF8FFU) + return true; // Private use area E000-F8FF + + if (unicode_code_point < 0xF0000U) + return false; + + if (unicode_code_point <= 0xFFFFDU) + return true; // Supplementary Private Use Area-A F0000-FFFFD + + // FFFFE and FFFFF are + + if (unicode_code_point < 0x100000U) + return false; + + if (unicode_code_point <= 0x10FFFDU) + return true; // Supplementary Private Use Area-B 100000-10FFFD + + // 10FFFE and 10FFFF are + + return false; +} + +bool ON_IsStandardUnicodeCodePoint(ON__UINT32 unicode_code_point) +{ + return + 0 != ON_IsValidUnicodeCodePoint(unicode_code_point) + && ON_UnicodeCodePoint::ON_ByteOrderMark != unicode_code_point + && false == ON_IsPrivateUseUnicodeCodePoint(unicode_code_point) + ; } int ON_IsUnicodeSpaceCodePoint( @@ -2891,7 +2972,11 @@ int ON_ConvertMSMBCPToWideChar( if ( 0 != error_status ) *error_status = 0; - bool bNullTerminated = false; + if (nullptr != sWideChar && sWideChar_capacity > 0) + sWideChar[0] = 0; + + bool bNullTerminated = false; // Mac OS code needs bNullTerminated + if ( -1 == sMBCS_count && nullptr != sMBCS ) { for ( sMBCS_count = 0; true; sMBCS_count++) @@ -2925,11 +3010,8 @@ int ON_ConvertMSMBCPToWideChar( { sWideChar_capacity = 0; } - else - { - sWideChar[0] = 0; - } + // ASCII check const char* c = sMBCS; const char* c1 = c + sMBCS_count; wchar_t* w = sWideChar; @@ -3088,6 +3170,294 @@ int ON_ConvertMSMBCPToWideChar( } +int ON_wString::ByteOrder(wchar_t bom_candidate) +{ + if (ON_UnicodeCodePoint::ON_ByteOrderMark == bom_candidate) + return 1; + if (ON_UnicodeCodePoint::ON_ByteOrderMark == ON_wString::SwapByteOrder(bom_candidate)) + return -1; + return 0; +} + +wchar_t ON_wString::SwapByteOrder(wchar_t w) +{ + unsigned char* b = (unsigned char*)(&w); + unsigned char tmp; +#if (2 == ON_SIZEOF_WCHAR_T) + tmp = b[0]; b[0] = b[1]; b[1] = tmp; +#elif (4 == ON_SIZEOF_WCHAR_T) + tmp = b[0]; b[0] = b[3]; b[3] = tmp; + tmp = b[1]; b[1] = b[2]; b[2] = tmp; +#endif + return w; +} + +int ON_ConvertWideCharToMSMBCP( + const wchar_t* sWideChar, + int sWideChar_count, + ON__UINT32 windows_code_page, + char* sMBCS, + int sMBCS_capacity, + unsigned int* error_status +) +{ + if (0 != error_status) + *error_status = 0; + + if (nullptr != sMBCS && sMBCS_capacity > 0) + sMBCS[0] = 0; + + if (-1 == sWideChar_count && nullptr != sWideChar) + { + for (sWideChar_count = 0; true; sWideChar_count++) + { + if (0 == sWideChar[sWideChar_count]) + break; + } + } + + if (nullptr == sWideChar || sWideChar_count < 0) + { + if (0 != error_status) + *error_status |= 1; + return 0; + } + + const int byte_order_mark = (nullptr != sWideChar && sWideChar_count > 0) ? ON_wString::ByteOrder(sWideChar[0]) : 0; + if (0 != byte_order_mark) + { + // handle leading byte order mark. + ++sWideChar; + --sWideChar_count; + + while (sWideChar_count > 0 && 0 != ON_wString::ByteOrder(sWideChar[0])) + { + // Ignore additional byte order marks. If this is causing trouble, + // you need to clean up your input before calling this function. + ++sWideChar; + --sWideChar_count; + } + + if (sWideChar_count <= 0) + { + // The entire input string was byte order marks. Nothing to convert + return 0; + } + + if (-1 == byte_order_mark) + { + // Recursively call this function 1 time with swapped bytes. + wchar_t* swappedWideChar = (wchar_t*)onmalloc((sWideChar_count + 1) * sizeof(swappedWideChar[0])); + for (int i = 0; i < sWideChar_count; ++i) + swappedWideChar[i] = ON_wString::SwapByteOrder(sWideChar[i]); + swappedWideChar[sWideChar_count] = 0; + if (0 == ON_wString::ByteOrder(swappedWideChar[0])) + { + // The 0 == ON_wString::ByteOrder(swappedWideChar[0]) condition insures we will not recurse again. + const int rc = ON_ConvertWideCharToMSMBCP(swappedWideChar, sWideChar_count, windows_code_page, sMBCS, sMBCS_capacity, error_status); + onfree(swappedWideChar); + return rc; + } + else + { + // A modification to this code made after May 2021 introduced a bug. + // Depending on the bug and the string length, a possible stack overflow recursion crash was prevented by this check. + ON_ERROR("A bug was added after May 2021."); + onfree(swappedWideChar); + } + } + } + + if (0 == sWideChar_count) + { + return 0; + } + + if (sMBCS_capacity <= 0) + { + sMBCS_capacity = 0; + sMBCS = nullptr; + } + else if (nullptr == sMBCS) + { + sMBCS_capacity = 0; + } + + // ASCII check + const wchar_t* w = sWideChar; + const wchar_t* w1 = w + sWideChar_count; + char* c = sMBCS; + char* c1 = c + sMBCS_capacity; + while (w < w1 && *w >= 0 && *w <= 127) + { + if (nullptr != c) + { + if (c >= c1) + break; + *c++ = (char)*w; + } + c++; + } + if (w == w1) + { + if (c < c1) + *c = 0; + return sWideChar_count; + } + + // UTF wide char to UTF-8 - use opennurbs converter + const int utf8_code_page = 65001; // UTF-8 + if (utf8_code_page == windows_code_page) + { + const unsigned int error_mask = 0xFFFFFFFFU; + return ON_ConvertWideCharToUTF8(false, sWideChar, sWideChar_count, sMBCS, sMBCS_capacity, error_status, error_mask, ON_UnicodeCodePoint::ON_ReplacementCharacter, nullptr); + } + +#if defined(ON_RUNTIME_WIN) + // Starting with Windows Vista, the function does not drop illegal code points when dwFlags=0. + // It replaces illegal sequences with U+FFFD (encoded as appropriate for the specified codepage). + const char default_char = '?'; + BOOL bUsedDefaultChar = 0; + + const char* pdefault_char = nullptr; + BOOL* pbUsedDefaultChar = nullptr; + DWORD dwFlags = 0; + + switch (windows_code_page) + { + case 42: // Symbol + case 50220: + case 50221: + case 50222: + case 50225: + case 50227: + case 50229: + case 57002: + case 57003: + case 57004: + case 57005: + case 57006: + case 57007: + case 57008: + case 57009: + case 57010: + case 57011: + case 65000: // UTF-7 + // For these code pages listed below, dwFlags must be 0. Otherwise, WideCharToMultiByte() fails with ERROR_INVALID_FLAGS. + break; + + case 54936: // GB18030 + case 65001: // UTF-8 + // dwFlags must be set to either 0 or WC_ERR_INVALID_CHARS. Otherwise, the function fails with ERROR_INVALID_FLAGS. + break; + + default: + pdefault_char = &default_char; + pbUsedDefaultChar = &bUsedDefaultChar; + dwFlags |= WC_NO_BEST_FIT_CHARS; + dwFlags |= WC_COMPOSITECHECK; + dwFlags |= WC_DEFAULTCHAR; + break; + } + + int sMBCS_count = ::WideCharToMultiByte(windows_code_page, dwFlags, sWideChar, sWideChar_count, sMBCS, sMBCS_capacity, pdefault_char, pbUsedDefaultChar); + if (sMBCS_count < 0) + sMBCS_count = 0; + + if (nullptr == sMBCS) + return sMBCS_count; + + for (int i = 0; i < sMBCS_count; i++) + { + if (0 == sMBCS[i]) + { + sMBCS_count = i; + break; + } + } + if (bUsedDefaultChar) + { + if (nullptr != error_status) + *error_status |= 16; + } + + if (sMBCS_count < sMBCS_capacity) + sMBCS[sMBCS_count] = 0; + return sMBCS_count; + +#elif defined (ON_RUNTIME_APPLE_OBJECTIVE_C_AVAILABLE) + // Add support for other platforms as needed. + ON_ERROR("Time to figure out how to create Windows code page encodings in MacOS"); + return 0; +#else + // Add support for other platforms as needed. + return 0; +#endif +} + +const ON_String ON_wString::MultiByteEncode(int windows_code_page) const +{ + unsigned int error_status0 = 0; + const int sChar_count0 = ON_ConvertWideCharToMSMBCP( + this->Array(), + this->Length(), + windows_code_page, + nullptr, // wchar_t* sWideChar, + 0, //int sWideChar_capacity, + &error_status0 + ); + if (sChar_count0 <= 0) + return ON_String::EmptyString; + + ON_String s; + s.ReserveArray(((size_t)sChar_count0) + 1); + unsigned int error_status1 = 0; + const int sChar_count1 = ON_ConvertWideCharToMSMBCP( + this->Array(), + this->Length(), + windows_code_page, + s.Array(), + sChar_count0 + 1, + &error_status1 + ); + if (sChar_count1 <= 0) + return ON_String::EmptyString; + + s.SetLength(sChar_count1); + return s; +} + +const ON_wString ON_String::MultiByteDecode(int windows_code_page) const +{ + unsigned int error_status0 = 0; + const int sWideChar_count0 = ON_ConvertMSMBCPToWideChar( + windows_code_page, + this->Array(), + this->Length(), + nullptr, // wchar_t* sWideChar, + 0, //int sWideChar_capacity, + &error_status0 + ); + if (sWideChar_count0 <= 0) + return ON_wString::EmptyString; + + ON_wString s; + s.ReserveArray(((size_t)sWideChar_count0) + 1); + unsigned int error_status1 = 0; + const int sWideChar_count1 = ON_ConvertMSMBCPToWideChar( + windows_code_page, + this->Array(), + this->Length(), + s.Array(), + sWideChar_count0+1, + &error_status1 + ); + if (sWideChar_count1 <= 0) + return ON_wString::EmptyString; + + s.SetLength(sWideChar_count1); + return s; +} unsigned ON_UnicodeSuperscriptFromCodePoint( @@ -3286,3 +3656,14429 @@ unsigned ON_UnicodeSubcriptFromCodePoint( return cp; } +const char* ON_Big5CodePoint::Decode( + const char* buffer, + size_t buffer_count, + bool bParseNull, + bool bParseASCII, + ON_Big5CodePoint* big5_code_point +) +{ + ON_Big5CodePoint local_cp; + if (nullptr == big5_code_point) + big5_code_point = &local_cp; + for (;;) + { + if (nullptr == buffer) + break; + if (-1 == buffer_count) + buffer_count = 2; // buffer[] is null terminated + if (buffer_count <= 0) + break; + + if (0 == buffer[0]) + { + if (bParseNull) + { + *big5_code_point = ON_Big5CodePoint::Null; + return buffer + 1; + } + break; + } + + if (buffer[0] > 0 && buffer[0] <= 0x7F) + { + if (bParseASCII) + { + *big5_code_point = ON_Big5CodePoint::Create((ON__UINT16)buffer[0]); + return buffer + 1; + } + break; + } + + if (buffer_count < 2) + break; + const ON__UINT16 db[2] = { ((const unsigned char*)buffer)[0], ((const unsigned char*)buffer)[1] }; + if ( + (db[0] >= 0x81 && db[0] <= 0xFE) + && + ((db[1] >= 0x40 && db[1] <= 0x7E) || (db[1] >= 0xA1 && db[1] <= 0xFE)) + ) + { + // valid BIG5 double double byte encoding. + *big5_code_point = ON_Big5CodePoint::Create(db[0] * 0x100 + db[1]); + return buffer + 2; + } + + break; + } + + *big5_code_point = ON_Big5CodePoint::Error; + return nullptr; +} + +int ON_Big5CodePoint::Encode( + char* buffer, + size_t buffer_capacity +) const +{ + if (nullptr == buffer || buffer_capacity <= 0) + return 0; + + if (IsValid(true, true)) + { + if (m_big5_code_point <= 0x7F) + { + buffer[0] = (char)m_big5_code_point; + if (buffer_capacity > 1) + buffer[1] = 0; + return 1; + } + + if (buffer_capacity < 2) + return 0; + + const unsigned db[2] = { m_big5_code_point / 0x100U, m_big5_code_point % 0x100U }; + if ( + (db[0] >= 0x81 && db[0] <= 0xFE) + && + ((db[1] >= 0x40 && db[1] <= 0x7E) || (db[1] >= 0xA1 && db[1] <= 0xFE)) + ) + { + ((unsigned char*)buffer)[0] = (unsigned char)(db[0]); + ((unsigned char*)buffer)[1] = (unsigned char)(db[1]); + if (buffer_capacity > 2) + buffer[2] = 0; + return 2; + } + + ON_ERROR("Bug in tis if() scope."); + } + + return 0; + +} + +const ON_Big5CodePoint ON_Big5CodePoint::Create(unsigned int big5_code_point) +{ + if (big5_code_point > 0xFFFF) + return ON_Big5CodePoint::Error; + ON_Big5CodePoint cp; + cp.m_big5_code_point = (big5_code_point <= 0xFFFF) ? ((ON__UINT16)big5_code_point) : ((ON__UINT16)0xFFFF); + return (cp.IsValid(true, true) || 0xFFFF==cp.m_big5_code_point) ? cp : ON_Big5CodePoint::Error; +} + +bool ON_Big5CodePoint::IsNull() const +{ + return 0 == m_big5_code_point; +} + +bool ON_Big5CodePoint::IsASCII(bool bNullIsASCII) const +{ + if (0 == m_big5_code_point) + return bNullIsASCII ? true : false; + return (m_big5_code_point > 0 && m_big5_code_point <= 0x007F); +} + +bool ON_Big5CodePoint::IsValid(bool bNullIsValid, bool bASCIICodePointIsValid) const +{ + if (0 == m_big5_code_point) + return bNullIsValid ? true : false; + + if (m_big5_code_point <= 0x007F) + return bASCIICodePointIsValid ? true : false; + + if (m_big5_code_point >= 0xA3C0 && m_big5_code_point <= 0xA3FE) + { + // Some older versions of Windows use the reserved BIG5 code point 0xA3E1 for the EURO CURRENCY SYMBOL + // The primary use of ON_Big5CodePoint is to convert legacy BIG5 encoded information + // into Unicode encoded information and ON_Big5CodePoint supports this legacy Windows mapping. + if (0xA3E1 != m_big5_code_point) + return false; // reserved for future use + } + + const ON__UINT16 db[2] = { (ON__UINT16)(m_big5_code_point / 0x100U), (ON__UINT16)(m_big5_code_point % 0x100U) }; + return + (db[0] >= 0x81U && db[0] <= 0xFEU) + && + ((db[1] >= 0x40U && db[1] <= 0x7EU) || (db[1] >= 0xA1U && db[1] <= 0xFEU)) + ; +} + +bool ON_Big5CodePoint::IsStandard(bool bNullIsValid, bool bASCIICodePointIsValid) const +{ + if (IsValid(bNullIsValid, bASCIICodePointIsValid)) + { + // 0xa140 to 0xa3bf + if (m_big5_code_point < 0xA140) + return false; + if (m_big5_code_point <= 0xA3BF) + return true; + + // 0xa3c0 to 0xa3fe - reserved - not user defined and not standard + if (0xA3E1 == m_big5_code_point) + return true; // Old Windows Euro currency symbol + + // 0xa440 to 0xc67e + if (m_big5_code_point < 0xA440) + return false; + if (m_big5_code_point <= 0xC67E) + return true; + + // 0xc940 to 0xf9d5 + if (m_big5_code_point < 0xC940) + return false; + if (m_big5_code_point <= 0xF9D5) + return true; + } + + return false; +} + + +bool ON_Big5CodePoint::IsPrivateUse() const +{ + if (IsValid(false,false)) + { + // 0x8140 to 0xa0fe + if (m_big5_code_point < 0x8140) + return false; + if (m_big5_code_point < 0xA140) + return true; + + // 0xc6a1 to 0xc8fe + if (m_big5_code_point < 0xC6A1) + return false; + if (m_big5_code_point <= 0xC8FE) + return true; + + // 0xf9d6 to 0xfefe + if (m_big5_code_point < 0xF9D6) + return false; + if (m_big5_code_point <= 0xFEFE) + return true; + } + + return false; +} + +unsigned int ON_Big5CodePoint::Big5CodePoint() const +{ + return m_big5_code_point; +} + +int ON_Big5CodePoint::Compare(const ON_Big5CodePoint* lhs, const ON_Big5CodePoint* rhs) +{ + const unsigned lhs_cp = (nullptr != lhs) ? ((unsigned)lhs->m_big5_code_point) : 0xFFFFFFFFU; + const unsigned rhs_cp = (nullptr != rhs) ? ((unsigned)rhs->m_big5_code_point) : 0xFFFFFFFFU; + if (lhs_cp < rhs_cp) + return -1; + if (lhs_cp > rhs_cp) + return 1; + return 0; +}; + +bool operator==(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs) +{ + return 0 == ON_Big5CodePoint::Compare(&lhs, &rhs); +} + +bool operator!=(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs) +{ + return 0 != ON_Big5CodePoint::Compare(&lhs, &rhs); +} + +bool operator<=(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs) +{ + return ON_Big5CodePoint::Compare(&lhs, &rhs) <= 0; +} + +bool operator>=(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs) +{ + return ON_Big5CodePoint::Compare(&lhs, &rhs) >= 0; +} + +bool operator<(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs) +{ + return ON_Big5CodePoint::Compare(&lhs, &rhs) < 0; +} + +bool operator>(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs) +{ + return ON_Big5CodePoint::Compare(&lhs, &rhs) > 0; +} + +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::Create(unsigned int unicode_code_point) +{ + ON_UnicodeShortCodePoint cp; + cp.m_unicode_code_point + = (0xFFFE == unicode_code_point || ON_IsValidUnicodeCodePoint(unicode_code_point)) + ? ((ON__UINT16)unicode_code_point) + : ((ON__UINT16)0xFFFFU) + ; + return cp; +} + +bool ON_UnicodeShortCodePoint::IsNull() const +{ + return 0 == m_unicode_code_point; +} + +bool ON_UnicodeShortCodePoint::IsASCII(bool bNullIsASCII) const +{ + if (0 == m_unicode_code_point) + return bNullIsASCII ? true : false; + + return (m_unicode_code_point > 0 && m_unicode_code_point <= 0x007F); +} + +bool ON_UnicodeShortCodePoint::IsValid(bool bNullIsValid, bool bByteOrderMarkIsValid) const +{ + if (0 == m_unicode_code_point) + return bNullIsValid ? true : false; + + if (0xFFFE == m_unicode_code_point) + return bByteOrderMarkIsValid ? true : false; + + return ON_IsValidUnicodeCodePoint(m_unicode_code_point); +} + +bool ON_UnicodeShortCodePoint::IsStandard(bool bNullIsValid) const +{ + if (IsValid(bNullIsValid,false)) + return ON_IsStandardUnicodeCodePoint(m_unicode_code_point); + + return false; +} + +bool ON_UnicodeShortCodePoint::IsPrivateUse() const +{ + return ON_IsPrivateUseUnicodeCodePoint(m_unicode_code_point); +} + +unsigned int ON_UnicodeShortCodePoint::UnicodeCodePoint() const +{ + return m_unicode_code_point; +} + +bool ON_UnicodeShortCodePoint::IsReplacementCharacter() const +{ + return 0xFFFD == m_unicode_code_point; +} + +bool ON_UnicodeShortCodePoint::IsByteOrderMark() const +{ + return 0xFFFE == m_unicode_code_point; +} + + +int ON_UnicodeShortCodePoint::Compare(const ON_UnicodeShortCodePoint* lhs, const ON_UnicodeShortCodePoint* rhs) +{ + const unsigned lhs_cp = (nullptr != lhs) ? ((unsigned)lhs->m_unicode_code_point) : 0xFFFFFFFFU; + const unsigned rhs_cp = (nullptr != rhs) ? ((unsigned)rhs->m_unicode_code_point) : 0xFFFFFFFFU; + if (lhs_cp < rhs_cp) + return -1; + if (lhs_cp > rhs_cp) + return 1; + return 0; +}; + +bool operator==(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs) +{ + return 0 == ON_UnicodeShortCodePoint::Compare(&lhs, &rhs); +} + +bool operator!=(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs) +{ + return 0 != ON_UnicodeShortCodePoint::Compare(&lhs, &rhs); +} + +bool operator<=(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs) +{ + return ON_UnicodeShortCodePoint::Compare(&lhs, &rhs) <= 0; +} + +bool operator>=(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs) +{ + return ON_UnicodeShortCodePoint::Compare(&lhs, &rhs) >= 0; +} + +bool operator<(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs) +{ + return ON_UnicodeShortCodePoint::Compare(&lhs, &rhs) < 0; +} + +bool operator>(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs) +{ + return ON_UnicodeShortCodePoint::Compare(&lhs, &rhs) > 0; +} + +const ON_Big5UnicodePair ON_Big5UnicodePair::Create( + ON_Big5CodePoint big5_code_point, + ON_UnicodeShortCodePoint unicode_code_point +) +{ + ON_Big5UnicodePair p; + p.m_big5 = big5_code_point; + p.m_unicode = unicode_code_point; + return p; +} + +const ON_Big5UnicodePair ON_Big5UnicodePair::Create( + unsigned int big5_code_point, + unsigned int unicode_code_point +) +{ + return ON_Big5UnicodePair::Create(ON_Big5CodePoint::Create(big5_code_point), ON_UnicodeShortCodePoint::Create(unicode_code_point)); +} + + +bool ON_Big5UnicodePair::IsNull() const +{ + return m_big5.IsNull() && m_unicode.IsNull(); +} + +bool ON_Big5UnicodePair::IsASCII(bool bNullIsASCII) const +{ + return m_big5.IsASCII(bNullIsASCII) && m_big5.Big5CodePoint() == m_unicode.UnicodeCodePoint(); +} + +bool ON_Big5UnicodePair::IsValid(bool bNullIsValid, bool bASCIICodePointIsValid) const +{ + const unsigned big5_code_point = m_big5.Big5CodePoint(); + if (0 == big5_code_point) + return bNullIsValid ? IsNull() : false; + + if (big5_code_point <= 0x7F) + return bASCIICodePointIsValid ? IsASCII(false) : false; + + return m_big5.IsValid(false, false) && m_unicode.IsValid(false,false); +} + +const ON_Big5CodePoint ON_Big5UnicodePair::Big5() const +{ + return m_big5; +} + +const ON_UnicodeShortCodePoint ON_Big5UnicodePair::Unicode() const +{ + return m_unicode; +} + +unsigned int ON_Big5UnicodePair::Big5CodePoint() const +{ + return m_big5.Big5CodePoint(); +} + +unsigned int ON_Big5UnicodePair::UnicodeCodePoint() const +{ + return m_unicode.UnicodeCodePoint(); +} + +bool ON_Big5UnicodePair::IsStandard(bool bNullIsValid, bool bASCIICodePointIsStandard) const +{ + const unsigned big5_code_point = m_big5.Big5CodePoint(); + if (0 == big5_code_point) + return bNullIsValid ? IsNull() : false; + + if (big5_code_point <= 0x7F) + return bASCIICodePointIsStandard ? IsASCII(false) : false; + + return m_big5.IsStandard(false, false) && m_unicode.IsStandard(false); +} + +bool ON_Big5UnicodePair::IsPrivateUse() const +{ + return IsValid(false, false) && (m_big5.IsPrivateUse() || m_unicode.IsPrivateUse()); +} + + +int ON_Big5UnicodePair::CompareBig5CodePoint(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs) +{ + const unsigned lhs_cp = (nullptr != lhs) ? lhs->Big5CodePoint() : 0xFFFFFFFFU; + const unsigned rhs_cp = (nullptr != rhs) ? rhs->Big5CodePoint() : 0xFFFFFFFFU; + if (lhs_cp < rhs_cp) + return -1; + if (lhs_cp > rhs_cp) + return 1; + return 0; +} + +int ON_Big5UnicodePair::CompareUnicodeCodePoint(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs) +{ + const unsigned lhs_cp = (nullptr != lhs) ? lhs->UnicodeCodePoint() : 0xFFFFFFFFU; + const unsigned rhs_cp = (nullptr != rhs) ? rhs->UnicodeCodePoint() : 0xFFFFFFFFU; + if (lhs_cp < rhs_cp) + return -1; + if (lhs_cp > rhs_cp) + return 1; + return 0; +} + +int ON_Big5UnicodePair::CompareBig5AndUnicodeCodePoints(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs) +{ + int rc = ON_Big5UnicodePair::CompareBig5CodePoint(lhs, rhs); + if (0 == rc) + rc = ON_Big5UnicodePair::CompareUnicodeCodePoint(lhs, rhs); + return rc; +} + +int ON_Big5UnicodePair::CompareUnicodeAndBig5CodePoints(const ON_Big5UnicodePair* lhs, const ON_Big5UnicodePair* rhs) +{ + int rc = ON_Big5UnicodePair::CompareUnicodeCodePoint(lhs, rhs); + if (0 == rc) + rc = ON_Big5UnicodePair::CompareBig5CodePoint(lhs, rhs); + return rc; +} + +bool operator==(ON_Big5UnicodePair lhs, ON_Big5UnicodePair rhs) +{ + return 0 == ON_Big5UnicodePair::CompareBig5AndUnicodeCodePoints(&lhs, &rhs); +} + +bool operator!=(ON_Big5UnicodePair lhs, ON_Big5UnicodePair rhs) +{ + return 0 != ON_Big5UnicodePair::CompareBig5AndUnicodeCodePoints(&lhs, &rhs); +} + +const ON_Big5CodePoint ON_Big5CodePoint::CreateFromUnicode( + unsigned int unicode_code_point, + ON_Big5CodePoint not_avilable +) +{ + if (unicode_code_point > 0xFFFF) + return ON_IsValidUnicodeCodePoint(unicode_code_point) ? not_avilable : ON_Big5CodePoint::Error; + + return ON_Big5CodePoint::CreateFromUnicode(ON_UnicodeShortCodePoint::Create(unicode_code_point), not_avilable); +} + +const ON_Big5CodePoint ON_Big5CodePoint::CreateFromUnicode( + const ON_UnicodeShortCodePoint& unicode_code_point, + ON_Big5CodePoint not_avilable +) +{ + if (unicode_code_point.IsASCII(true)) + return ON_Big5CodePoint::Create(unicode_code_point.UnicodeCodePoint()); // ASCII code point + + if (false == unicode_code_point.IsValid(false, false)) + return ON_Big5CodePoint::Error; + + const ON_SimpleArray& unicode_to_big5 = ON_Big5UnicodePair::UnicodeToBig5(); + + const ON_Big5UnicodePair key = ON_Big5UnicodePair::Create(ON_Big5CodePoint::Null, unicode_code_point); + const int i = unicode_to_big5.BinarySearch(&key, ON_Big5UnicodePair::CompareUnicodeCodePoint); + if (i >= 0) + { + const ON_Big5UnicodePair pair = unicode_to_big5[i]; + if (unicode_code_point == pair.Unicode() && pair.IsValid(false, false)) + return pair.Big5(); + } + + // No BIG5 code point available for this Unicode code point. + return not_avilable; +} + +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::CreateFromBig5( + unsigned int big5_code_point, + ON_UnicodeShortCodePoint not_avilable +) +{ + return ON_UnicodeShortCodePoint::CreateFromBig5(ON_Big5CodePoint::Create(big5_code_point), not_avilable); +} + +const ON_UnicodeShortCodePoint ON_UnicodeShortCodePoint::CreateFromBig5( + const ON_Big5CodePoint& big5_code_point, + ON_UnicodeShortCodePoint not_avilable +) +{ + if (big5_code_point.IsASCII(true)) + return ON_UnicodeShortCodePoint::Create(big5_code_point.Big5CodePoint()); // ASCII code point + + if (false == big5_code_point.IsValid(false, false)) + return ON_UnicodeShortCodePoint::Error; + + const ON_SimpleArray& big5_to_unicode = ON_Big5UnicodePair::Big5ToUnicode(); + + const ON_Big5UnicodePair key = ON_Big5UnicodePair::Create(big5_code_point, ON_UnicodeShortCodePoint::Null); + const int i = big5_to_unicode.BinarySearch(&key, ON_Big5UnicodePair::CompareBig5CodePoint); + if (i >= 0) + { + const ON_Big5UnicodePair pair = big5_to_unicode[i]; + if (big5_code_point == pair.Big5() && pair.IsValid(false, false)) + return pair.Unicode(); + } + + // No Unicode code point available for this BIG5 code point. + return not_avilable; +} + +//////////////////////// + +const ON_SimpleArray< ON_Big5UnicodePair >& ON_Big5UnicodePair::Big5ToUnicode() +{ + // The pair[][2] array was created by combining information from + // http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT, retrieved: May 17, 2021, + // and WIndows 10 MultiByteToWideChar() using code page 950. + // + // pairs[][2] = {...{BIG5 code point, Unicode code point}...} + // sorted by BIG5 code point. All Unicode code points must be valid and < 0xFFFF. + // + // The primary use of this code is to convert legacy BIG5 encoded information into + // Unicode encoded information and modificiations to the original sources + // (marked with [MODyyymmdd]) were made to make thos conversions as robust as possible. + // + + static const ON__UINT16 pairs[][2] = { + {0xA140,0x3000}, // IDEOGRAPHIC SPACE + {0xA141,0xff0c}, // FULLWIDTH COMMA + {0xA142,0x3001}, // IDEOGRAPHIC COMMA + {0xA143,0x3002}, // IDEOGRAPHIC FULL STOP + {0xA144,0xff0e}, // FULLWIDTH FULL STOP + {0xA145,0x2027}, // HYPHENATION POINT [MOD20210517] changed from 0x2022 # BULLET + {0xA146,0xff1b}, // FULLWIDTH SEMICOLON + {0xA147,0xff1a}, // FULLWIDTH COLON + {0xA148,0xff1f}, // FULLWIDTH QUESTION MARK + {0xA149,0xff01}, // FULLWIDTH EXCLAMATION MARK + {0xA14A,0xfe30}, // PRESENTATION FORM FOR VERTICAL TWO DOT LEADER + {0xA14B,0x2026}, // HORIZONTAL ELLIPSIS + {0xA14C,0x2025}, // TWO DOT LEADER + {0xA14D,0xfe50}, // SMALL COMMA + {0xA14E,0xfe51}, // SMALL IDEOGRAPHIC COMMA [MOD20210517] changed from 0xFF64 # HALFWIDTH IDEOGRAPHIC COMMA + {0xA14F,0xfe52}, // SMALL FULL STOP + {0xA150,0x00b7}, // MIDDLE DOT + {0xA151,0xfe54}, // SMALL SEMICOLON + {0xA152,0xfe55}, // SMALL COLON + {0xA153,0xfe56}, // SMALL QUESTION MARK + {0xA154,0xfe57}, // SMALL EXCLAMATION MARK + {0xA155,0xff5c}, // FULLWIDTH VERTICAL BAR + {0xA156,0x2013}, // EN DASH + {0xA157,0xfe31}, // PRESENTATION FORM FOR VERTICAL EM DASH + {0xA158,0x2014}, // EM DASH + {0xA159,0xfe33}, // PRESENTATION FORM FOR VERTICAL LOW LINE + {0xA15A,0x2574}, // BOX DRAWINGS LIGHT LEFT [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA15B,0xfe34}, // PRESENTATION FORM FOR VERTICAL WAVY LOW LINE + {0xA15C,0xfe4f}, // WAVY LOW LINE + {0xA15D,0xff08}, // FULLWIDTH LEFT PARENTHESIS + {0xA15E,0xff09}, // FULLWIDTH RIGHT PARENTHESIS + {0xA15F,0xfe35}, // PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS + {0xA160,0xfe36}, // PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS + {0xA161,0xff5b}, // FULLWIDTH LEFT CURLY BRACKET + {0xA162,0xff5d}, // FULLWIDTH RIGHT CURLY BRACKET + {0xA163,0xfe37}, // PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET + {0xA164,0xfe38}, // PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET + {0xA165,0x3014}, // LEFT TORTOISE SHELL BRACKET + {0xA166,0x3015}, // RIGHT TORTOISE SHELL BRACKET + {0xA167,0xfe39}, // PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET + {0xA168,0xfe3a}, // PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET + {0xA169,0x3010}, // LEFT BLACK LENTICULAR BRACKET + {0xA16A,0x3011}, // RIGHT BLACK LENTICULAR BRACKET + {0xA16B,0xfe3b}, // PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET + {0xA16C,0xfe3c}, // PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET + {0xA16D,0x300a}, // LEFT DOUBLE ANGLE BRACKET + {0xA16E,0x300b}, // RIGHT DOUBLE ANGLE BRACKET + {0xA16F,0xfe3d}, // PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET + {0xA170,0xfe3e}, // PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET + {0xA171,0x3008}, // LEFT ANGLE BRACKET + {0xA172,0x3009}, // RIGHT ANGLE BRACKET + {0xA173,0xfe3f}, // PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET + {0xA174,0xfe40}, // PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET + {0xA175,0x300c}, // LEFT CORNER BRACKET + {0xA176,0x300d}, // RIGHT CORNER BRACKET + {0xA177,0xfe41}, // PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET + {0xA178,0xfe42}, // PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET + {0xA179,0x300e}, // LEFT WHITE CORNER BRACKET + {0xA17A,0x300f}, // RIGHT WHITE CORNER BRACKET + {0xA17B,0xfe43}, // PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET + {0xA17C,0xfe44}, // PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET + {0xA17D,0xfe59}, // SMALL LEFT PARENTHESIS + {0xA17E,0xfe5a}, // SMALL RIGHT PARENTHESIS + {0xA1A1,0xfe5b}, // SMALL LEFT CURLY BRACKET + {0xA1A2,0xfe5c}, // SMALL RIGHT CURLY BRACKET + {0xA1A3,0xfe5d}, // SMALL LEFT TORTOISE SHELL BRACKET + {0xA1A4,0xfe5e}, // SMALL RIGHT TORTOISE SHELL BRACKET + {0xA1A5,0x2018}, // LEFT SINGLE QUOTATION MARK + {0xA1A6,0x2019}, // RIGHT SINGLE QUOTATION MARK + {0xA1A7,0x201c}, // LEFT DOUBLE QUOTATION MARK + {0xA1A8,0x201d}, // RIGHT DOUBLE QUOTATION MARK + {0xA1A9,0x301d}, // REVERSED DOUBLE PRIME QUOTATION MARK + {0xA1AA,0x301e}, // DOUBLE PRIME QUOTATION MARK + {0xA1AB,0x2035}, // REVERSED PRIME + {0xA1AC,0x2032}, // PRIME + {0xA1AD,0xff03}, // FULLWIDTH NUMBER SIGN + {0xA1AE,0xff06}, // FULLWIDTH AMPERSAND + {0xA1AF,0xff0a}, // FULLWIDTH ASTERISK + {0xA1B0,0x203b}, // REFERENCE MARK + {0xA1B1,0x00a7}, // SECTION SIGN + {0xA1B2,0x3003}, // DITTO MARK + {0xA1B3,0x25cb}, // WHITE CIRCLE + {0xA1B4,0x25cf}, // BLACK CIRCLE + {0xA1B5,0x25b3}, // WHITE UP-POINTING TRIANGLE + {0xA1B6,0x25b2}, // BLACK UP-POINTING TRIANGLE + {0xA1B7,0x25ce}, // BULLSEYE + {0xA1B8,0x2606}, // WHITE STAR + {0xA1B9,0x2605}, // BLACK STAR + {0xA1BA,0x25c7}, // WHITE DIAMOND + {0xA1BB,0x25c6}, // BLACK DIAMOND + {0xA1BC,0x25a1}, // WHITE SQUARE + {0xA1BD,0x25a0}, // BLACK SQUARE + {0xA1BE,0x25bd}, // WHITE DOWN-POINTING TRIANGLE + {0xA1BF,0x25bc}, // BLACK DOWN-POINTING TRIANGLE + {0xA1C0,0x32a3}, // CIRCLED IDEOGRAPH CORRECT + {0xA1C1,0x2105}, // CARE OF + {0xA1C2,0x00af}, // MACRON [MOD20210517] changed from 0x203E # OVERLINE + {0xA1C3,0xffe3}, // FULLWIDTH MACRON [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA1C4,0xff3f}, // FULLWIDTH LOW LINE + {0xA1C5,0x02cd}, // MODIFIER LETTER LOW MACRON [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA1C6,0xfe49}, // DASHED OVERLINE + {0xA1C7,0xfe4a}, // CENTRELINE OVERLINE + {0xA1C8,0xfe4d}, // DASHED LOW LINE + {0xA1C9,0xfe4e}, // CENTRELINE LOW LINE + {0xA1CA,0xfe4b}, // WAVY OVERLINE + {0xA1CB,0xfe4c}, // DOUBLE WAVY OVERLINE + {0xA1CC,0xfe5f}, // SMALL NUMBER SIGN + {0xA1CD,0xfe60}, // SMALL AMPERSAND + {0xA1CE,0xfe61}, // SMALL ASTERISK + {0xA1CF,0xff0b}, // FULLWIDTH PLUS SIGN + {0xA1D0,0xff0d}, // FULLWIDTH HYPHEN-MINUS + {0xA1D1,0x00d7}, // MULTIPLICATION SIGN + {0xA1D2,0x00f7}, // DIVISION SIGN + {0xA1D3,0x00b1}, // PLUS-MINUS SIGN + {0xA1D4,0x221a}, // SQUARE ROOT + {0xA1D5,0xff1c}, // FULLWIDTH LESS-THAN SIGN + {0xA1D6,0xff1e}, // FULLWIDTH GREATER-THAN SIGN + {0xA1D7,0xff1d}, // FULLWIDTH EQUALS SIGN + {0xA1D8,0x2266}, // LESS THAN OVER EQUAL TO + {0xA1D9,0x2267}, // GREATER THAN OVER EQUAL TO + {0xA1DA,0x2260}, // NOT EQUAL TO + {0xA1DB,0x221e}, // INFINITY + {0xA1DC,0x2252}, // APPROXIMATELY EQUAL TO OR THE IMAGE OF + {0xA1DD,0x2261}, // IDENTICAL TO + {0xA1DE,0xfe62}, // SMALL PLUS SIGN + {0xA1DF,0xfe63}, // SMALL HYPHEN-MINUS + {0xA1E0,0xfe64}, // SMALL LESS-THAN SIGN + {0xA1E1,0xfe65}, // SMALL GREATER-THAN SIGN + {0xA1E2,0xfe66}, // SMALL EQUALS SIGN + {0xA1E3,0xff5e}, // YI SYLLABLE GAP [MOD20210517] changed from 0x223C # TILDE OPERATOR + {0xA1E4,0x2229}, // INTERSECTION + {0xA1E5,0x222a}, // UNION + {0xA1E6,0x22a5}, // UP TACK + {0xA1E7,0x2220}, // ANGLE + {0xA1E8,0x221f}, // RIGHT ANGLE + {0xA1E9,0x22bf}, // RIGHT TRIANGLE + {0xA1EA,0x33d2}, // SQUARE LOG + {0xA1EB,0x33d1}, // SQUARE LN + {0xA1EC,0x222b}, // INTEGRAL + {0xA1ED,0x222e}, // CONTOUR INTEGRAL + {0xA1EE,0x2235}, // BECAUSE + {0xA1EF,0x2234}, // THEREFORE + {0xA1F0,0x2640}, // FEMALE SIGN + {0xA1F1,0x2642}, // MALE SIGN + {0xA1F2,0x2295}, // CIRCLED PLUS [MOD20210517] changed from 0x2641 # EARTH + {0xA1F3,0x2299}, // CIRCLED DOT OPERATOR [MOD20210517] changed from 0x2609 # SUN + {0xA1F4,0x2191}, // UPWARDS ARROW + {0xA1F5,0x2193}, // DOWNWARDS ARROW + {0xA1F6,0x2190}, // LEFTWARDS ARROW + {0xA1F7,0x2192}, // RIGHTWARDS ARROW + {0xA1F8,0x2196}, // NORTH WEST ARROW + {0xA1F9,0x2197}, // NORTH EAST ARROW + {0xA1FA,0x2199}, // SOUTH WEST ARROW + {0xA1FB,0x2198}, // SOUTH EAST ARROW + {0xA1FC,0x2225}, // PARALLEL TO + {0xA1FD,0x2223}, // DIVIDES + {0xA1FE,0xff0f}, // FULLWIDTH SOLIDUS [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA240,0xff3c}, // FULLWIDTH REVERSE SOLIDUS [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA241,0x2215}, // DIVISION SLASH [MOD20210517] changed from 0xFF0F # FULLWIDTH SOLIDUS + {0xA242,0xfe68}, // SMALL REVERSE SOLIDUS [MOD20210517] changed from 0xFF3C # FULLWIDTH REVERSE SOLIDUS + {0xA243,0xff04}, // FULLWIDTH DOLLAR SIGN + {0xA244,0xffe5}, // FULLWIDTH YEN SIGN [MOD20210517] changed from 0x00A5 # YEN SIGN + {0xA245,0x3012}, // POSTAL MARK + {0xA246,0xffe0}, // FULLWIDTH CENT SIGN [MOD20210517] changed from 0x00A2 # CENT SIGN + {0xA247,0xffe1}, // FULLWIDTH POUND SIGN [MOD20210517] changed from 0x00A3 # POUND SIGN + {0xA248,0xff05}, // FULLWIDTH PERCENT SIGN + {0xA249,0xff20}, // FULLWIDTH COMMERCIAL AT + {0xA24A,0x2103}, // DEGREE CELSIUS + {0xA24B,0x2109}, // DEGREE FAHRENHEIT + {0xA24C,0xfe69}, // SMALL DOLLAR SIGN + {0xA24D,0xfe6a}, // SMALL PERCENT SIGN + {0xA24E,0xfe6b}, // SMALL COMMERCIAL AT + {0xA24F,0x33d5}, // SQUARE MIL + {0xA250,0x339c}, // SQUARE MM + {0xA251,0x339d}, // SQUARE CM + {0xA252,0x339e}, // SQUARE KM + {0xA253,0x33ce}, // SQUARE KM CAPITAL + {0xA254,0x33a1}, // SQUARE M SQUARED + {0xA255,0x338e}, // SQUARE MG + {0xA256,0x338f}, // SQUARE KG + {0xA257,0x33c4}, // SQUARE CC + {0xA258,0x00b0}, // DEGREE SIGN + {0xA259,0x5159}, // + {0xA25A,0x515b}, // + {0xA25B,0x515e}, // + {0xA25C,0x515d}, // + {0xA25D,0x5161}, // + {0xA25E,0x5163}, // + {0xA25F,0x55e7}, // + {0xA260,0x74e9}, // + {0xA261,0x7cce}, // + {0xA262,0x2581}, // LOWER ONE EIGHTH BLOCK + {0xA263,0x2582}, // LOWER ONE QUARTER BLOCK + {0xA264,0x2583}, // LOWER THREE EIGHTHS BLOCK + {0xA265,0x2584}, // LOWER HALF BLOCK + {0xA266,0x2585}, // LOWER FIVE EIGHTHS BLOCK + {0xA267,0x2586}, // LOWER THREE QUARTERS BLOCK + {0xA268,0x2587}, // LOWER SEVEN EIGHTHS BLOCK + {0xA269,0x2588}, // FULL BLOCK + {0xA26A,0x258f}, // LEFT ONE EIGHTH BLOCK + {0xA26B,0x258e}, // LEFT ONE QUARTER BLOCK + {0xA26C,0x258d}, // LEFT THREE EIGHTHS BLOCK + {0xA26D,0x258c}, // LEFT HALF BLOCK + {0xA26E,0x258b}, // LEFT FIVE EIGHTHS BLOCK + {0xA26F,0x258a}, // LEFT THREE QUARTERS BLOCK + {0xA270,0x2589}, // LEFT SEVEN EIGHTHS BLOCK + {0xA271,0x253c}, // BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL + {0xA272,0x2534}, // BOX DRAWINGS LIGHT UP AND HORIZONTAL + {0xA273,0x252c}, // BOX DRAWINGS LIGHT DOWN AND HORIZONTAL + {0xA274,0x2524}, // BOX DRAWINGS LIGHT VERTICAL AND LEFT + {0xA275,0x251c}, // BOX DRAWINGS LIGHT VERTICAL AND RIGHT + {0xA276,0x2594}, // UPPER ONE EIGHTH BLOCK + {0xA277,0x2500}, // BOX DRAWINGS LIGHT HORIZONTAL + {0xA278,0x2502}, // BOX DRAWINGS LIGHT VERTICAL + {0xA279,0x2595}, // RIGHT ONE EIGHTH BLOCK + {0xA27A,0x250c}, // BOX DRAWINGS LIGHT DOWN AND RIGHT + {0xA27B,0x2510}, // BOX DRAWINGS LIGHT DOWN AND LEFT + {0xA27C,0x2514}, // BOX DRAWINGS LIGHT UP AND RIGHT + {0xA27D,0x2518}, // BOX DRAWINGS LIGHT UP AND LEFT + {0xA27E,0x256d}, // BOX DRAWINGS LIGHT ARC DOWN AND RIGHT + {0xA2A1,0x256e}, // BOX DRAWINGS LIGHT ARC DOWN AND LEFT + {0xA2A2,0x2570}, // BOX DRAWINGS LIGHT ARC UP AND RIGHT + {0xA2A3,0x256f}, // BOX DRAWINGS LIGHT ARC UP AND LEFT + {0xA2A4,0x2550}, // BOX DRAWINGS DOUBLE HORIZONTAL + {0xA2A5,0x255e}, // BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE + {0xA2A6,0x256a}, // BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE + {0xA2A7,0x2561}, // BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE + {0xA2A8,0x25e2}, // BLACK LOWER RIGHT TRIANGLE + {0xA2A9,0x25e3}, // BLACK LOWER LEFT TRIANGLE + {0xA2AA,0x25e5}, // BLACK UPPER RIGHT TRIANGLE + {0xA2AB,0x25e4}, // BLACK UPPER LEFT TRIANGLE + {0xA2AC,0x2571}, // BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT + {0xA2AD,0x2572}, // BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT + {0xA2AE,0x2573}, // BOX DRAWINGS LIGHT DIAGONAL CROSS + {0xA2AF,0xff10}, // FULLWIDTH DIGIT ZERO + {0xA2B0,0xff11}, // FULLWIDTH DIGIT ONE + {0xA2B1,0xff12}, // FULLWIDTH DIGIT TWO + {0xA2B2,0xff13}, // FULLWIDTH DIGIT THREE + {0xA2B3,0xff14}, // FULLWIDTH DIGIT FOUR + {0xA2B4,0xff15}, // FULLWIDTH DIGIT FIVE + {0xA2B5,0xff16}, // FULLWIDTH DIGIT SIX + {0xA2B6,0xff17}, // FULLWIDTH DIGIT SEVEN + {0xA2B7,0xff18}, // FULLWIDTH DIGIT EIGHT + {0xA2B8,0xff19}, // FULLWIDTH DIGIT NINE + {0xA2B9,0x2160}, // ROMAN NUMERAL ONE + {0xA2BA,0x2161}, // ROMAN NUMERAL TWO + {0xA2BB,0x2162}, // ROMAN NUMERAL THREE + {0xA2BC,0x2163}, // ROMAN NUMERAL FOUR + {0xA2BD,0x2164}, // ROMAN NUMERAL FIVE + {0xA2BE,0x2165}, // ROMAN NUMERAL SIX + {0xA2BF,0x2166}, // ROMAN NUMERAL SEVEN + {0xA2C0,0x2167}, // ROMAN NUMERAL EIGHT + {0xA2C1,0x2168}, // ROMAN NUMERAL NINE + {0xA2C2,0x2169}, // ROMAN NUMERAL TEN + {0xA2C3,0x3021}, // HANGZHOU NUMERAL ONE + {0xA2C4,0x3022}, // HANGZHOU NUMERAL TWO + {0xA2C5,0x3023}, // HANGZHOU NUMERAL THREE + {0xA2C6,0x3024}, // HANGZHOU NUMERAL FOUR + {0xA2C7,0x3025}, // HANGZHOU NUMERAL FIVE + {0xA2C8,0x3026}, // HANGZHOU NUMERAL SIX + {0xA2C9,0x3027}, // HANGZHOU NUMERAL SEVEN + {0xA2CA,0x3028}, // HANGZHOU NUMERAL EIGHT + {0xA2CB,0x3029}, // HANGZHOU NUMERAL NINE + {0xA2CC,0x5341}, // [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA2CD,0x5344}, // + {0xA2CE,0x5345}, // [MOD20210517] changed from 0xFFFD # *** NO MAPPING *** + {0xA2CF,0xff21}, // FULLWIDTH LATIN CAPITAL LETTER A + {0xA2D0,0xff22}, // FULLWIDTH LATIN CAPITAL LETTER B + {0xA2D1,0xff23}, // FULLWIDTH LATIN CAPITAL LETTER C + {0xA2D2,0xff24}, // FULLWIDTH LATIN CAPITAL LETTER D + {0xA2D3,0xff25}, // FULLWIDTH LATIN CAPITAL LETTER E + {0xA2D4,0xff26}, // FULLWIDTH LATIN CAPITAL LETTER F + {0xA2D5,0xff27}, // FULLWIDTH LATIN CAPITAL LETTER G + {0xA2D6,0xff28}, // FULLWIDTH LATIN CAPITAL LETTER H + {0xA2D7,0xff29}, // FULLWIDTH LATIN CAPITAL LETTER I + {0xA2D8,0xff2a}, // FULLWIDTH LATIN CAPITAL LETTER J + {0xA2D9,0xff2b}, // FULLWIDTH LATIN CAPITAL LETTER K + {0xA2DA,0xff2c}, // FULLWIDTH LATIN CAPITAL LETTER L + {0xA2DB,0xff2d}, // FULLWIDTH LATIN CAPITAL LETTER M + {0xA2DC,0xff2e}, // FULLWIDTH LATIN CAPITAL LETTER N + {0xA2DD,0xff2f}, // FULLWIDTH LATIN CAPITAL LETTER O + {0xA2DE,0xff30}, // FULLWIDTH LATIN CAPITAL LETTER P + {0xA2DF,0xff31}, // FULLWIDTH LATIN CAPITAL LETTER Q + {0xA2E0,0xff32}, // FULLWIDTH LATIN CAPITAL LETTER R + {0xA2E1,0xff33}, // FULLWIDTH LATIN CAPITAL LETTER S + {0xA2E2,0xff34}, // FULLWIDTH LATIN CAPITAL LETTER T + {0xA2E3,0xff35}, // FULLWIDTH LATIN CAPITAL LETTER U + {0xA2E4,0xff36}, // FULLWIDTH LATIN CAPITAL LETTER V + {0xA2E5,0xff37}, // FULLWIDTH LATIN CAPITAL LETTER W + {0xA2E6,0xff38}, // FULLWIDTH LATIN CAPITAL LETTER X + {0xA2E7,0xff39}, // FULLWIDTH LATIN CAPITAL LETTER Y + {0xA2E8,0xff3a}, // FULLWIDTH LATIN CAPITAL LETTER Z + {0xA2E9,0xff41}, // FULLWIDTH LATIN SMALL LETTER A + {0xA2EA,0xff42}, // FULLWIDTH LATIN SMALL LETTER B + {0xA2EB,0xff43}, // FULLWIDTH LATIN SMALL LETTER C + {0xA2EC,0xff44}, // FULLWIDTH LATIN SMALL LETTER D + {0xA2ED,0xff45}, // FULLWIDTH LATIN SMALL LETTER E + {0xA2EE,0xff46}, // FULLWIDTH LATIN SMALL LETTER F + {0xA2EF,0xff47}, // FULLWIDTH LATIN SMALL LETTER G + {0xA2F0,0xff48}, // FULLWIDTH LATIN SMALL LETTER H + {0xA2F1,0xff49}, // FULLWIDTH LATIN SMALL LETTER I + {0xA2F2,0xff4a}, // FULLWIDTH LATIN SMALL LETTER J + {0xA2F3,0xff4b}, // FULLWIDTH LATIN SMALL LETTER K + {0xA2F4,0xff4c}, // FULLWIDTH LATIN SMALL LETTER L + {0xA2F5,0xff4d}, // FULLWIDTH LATIN SMALL LETTER M + {0xA2F6,0xff4e}, // FULLWIDTH LATIN SMALL LETTER N + {0xA2F7,0xff4f}, // FULLWIDTH LATIN SMALL LETTER O + {0xA2F8,0xff50}, // FULLWIDTH LATIN SMALL LETTER P + {0xA2F9,0xff51}, // FULLWIDTH LATIN SMALL LETTER Q + {0xA2FA,0xff52}, // FULLWIDTH LATIN SMALL LETTER R + {0xA2FB,0xff53}, // FULLWIDTH LATIN SMALL LETTER S + {0xA2FC,0xff54}, // FULLWIDTH LATIN SMALL LETTER T + {0xA2FD,0xff55}, // FULLWIDTH LATIN SMALL LETTER U + {0xA2FE,0xff56}, // FULLWIDTH LATIN SMALL LETTER V + {0xA340,0xff57}, // FULLWIDTH LATIN SMALL LETTER W + {0xA341,0xff58}, // FULLWIDTH LATIN SMALL LETTER X + {0xA342,0xff59}, // FULLWIDTH LATIN SMALL LETTER Y + {0xA343,0xff5a}, // FULLWIDTH LATIN SMALL LETTER Z + {0xA344,0x0391}, // GREEK CAPITAL LETTER ALPHA + {0xA345,0x0392}, // GREEK CAPITAL LETTER BETA + {0xA346,0x0393}, // GREEK CAPITAL LETTER GAMMA + {0xA347,0x0394}, // GREEK CAPITAL LETTER DELTA + {0xA348,0x0395}, // GREEK CAPITAL LETTER EPSILON + {0xA349,0x0396}, // GREEK CAPITAL LETTER ZETA + {0xA34A,0x0397}, // GREEK CAPITAL LETTER ETA + {0xA34B,0x0398}, // GREEK CAPITAL LETTER THETA + {0xA34C,0x0399}, // GREEK CAPITAL LETTER IOTA + {0xA34D,0x039a}, // GREEK CAPITAL LETTER KAPPA + {0xA34E,0x039b}, // GREEK CAPITAL LETTER LAMDA + {0xA34F,0x039c}, // GREEK CAPITAL LETTER MU + {0xA350,0x039d}, // GREEK CAPITAL LETTER NU + {0xA351,0x039e}, // GREEK CAPITAL LETTER XI + {0xA352,0x039f}, // GREEK CAPITAL LETTER OMICRON + {0xA353,0x03a0}, // GREEK CAPITAL LETTER PI + {0xA354,0x03a1}, // GREEK CAPITAL LETTER RHO + {0xA355,0x03a3}, // GREEK CAPITAL LETTER SIGMA + {0xA356,0x03a4}, // GREEK CAPITAL LETTER TAU + {0xA357,0x03a5}, // GREEK CAPITAL LETTER UPSILON + {0xA358,0x03a6}, // GREEK CAPITAL LETTER PHI + {0xA359,0x03a7}, // GREEK CAPITAL LETTER CHI + {0xA35A,0x03a8}, // GREEK CAPITAL LETTER PSI + {0xA35B,0x03a9}, // GREEK CAPITAL LETTER OMEGA + {0xA35C,0x03b1}, // GREEK SMALL LETTER ALPHA + {0xA35D,0x03b2}, // GREEK SMALL LETTER BETA + {0xA35E,0x03b3}, // GREEK SMALL LETTER GAMMA + {0xA35F,0x03b4}, // GREEK SMALL LETTER DELTA + {0xA360,0x03b5}, // GREEK SMALL LETTER EPSILON + {0xA361,0x03b6}, // GREEK SMALL LETTER ZETA + {0xA362,0x03b7}, // GREEK SMALL LETTER ETA + {0xA363,0x03b8}, // GREEK SMALL LETTER THETA + {0xA364,0x03b9}, // GREEK SMALL LETTER IOTA + {0xA365,0x03ba}, // GREEK SMALL LETTER KAPPA + {0xA366,0x03bb}, // GREEK SMALL LETTER LAMDA + {0xA367,0x03bc}, // GREEK SMALL LETTER MU + {0xA368,0x03bd}, // GREEK SMALL LETTER NU + {0xA369,0x03be}, // GREEK SMALL LETTER XI + {0xA36A,0x03bf}, // GREEK SMALL LETTER OMICRON + {0xA36B,0x03c0}, // GREEK SMALL LETTER PI + {0xA36C,0x03c1}, // GREEK SMALL LETTER RHO + {0xA36D,0x03c3}, // GREEK SMALL LETTER SIGMA + {0xA36E,0x03c4}, // GREEK SMALL LETTER TAU + {0xA36F,0x03c5}, // GREEK SMALL LETTER UPSILON + {0xA370,0x03c6}, // GREEK SMALL LETTER PHI + {0xA371,0x03c7}, // GREEK SMALL LETTER CHI + {0xA372,0x03c8}, // GREEK SMALL LETTER PSI + {0xA373,0x03c9}, // GREEK SMALL LETTER OMEGA + {0xA374,0x3105}, // BOPOMOFO LETTER B + {0xA375,0x3106}, // BOPOMOFO LETTER P + {0xA376,0x3107}, // BOPOMOFO LETTER M + {0xA377,0x3108}, // BOPOMOFO LETTER F + {0xA378,0x3109}, // BOPOMOFO LETTER D + {0xA379,0x310a}, // BOPOMOFO LETTER T + {0xA37A,0x310b}, // BOPOMOFO LETTER N + {0xA37B,0x310c}, // BOPOMOFO LETTER L + {0xA37C,0x310d}, // BOPOMOFO LETTER G + {0xA37D,0x310e}, // BOPOMOFO LETTER K + {0xA37E,0x310f}, // BOPOMOFO LETTER H + {0xA3A1,0x3110}, // BOPOMOFO LETTER J + {0xA3A2,0x3111}, // BOPOMOFO LETTER Q + {0xA3A3,0x3112}, // BOPOMOFO LETTER X + {0xA3A4,0x3113}, // BOPOMOFO LETTER ZH + {0xA3A5,0x3114}, // BOPOMOFO LETTER CH + {0xA3A6,0x3115}, // BOPOMOFO LETTER SH + {0xA3A7,0x3116}, // BOPOMOFO LETTER R + {0xA3A8,0x3117}, // BOPOMOFO LETTER Z + {0xA3A9,0x3118}, // BOPOMOFO LETTER C + {0xA3AA,0x3119}, // BOPOMOFO LETTER S + {0xA3AB,0x311a}, // BOPOMOFO LETTER A + {0xA3AC,0x311b}, // BOPOMOFO LETTER O + {0xA3AD,0x311c}, // BOPOMOFO LETTER E + {0xA3AE,0x311d}, // BOPOMOFO LETTER EH + {0xA3AF,0x311e}, // BOPOMOFO LETTER AI + {0xA3B0,0x311f}, // BOPOMOFO LETTER EI + {0xA3B1,0x3120}, // BOPOMOFO LETTER AU + {0xA3B2,0x3121}, // BOPOMOFO LETTER OU + {0xA3B3,0x3122}, // BOPOMOFO LETTER AN + {0xA3B4,0x3123}, // BOPOMOFO LETTER EN + {0xA3B5,0x3124}, // BOPOMOFO LETTER ANG + {0xA3B6,0x3125}, // BOPOMOFO LETTER ENG + {0xA3B7,0x3126}, // BOPOMOFO LETTER ER + {0xA3B8,0x3127}, // BOPOMOFO LETTER I + {0xA3B9,0x3128}, // BOPOMOFO LETTER U + {0xA3BA,0x3129}, // BOPOMOFO LETTER IU + {0xA3BB,0x02d9}, // DOT ABOVE (Mandarin Chinese light tone) + {0xA3BC,0x02c9}, // MODIFIER LETTER MACRON (Mandarin Chinese first tone) + {0xA3BD,0x02ca}, // MODIFIER LETTER ACUTE ACCENT (Mandarin Chinese second tone) + {0xA3BE,0x02c7}, // CARON (Mandarin Chinese third tone) + {0xA3BF,0x02cb}, // MODIFIER LETTER GRAVE ACCENT (Mandarin Chinese fourth tone) + {0xA3E1,0x20ac}, // EURO SIGN [MOD20210517] Old versions of Windows code page 950 addition + {0xA440,0x4e00}, // + {0xA441,0x4e59}, // + {0xA442,0x4e01}, // + {0xA443,0x4e03}, // + {0xA444,0x4e43}, // + {0xA445,0x4e5d}, // + {0xA446,0x4e86}, // + {0xA447,0x4e8c}, // + {0xA448,0x4eba}, // + {0xA449,0x513f}, // + {0xA44A,0x5165}, // + {0xA44B,0x516b}, // + {0xA44C,0x51e0}, // + {0xA44D,0x5200}, // + {0xA44E,0x5201}, // + {0xA44F,0x529b}, // + {0xA450,0x5315}, // + {0xA451,0x5341}, // + {0xA452,0x535c}, // + {0xA453,0x53c8}, // + {0xA454,0x4e09}, // + {0xA455,0x4e0b}, // + {0xA456,0x4e08}, // + {0xA457,0x4e0a}, // + {0xA458,0x4e2b}, // + {0xA459,0x4e38}, // + {0xA45A,0x51e1}, // + {0xA45B,0x4e45}, // + {0xA45C,0x4e48}, // + {0xA45D,0x4e5f}, // + {0xA45E,0x4e5e}, // + {0xA45F,0x4e8e}, // + {0xA460,0x4ea1}, // + {0xA461,0x5140}, // + {0xA462,0x5203}, // + {0xA463,0x52fa}, // + {0xA464,0x5343}, // + {0xA465,0x53c9}, // + {0xA466,0x53e3}, // + {0xA467,0x571f}, // + {0xA468,0x58eb}, // + {0xA469,0x5915}, // + {0xA46A,0x5927}, // + {0xA46B,0x5973}, // + {0xA46C,0x5b50}, // + {0xA46D,0x5b51}, // + {0xA46E,0x5b53}, // + {0xA46F,0x5bf8}, // + {0xA470,0x5c0f}, // + {0xA471,0x5c22}, // + {0xA472,0x5c38}, // + {0xA473,0x5c71}, // + {0xA474,0x5ddd}, // + {0xA475,0x5de5}, // + {0xA476,0x5df1}, // + {0xA477,0x5df2}, // + {0xA478,0x5df3}, // + {0xA479,0x5dfe}, // + {0xA47A,0x5e72}, // + {0xA47B,0x5efe}, // + {0xA47C,0x5f0b}, // + {0xA47D,0x5f13}, // + {0xA47E,0x624d}, // + {0xA4A1,0x4e11}, // + {0xA4A2,0x4e10}, // + {0xA4A3,0x4e0d}, // + {0xA4A4,0x4e2d}, // + {0xA4A5,0x4e30}, // + {0xA4A6,0x4e39}, // + {0xA4A7,0x4e4b}, // + {0xA4A8,0x5c39}, // + {0xA4A9,0x4e88}, // + {0xA4AA,0x4e91}, // + {0xA4AB,0x4e95}, // + {0xA4AC,0x4e92}, // + {0xA4AD,0x4e94}, // + {0xA4AE,0x4ea2}, // + {0xA4AF,0x4ec1}, // + {0xA4B0,0x4ec0}, // + {0xA4B1,0x4ec3}, // + {0xA4B2,0x4ec6}, // + {0xA4B3,0x4ec7}, // + {0xA4B4,0x4ecd}, // + {0xA4B5,0x4eca}, // + {0xA4B6,0x4ecb}, // + {0xA4B7,0x4ec4}, // + {0xA4B8,0x5143}, // + {0xA4B9,0x5141}, // + {0xA4BA,0x5167}, // + {0xA4BB,0x516d}, // + {0xA4BC,0x516e}, // + {0xA4BD,0x516c}, // + {0xA4BE,0x5197}, // + {0xA4BF,0x51f6}, // + {0xA4C0,0x5206}, // + {0xA4C1,0x5207}, // + {0xA4C2,0x5208}, // + {0xA4C3,0x52fb}, // + {0xA4C4,0x52fe}, // + {0xA4C5,0x52ff}, // + {0xA4C6,0x5316}, // + {0xA4C7,0x5339}, // + {0xA4C8,0x5348}, // + {0xA4C9,0x5347}, // + {0xA4CA,0x5345}, // + {0xA4CB,0x535e}, // + {0xA4CC,0x5384}, // + {0xA4CD,0x53cb}, // + {0xA4CE,0x53ca}, // + {0xA4CF,0x53cd}, // + {0xA4D0,0x58ec}, // + {0xA4D1,0x5929}, // + {0xA4D2,0x592b}, // + {0xA4D3,0x592a}, // + {0xA4D4,0x592d}, // + {0xA4D5,0x5b54}, // + {0xA4D6,0x5c11}, // + {0xA4D7,0x5c24}, // + {0xA4D8,0x5c3a}, // + {0xA4D9,0x5c6f}, // + {0xA4DA,0x5df4}, // + {0xA4DB,0x5e7b}, // + {0xA4DC,0x5eff}, // + {0xA4DD,0x5f14}, // + {0xA4DE,0x5f15}, // + {0xA4DF,0x5fc3}, // + {0xA4E0,0x6208}, // + {0xA4E1,0x6236}, // + {0xA4E2,0x624b}, // + {0xA4E3,0x624e}, // + {0xA4E4,0x652f}, // + {0xA4E5,0x6587}, // + {0xA4E6,0x6597}, // + {0xA4E7,0x65a4}, // + {0xA4E8,0x65b9}, // + {0xA4E9,0x65e5}, // + {0xA4EA,0x66f0}, // + {0xA4EB,0x6708}, // + {0xA4EC,0x6728}, // + {0xA4ED,0x6b20}, // + {0xA4EE,0x6b62}, // + {0xA4EF,0x6b79}, // + {0xA4F0,0x6bcb}, // + {0xA4F1,0x6bd4}, // + {0xA4F2,0x6bdb}, // + {0xA4F3,0x6c0f}, // + {0xA4F4,0x6c34}, // + {0xA4F5,0x706b}, // + {0xA4F6,0x722a}, // + {0xA4F7,0x7236}, // + {0xA4F8,0x723b}, // + {0xA4F9,0x7247}, // + {0xA4FA,0x7259}, // + {0xA4FB,0x725b}, // + {0xA4FC,0x72ac}, // + {0xA4FD,0x738b}, // + {0xA4FE,0x4e19}, // + {0xA540,0x4e16}, // + {0xA541,0x4e15}, // + {0xA542,0x4e14}, // + {0xA543,0x4e18}, // + {0xA544,0x4e3b}, // + {0xA545,0x4e4d}, // + {0xA546,0x4e4f}, // + {0xA547,0x4e4e}, // + {0xA548,0x4ee5}, // + {0xA549,0x4ed8}, // + {0xA54A,0x4ed4}, // + {0xA54B,0x4ed5}, // + {0xA54C,0x4ed6}, // + {0xA54D,0x4ed7}, // + {0xA54E,0x4ee3}, // + {0xA54F,0x4ee4}, // + {0xA550,0x4ed9}, // + {0xA551,0x4ede}, // + {0xA552,0x5145}, // + {0xA553,0x5144}, // + {0xA554,0x5189}, // + {0xA555,0x518a}, // + {0xA556,0x51ac}, // + {0xA557,0x51f9}, // + {0xA558,0x51fa}, // + {0xA559,0x51f8}, // + {0xA55A,0x520a}, // + {0xA55B,0x52a0}, // + {0xA55C,0x529f}, // + {0xA55D,0x5305}, // + {0xA55E,0x5306}, // + {0xA55F,0x5317}, // + {0xA560,0x531d}, // + {0xA561,0x4edf}, // + {0xA562,0x534a}, // + {0xA563,0x5349}, // + {0xA564,0x5361}, // + {0xA565,0x5360}, // + {0xA566,0x536f}, // + {0xA567,0x536e}, // + {0xA568,0x53bb}, // + {0xA569,0x53ef}, // + {0xA56A,0x53e4}, // + {0xA56B,0x53f3}, // + {0xA56C,0x53ec}, // + {0xA56D,0x53ee}, // + {0xA56E,0x53e9}, // + {0xA56F,0x53e8}, // + {0xA570,0x53fc}, // + {0xA571,0x53f8}, // + {0xA572,0x53f5}, // + {0xA573,0x53eb}, // + {0xA574,0x53e6}, // + {0xA575,0x53ea}, // + {0xA576,0x53f2}, // + {0xA577,0x53f1}, // + {0xA578,0x53f0}, // + {0xA579,0x53e5}, // + {0xA57A,0x53ed}, // + {0xA57B,0x53fb}, // + {0xA57C,0x56db}, // + {0xA57D,0x56da}, // + {0xA57E,0x5916}, // + {0xA5A1,0x592e}, // + {0xA5A2,0x5931}, // + {0xA5A3,0x5974}, // + {0xA5A4,0x5976}, // + {0xA5A5,0x5b55}, // + {0xA5A6,0x5b83}, // + {0xA5A7,0x5c3c}, // + {0xA5A8,0x5de8}, // + {0xA5A9,0x5de7}, // + {0xA5AA,0x5de6}, // + {0xA5AB,0x5e02}, // + {0xA5AC,0x5e03}, // + {0xA5AD,0x5e73}, // + {0xA5AE,0x5e7c}, // + {0xA5AF,0x5f01}, // + {0xA5B0,0x5f18}, // + {0xA5B1,0x5f17}, // + {0xA5B2,0x5fc5}, // + {0xA5B3,0x620a}, // + {0xA5B4,0x6253}, // + {0xA5B5,0x6254}, // + {0xA5B6,0x6252}, // + {0xA5B7,0x6251}, // + {0xA5B8,0x65a5}, // + {0xA5B9,0x65e6}, // + {0xA5BA,0x672e}, // + {0xA5BB,0x672c}, // + {0xA5BC,0x672a}, // + {0xA5BD,0x672b}, // + {0xA5BE,0x672d}, // + {0xA5BF,0x6b63}, // + {0xA5C0,0x6bcd}, // + {0xA5C1,0x6c11}, // + {0xA5C2,0x6c10}, // + {0xA5C3,0x6c38}, // + {0xA5C4,0x6c41}, // + {0xA5C5,0x6c40}, // + {0xA5C6,0x6c3e}, // + {0xA5C7,0x72af}, // + {0xA5C8,0x7384}, // + {0xA5C9,0x7389}, // + {0xA5CA,0x74dc}, // + {0xA5CB,0x74e6}, // + {0xA5CC,0x7518}, // + {0xA5CD,0x751f}, // + {0xA5CE,0x7528}, // + {0xA5CF,0x7529}, // + {0xA5D0,0x7530}, // + {0xA5D1,0x7531}, // + {0xA5D2,0x7532}, // + {0xA5D3,0x7533}, // + {0xA5D4,0x758b}, // + {0xA5D5,0x767d}, // + {0xA5D6,0x76ae}, // + {0xA5D7,0x76bf}, // + {0xA5D8,0x76ee}, // + {0xA5D9,0x77db}, // + {0xA5DA,0x77e2}, // + {0xA5DB,0x77f3}, // + {0xA5DC,0x793a}, // + {0xA5DD,0x79be}, // + {0xA5DE,0x7a74}, // + {0xA5DF,0x7acb}, // + {0xA5E0,0x4e1e}, // + {0xA5E1,0x4e1f}, // + {0xA5E2,0x4e52}, // + {0xA5E3,0x4e53}, // + {0xA5E4,0x4e69}, // + {0xA5E5,0x4e99}, // + {0xA5E6,0x4ea4}, // + {0xA5E7,0x4ea6}, // + {0xA5E8,0x4ea5}, // + {0xA5E9,0x4eff}, // + {0xA5EA,0x4f09}, // + {0xA5EB,0x4f19}, // + {0xA5EC,0x4f0a}, // + {0xA5ED,0x4f15}, // + {0xA5EE,0x4f0d}, // + {0xA5EF,0x4f10}, // + {0xA5F0,0x4f11}, // + {0xA5F1,0x4f0f}, // + {0xA5F2,0x4ef2}, // + {0xA5F3,0x4ef6}, // + {0xA5F4,0x4efb}, // + {0xA5F5,0x4ef0}, // + {0xA5F6,0x4ef3}, // + {0xA5F7,0x4efd}, // + {0xA5F8,0x4f01}, // + {0xA5F9,0x4f0b}, // + {0xA5FA,0x5149}, // + {0xA5FB,0x5147}, // + {0xA5FC,0x5146}, // + {0xA5FD,0x5148}, // + {0xA5FE,0x5168}, // + {0xA640,0x5171}, // + {0xA641,0x518d}, // + {0xA642,0x51b0}, // + {0xA643,0x5217}, // + {0xA644,0x5211}, // + {0xA645,0x5212}, // + {0xA646,0x520e}, // + {0xA647,0x5216}, // + {0xA648,0x52a3}, // + {0xA649,0x5308}, // + {0xA64A,0x5321}, // + {0xA64B,0x5320}, // + {0xA64C,0x5370}, // + {0xA64D,0x5371}, // + {0xA64E,0x5409}, // + {0xA64F,0x540f}, // + {0xA650,0x540c}, // + {0xA651,0x540a}, // + {0xA652,0x5410}, // + {0xA653,0x5401}, // + {0xA654,0x540b}, // + {0xA655,0x5404}, // + {0xA656,0x5411}, // + {0xA657,0x540d}, // + {0xA658,0x5408}, // + {0xA659,0x5403}, // + {0xA65A,0x540e}, // + {0xA65B,0x5406}, // + {0xA65C,0x5412}, // + {0xA65D,0x56e0}, // + {0xA65E,0x56de}, // + {0xA65F,0x56dd}, // + {0xA660,0x5733}, // + {0xA661,0x5730}, // + {0xA662,0x5728}, // + {0xA663,0x572d}, // + {0xA664,0x572c}, // + {0xA665,0x572f}, // + {0xA666,0x5729}, // + {0xA667,0x5919}, // + {0xA668,0x591a}, // + {0xA669,0x5937}, // + {0xA66A,0x5938}, // + {0xA66B,0x5984}, // + {0xA66C,0x5978}, // + {0xA66D,0x5983}, // + {0xA66E,0x597d}, // + {0xA66F,0x5979}, // + {0xA670,0x5982}, // + {0xA671,0x5981}, // + {0xA672,0x5b57}, // + {0xA673,0x5b58}, // + {0xA674,0x5b87}, // + {0xA675,0x5b88}, // + {0xA676,0x5b85}, // + {0xA677,0x5b89}, // + {0xA678,0x5bfa}, // + {0xA679,0x5c16}, // + {0xA67A,0x5c79}, // + {0xA67B,0x5dde}, // + {0xA67C,0x5e06}, // + {0xA67D,0x5e76}, // + {0xA67E,0x5e74}, // + {0xA6A1,0x5f0f}, // + {0xA6A2,0x5f1b}, // + {0xA6A3,0x5fd9}, // + {0xA6A4,0x5fd6}, // + {0xA6A5,0x620e}, // + {0xA6A6,0x620c}, // + {0xA6A7,0x620d}, // + {0xA6A8,0x6210}, // + {0xA6A9,0x6263}, // + {0xA6AA,0x625b}, // + {0xA6AB,0x6258}, // + {0xA6AC,0x6536}, // + {0xA6AD,0x65e9}, // + {0xA6AE,0x65e8}, // + {0xA6AF,0x65ec}, // + {0xA6B0,0x65ed}, // + {0xA6B1,0x66f2}, // + {0xA6B2,0x66f3}, // + {0xA6B3,0x6709}, // + {0xA6B4,0x673d}, // + {0xA6B5,0x6734}, // + {0xA6B6,0x6731}, // + {0xA6B7,0x6735}, // + {0xA6B8,0x6b21}, // + {0xA6B9,0x6b64}, // + {0xA6BA,0x6b7b}, // + {0xA6BB,0x6c16}, // + {0xA6BC,0x6c5d}, // + {0xA6BD,0x6c57}, // + {0xA6BE,0x6c59}, // + {0xA6BF,0x6c5f}, // + {0xA6C0,0x6c60}, // + {0xA6C1,0x6c50}, // + {0xA6C2,0x6c55}, // + {0xA6C3,0x6c61}, // + {0xA6C4,0x6c5b}, // + {0xA6C5,0x6c4d}, // + {0xA6C6,0x6c4e}, // + {0xA6C7,0x7070}, // + {0xA6C8,0x725f}, // + {0xA6C9,0x725d}, // + {0xA6CA,0x767e}, // + {0xA6CB,0x7af9}, // + {0xA6CC,0x7c73}, // + {0xA6CD,0x7cf8}, // + {0xA6CE,0x7f36}, // + {0xA6CF,0x7f8a}, // + {0xA6D0,0x7fbd}, // + {0xA6D1,0x8001}, // + {0xA6D2,0x8003}, // + {0xA6D3,0x800c}, // + {0xA6D4,0x8012}, // + {0xA6D5,0x8033}, // + {0xA6D6,0x807f}, // + {0xA6D7,0x8089}, // + {0xA6D8,0x808b}, // + {0xA6D9,0x808c}, // + {0xA6DA,0x81e3}, // + {0xA6DB,0x81ea}, // + {0xA6DC,0x81f3}, // + {0xA6DD,0x81fc}, // + {0xA6DE,0x820c}, // + {0xA6DF,0x821b}, // + {0xA6E0,0x821f}, // + {0xA6E1,0x826e}, // + {0xA6E2,0x8272}, // + {0xA6E3,0x827e}, // + {0xA6E4,0x866b}, // + {0xA6E5,0x8840}, // + {0xA6E6,0x884c}, // + {0xA6E7,0x8863}, // + {0xA6E8,0x897f}, // + {0xA6E9,0x9621}, // + {0xA6EA,0x4e32}, // + {0xA6EB,0x4ea8}, // + {0xA6EC,0x4f4d}, // + {0xA6ED,0x4f4f}, // + {0xA6EE,0x4f47}, // + {0xA6EF,0x4f57}, // + {0xA6F0,0x4f5e}, // + {0xA6F1,0x4f34}, // + {0xA6F2,0x4f5b}, // + {0xA6F3,0x4f55}, // + {0xA6F4,0x4f30}, // + {0xA6F5,0x4f50}, // + {0xA6F6,0x4f51}, // + {0xA6F7,0x4f3d}, // + {0xA6F8,0x4f3a}, // + {0xA6F9,0x4f38}, // + {0xA6FA,0x4f43}, // + {0xA6FB,0x4f54}, // + {0xA6FC,0x4f3c}, // + {0xA6FD,0x4f46}, // + {0xA6FE,0x4f63}, // + {0xA740,0x4f5c}, // + {0xA741,0x4f60}, // + {0xA742,0x4f2f}, // + {0xA743,0x4f4e}, // + {0xA744,0x4f36}, // + {0xA745,0x4f59}, // + {0xA746,0x4f5d}, // + {0xA747,0x4f48}, // + {0xA748,0x4f5a}, // + {0xA749,0x514c}, // + {0xA74A,0x514b}, // + {0xA74B,0x514d}, // + {0xA74C,0x5175}, // + {0xA74D,0x51b6}, // + {0xA74E,0x51b7}, // + {0xA74F,0x5225}, // + {0xA750,0x5224}, // + {0xA751,0x5229}, // + {0xA752,0x522a}, // + {0xA753,0x5228}, // + {0xA754,0x52ab}, // + {0xA755,0x52a9}, // + {0xA756,0x52aa}, // + {0xA757,0x52ac}, // + {0xA758,0x5323}, // + {0xA759,0x5373}, // + {0xA75A,0x5375}, // + {0xA75B,0x541d}, // + {0xA75C,0x542d}, // + {0xA75D,0x541e}, // + {0xA75E,0x543e}, // + {0xA75F,0x5426}, // + {0xA760,0x544e}, // + {0xA761,0x5427}, // + {0xA762,0x5446}, // + {0xA763,0x5443}, // + {0xA764,0x5433}, // + {0xA765,0x5448}, // + {0xA766,0x5442}, // + {0xA767,0x541b}, // + {0xA768,0x5429}, // + {0xA769,0x544a}, // + {0xA76A,0x5439}, // + {0xA76B,0x543b}, // + {0xA76C,0x5438}, // + {0xA76D,0x542e}, // + {0xA76E,0x5435}, // + {0xA76F,0x5436}, // + {0xA770,0x5420}, // + {0xA771,0x543c}, // + {0xA772,0x5440}, // + {0xA773,0x5431}, // + {0xA774,0x542b}, // + {0xA775,0x541f}, // + {0xA776,0x542c}, // + {0xA777,0x56ea}, // + {0xA778,0x56f0}, // + {0xA779,0x56e4}, // + {0xA77A,0x56eb}, // + {0xA77B,0x574a}, // + {0xA77C,0x5751}, // + {0xA77D,0x5740}, // + {0xA77E,0x574d}, // + {0xA7A1,0x5747}, // + {0xA7A2,0x574e}, // + {0xA7A3,0x573e}, // + {0xA7A4,0x5750}, // + {0xA7A5,0x574f}, // + {0xA7A6,0x573b}, // + {0xA7A7,0x58ef}, // + {0xA7A8,0x593e}, // + {0xA7A9,0x599d}, // + {0xA7AA,0x5992}, // + {0xA7AB,0x59a8}, // + {0xA7AC,0x599e}, // + {0xA7AD,0x59a3}, // + {0xA7AE,0x5999}, // + {0xA7AF,0x5996}, // + {0xA7B0,0x598d}, // + {0xA7B1,0x59a4}, // + {0xA7B2,0x5993}, // + {0xA7B3,0x598a}, // + {0xA7B4,0x59a5}, // + {0xA7B5,0x5b5d}, // + {0xA7B6,0x5b5c}, // + {0xA7B7,0x5b5a}, // + {0xA7B8,0x5b5b}, // + {0xA7B9,0x5b8c}, // + {0xA7BA,0x5b8b}, // + {0xA7BB,0x5b8f}, // + {0xA7BC,0x5c2c}, // + {0xA7BD,0x5c40}, // + {0xA7BE,0x5c41}, // + {0xA7BF,0x5c3f}, // + {0xA7C0,0x5c3e}, // + {0xA7C1,0x5c90}, // + {0xA7C2,0x5c91}, // + {0xA7C3,0x5c94}, // + {0xA7C4,0x5c8c}, // + {0xA7C5,0x5deb}, // + {0xA7C6,0x5e0c}, // + {0xA7C7,0x5e8f}, // + {0xA7C8,0x5e87}, // + {0xA7C9,0x5e8a}, // + {0xA7CA,0x5ef7}, // + {0xA7CB,0x5f04}, // + {0xA7CC,0x5f1f}, // + {0xA7CD,0x5f64}, // + {0xA7CE,0x5f62}, // + {0xA7CF,0x5f77}, // + {0xA7D0,0x5f79}, // + {0xA7D1,0x5fd8}, // + {0xA7D2,0x5fcc}, // + {0xA7D3,0x5fd7}, // + {0xA7D4,0x5fcd}, // + {0xA7D5,0x5ff1}, // + {0xA7D6,0x5feb}, // + {0xA7D7,0x5ff8}, // + {0xA7D8,0x5fea}, // + {0xA7D9,0x6212}, // + {0xA7DA,0x6211}, // + {0xA7DB,0x6284}, // + {0xA7DC,0x6297}, // + {0xA7DD,0x6296}, // + {0xA7DE,0x6280}, // + {0xA7DF,0x6276}, // + {0xA7E0,0x6289}, // + {0xA7E1,0x626d}, // + {0xA7E2,0x628a}, // + {0xA7E3,0x627c}, // + {0xA7E4,0x627e}, // + {0xA7E5,0x6279}, // + {0xA7E6,0x6273}, // + {0xA7E7,0x6292}, // + {0xA7E8,0x626f}, // + {0xA7E9,0x6298}, // + {0xA7EA,0x626e}, // + {0xA7EB,0x6295}, // + {0xA7EC,0x6293}, // + {0xA7ED,0x6291}, // + {0xA7EE,0x6286}, // + {0xA7EF,0x6539}, // + {0xA7F0,0x653b}, // + {0xA7F1,0x6538}, // + {0xA7F2,0x65f1}, // + {0xA7F3,0x66f4}, // + {0xA7F4,0x675f}, // + {0xA7F5,0x674e}, // + {0xA7F6,0x674f}, // + {0xA7F7,0x6750}, // + {0xA7F8,0x6751}, // + {0xA7F9,0x675c}, // + {0xA7FA,0x6756}, // + {0xA7FB,0x675e}, // + {0xA7FC,0x6749}, // + {0xA7FD,0x6746}, // + {0xA7FE,0x6760}, // + {0xA840,0x6753}, // + {0xA841,0x6757}, // + {0xA842,0x6b65}, // + {0xA843,0x6bcf}, // + {0xA844,0x6c42}, // + {0xA845,0x6c5e}, // + {0xA846,0x6c99}, // + {0xA847,0x6c81}, // + {0xA848,0x6c88}, // + {0xA849,0x6c89}, // + {0xA84A,0x6c85}, // + {0xA84B,0x6c9b}, // + {0xA84C,0x6c6a}, // + {0xA84D,0x6c7a}, // + {0xA84E,0x6c90}, // + {0xA84F,0x6c70}, // + {0xA850,0x6c8c}, // + {0xA851,0x6c68}, // + {0xA852,0x6c96}, // + {0xA853,0x6c92}, // + {0xA854,0x6c7d}, // + {0xA855,0x6c83}, // + {0xA856,0x6c72}, // + {0xA857,0x6c7e}, // + {0xA858,0x6c74}, // + {0xA859,0x6c86}, // + {0xA85A,0x6c76}, // + {0xA85B,0x6c8d}, // + {0xA85C,0x6c94}, // + {0xA85D,0x6c98}, // + {0xA85E,0x6c82}, // + {0xA85F,0x7076}, // + {0xA860,0x707c}, // + {0xA861,0x707d}, // + {0xA862,0x7078}, // + {0xA863,0x7262}, // + {0xA864,0x7261}, // + {0xA865,0x7260}, // + {0xA866,0x72c4}, // + {0xA867,0x72c2}, // + {0xA868,0x7396}, // + {0xA869,0x752c}, // + {0xA86A,0x752b}, // + {0xA86B,0x7537}, // + {0xA86C,0x7538}, // + {0xA86D,0x7682}, // + {0xA86E,0x76ef}, // + {0xA86F,0x77e3}, // + {0xA870,0x79c1}, // + {0xA871,0x79c0}, // + {0xA872,0x79bf}, // + {0xA873,0x7a76}, // + {0xA874,0x7cfb}, // + {0xA875,0x7f55}, // + {0xA876,0x8096}, // + {0xA877,0x8093}, // + {0xA878,0x809d}, // + {0xA879,0x8098}, // + {0xA87A,0x809b}, // + {0xA87B,0x809a}, // + {0xA87C,0x80b2}, // + {0xA87D,0x826f}, // + {0xA87E,0x8292}, // + {0xA8A1,0x828b}, // + {0xA8A2,0x828d}, // + {0xA8A3,0x898b}, // + {0xA8A4,0x89d2}, // + {0xA8A5,0x8a00}, // + {0xA8A6,0x8c37}, // + {0xA8A7,0x8c46}, // + {0xA8A8,0x8c55}, // + {0xA8A9,0x8c9d}, // + {0xA8AA,0x8d64}, // + {0xA8AB,0x8d70}, // + {0xA8AC,0x8db3}, // + {0xA8AD,0x8eab}, // + {0xA8AE,0x8eca}, // + {0xA8AF,0x8f9b}, // + {0xA8B0,0x8fb0}, // + {0xA8B1,0x8fc2}, // + {0xA8B2,0x8fc6}, // + {0xA8B3,0x8fc5}, // + {0xA8B4,0x8fc4}, // + {0xA8B5,0x5de1}, // + {0xA8B6,0x9091}, // + {0xA8B7,0x90a2}, // + {0xA8B8,0x90aa}, // + {0xA8B9,0x90a6}, // + {0xA8BA,0x90a3}, // + {0xA8BB,0x9149}, // + {0xA8BC,0x91c6}, // + {0xA8BD,0x91cc}, // + {0xA8BE,0x9632}, // + {0xA8BF,0x962e}, // + {0xA8C0,0x9631}, // + {0xA8C1,0x962a}, // + {0xA8C2,0x962c}, // + {0xA8C3,0x4e26}, // + {0xA8C4,0x4e56}, // + {0xA8C5,0x4e73}, // + {0xA8C6,0x4e8b}, // + {0xA8C7,0x4e9b}, // + {0xA8C8,0x4e9e}, // + {0xA8C9,0x4eab}, // + {0xA8CA,0x4eac}, // + {0xA8CB,0x4f6f}, // + {0xA8CC,0x4f9d}, // + {0xA8CD,0x4f8d}, // + {0xA8CE,0x4f73}, // + {0xA8CF,0x4f7f}, // + {0xA8D0,0x4f6c}, // + {0xA8D1,0x4f9b}, // + {0xA8D2,0x4f8b}, // + {0xA8D3,0x4f86}, // + {0xA8D4,0x4f83}, // + {0xA8D5,0x4f70}, // + {0xA8D6,0x4f75}, // + {0xA8D7,0x4f88}, // + {0xA8D8,0x4f69}, // + {0xA8D9,0x4f7b}, // + {0xA8DA,0x4f96}, // + {0xA8DB,0x4f7e}, // + {0xA8DC,0x4f8f}, // + {0xA8DD,0x4f91}, // + {0xA8DE,0x4f7a}, // + {0xA8DF,0x5154}, // + {0xA8E0,0x5152}, // + {0xA8E1,0x5155}, // + {0xA8E2,0x5169}, // + {0xA8E3,0x5177}, // + {0xA8E4,0x5176}, // + {0xA8E5,0x5178}, // + {0xA8E6,0x51bd}, // + {0xA8E7,0x51fd}, // + {0xA8E8,0x523b}, // + {0xA8E9,0x5238}, // + {0xA8EA,0x5237}, // + {0xA8EB,0x523a}, // + {0xA8EC,0x5230}, // + {0xA8ED,0x522e}, // + {0xA8EE,0x5236}, // + {0xA8EF,0x5241}, // + {0xA8F0,0x52be}, // + {0xA8F1,0x52bb}, // + {0xA8F2,0x5352}, // + {0xA8F3,0x5354}, // + {0xA8F4,0x5353}, // + {0xA8F5,0x5351}, // + {0xA8F6,0x5366}, // + {0xA8F7,0x5377}, // + {0xA8F8,0x5378}, // + {0xA8F9,0x5379}, // + {0xA8FA,0x53d6}, // + {0xA8FB,0x53d4}, // + {0xA8FC,0x53d7}, // + {0xA8FD,0x5473}, // + {0xA8FE,0x5475}, // + {0xA940,0x5496}, // + {0xA941,0x5478}, // + {0xA942,0x5495}, // + {0xA943,0x5480}, // + {0xA944,0x547b}, // + {0xA945,0x5477}, // + {0xA946,0x5484}, // + {0xA947,0x5492}, // + {0xA948,0x5486}, // + {0xA949,0x547c}, // + {0xA94A,0x5490}, // + {0xA94B,0x5471}, // + {0xA94C,0x5476}, // + {0xA94D,0x548c}, // + {0xA94E,0x549a}, // + {0xA94F,0x5462}, // + {0xA950,0x5468}, // + {0xA951,0x548b}, // + {0xA952,0x547d}, // + {0xA953,0x548e}, // + {0xA954,0x56fa}, // + {0xA955,0x5783}, // + {0xA956,0x5777}, // + {0xA957,0x576a}, // + {0xA958,0x5769}, // + {0xA959,0x5761}, // + {0xA95A,0x5766}, // + {0xA95B,0x5764}, // + {0xA95C,0x577c}, // + {0xA95D,0x591c}, // + {0xA95E,0x5949}, // + {0xA95F,0x5947}, // + {0xA960,0x5948}, // + {0xA961,0x5944}, // + {0xA962,0x5954}, // + {0xA963,0x59be}, // + {0xA964,0x59bb}, // + {0xA965,0x59d4}, // + {0xA966,0x59b9}, // + {0xA967,0x59ae}, // + {0xA968,0x59d1}, // + {0xA969,0x59c6}, // + {0xA96A,0x59d0}, // + {0xA96B,0x59cd}, // + {0xA96C,0x59cb}, // + {0xA96D,0x59d3}, // + {0xA96E,0x59ca}, // + {0xA96F,0x59af}, // + {0xA970,0x59b3}, // + {0xA971,0x59d2}, // + {0xA972,0x59c5}, // + {0xA973,0x5b5f}, // + {0xA974,0x5b64}, // + {0xA975,0x5b63}, // + {0xA976,0x5b97}, // + {0xA977,0x5b9a}, // + {0xA978,0x5b98}, // + {0xA979,0x5b9c}, // + {0xA97A,0x5b99}, // + {0xA97B,0x5b9b}, // + {0xA97C,0x5c1a}, // + {0xA97D,0x5c48}, // + {0xA97E,0x5c45}, // + {0xA9A1,0x5c46}, // + {0xA9A2,0x5cb7}, // + {0xA9A3,0x5ca1}, // + {0xA9A4,0x5cb8}, // + {0xA9A5,0x5ca9}, // + {0xA9A6,0x5cab}, // + {0xA9A7,0x5cb1}, // + {0xA9A8,0x5cb3}, // + {0xA9A9,0x5e18}, // + {0xA9AA,0x5e1a}, // + {0xA9AB,0x5e16}, // + {0xA9AC,0x5e15}, // + {0xA9AD,0x5e1b}, // + {0xA9AE,0x5e11}, // + {0xA9AF,0x5e78}, // + {0xA9B0,0x5e9a}, // + {0xA9B1,0x5e97}, // + {0xA9B2,0x5e9c}, // + {0xA9B3,0x5e95}, // + {0xA9B4,0x5e96}, // + {0xA9B5,0x5ef6}, // + {0xA9B6,0x5f26}, // + {0xA9B7,0x5f27}, // + {0xA9B8,0x5f29}, // + {0xA9B9,0x5f80}, // + {0xA9BA,0x5f81}, // + {0xA9BB,0x5f7f}, // + {0xA9BC,0x5f7c}, // + {0xA9BD,0x5fdd}, // + {0xA9BE,0x5fe0}, // + {0xA9BF,0x5ffd}, // + {0xA9C0,0x5ff5}, // + {0xA9C1,0x5fff}, // + {0xA9C2,0x600f}, // + {0xA9C3,0x6014}, // + {0xA9C4,0x602f}, // + {0xA9C5,0x6035}, // + {0xA9C6,0x6016}, // + {0xA9C7,0x602a}, // + {0xA9C8,0x6015}, // + {0xA9C9,0x6021}, // + {0xA9CA,0x6027}, // + {0xA9CB,0x6029}, // + {0xA9CC,0x602b}, // + {0xA9CD,0x601b}, // + {0xA9CE,0x6216}, // + {0xA9CF,0x6215}, // + {0xA9D0,0x623f}, // + {0xA9D1,0x623e}, // + {0xA9D2,0x6240}, // + {0xA9D3,0x627f}, // + {0xA9D4,0x62c9}, // + {0xA9D5,0x62cc}, // + {0xA9D6,0x62c4}, // + {0xA9D7,0x62bf}, // + {0xA9D8,0x62c2}, // + {0xA9D9,0x62b9}, // + {0xA9DA,0x62d2}, // + {0xA9DB,0x62db}, // + {0xA9DC,0x62ab}, // + {0xA9DD,0x62d3}, // + {0xA9DE,0x62d4}, // + {0xA9DF,0x62cb}, // + {0xA9E0,0x62c8}, // + {0xA9E1,0x62a8}, // + {0xA9E2,0x62bd}, // + {0xA9E3,0x62bc}, // + {0xA9E4,0x62d0}, // + {0xA9E5,0x62d9}, // + {0xA9E6,0x62c7}, // + {0xA9E7,0x62cd}, // + {0xA9E8,0x62b5}, // + {0xA9E9,0x62da}, // + {0xA9EA,0x62b1}, // + {0xA9EB,0x62d8}, // + {0xA9EC,0x62d6}, // + {0xA9ED,0x62d7}, // + {0xA9EE,0x62c6}, // + {0xA9EF,0x62ac}, // + {0xA9F0,0x62ce}, // + {0xA9F1,0x653e}, // + {0xA9F2,0x65a7}, // + {0xA9F3,0x65bc}, // + {0xA9F4,0x65fa}, // + {0xA9F5,0x6614}, // + {0xA9F6,0x6613}, // + {0xA9F7,0x660c}, // + {0xA9F8,0x6606}, // + {0xA9F9,0x6602}, // + {0xA9FA,0x660e}, // + {0xA9FB,0x6600}, // + {0xA9FC,0x660f}, // + {0xA9FD,0x6615}, // + {0xA9FE,0x660a}, // + {0xAA40,0x6607}, // + {0xAA41,0x670d}, // + {0xAA42,0x670b}, // + {0xAA43,0x676d}, // + {0xAA44,0x678b}, // + {0xAA45,0x6795}, // + {0xAA46,0x6771}, // + {0xAA47,0x679c}, // + {0xAA48,0x6773}, // + {0xAA49,0x6777}, // + {0xAA4A,0x6787}, // + {0xAA4B,0x679d}, // + {0xAA4C,0x6797}, // + {0xAA4D,0x676f}, // + {0xAA4E,0x6770}, // + {0xAA4F,0x677f}, // + {0xAA50,0x6789}, // + {0xAA51,0x677e}, // + {0xAA52,0x6790}, // + {0xAA53,0x6775}, // + {0xAA54,0x679a}, // + {0xAA55,0x6793}, // + {0xAA56,0x677c}, // + {0xAA57,0x676a}, // + {0xAA58,0x6772}, // + {0xAA59,0x6b23}, // + {0xAA5A,0x6b66}, // + {0xAA5B,0x6b67}, // + {0xAA5C,0x6b7f}, // + {0xAA5D,0x6c13}, // + {0xAA5E,0x6c1b}, // + {0xAA5F,0x6ce3}, // + {0xAA60,0x6ce8}, // + {0xAA61,0x6cf3}, // + {0xAA62,0x6cb1}, // + {0xAA63,0x6ccc}, // + {0xAA64,0x6ce5}, // + {0xAA65,0x6cb3}, // + {0xAA66,0x6cbd}, // + {0xAA67,0x6cbe}, // + {0xAA68,0x6cbc}, // + {0xAA69,0x6ce2}, // + {0xAA6A,0x6cab}, // + {0xAA6B,0x6cd5}, // + {0xAA6C,0x6cd3}, // + {0xAA6D,0x6cb8}, // + {0xAA6E,0x6cc4}, // + {0xAA6F,0x6cb9}, // + {0xAA70,0x6cc1}, // + {0xAA71,0x6cae}, // + {0xAA72,0x6cd7}, // + {0xAA73,0x6cc5}, // + {0xAA74,0x6cf1}, // + {0xAA75,0x6cbf}, // + {0xAA76,0x6cbb}, // + {0xAA77,0x6ce1}, // + {0xAA78,0x6cdb}, // + {0xAA79,0x6cca}, // + {0xAA7A,0x6cac}, // + {0xAA7B,0x6cef}, // + {0xAA7C,0x6cdc}, // + {0xAA7D,0x6cd6}, // + {0xAA7E,0x6ce0}, // + {0xAAA1,0x7095}, // + {0xAAA2,0x708e}, // + {0xAAA3,0x7092}, // + {0xAAA4,0x708a}, // + {0xAAA5,0x7099}, // + {0xAAA6,0x722c}, // + {0xAAA7,0x722d}, // + {0xAAA8,0x7238}, // + {0xAAA9,0x7248}, // + {0xAAAA,0x7267}, // + {0xAAAB,0x7269}, // + {0xAAAC,0x72c0}, // + {0xAAAD,0x72ce}, // + {0xAAAE,0x72d9}, // + {0xAAAF,0x72d7}, // + {0xAAB0,0x72d0}, // + {0xAAB1,0x73a9}, // + {0xAAB2,0x73a8}, // + {0xAAB3,0x739f}, // + {0xAAB4,0x73ab}, // + {0xAAB5,0x73a5}, // + {0xAAB6,0x753d}, // + {0xAAB7,0x759d}, // + {0xAAB8,0x7599}, // + {0xAAB9,0x759a}, // + {0xAABA,0x7684}, // + {0xAABB,0x76c2}, // + {0xAABC,0x76f2}, // + {0xAABD,0x76f4}, // + {0xAABE,0x77e5}, // + {0xAABF,0x77fd}, // + {0xAAC0,0x793e}, // + {0xAAC1,0x7940}, // + {0xAAC2,0x7941}, // + {0xAAC3,0x79c9}, // + {0xAAC4,0x79c8}, // + {0xAAC5,0x7a7a}, // + {0xAAC6,0x7a79}, // + {0xAAC7,0x7afa}, // + {0xAAC8,0x7cfe}, // + {0xAAC9,0x7f54}, // + {0xAACA,0x7f8c}, // + {0xAACB,0x7f8b}, // + {0xAACC,0x8005}, // + {0xAACD,0x80ba}, // + {0xAACE,0x80a5}, // + {0xAACF,0x80a2}, // + {0xAAD0,0x80b1}, // + {0xAAD1,0x80a1}, // + {0xAAD2,0x80ab}, // + {0xAAD3,0x80a9}, // + {0xAAD4,0x80b4}, // + {0xAAD5,0x80aa}, // + {0xAAD6,0x80af}, // + {0xAAD7,0x81e5}, // + {0xAAD8,0x81fe}, // + {0xAAD9,0x820d}, // + {0xAADA,0x82b3}, // + {0xAADB,0x829d}, // + {0xAADC,0x8299}, // + {0xAADD,0x82ad}, // + {0xAADE,0x82bd}, // + {0xAADF,0x829f}, // + {0xAAE0,0x82b9}, // + {0xAAE1,0x82b1}, // + {0xAAE2,0x82ac}, // + {0xAAE3,0x82a5}, // + {0xAAE4,0x82af}, // + {0xAAE5,0x82b8}, // + {0xAAE6,0x82a3}, // + {0xAAE7,0x82b0}, // + {0xAAE8,0x82be}, // + {0xAAE9,0x82b7}, // + {0xAAEA,0x864e}, // + {0xAAEB,0x8671}, // + {0xAAEC,0x521d}, // + {0xAAED,0x8868}, // + {0xAAEE,0x8ecb}, // + {0xAAEF,0x8fce}, // + {0xAAF0,0x8fd4}, // + {0xAAF1,0x8fd1}, // + {0xAAF2,0x90b5}, // + {0xAAF3,0x90b8}, // + {0xAAF4,0x90b1}, // + {0xAAF5,0x90b6}, // + {0xAAF6,0x91c7}, // + {0xAAF7,0x91d1}, // + {0xAAF8,0x9577}, // + {0xAAF9,0x9580}, // + {0xAAFA,0x961c}, // + {0xAAFB,0x9640}, // + {0xAAFC,0x963f}, // + {0xAAFD,0x963b}, // + {0xAAFE,0x9644}, // + {0xAB40,0x9642}, // + {0xAB41,0x96b9}, // + {0xAB42,0x96e8}, // + {0xAB43,0x9752}, // + {0xAB44,0x975e}, // + {0xAB45,0x4e9f}, // + {0xAB46,0x4ead}, // + {0xAB47,0x4eae}, // + {0xAB48,0x4fe1}, // + {0xAB49,0x4fb5}, // + {0xAB4A,0x4faf}, // + {0xAB4B,0x4fbf}, // + {0xAB4C,0x4fe0}, // + {0xAB4D,0x4fd1}, // + {0xAB4E,0x4fcf}, // + {0xAB4F,0x4fdd}, // + {0xAB50,0x4fc3}, // + {0xAB51,0x4fb6}, // + {0xAB52,0x4fd8}, // + {0xAB53,0x4fdf}, // + {0xAB54,0x4fca}, // + {0xAB55,0x4fd7}, // + {0xAB56,0x4fae}, // + {0xAB57,0x4fd0}, // + {0xAB58,0x4fc4}, // + {0xAB59,0x4fc2}, // + {0xAB5A,0x4fda}, // + {0xAB5B,0x4fce}, // + {0xAB5C,0x4fde}, // + {0xAB5D,0x4fb7}, // + {0xAB5E,0x5157}, // + {0xAB5F,0x5192}, // + {0xAB60,0x5191}, // + {0xAB61,0x51a0}, // + {0xAB62,0x524e}, // + {0xAB63,0x5243}, // + {0xAB64,0x524a}, // + {0xAB65,0x524d}, // + {0xAB66,0x524c}, // + {0xAB67,0x524b}, // + {0xAB68,0x5247}, // + {0xAB69,0x52c7}, // + {0xAB6A,0x52c9}, // + {0xAB6B,0x52c3}, // + {0xAB6C,0x52c1}, // + {0xAB6D,0x530d}, // + {0xAB6E,0x5357}, // + {0xAB6F,0x537b}, // + {0xAB70,0x539a}, // + {0xAB71,0x53db}, // + {0xAB72,0x54ac}, // + {0xAB73,0x54c0}, // + {0xAB74,0x54a8}, // + {0xAB75,0x54ce}, // + {0xAB76,0x54c9}, // + {0xAB77,0x54b8}, // + {0xAB78,0x54a6}, // + {0xAB79,0x54b3}, // + {0xAB7A,0x54c7}, // + {0xAB7B,0x54c2}, // + {0xAB7C,0x54bd}, // + {0xAB7D,0x54aa}, // + {0xAB7E,0x54c1}, // + {0xABA1,0x54c4}, // + {0xABA2,0x54c8}, // + {0xABA3,0x54af}, // + {0xABA4,0x54ab}, // + {0xABA5,0x54b1}, // + {0xABA6,0x54bb}, // + {0xABA7,0x54a9}, // + {0xABA8,0x54a7}, // + {0xABA9,0x54bf}, // + {0xABAA,0x56ff}, // + {0xABAB,0x5782}, // + {0xABAC,0x578b}, // + {0xABAD,0x57a0}, // + {0xABAE,0x57a3}, // + {0xABAF,0x57a2}, // + {0xABB0,0x57ce}, // + {0xABB1,0x57ae}, // + {0xABB2,0x5793}, // + {0xABB3,0x5955}, // + {0xABB4,0x5951}, // + {0xABB5,0x594f}, // + {0xABB6,0x594e}, // + {0xABB7,0x5950}, // + {0xABB8,0x59dc}, // + {0xABB9,0x59d8}, // + {0xABBA,0x59ff}, // + {0xABBB,0x59e3}, // + {0xABBC,0x59e8}, // + {0xABBD,0x5a03}, // + {0xABBE,0x59e5}, // + {0xABBF,0x59ea}, // + {0xABC0,0x59da}, // + {0xABC1,0x59e6}, // + {0xABC2,0x5a01}, // + {0xABC3,0x59fb}, // + {0xABC4,0x5b69}, // + {0xABC5,0x5ba3}, // + {0xABC6,0x5ba6}, // + {0xABC7,0x5ba4}, // + {0xABC8,0x5ba2}, // + {0xABC9,0x5ba5}, // + {0xABCA,0x5c01}, // + {0xABCB,0x5c4e}, // + {0xABCC,0x5c4f}, // + {0xABCD,0x5c4d}, // + {0xABCE,0x5c4b}, // + {0xABCF,0x5cd9}, // + {0xABD0,0x5cd2}, // + {0xABD1,0x5df7}, // + {0xABD2,0x5e1d}, // + {0xABD3,0x5e25}, // + {0xABD4,0x5e1f}, // + {0xABD5,0x5e7d}, // + {0xABD6,0x5ea0}, // + {0xABD7,0x5ea6}, // + {0xABD8,0x5efa}, // + {0xABD9,0x5f08}, // + {0xABDA,0x5f2d}, // + {0xABDB,0x5f65}, // + {0xABDC,0x5f88}, // + {0xABDD,0x5f85}, // + {0xABDE,0x5f8a}, // + {0xABDF,0x5f8b}, // + {0xABE0,0x5f87}, // + {0xABE1,0x5f8c}, // + {0xABE2,0x5f89}, // + {0xABE3,0x6012}, // + {0xABE4,0x601d}, // + {0xABE5,0x6020}, // + {0xABE6,0x6025}, // + {0xABE7,0x600e}, // + {0xABE8,0x6028}, // + {0xABE9,0x604d}, // + {0xABEA,0x6070}, // + {0xABEB,0x6068}, // + {0xABEC,0x6062}, // + {0xABED,0x6046}, // + {0xABEE,0x6043}, // + {0xABEF,0x606c}, // + {0xABF0,0x606b}, // + {0xABF1,0x606a}, // + {0xABF2,0x6064}, // + {0xABF3,0x6241}, // + {0xABF4,0x62dc}, // + {0xABF5,0x6316}, // + {0xABF6,0x6309}, // + {0xABF7,0x62fc}, // + {0xABF8,0x62ed}, // + {0xABF9,0x6301}, // + {0xABFA,0x62ee}, // + {0xABFB,0x62fd}, // + {0xABFC,0x6307}, // + {0xABFD,0x62f1}, // + {0xABFE,0x62f7}, // + {0xAC40,0x62ef}, // + {0xAC41,0x62ec}, // + {0xAC42,0x62fe}, // + {0xAC43,0x62f4}, // + {0xAC44,0x6311}, // + {0xAC45,0x6302}, // + {0xAC46,0x653f}, // + {0xAC47,0x6545}, // + {0xAC48,0x65ab}, // + {0xAC49,0x65bd}, // + {0xAC4A,0x65e2}, // + {0xAC4B,0x6625}, // + {0xAC4C,0x662d}, // + {0xAC4D,0x6620}, // + {0xAC4E,0x6627}, // + {0xAC4F,0x662f}, // + {0xAC50,0x661f}, // + {0xAC51,0x6628}, // + {0xAC52,0x6631}, // + {0xAC53,0x6624}, // + {0xAC54,0x66f7}, // + {0xAC55,0x67ff}, // + {0xAC56,0x67d3}, // + {0xAC57,0x67f1}, // + {0xAC58,0x67d4}, // + {0xAC59,0x67d0}, // + {0xAC5A,0x67ec}, // + {0xAC5B,0x67b6}, // + {0xAC5C,0x67af}, // + {0xAC5D,0x67f5}, // + {0xAC5E,0x67e9}, // + {0xAC5F,0x67ef}, // + {0xAC60,0x67c4}, // + {0xAC61,0x67d1}, // + {0xAC62,0x67b4}, // + {0xAC63,0x67da}, // + {0xAC64,0x67e5}, // + {0xAC65,0x67b8}, // + {0xAC66,0x67cf}, // + {0xAC67,0x67de}, // + {0xAC68,0x67f3}, // + {0xAC69,0x67b0}, // + {0xAC6A,0x67d9}, // + {0xAC6B,0x67e2}, // + {0xAC6C,0x67dd}, // + {0xAC6D,0x67d2}, // + {0xAC6E,0x6b6a}, // + {0xAC6F,0x6b83}, // + {0xAC70,0x6b86}, // + {0xAC71,0x6bb5}, // + {0xAC72,0x6bd2}, // + {0xAC73,0x6bd7}, // + {0xAC74,0x6c1f}, // + {0xAC75,0x6cc9}, // + {0xAC76,0x6d0b}, // + {0xAC77,0x6d32}, // + {0xAC78,0x6d2a}, // + {0xAC79,0x6d41}, // + {0xAC7A,0x6d25}, // + {0xAC7B,0x6d0c}, // + {0xAC7C,0x6d31}, // + {0xAC7D,0x6d1e}, // + {0xAC7E,0x6d17}, // + {0xACA1,0x6d3b}, // + {0xACA2,0x6d3d}, // + {0xACA3,0x6d3e}, // + {0xACA4,0x6d36}, // + {0xACA5,0x6d1b}, // + {0xACA6,0x6cf5}, // + {0xACA7,0x6d39}, // + {0xACA8,0x6d27}, // + {0xACA9,0x6d38}, // + {0xACAA,0x6d29}, // + {0xACAB,0x6d2e}, // + {0xACAC,0x6d35}, // + {0xACAD,0x6d0e}, // + {0xACAE,0x6d2b}, // + {0xACAF,0x70ab}, // + {0xACB0,0x70ba}, // + {0xACB1,0x70b3}, // + {0xACB2,0x70ac}, // + {0xACB3,0x70af}, // + {0xACB4,0x70ad}, // + {0xACB5,0x70b8}, // + {0xACB6,0x70ae}, // + {0xACB7,0x70a4}, // + {0xACB8,0x7230}, // + {0xACB9,0x7272}, // + {0xACBA,0x726f}, // + {0xACBB,0x7274}, // + {0xACBC,0x72e9}, // + {0xACBD,0x72e0}, // + {0xACBE,0x72e1}, // + {0xACBF,0x73b7}, // + {0xACC0,0x73ca}, // + {0xACC1,0x73bb}, // + {0xACC2,0x73b2}, // + {0xACC3,0x73cd}, // + {0xACC4,0x73c0}, // + {0xACC5,0x73b3}, // + {0xACC6,0x751a}, // + {0xACC7,0x752d}, // + {0xACC8,0x754f}, // + {0xACC9,0x754c}, // + {0xACCA,0x754e}, // + {0xACCB,0x754b}, // + {0xACCC,0x75ab}, // + {0xACCD,0x75a4}, // + {0xACCE,0x75a5}, // + {0xACCF,0x75a2}, // + {0xACD0,0x75a3}, // + {0xACD1,0x7678}, // + {0xACD2,0x7686}, // + {0xACD3,0x7687}, // + {0xACD4,0x7688}, // + {0xACD5,0x76c8}, // + {0xACD6,0x76c6}, // + {0xACD7,0x76c3}, // + {0xACD8,0x76c5}, // + {0xACD9,0x7701}, // + {0xACDA,0x76f9}, // + {0xACDB,0x76f8}, // + {0xACDC,0x7709}, // + {0xACDD,0x770b}, // + {0xACDE,0x76fe}, // + {0xACDF,0x76fc}, // + {0xACE0,0x7707}, // + {0xACE1,0x77dc}, // + {0xACE2,0x7802}, // + {0xACE3,0x7814}, // + {0xACE4,0x780c}, // + {0xACE5,0x780d}, // + {0xACE6,0x7946}, // + {0xACE7,0x7949}, // + {0xACE8,0x7948}, // + {0xACE9,0x7947}, // + {0xACEA,0x79b9}, // + {0xACEB,0x79ba}, // + {0xACEC,0x79d1}, // + {0xACED,0x79d2}, // + {0xACEE,0x79cb}, // + {0xACEF,0x7a7f}, // + {0xACF0,0x7a81}, // + {0xACF1,0x7aff}, // + {0xACF2,0x7afd}, // + {0xACF3,0x7c7d}, // + {0xACF4,0x7d02}, // + {0xACF5,0x7d05}, // + {0xACF6,0x7d00}, // + {0xACF7,0x7d09}, // + {0xACF8,0x7d07}, // + {0xACF9,0x7d04}, // + {0xACFA,0x7d06}, // + {0xACFB,0x7f38}, // + {0xACFC,0x7f8e}, // + {0xACFD,0x7fbf}, // + {0xACFE,0x8004}, // + {0xAD40,0x8010}, // + {0xAD41,0x800d}, // + {0xAD42,0x8011}, // + {0xAD43,0x8036}, // + {0xAD44,0x80d6}, // + {0xAD45,0x80e5}, // + {0xAD46,0x80da}, // + {0xAD47,0x80c3}, // + {0xAD48,0x80c4}, // + {0xAD49,0x80cc}, // + {0xAD4A,0x80e1}, // + {0xAD4B,0x80db}, // + {0xAD4C,0x80ce}, // + {0xAD4D,0x80de}, // + {0xAD4E,0x80e4}, // + {0xAD4F,0x80dd}, // + {0xAD50,0x81f4}, // + {0xAD51,0x8222}, // + {0xAD52,0x82e7}, // + {0xAD53,0x8303}, // + {0xAD54,0x8305}, // + {0xAD55,0x82e3}, // + {0xAD56,0x82db}, // + {0xAD57,0x82e6}, // + {0xAD58,0x8304}, // + {0xAD59,0x82e5}, // + {0xAD5A,0x8302}, // + {0xAD5B,0x8309}, // + {0xAD5C,0x82d2}, // + {0xAD5D,0x82d7}, // + {0xAD5E,0x82f1}, // + {0xAD5F,0x8301}, // + {0xAD60,0x82dc}, // + {0xAD61,0x82d4}, // + {0xAD62,0x82d1}, // + {0xAD63,0x82de}, // + {0xAD64,0x82d3}, // + {0xAD65,0x82df}, // + {0xAD66,0x82ef}, // + {0xAD67,0x8306}, // + {0xAD68,0x8650}, // + {0xAD69,0x8679}, // + {0xAD6A,0x867b}, // + {0xAD6B,0x867a}, // + {0xAD6C,0x884d}, // + {0xAD6D,0x886b}, // + {0xAD6E,0x8981}, // + {0xAD6F,0x89d4}, // + {0xAD70,0x8a08}, // + {0xAD71,0x8a02}, // + {0xAD72,0x8a03}, // + {0xAD73,0x8c9e}, // + {0xAD74,0x8ca0}, // + {0xAD75,0x8d74}, // + {0xAD76,0x8d73}, // + {0xAD77,0x8db4}, // + {0xAD78,0x8ecd}, // + {0xAD79,0x8ecc}, // + {0xAD7A,0x8ff0}, // + {0xAD7B,0x8fe6}, // + {0xAD7C,0x8fe2}, // + {0xAD7D,0x8fea}, // + {0xAD7E,0x8fe5}, // + {0xADA1,0x8fed}, // + {0xADA2,0x8feb}, // + {0xADA3,0x8fe4}, // + {0xADA4,0x8fe8}, // + {0xADA5,0x90ca}, // + {0xADA6,0x90ce}, // + {0xADA7,0x90c1}, // + {0xADA8,0x90c3}, // + {0xADA9,0x914b}, // + {0xADAA,0x914a}, // + {0xADAB,0x91cd}, // + {0xADAC,0x9582}, // + {0xADAD,0x9650}, // + {0xADAE,0x964b}, // + {0xADAF,0x964c}, // + {0xADB0,0x964d}, // + {0xADB1,0x9762}, // + {0xADB2,0x9769}, // + {0xADB3,0x97cb}, // + {0xADB4,0x97ed}, // + {0xADB5,0x97f3}, // + {0xADB6,0x9801}, // + {0xADB7,0x98a8}, // + {0xADB8,0x98db}, // + {0xADB9,0x98df}, // + {0xADBA,0x9996}, // + {0xADBB,0x9999}, // + {0xADBC,0x4e58}, // + {0xADBD,0x4eb3}, // + {0xADBE,0x500c}, // + {0xADBF,0x500d}, // + {0xADC0,0x5023}, // + {0xADC1,0x4fef}, // + {0xADC2,0x5026}, // + {0xADC3,0x5025}, // + {0xADC4,0x4ff8}, // + {0xADC5,0x5029}, // + {0xADC6,0x5016}, // + {0xADC7,0x5006}, // + {0xADC8,0x503c}, // + {0xADC9,0x501f}, // + {0xADCA,0x501a}, // + {0xADCB,0x5012}, // + {0xADCC,0x5011}, // + {0xADCD,0x4ffa}, // + {0xADCE,0x5000}, // + {0xADCF,0x5014}, // + {0xADD0,0x5028}, // + {0xADD1,0x4ff1}, // + {0xADD2,0x5021}, // + {0xADD3,0x500b}, // + {0xADD4,0x5019}, // + {0xADD5,0x5018}, // + {0xADD6,0x4ff3}, // + {0xADD7,0x4fee}, // + {0xADD8,0x502d}, // + {0xADD9,0x502a}, // + {0xADDA,0x4ffe}, // + {0xADDB,0x502b}, // + {0xADDC,0x5009}, // + {0xADDD,0x517c}, // + {0xADDE,0x51a4}, // + {0xADDF,0x51a5}, // + {0xADE0,0x51a2}, // + {0xADE1,0x51cd}, // + {0xADE2,0x51cc}, // + {0xADE3,0x51c6}, // + {0xADE4,0x51cb}, // + {0xADE5,0x5256}, // + {0xADE6,0x525c}, // + {0xADE7,0x5254}, // + {0xADE8,0x525b}, // + {0xADE9,0x525d}, // + {0xADEA,0x532a}, // + {0xADEB,0x537f}, // + {0xADEC,0x539f}, // + {0xADED,0x539d}, // + {0xADEE,0x53df}, // + {0xADEF,0x54e8}, // + {0xADF0,0x5510}, // + {0xADF1,0x5501}, // + {0xADF2,0x5537}, // + {0xADF3,0x54fc}, // + {0xADF4,0x54e5}, // + {0xADF5,0x54f2}, // + {0xADF6,0x5506}, // + {0xADF7,0x54fa}, // + {0xADF8,0x5514}, // + {0xADF9,0x54e9}, // + {0xADFA,0x54ed}, // + {0xADFB,0x54e1}, // + {0xADFC,0x5509}, // + {0xADFD,0x54ee}, // + {0xADFE,0x54ea}, // + {0xAE40,0x54e6}, // + {0xAE41,0x5527}, // + {0xAE42,0x5507}, // + {0xAE43,0x54fd}, // + {0xAE44,0x550f}, // + {0xAE45,0x5703}, // + {0xAE46,0x5704}, // + {0xAE47,0x57c2}, // + {0xAE48,0x57d4}, // + {0xAE49,0x57cb}, // + {0xAE4A,0x57c3}, // + {0xAE4B,0x5809}, // + {0xAE4C,0x590f}, // + {0xAE4D,0x5957}, // + {0xAE4E,0x5958}, // + {0xAE4F,0x595a}, // + {0xAE50,0x5a11}, // + {0xAE51,0x5a18}, // + {0xAE52,0x5a1c}, // + {0xAE53,0x5a1f}, // + {0xAE54,0x5a1b}, // + {0xAE55,0x5a13}, // + {0xAE56,0x59ec}, // + {0xAE57,0x5a20}, // + {0xAE58,0x5a23}, // + {0xAE59,0x5a29}, // + {0xAE5A,0x5a25}, // + {0xAE5B,0x5a0c}, // + {0xAE5C,0x5a09}, // + {0xAE5D,0x5b6b}, // + {0xAE5E,0x5c58}, // + {0xAE5F,0x5bb0}, // + {0xAE60,0x5bb3}, // + {0xAE61,0x5bb6}, // + {0xAE62,0x5bb4}, // + {0xAE63,0x5bae}, // + {0xAE64,0x5bb5}, // + {0xAE65,0x5bb9}, // + {0xAE66,0x5bb8}, // + {0xAE67,0x5c04}, // + {0xAE68,0x5c51}, // + {0xAE69,0x5c55}, // + {0xAE6A,0x5c50}, // + {0xAE6B,0x5ced}, // + {0xAE6C,0x5cfd}, // + {0xAE6D,0x5cfb}, // + {0xAE6E,0x5cea}, // + {0xAE6F,0x5ce8}, // + {0xAE70,0x5cf0}, // + {0xAE71,0x5cf6}, // + {0xAE72,0x5d01}, // + {0xAE73,0x5cf4}, // + {0xAE74,0x5dee}, // + {0xAE75,0x5e2d}, // + {0xAE76,0x5e2b}, // + {0xAE77,0x5eab}, // + {0xAE78,0x5ead}, // + {0xAE79,0x5ea7}, // + {0xAE7A,0x5f31}, // + {0xAE7B,0x5f92}, // + {0xAE7C,0x5f91}, // + {0xAE7D,0x5f90}, // + {0xAE7E,0x6059}, // + {0xAEA1,0x6063}, // + {0xAEA2,0x6065}, // + {0xAEA3,0x6050}, // + {0xAEA4,0x6055}, // + {0xAEA5,0x606d}, // + {0xAEA6,0x6069}, // + {0xAEA7,0x606f}, // + {0xAEA8,0x6084}, // + {0xAEA9,0x609f}, // + {0xAEAA,0x609a}, // + {0xAEAB,0x608d}, // + {0xAEAC,0x6094}, // + {0xAEAD,0x608c}, // + {0xAEAE,0x6085}, // + {0xAEAF,0x6096}, // + {0xAEB0,0x6247}, // + {0xAEB1,0x62f3}, // + {0xAEB2,0x6308}, // + {0xAEB3,0x62ff}, // + {0xAEB4,0x634e}, // + {0xAEB5,0x633e}, // + {0xAEB6,0x632f}, // + {0xAEB7,0x6355}, // + {0xAEB8,0x6342}, // + {0xAEB9,0x6346}, // + {0xAEBA,0x634f}, // + {0xAEBB,0x6349}, // + {0xAEBC,0x633a}, // + {0xAEBD,0x6350}, // + {0xAEBE,0x633d}, // + {0xAEBF,0x632a}, // + {0xAEC0,0x632b}, // + {0xAEC1,0x6328}, // + {0xAEC2,0x634d}, // + {0xAEC3,0x634c}, // + {0xAEC4,0x6548}, // + {0xAEC5,0x6549}, // + {0xAEC6,0x6599}, // + {0xAEC7,0x65c1}, // + {0xAEC8,0x65c5}, // + {0xAEC9,0x6642}, // + {0xAECA,0x6649}, // + {0xAECB,0x664f}, // + {0xAECC,0x6643}, // + {0xAECD,0x6652}, // + {0xAECE,0x664c}, // + {0xAECF,0x6645}, // + {0xAED0,0x6641}, // + {0xAED1,0x66f8}, // + {0xAED2,0x6714}, // + {0xAED3,0x6715}, // + {0xAED4,0x6717}, // + {0xAED5,0x6821}, // + {0xAED6,0x6838}, // + {0xAED7,0x6848}, // + {0xAED8,0x6846}, // + {0xAED9,0x6853}, // + {0xAEDA,0x6839}, // + {0xAEDB,0x6842}, // + {0xAEDC,0x6854}, // + {0xAEDD,0x6829}, // + {0xAEDE,0x68b3}, // + {0xAEDF,0x6817}, // + {0xAEE0,0x684c}, // + {0xAEE1,0x6851}, // + {0xAEE2,0x683d}, // + {0xAEE3,0x67f4}, // + {0xAEE4,0x6850}, // + {0xAEE5,0x6840}, // + {0xAEE6,0x683c}, // + {0xAEE7,0x6843}, // + {0xAEE8,0x682a}, // + {0xAEE9,0x6845}, // + {0xAEEA,0x6813}, // + {0xAEEB,0x6818}, // + {0xAEEC,0x6841}, // + {0xAEED,0x6b8a}, // + {0xAEEE,0x6b89}, // + {0xAEEF,0x6bb7}, // + {0xAEF0,0x6c23}, // + {0xAEF1,0x6c27}, // + {0xAEF2,0x6c28}, // + {0xAEF3,0x6c26}, // + {0xAEF4,0x6c24}, // + {0xAEF5,0x6cf0}, // + {0xAEF6,0x6d6a}, // + {0xAEF7,0x6d95}, // + {0xAEF8,0x6d88}, // + {0xAEF9,0x6d87}, // + {0xAEFA,0x6d66}, // + {0xAEFB,0x6d78}, // + {0xAEFC,0x6d77}, // + {0xAEFD,0x6d59}, // + {0xAEFE,0x6d93}, // + {0xAF40,0x6d6c}, // + {0xAF41,0x6d89}, // + {0xAF42,0x6d6e}, // + {0xAF43,0x6d5a}, // + {0xAF44,0x6d74}, // + {0xAF45,0x6d69}, // + {0xAF46,0x6d8c}, // + {0xAF47,0x6d8a}, // + {0xAF48,0x6d79}, // + {0xAF49,0x6d85}, // + {0xAF4A,0x6d65}, // + {0xAF4B,0x6d94}, // + {0xAF4C,0x70ca}, // + {0xAF4D,0x70d8}, // + {0xAF4E,0x70e4}, // + {0xAF4F,0x70d9}, // + {0xAF50,0x70c8}, // + {0xAF51,0x70cf}, // + {0xAF52,0x7239}, // + {0xAF53,0x7279}, // + {0xAF54,0x72fc}, // + {0xAF55,0x72f9}, // + {0xAF56,0x72fd}, // + {0xAF57,0x72f8}, // + {0xAF58,0x72f7}, // + {0xAF59,0x7386}, // + {0xAF5A,0x73ed}, // + {0xAF5B,0x7409}, // + {0xAF5C,0x73ee}, // + {0xAF5D,0x73e0}, // + {0xAF5E,0x73ea}, // + {0xAF5F,0x73de}, // + {0xAF60,0x7554}, // + {0xAF61,0x755d}, // + {0xAF62,0x755c}, // + {0xAF63,0x755a}, // + {0xAF64,0x7559}, // + {0xAF65,0x75be}, // + {0xAF66,0x75c5}, // + {0xAF67,0x75c7}, // + {0xAF68,0x75b2}, // + {0xAF69,0x75b3}, // + {0xAF6A,0x75bd}, // + {0xAF6B,0x75bc}, // + {0xAF6C,0x75b9}, // + {0xAF6D,0x75c2}, // + {0xAF6E,0x75b8}, // + {0xAF6F,0x768b}, // + {0xAF70,0x76b0}, // + {0xAF71,0x76ca}, // + {0xAF72,0x76cd}, // + {0xAF73,0x76ce}, // + {0xAF74,0x7729}, // + {0xAF75,0x771f}, // + {0xAF76,0x7720}, // + {0xAF77,0x7728}, // + {0xAF78,0x77e9}, // + {0xAF79,0x7830}, // + {0xAF7A,0x7827}, // + {0xAF7B,0x7838}, // + {0xAF7C,0x781d}, // + {0xAF7D,0x7834}, // + {0xAF7E,0x7837}, // + {0xAFA1,0x7825}, // + {0xAFA2,0x782d}, // + {0xAFA3,0x7820}, // + {0xAFA4,0x781f}, // + {0xAFA5,0x7832}, // + {0xAFA6,0x7955}, // + {0xAFA7,0x7950}, // + {0xAFA8,0x7960}, // + {0xAFA9,0x795f}, // + {0xAFAA,0x7956}, // + {0xAFAB,0x795e}, // + {0xAFAC,0x795d}, // + {0xAFAD,0x7957}, // + {0xAFAE,0x795a}, // + {0xAFAF,0x79e4}, // + {0xAFB0,0x79e3}, // + {0xAFB1,0x79e7}, // + {0xAFB2,0x79df}, // + {0xAFB3,0x79e6}, // + {0xAFB4,0x79e9}, // + {0xAFB5,0x79d8}, // + {0xAFB6,0x7a84}, // + {0xAFB7,0x7a88}, // + {0xAFB8,0x7ad9}, // + {0xAFB9,0x7b06}, // + {0xAFBA,0x7b11}, // + {0xAFBB,0x7c89}, // + {0xAFBC,0x7d21}, // + {0xAFBD,0x7d17}, // + {0xAFBE,0x7d0b}, // + {0xAFBF,0x7d0a}, // + {0xAFC0,0x7d20}, // + {0xAFC1,0x7d22}, // + {0xAFC2,0x7d14}, // + {0xAFC3,0x7d10}, // + {0xAFC4,0x7d15}, // + {0xAFC5,0x7d1a}, // + {0xAFC6,0x7d1c}, // + {0xAFC7,0x7d0d}, // + {0xAFC8,0x7d19}, // + {0xAFC9,0x7d1b}, // + {0xAFCA,0x7f3a}, // + {0xAFCB,0x7f5f}, // + {0xAFCC,0x7f94}, // + {0xAFCD,0x7fc5}, // + {0xAFCE,0x7fc1}, // + {0xAFCF,0x8006}, // + {0xAFD0,0x8018}, // + {0xAFD1,0x8015}, // + {0xAFD2,0x8019}, // + {0xAFD3,0x8017}, // + {0xAFD4,0x803d}, // + {0xAFD5,0x803f}, // + {0xAFD6,0x80f1}, // + {0xAFD7,0x8102}, // + {0xAFD8,0x80f0}, // + {0xAFD9,0x8105}, // + {0xAFDA,0x80ed}, // + {0xAFDB,0x80f4}, // + {0xAFDC,0x8106}, // + {0xAFDD,0x80f8}, // + {0xAFDE,0x80f3}, // + {0xAFDF,0x8108}, // + {0xAFE0,0x80fd}, // + {0xAFE1,0x810a}, // + {0xAFE2,0x80fc}, // + {0xAFE3,0x80ef}, // + {0xAFE4,0x81ed}, // + {0xAFE5,0x81ec}, // + {0xAFE6,0x8200}, // + {0xAFE7,0x8210}, // + {0xAFE8,0x822a}, // + {0xAFE9,0x822b}, // + {0xAFEA,0x8228}, // + {0xAFEB,0x822c}, // + {0xAFEC,0x82bb}, // + {0xAFED,0x832b}, // + {0xAFEE,0x8352}, // + {0xAFEF,0x8354}, // + {0xAFF0,0x834a}, // + {0xAFF1,0x8338}, // + {0xAFF2,0x8350}, // + {0xAFF3,0x8349}, // + {0xAFF4,0x8335}, // + {0xAFF5,0x8334}, // + {0xAFF6,0x834f}, // + {0xAFF7,0x8332}, // + {0xAFF8,0x8339}, // + {0xAFF9,0x8336}, // + {0xAFFA,0x8317}, // + {0xAFFB,0x8340}, // + {0xAFFC,0x8331}, // + {0xAFFD,0x8328}, // + {0xAFFE,0x8343}, // + {0xB040,0x8654}, // + {0xB041,0x868a}, // + {0xB042,0x86aa}, // + {0xB043,0x8693}, // + {0xB044,0x86a4}, // + {0xB045,0x86a9}, // + {0xB046,0x868c}, // + {0xB047,0x86a3}, // + {0xB048,0x869c}, // + {0xB049,0x8870}, // + {0xB04A,0x8877}, // + {0xB04B,0x8881}, // + {0xB04C,0x8882}, // + {0xB04D,0x887d}, // + {0xB04E,0x8879}, // + {0xB04F,0x8a18}, // + {0xB050,0x8a10}, // + {0xB051,0x8a0e}, // + {0xB052,0x8a0c}, // + {0xB053,0x8a15}, // + {0xB054,0x8a0a}, // + {0xB055,0x8a17}, // + {0xB056,0x8a13}, // + {0xB057,0x8a16}, // + {0xB058,0x8a0f}, // + {0xB059,0x8a11}, // + {0xB05A,0x8c48}, // + {0xB05B,0x8c7a}, // + {0xB05C,0x8c79}, // + {0xB05D,0x8ca1}, // + {0xB05E,0x8ca2}, // + {0xB05F,0x8d77}, // + {0xB060,0x8eac}, // + {0xB061,0x8ed2}, // + {0xB062,0x8ed4}, // + {0xB063,0x8ecf}, // + {0xB064,0x8fb1}, // + {0xB065,0x9001}, // + {0xB066,0x9006}, // + {0xB067,0x8ff7}, // + {0xB068,0x9000}, // + {0xB069,0x8ffa}, // + {0xB06A,0x8ff4}, // + {0xB06B,0x9003}, // + {0xB06C,0x8ffd}, // + {0xB06D,0x9005}, // + {0xB06E,0x8ff8}, // + {0xB06F,0x9095}, // + {0xB070,0x90e1}, // + {0xB071,0x90dd}, // + {0xB072,0x90e2}, // + {0xB073,0x9152}, // + {0xB074,0x914d}, // + {0xB075,0x914c}, // + {0xB076,0x91d8}, // + {0xB077,0x91dd}, // + {0xB078,0x91d7}, // + {0xB079,0x91dc}, // + {0xB07A,0x91d9}, // + {0xB07B,0x9583}, // + {0xB07C,0x9662}, // + {0xB07D,0x9663}, // + {0xB07E,0x9661}, // + {0xB0A1,0x965b}, // + {0xB0A2,0x965d}, // + {0xB0A3,0x9664}, // + {0xB0A4,0x9658}, // + {0xB0A5,0x965e}, // + {0xB0A6,0x96bb}, // + {0xB0A7,0x98e2}, // + {0xB0A8,0x99ac}, // + {0xB0A9,0x9aa8}, // + {0xB0AA,0x9ad8}, // + {0xB0AB,0x9b25}, // + {0xB0AC,0x9b32}, // + {0xB0AD,0x9b3c}, // + {0xB0AE,0x4e7e}, // + {0xB0AF,0x507a}, // + {0xB0B0,0x507d}, // + {0xB0B1,0x505c}, // + {0xB0B2,0x5047}, // + {0xB0B3,0x5043}, // + {0xB0B4,0x504c}, // + {0xB0B5,0x505a}, // + {0xB0B6,0x5049}, // + {0xB0B7,0x5065}, // + {0xB0B8,0x5076}, // + {0xB0B9,0x504e}, // + {0xB0BA,0x5055}, // + {0xB0BB,0x5075}, // + {0xB0BC,0x5074}, // + {0xB0BD,0x5077}, // + {0xB0BE,0x504f}, // + {0xB0BF,0x500f}, // + {0xB0C0,0x506f}, // + {0xB0C1,0x506d}, // + {0xB0C2,0x515c}, // + {0xB0C3,0x5195}, // + {0xB0C4,0x51f0}, // + {0xB0C5,0x526a}, // + {0xB0C6,0x526f}, // + {0xB0C7,0x52d2}, // + {0xB0C8,0x52d9}, // + {0xB0C9,0x52d8}, // + {0xB0CA,0x52d5}, // + {0xB0CB,0x5310}, // + {0xB0CC,0x530f}, // + {0xB0CD,0x5319}, // + {0xB0CE,0x533f}, // + {0xB0CF,0x5340}, // + {0xB0D0,0x533e}, // + {0xB0D1,0x53c3}, // + {0xB0D2,0x66fc}, // + {0xB0D3,0x5546}, // + {0xB0D4,0x556a}, // + {0xB0D5,0x5566}, // + {0xB0D6,0x5544}, // + {0xB0D7,0x555e}, // + {0xB0D8,0x5561}, // + {0xB0D9,0x5543}, // + {0xB0DA,0x554a}, // + {0xB0DB,0x5531}, // + {0xB0DC,0x5556}, // + {0xB0DD,0x554f}, // + {0xB0DE,0x5555}, // + {0xB0DF,0x552f}, // + {0xB0E0,0x5564}, // + {0xB0E1,0x5538}, // + {0xB0E2,0x552e}, // + {0xB0E3,0x555c}, // + {0xB0E4,0x552c}, // + {0xB0E5,0x5563}, // + {0xB0E6,0x5533}, // + {0xB0E7,0x5541}, // + {0xB0E8,0x5557}, // + {0xB0E9,0x5708}, // + {0xB0EA,0x570b}, // + {0xB0EB,0x5709}, // + {0xB0EC,0x57df}, // + {0xB0ED,0x5805}, // + {0xB0EE,0x580a}, // + {0xB0EF,0x5806}, // + {0xB0F0,0x57e0}, // + {0xB0F1,0x57e4}, // + {0xB0F2,0x57fa}, // + {0xB0F3,0x5802}, // + {0xB0F4,0x5835}, // + {0xB0F5,0x57f7}, // + {0xB0F6,0x57f9}, // + {0xB0F7,0x5920}, // + {0xB0F8,0x5962}, // + {0xB0F9,0x5a36}, // + {0xB0FA,0x5a41}, // + {0xB0FB,0x5a49}, // + {0xB0FC,0x5a66}, // + {0xB0FD,0x5a6a}, // + {0xB0FE,0x5a40}, // + {0xB140,0x5a3c}, // + {0xB141,0x5a62}, // + {0xB142,0x5a5a}, // + {0xB143,0x5a46}, // + {0xB144,0x5a4a}, // + {0xB145,0x5b70}, // + {0xB146,0x5bc7}, // + {0xB147,0x5bc5}, // + {0xB148,0x5bc4}, // + {0xB149,0x5bc2}, // + {0xB14A,0x5bbf}, // + {0xB14B,0x5bc6}, // + {0xB14C,0x5c09}, // + {0xB14D,0x5c08}, // + {0xB14E,0x5c07}, // + {0xB14F,0x5c60}, // + {0xB150,0x5c5c}, // + {0xB151,0x5c5d}, // + {0xB152,0x5d07}, // + {0xB153,0x5d06}, // + {0xB154,0x5d0e}, // + {0xB155,0x5d1b}, // + {0xB156,0x5d16}, // + {0xB157,0x5d22}, // + {0xB158,0x5d11}, // + {0xB159,0x5d29}, // + {0xB15A,0x5d14}, // + {0xB15B,0x5d19}, // + {0xB15C,0x5d24}, // + {0xB15D,0x5d27}, // + {0xB15E,0x5d17}, // + {0xB15F,0x5de2}, // + {0xB160,0x5e38}, // + {0xB161,0x5e36}, // + {0xB162,0x5e33}, // + {0xB163,0x5e37}, // + {0xB164,0x5eb7}, // + {0xB165,0x5eb8}, // + {0xB166,0x5eb6}, // + {0xB167,0x5eb5}, // + {0xB168,0x5ebe}, // + {0xB169,0x5f35}, // + {0xB16A,0x5f37}, // + {0xB16B,0x5f57}, // + {0xB16C,0x5f6c}, // + {0xB16D,0x5f69}, // + {0xB16E,0x5f6b}, // + {0xB16F,0x5f97}, // + {0xB170,0x5f99}, // + {0xB171,0x5f9e}, // + {0xB172,0x5f98}, // + {0xB173,0x5fa1}, // + {0xB174,0x5fa0}, // + {0xB175,0x5f9c}, // + {0xB176,0x607f}, // + {0xB177,0x60a3}, // + {0xB178,0x6089}, // + {0xB179,0x60a0}, // + {0xB17A,0x60a8}, // + {0xB17B,0x60cb}, // + {0xB17C,0x60b4}, // + {0xB17D,0x60e6}, // + {0xB17E,0x60bd}, // + {0xB1A1,0x60c5}, // + {0xB1A2,0x60bb}, // + {0xB1A3,0x60b5}, // + {0xB1A4,0x60dc}, // + {0xB1A5,0x60bc}, // + {0xB1A6,0x60d8}, // + {0xB1A7,0x60d5}, // + {0xB1A8,0x60c6}, // + {0xB1A9,0x60df}, // + {0xB1AA,0x60b8}, // + {0xB1AB,0x60da}, // + {0xB1AC,0x60c7}, // + {0xB1AD,0x621a}, // + {0xB1AE,0x621b}, // + {0xB1AF,0x6248}, // + {0xB1B0,0x63a0}, // + {0xB1B1,0x63a7}, // + {0xB1B2,0x6372}, // + {0xB1B3,0x6396}, // + {0xB1B4,0x63a2}, // + {0xB1B5,0x63a5}, // + {0xB1B6,0x6377}, // + {0xB1B7,0x6367}, // + {0xB1B8,0x6398}, // + {0xB1B9,0x63aa}, // + {0xB1BA,0x6371}, // + {0xB1BB,0x63a9}, // + {0xB1BC,0x6389}, // + {0xB1BD,0x6383}, // + {0xB1BE,0x639b}, // + {0xB1BF,0x636b}, // + {0xB1C0,0x63a8}, // + {0xB1C1,0x6384}, // + {0xB1C2,0x6388}, // + {0xB1C3,0x6399}, // + {0xB1C4,0x63a1}, // + {0xB1C5,0x63ac}, // + {0xB1C6,0x6392}, // + {0xB1C7,0x638f}, // + {0xB1C8,0x6380}, // + {0xB1C9,0x637b}, // + {0xB1CA,0x6369}, // + {0xB1CB,0x6368}, // + {0xB1CC,0x637a}, // + {0xB1CD,0x655d}, // + {0xB1CE,0x6556}, // + {0xB1CF,0x6551}, // + {0xB1D0,0x6559}, // + {0xB1D1,0x6557}, // + {0xB1D2,0x555f}, // + {0xB1D3,0x654f}, // + {0xB1D4,0x6558}, // + {0xB1D5,0x6555}, // + {0xB1D6,0x6554}, // + {0xB1D7,0x659c}, // + {0xB1D8,0x659b}, // + {0xB1D9,0x65ac}, // + {0xB1DA,0x65cf}, // + {0xB1DB,0x65cb}, // + {0xB1DC,0x65cc}, // + {0xB1DD,0x65ce}, // + {0xB1DE,0x665d}, // + {0xB1DF,0x665a}, // + {0xB1E0,0x6664}, // + {0xB1E1,0x6668}, // + {0xB1E2,0x6666}, // + {0xB1E3,0x665e}, // + {0xB1E4,0x66f9}, // + {0xB1E5,0x52d7}, // + {0xB1E6,0x671b}, // + {0xB1E7,0x6881}, // + {0xB1E8,0x68af}, // + {0xB1E9,0x68a2}, // + {0xB1EA,0x6893}, // + {0xB1EB,0x68b5}, // + {0xB1EC,0x687f}, // + {0xB1ED,0x6876}, // + {0xB1EE,0x68b1}, // + {0xB1EF,0x68a7}, // + {0xB1F0,0x6897}, // + {0xB1F1,0x68b0}, // + {0xB1F2,0x6883}, // + {0xB1F3,0x68c4}, // + {0xB1F4,0x68ad}, // + {0xB1F5,0x6886}, // + {0xB1F6,0x6885}, // + {0xB1F7,0x6894}, // + {0xB1F8,0x689d}, // + {0xB1F9,0x68a8}, // + {0xB1FA,0x689f}, // + {0xB1FB,0x68a1}, // + {0xB1FC,0x6882}, // + {0xB1FD,0x6b32}, // + {0xB1FE,0x6bba}, // + {0xB240,0x6beb}, // + {0xB241,0x6bec}, // + {0xB242,0x6c2b}, // + {0xB243,0x6d8e}, // + {0xB244,0x6dbc}, // + {0xB245,0x6df3}, // + {0xB246,0x6dd9}, // + {0xB247,0x6db2}, // + {0xB248,0x6de1}, // + {0xB249,0x6dcc}, // + {0xB24A,0x6de4}, // + {0xB24B,0x6dfb}, // + {0xB24C,0x6dfa}, // + {0xB24D,0x6e05}, // + {0xB24E,0x6dc7}, // + {0xB24F,0x6dcb}, // + {0xB250,0x6daf}, // + {0xB251,0x6dd1}, // + {0xB252,0x6dae}, // + {0xB253,0x6dde}, // + {0xB254,0x6df9}, // + {0xB255,0x6db8}, // + {0xB256,0x6df7}, // + {0xB257,0x6df5}, // + {0xB258,0x6dc5}, // + {0xB259,0x6dd2}, // + {0xB25A,0x6e1a}, // + {0xB25B,0x6db5}, // + {0xB25C,0x6dda}, // + {0xB25D,0x6deb}, // + {0xB25E,0x6dd8}, // + {0xB25F,0x6dea}, // + {0xB260,0x6df1}, // + {0xB261,0x6dee}, // + {0xB262,0x6de8}, // + {0xB263,0x6dc6}, // + {0xB264,0x6dc4}, // + {0xB265,0x6daa}, // + {0xB266,0x6dec}, // + {0xB267,0x6dbf}, // + {0xB268,0x6de6}, // + {0xB269,0x70f9}, // + {0xB26A,0x7109}, // + {0xB26B,0x710a}, // + {0xB26C,0x70fd}, // + {0xB26D,0x70ef}, // + {0xB26E,0x723d}, // + {0xB26F,0x727d}, // + {0xB270,0x7281}, // + {0xB271,0x731c}, // + {0xB272,0x731b}, // + {0xB273,0x7316}, // + {0xB274,0x7313}, // + {0xB275,0x7319}, // + {0xB276,0x7387}, // + {0xB277,0x7405}, // + {0xB278,0x740a}, // + {0xB279,0x7403}, // + {0xB27A,0x7406}, // + {0xB27B,0x73fe}, // + {0xB27C,0x740d}, // + {0xB27D,0x74e0}, // + {0xB27E,0x74f6}, // + {0xB2A1,0x74f7}, // + {0xB2A2,0x751c}, // + {0xB2A3,0x7522}, // + {0xB2A4,0x7565}, // + {0xB2A5,0x7566}, // + {0xB2A6,0x7562}, // + {0xB2A7,0x7570}, // + {0xB2A8,0x758f}, // + {0xB2A9,0x75d4}, // + {0xB2AA,0x75d5}, // + {0xB2AB,0x75b5}, // + {0xB2AC,0x75ca}, // + {0xB2AD,0x75cd}, // + {0xB2AE,0x768e}, // + {0xB2AF,0x76d4}, // + {0xB2B0,0x76d2}, // + {0xB2B1,0x76db}, // + {0xB2B2,0x7737}, // + {0xB2B3,0x773e}, // + {0xB2B4,0x773c}, // + {0xB2B5,0x7736}, // + {0xB2B6,0x7738}, // + {0xB2B7,0x773a}, // + {0xB2B8,0x786b}, // + {0xB2B9,0x7843}, // + {0xB2BA,0x784e}, // + {0xB2BB,0x7965}, // + {0xB2BC,0x7968}, // + {0xB2BD,0x796d}, // + {0xB2BE,0x79fb}, // + {0xB2BF,0x7a92}, // + {0xB2C0,0x7a95}, // + {0xB2C1,0x7b20}, // + {0xB2C2,0x7b28}, // + {0xB2C3,0x7b1b}, // + {0xB2C4,0x7b2c}, // + {0xB2C5,0x7b26}, // + {0xB2C6,0x7b19}, // + {0xB2C7,0x7b1e}, // + {0xB2C8,0x7b2e}, // + {0xB2C9,0x7c92}, // + {0xB2CA,0x7c97}, // + {0xB2CB,0x7c95}, // + {0xB2CC,0x7d46}, // + {0xB2CD,0x7d43}, // + {0xB2CE,0x7d71}, // + {0xB2CF,0x7d2e}, // + {0xB2D0,0x7d39}, // + {0xB2D1,0x7d3c}, // + {0xB2D2,0x7d40}, // + {0xB2D3,0x7d30}, // + {0xB2D4,0x7d33}, // + {0xB2D5,0x7d44}, // + {0xB2D6,0x7d2f}, // + {0xB2D7,0x7d42}, // + {0xB2D8,0x7d32}, // + {0xB2D9,0x7d31}, // + {0xB2DA,0x7f3d}, // + {0xB2DB,0x7f9e}, // + {0xB2DC,0x7f9a}, // + {0xB2DD,0x7fcc}, // + {0xB2DE,0x7fce}, // + {0xB2DF,0x7fd2}, // + {0xB2E0,0x801c}, // + {0xB2E1,0x804a}, // + {0xB2E2,0x8046}, // + {0xB2E3,0x812f}, // + {0xB2E4,0x8116}, // + {0xB2E5,0x8123}, // + {0xB2E6,0x812b}, // + {0xB2E7,0x8129}, // + {0xB2E8,0x8130}, // + {0xB2E9,0x8124}, // + {0xB2EA,0x8202}, // + {0xB2EB,0x8235}, // + {0xB2EC,0x8237}, // + {0xB2ED,0x8236}, // + {0xB2EE,0x8239}, // + {0xB2EF,0x838e}, // + {0xB2F0,0x839e}, // + {0xB2F1,0x8398}, // + {0xB2F2,0x8378}, // + {0xB2F3,0x83a2}, // + {0xB2F4,0x8396}, // + {0xB2F5,0x83bd}, // + {0xB2F6,0x83ab}, // + {0xB2F7,0x8392}, // + {0xB2F8,0x838a}, // + {0xB2F9,0x8393}, // + {0xB2FA,0x8389}, // + {0xB2FB,0x83a0}, // + {0xB2FC,0x8377}, // + {0xB2FD,0x837b}, // + {0xB2FE,0x837c}, // + {0xB340,0x8386}, // + {0xB341,0x83a7}, // + {0xB342,0x8655}, // + {0xB343,0x5f6a}, // + {0xB344,0x86c7}, // + {0xB345,0x86c0}, // + {0xB346,0x86b6}, // + {0xB347,0x86c4}, // + {0xB348,0x86b5}, // + {0xB349,0x86c6}, // + {0xB34A,0x86cb}, // + {0xB34B,0x86b1}, // + {0xB34C,0x86af}, // + {0xB34D,0x86c9}, // + {0xB34E,0x8853}, // + {0xB34F,0x889e}, // + {0xB350,0x8888}, // + {0xB351,0x88ab}, // + {0xB352,0x8892}, // + {0xB353,0x8896}, // + {0xB354,0x888d}, // + {0xB355,0x888b}, // + {0xB356,0x8993}, // + {0xB357,0x898f}, // + {0xB358,0x8a2a}, // + {0xB359,0x8a1d}, // + {0xB35A,0x8a23}, // + {0xB35B,0x8a25}, // + {0xB35C,0x8a31}, // + {0xB35D,0x8a2d}, // + {0xB35E,0x8a1f}, // + {0xB35F,0x8a1b}, // + {0xB360,0x8a22}, // + {0xB361,0x8c49}, // + {0xB362,0x8c5a}, // + {0xB363,0x8ca9}, // + {0xB364,0x8cac}, // + {0xB365,0x8cab}, // + {0xB366,0x8ca8}, // + {0xB367,0x8caa}, // + {0xB368,0x8ca7}, // + {0xB369,0x8d67}, // + {0xB36A,0x8d66}, // + {0xB36B,0x8dbe}, // + {0xB36C,0x8dba}, // + {0xB36D,0x8edb}, // + {0xB36E,0x8edf}, // + {0xB36F,0x9019}, // + {0xB370,0x900d}, // + {0xB371,0x901a}, // + {0xB372,0x9017}, // + {0xB373,0x9023}, // + {0xB374,0x901f}, // + {0xB375,0x901d}, // + {0xB376,0x9010}, // + {0xB377,0x9015}, // + {0xB378,0x901e}, // + {0xB379,0x9020}, // + {0xB37A,0x900f}, // + {0xB37B,0x9022}, // + {0xB37C,0x9016}, // + {0xB37D,0x901b}, // + {0xB37E,0x9014}, // + {0xB3A1,0x90e8}, // + {0xB3A2,0x90ed}, // + {0xB3A3,0x90fd}, // + {0xB3A4,0x9157}, // + {0xB3A5,0x91ce}, // + {0xB3A6,0x91f5}, // + {0xB3A7,0x91e6}, // + {0xB3A8,0x91e3}, // + {0xB3A9,0x91e7}, // + {0xB3AA,0x91ed}, // + {0xB3AB,0x91e9}, // + {0xB3AC,0x9589}, // + {0xB3AD,0x966a}, // + {0xB3AE,0x9675}, // + {0xB3AF,0x9673}, // + {0xB3B0,0x9678}, // + {0xB3B1,0x9670}, // + {0xB3B2,0x9674}, // + {0xB3B3,0x9676}, // + {0xB3B4,0x9677}, // + {0xB3B5,0x966c}, // + {0xB3B6,0x96c0}, // + {0xB3B7,0x96ea}, // + {0xB3B8,0x96e9}, // + {0xB3B9,0x7ae0}, // + {0xB3BA,0x7adf}, // + {0xB3BB,0x9802}, // + {0xB3BC,0x9803}, // + {0xB3BD,0x9b5a}, // + {0xB3BE,0x9ce5}, // + {0xB3BF,0x9e75}, // + {0xB3C0,0x9e7f}, // + {0xB3C1,0x9ea5}, // + {0xB3C2,0x9ebb}, // + {0xB3C3,0x50a2}, // + {0xB3C4,0x508d}, // + {0xB3C5,0x5085}, // + {0xB3C6,0x5099}, // + {0xB3C7,0x5091}, // + {0xB3C8,0x5080}, // + {0xB3C9,0x5096}, // + {0xB3CA,0x5098}, // + {0xB3CB,0x509a}, // + {0xB3CC,0x6700}, // + {0xB3CD,0x51f1}, // + {0xB3CE,0x5272}, // + {0xB3CF,0x5274}, // + {0xB3D0,0x5275}, // + {0xB3D1,0x5269}, // + {0xB3D2,0x52de}, // + {0xB3D3,0x52dd}, // + {0xB3D4,0x52db}, // + {0xB3D5,0x535a}, // + {0xB3D6,0x53a5}, // + {0xB3D7,0x557b}, // + {0xB3D8,0x5580}, // + {0xB3D9,0x55a7}, // + {0xB3DA,0x557c}, // + {0xB3DB,0x558a}, // + {0xB3DC,0x559d}, // + {0xB3DD,0x5598}, // + {0xB3DE,0x5582}, // + {0xB3DF,0x559c}, // + {0xB3E0,0x55aa}, // + {0xB3E1,0x5594}, // + {0xB3E2,0x5587}, // + {0xB3E3,0x558b}, // + {0xB3E4,0x5583}, // + {0xB3E5,0x55b3}, // + {0xB3E6,0x55ae}, // + {0xB3E7,0x559f}, // + {0xB3E8,0x553e}, // + {0xB3E9,0x55b2}, // + {0xB3EA,0x559a}, // + {0xB3EB,0x55bb}, // + {0xB3EC,0x55ac}, // + {0xB3ED,0x55b1}, // + {0xB3EE,0x557e}, // + {0xB3EF,0x5589}, // + {0xB3F0,0x55ab}, // + {0xB3F1,0x5599}, // + {0xB3F2,0x570d}, // + {0xB3F3,0x582f}, // + {0xB3F4,0x582a}, // + {0xB3F5,0x5834}, // + {0xB3F6,0x5824}, // + {0xB3F7,0x5830}, // + {0xB3F8,0x5831}, // + {0xB3F9,0x5821}, // + {0xB3FA,0x581d}, // + {0xB3FB,0x5820}, // + {0xB3FC,0x58f9}, // + {0xB3FD,0x58fa}, // + {0xB3FE,0x5960}, // + {0xB440,0x5a77}, // + {0xB441,0x5a9a}, // + {0xB442,0x5a7f}, // + {0xB443,0x5a92}, // + {0xB444,0x5a9b}, // + {0xB445,0x5aa7}, // + {0xB446,0x5b73}, // + {0xB447,0x5b71}, // + {0xB448,0x5bd2}, // + {0xB449,0x5bcc}, // + {0xB44A,0x5bd3}, // + {0xB44B,0x5bd0}, // + {0xB44C,0x5c0a}, // + {0xB44D,0x5c0b}, // + {0xB44E,0x5c31}, // + {0xB44F,0x5d4c}, // + {0xB450,0x5d50}, // + {0xB451,0x5d34}, // + {0xB452,0x5d47}, // + {0xB453,0x5dfd}, // + {0xB454,0x5e45}, // + {0xB455,0x5e3d}, // + {0xB456,0x5e40}, // + {0xB457,0x5e43}, // + {0xB458,0x5e7e}, // + {0xB459,0x5eca}, // + {0xB45A,0x5ec1}, // + {0xB45B,0x5ec2}, // + {0xB45C,0x5ec4}, // + {0xB45D,0x5f3c}, // + {0xB45E,0x5f6d}, // + {0xB45F,0x5fa9}, // + {0xB460,0x5faa}, // + {0xB461,0x5fa8}, // + {0xB462,0x60d1}, // + {0xB463,0x60e1}, // + {0xB464,0x60b2}, // + {0xB465,0x60b6}, // + {0xB466,0x60e0}, // + {0xB467,0x611c}, // + {0xB468,0x6123}, // + {0xB469,0x60fa}, // + {0xB46A,0x6115}, // + {0xB46B,0x60f0}, // + {0xB46C,0x60fb}, // + {0xB46D,0x60f4}, // + {0xB46E,0x6168}, // + {0xB46F,0x60f1}, // + {0xB470,0x610e}, // + {0xB471,0x60f6}, // + {0xB472,0x6109}, // + {0xB473,0x6100}, // + {0xB474,0x6112}, // + {0xB475,0x621f}, // + {0xB476,0x6249}, // + {0xB477,0x63a3}, // + {0xB478,0x638c}, // + {0xB479,0x63cf}, // + {0xB47A,0x63c0}, // + {0xB47B,0x63e9}, // + {0xB47C,0x63c9}, // + {0xB47D,0x63c6}, // + {0xB47E,0x63cd}, // + {0xB4A1,0x63d2}, // + {0xB4A2,0x63e3}, // + {0xB4A3,0x63d0}, // + {0xB4A4,0x63e1}, // + {0xB4A5,0x63d6}, // + {0xB4A6,0x63ed}, // + {0xB4A7,0x63ee}, // + {0xB4A8,0x6376}, // + {0xB4A9,0x63f4}, // + {0xB4AA,0x63ea}, // + {0xB4AB,0x63db}, // + {0xB4AC,0x6452}, // + {0xB4AD,0x63da}, // + {0xB4AE,0x63f9}, // + {0xB4AF,0x655e}, // + {0xB4B0,0x6566}, // + {0xB4B1,0x6562}, // + {0xB4B2,0x6563}, // + {0xB4B3,0x6591}, // + {0xB4B4,0x6590}, // + {0xB4B5,0x65af}, // + {0xB4B6,0x666e}, // + {0xB4B7,0x6670}, // + {0xB4B8,0x6674}, // + {0xB4B9,0x6676}, // + {0xB4BA,0x666f}, // + {0xB4BB,0x6691}, // + {0xB4BC,0x667a}, // + {0xB4BD,0x667e}, // + {0xB4BE,0x6677}, // + {0xB4BF,0x66fe}, // + {0xB4C0,0x66ff}, // + {0xB4C1,0x671f}, // + {0xB4C2,0x671d}, // + {0xB4C3,0x68fa}, // + {0xB4C4,0x68d5}, // + {0xB4C5,0x68e0}, // + {0xB4C6,0x68d8}, // + {0xB4C7,0x68d7}, // + {0xB4C8,0x6905}, // + {0xB4C9,0x68df}, // + {0xB4CA,0x68f5}, // + {0xB4CB,0x68ee}, // + {0xB4CC,0x68e7}, // + {0xB4CD,0x68f9}, // + {0xB4CE,0x68d2}, // + {0xB4CF,0x68f2}, // + {0xB4D0,0x68e3}, // + {0xB4D1,0x68cb}, // + {0xB4D2,0x68cd}, // + {0xB4D3,0x690d}, // + {0xB4D4,0x6912}, // + {0xB4D5,0x690e}, // + {0xB4D6,0x68c9}, // + {0xB4D7,0x68da}, // + {0xB4D8,0x696e}, // + {0xB4D9,0x68fb}, // + {0xB4DA,0x6b3e}, // + {0xB4DB,0x6b3a}, // + {0xB4DC,0x6b3d}, // + {0xB4DD,0x6b98}, // + {0xB4DE,0x6b96}, // + {0xB4DF,0x6bbc}, // + {0xB4E0,0x6bef}, // + {0xB4E1,0x6c2e}, // + {0xB4E2,0x6c2f}, // + {0xB4E3,0x6c2c}, // + {0xB4E4,0x6e2f}, // + {0xB4E5,0x6e38}, // + {0xB4E6,0x6e54}, // + {0xB4E7,0x6e21}, // + {0xB4E8,0x6e32}, // + {0xB4E9,0x6e67}, // + {0xB4EA,0x6e4a}, // + {0xB4EB,0x6e20}, // + {0xB4EC,0x6e25}, // + {0xB4ED,0x6e23}, // + {0xB4EE,0x6e1b}, // + {0xB4EF,0x6e5b}, // + {0xB4F0,0x6e58}, // + {0xB4F1,0x6e24}, // + {0xB4F2,0x6e56}, // + {0xB4F3,0x6e6e}, // + {0xB4F4,0x6e2d}, // + {0xB4F5,0x6e26}, // + {0xB4F6,0x6e6f}, // + {0xB4F7,0x6e34}, // + {0xB4F8,0x6e4d}, // + {0xB4F9,0x6e3a}, // + {0xB4FA,0x6e2c}, // + {0xB4FB,0x6e43}, // + {0xB4FC,0x6e1d}, // + {0xB4FD,0x6e3e}, // + {0xB4FE,0x6ecb}, // + {0xB540,0x6e89}, // + {0xB541,0x6e19}, // + {0xB542,0x6e4e}, // + {0xB543,0x6e63}, // + {0xB544,0x6e44}, // + {0xB545,0x6e72}, // + {0xB546,0x6e69}, // + {0xB547,0x6e5f}, // + {0xB548,0x7119}, // + {0xB549,0x711a}, // + {0xB54A,0x7126}, // + {0xB54B,0x7130}, // + {0xB54C,0x7121}, // + {0xB54D,0x7136}, // + {0xB54E,0x716e}, // + {0xB54F,0x711c}, // + {0xB550,0x724c}, // + {0xB551,0x7284}, // + {0xB552,0x7280}, // + {0xB553,0x7336}, // + {0xB554,0x7325}, // + {0xB555,0x7334}, // + {0xB556,0x7329}, // + {0xB557,0x743a}, // + {0xB558,0x742a}, // + {0xB559,0x7433}, // + {0xB55A,0x7422}, // + {0xB55B,0x7425}, // + {0xB55C,0x7435}, // + {0xB55D,0x7436}, // + {0xB55E,0x7434}, // + {0xB55F,0x742f}, // + {0xB560,0x741b}, // + {0xB561,0x7426}, // + {0xB562,0x7428}, // + {0xB563,0x7525}, // + {0xB564,0x7526}, // + {0xB565,0x756b}, // + {0xB566,0x756a}, // + {0xB567,0x75e2}, // + {0xB568,0x75db}, // + {0xB569,0x75e3}, // + {0xB56A,0x75d9}, // + {0xB56B,0x75d8}, // + {0xB56C,0x75de}, // + {0xB56D,0x75e0}, // + {0xB56E,0x767b}, // + {0xB56F,0x767c}, // + {0xB570,0x7696}, // + {0xB571,0x7693}, // + {0xB572,0x76b4}, // + {0xB573,0x76dc}, // + {0xB574,0x774f}, // + {0xB575,0x77ed}, // + {0xB576,0x785d}, // + {0xB577,0x786c}, // + {0xB578,0x786f}, // + {0xB579,0x7a0d}, // + {0xB57A,0x7a08}, // + {0xB57B,0x7a0b}, // + {0xB57C,0x7a05}, // + {0xB57D,0x7a00}, // + {0xB57E,0x7a98}, // + {0xB5A1,0x7a97}, // + {0xB5A2,0x7a96}, // + {0xB5A3,0x7ae5}, // + {0xB5A4,0x7ae3}, // + {0xB5A5,0x7b49}, // + {0xB5A6,0x7b56}, // + {0xB5A7,0x7b46}, // + {0xB5A8,0x7b50}, // + {0xB5A9,0x7b52}, // + {0xB5AA,0x7b54}, // + {0xB5AB,0x7b4d}, // + {0xB5AC,0x7b4b}, // + {0xB5AD,0x7b4f}, // + {0xB5AE,0x7b51}, // + {0xB5AF,0x7c9f}, // + {0xB5B0,0x7ca5}, // + {0xB5B1,0x7d5e}, // + {0xB5B2,0x7d50}, // + {0xB5B3,0x7d68}, // + {0xB5B4,0x7d55}, // + {0xB5B5,0x7d2b}, // + {0xB5B6,0x7d6e}, // + {0xB5B7,0x7d72}, // + {0xB5B8,0x7d61}, // + {0xB5B9,0x7d66}, // + {0xB5BA,0x7d62}, // + {0xB5BB,0x7d70}, // + {0xB5BC,0x7d73}, // + {0xB5BD,0x5584}, // + {0xB5BE,0x7fd4}, // + {0xB5BF,0x7fd5}, // + {0xB5C0,0x800b}, // + {0xB5C1,0x8052}, // + {0xB5C2,0x8085}, // + {0xB5C3,0x8155}, // + {0xB5C4,0x8154}, // + {0xB5C5,0x814b}, // + {0xB5C6,0x8151}, // + {0xB5C7,0x814e}, // + {0xB5C8,0x8139}, // + {0xB5C9,0x8146}, // + {0xB5CA,0x813e}, // + {0xB5CB,0x814c}, // + {0xB5CC,0x8153}, // + {0xB5CD,0x8174}, // + {0xB5CE,0x8212}, // + {0xB5CF,0x821c}, // + {0xB5D0,0x83e9}, // + {0xB5D1,0x8403}, // + {0xB5D2,0x83f8}, // + {0xB5D3,0x840d}, // + {0xB5D4,0x83e0}, // + {0xB5D5,0x83c5}, // + {0xB5D6,0x840b}, // + {0xB5D7,0x83c1}, // + {0xB5D8,0x83ef}, // + {0xB5D9,0x83f1}, // + {0xB5DA,0x83f4}, // + {0xB5DB,0x8457}, // + {0xB5DC,0x840a}, // + {0xB5DD,0x83f0}, // + {0xB5DE,0x840c}, // + {0xB5DF,0x83cc}, // + {0xB5E0,0x83fd}, // + {0xB5E1,0x83f2}, // + {0xB5E2,0x83ca}, // + {0xB5E3,0x8438}, // + {0xB5E4,0x840e}, // + {0xB5E5,0x8404}, // + {0xB5E6,0x83dc}, // + {0xB5E7,0x8407}, // + {0xB5E8,0x83d4}, // + {0xB5E9,0x83df}, // + {0xB5EA,0x865b}, // + {0xB5EB,0x86df}, // + {0xB5EC,0x86d9}, // + {0xB5ED,0x86ed}, // + {0xB5EE,0x86d4}, // + {0xB5EF,0x86db}, // + {0xB5F0,0x86e4}, // + {0xB5F1,0x86d0}, // + {0xB5F2,0x86de}, // + {0xB5F3,0x8857}, // + {0xB5F4,0x88c1}, // + {0xB5F5,0x88c2}, // + {0xB5F6,0x88b1}, // + {0xB5F7,0x8983}, // + {0xB5F8,0x8996}, // + {0xB5F9,0x8a3b}, // + {0xB5FA,0x8a60}, // + {0xB5FB,0x8a55}, // + {0xB5FC,0x8a5e}, // + {0xB5FD,0x8a3c}, // + {0xB5FE,0x8a41}, // + {0xB640,0x8a54}, // + {0xB641,0x8a5b}, // + {0xB642,0x8a50}, // + {0xB643,0x8a46}, // + {0xB644,0x8a34}, // + {0xB645,0x8a3a}, // + {0xB646,0x8a36}, // + {0xB647,0x8a56}, // + {0xB648,0x8c61}, // + {0xB649,0x8c82}, // + {0xB64A,0x8caf}, // + {0xB64B,0x8cbc}, // + {0xB64C,0x8cb3}, // + {0xB64D,0x8cbd}, // + {0xB64E,0x8cc1}, // + {0xB64F,0x8cbb}, // + {0xB650,0x8cc0}, // + {0xB651,0x8cb4}, // + {0xB652,0x8cb7}, // + {0xB653,0x8cb6}, // + {0xB654,0x8cbf}, // + {0xB655,0x8cb8}, // + {0xB656,0x8d8a}, // + {0xB657,0x8d85}, // + {0xB658,0x8d81}, // + {0xB659,0x8dce}, // + {0xB65A,0x8ddd}, // + {0xB65B,0x8dcb}, // + {0xB65C,0x8dda}, // + {0xB65D,0x8dd1}, // + {0xB65E,0x8dcc}, // + {0xB65F,0x8ddb}, // + {0xB660,0x8dc6}, // + {0xB661,0x8efb}, // + {0xB662,0x8ef8}, // + {0xB663,0x8efc}, // + {0xB664,0x8f9c}, // + {0xB665,0x902e}, // + {0xB666,0x9035}, // + {0xB667,0x9031}, // + {0xB668,0x9038}, // + {0xB669,0x9032}, // + {0xB66A,0x9036}, // + {0xB66B,0x9102}, // + {0xB66C,0x90f5}, // + {0xB66D,0x9109}, // + {0xB66E,0x90fe}, // + {0xB66F,0x9163}, // + {0xB670,0x9165}, // + {0xB671,0x91cf}, // + {0xB672,0x9214}, // + {0xB673,0x9215}, // + {0xB674,0x9223}, // + {0xB675,0x9209}, // + {0xB676,0x921e}, // + {0xB677,0x920d}, // + {0xB678,0x9210}, // + {0xB679,0x9207}, // + {0xB67A,0x9211}, // + {0xB67B,0x9594}, // + {0xB67C,0x958f}, // + {0xB67D,0x958b}, // + {0xB67E,0x9591}, // + {0xB6A1,0x9593}, // + {0xB6A2,0x9592}, // + {0xB6A3,0x958e}, // + {0xB6A4,0x968a}, // + {0xB6A5,0x968e}, // + {0xB6A6,0x968b}, // + {0xB6A7,0x967d}, // + {0xB6A8,0x9685}, // + {0xB6A9,0x9686}, // + {0xB6AA,0x968d}, // + {0xB6AB,0x9672}, // + {0xB6AC,0x9684}, // + {0xB6AD,0x96c1}, // + {0xB6AE,0x96c5}, // + {0xB6AF,0x96c4}, // + {0xB6B0,0x96c6}, // + {0xB6B1,0x96c7}, // + {0xB6B2,0x96ef}, // + {0xB6B3,0x96f2}, // + {0xB6B4,0x97cc}, // + {0xB6B5,0x9805}, // + {0xB6B6,0x9806}, // + {0xB6B7,0x9808}, // + {0xB6B8,0x98e7}, // + {0xB6B9,0x98ea}, // + {0xB6BA,0x98ef}, // + {0xB6BB,0x98e9}, // + {0xB6BC,0x98f2}, // + {0xB6BD,0x98ed}, // + {0xB6BE,0x99ae}, // + {0xB6BF,0x99ad}, // + {0xB6C0,0x9ec3}, // + {0xB6C1,0x9ecd}, // + {0xB6C2,0x9ed1}, // + {0xB6C3,0x4e82}, // + {0xB6C4,0x50ad}, // + {0xB6C5,0x50b5}, // + {0xB6C6,0x50b2}, // + {0xB6C7,0x50b3}, // + {0xB6C8,0x50c5}, // + {0xB6C9,0x50be}, // + {0xB6CA,0x50ac}, // + {0xB6CB,0x50b7}, // + {0xB6CC,0x50bb}, // + {0xB6CD,0x50af}, // + {0xB6CE,0x50c7}, // + {0xB6CF,0x527f}, // + {0xB6D0,0x5277}, // + {0xB6D1,0x527d}, // + {0xB6D2,0x52df}, // + {0xB6D3,0x52e6}, // + {0xB6D4,0x52e4}, // + {0xB6D5,0x52e2}, // + {0xB6D6,0x52e3}, // + {0xB6D7,0x532f}, // + {0xB6D8,0x55df}, // + {0xB6D9,0x55e8}, // + {0xB6DA,0x55d3}, // + {0xB6DB,0x55e6}, // + {0xB6DC,0x55ce}, // + {0xB6DD,0x55dc}, // + {0xB6DE,0x55c7}, // + {0xB6DF,0x55d1}, // + {0xB6E0,0x55e3}, // + {0xB6E1,0x55e4}, // + {0xB6E2,0x55ef}, // + {0xB6E3,0x55da}, // + {0xB6E4,0x55e1}, // + {0xB6E5,0x55c5}, // + {0xB6E6,0x55c6}, // + {0xB6E7,0x55e5}, // + {0xB6E8,0x55c9}, // + {0xB6E9,0x5712}, // + {0xB6EA,0x5713}, // + {0xB6EB,0x585e}, // + {0xB6EC,0x5851}, // + {0xB6ED,0x5858}, // + {0xB6EE,0x5857}, // + {0xB6EF,0x585a}, // + {0xB6F0,0x5854}, // + {0xB6F1,0x586b}, // + {0xB6F2,0x584c}, // + {0xB6F3,0x586d}, // + {0xB6F4,0x584a}, // + {0xB6F5,0x5862}, // + {0xB6F6,0x5852}, // + {0xB6F7,0x584b}, // + {0xB6F8,0x5967}, // + {0xB6F9,0x5ac1}, // + {0xB6FA,0x5ac9}, // + {0xB6FB,0x5acc}, // + {0xB6FC,0x5abe}, // + {0xB6FD,0x5abd}, // + {0xB6FE,0x5abc}, // + {0xB740,0x5ab3}, // + {0xB741,0x5ac2}, // + {0xB742,0x5ab2}, // + {0xB743,0x5d69}, // + {0xB744,0x5d6f}, // + {0xB745,0x5e4c}, // + {0xB746,0x5e79}, // + {0xB747,0x5ec9}, // + {0xB748,0x5ec8}, // + {0xB749,0x5f12}, // + {0xB74A,0x5f59}, // + {0xB74B,0x5fac}, // + {0xB74C,0x5fae}, // + {0xB74D,0x611a}, // + {0xB74E,0x610f}, // + {0xB74F,0x6148}, // + {0xB750,0x611f}, // + {0xB751,0x60f3}, // + {0xB752,0x611b}, // + {0xB753,0x60f9}, // + {0xB754,0x6101}, // + {0xB755,0x6108}, // + {0xB756,0x614e}, // + {0xB757,0x614c}, // + {0xB758,0x6144}, // + {0xB759,0x614d}, // + {0xB75A,0x613e}, // + {0xB75B,0x6134}, // + {0xB75C,0x6127}, // + {0xB75D,0x610d}, // + {0xB75E,0x6106}, // + {0xB75F,0x6137}, // + {0xB760,0x6221}, // + {0xB761,0x6222}, // + {0xB762,0x6413}, // + {0xB763,0x643e}, // + {0xB764,0x641e}, // + {0xB765,0x642a}, // + {0xB766,0x642d}, // + {0xB767,0x643d}, // + {0xB768,0x642c}, // + {0xB769,0x640f}, // + {0xB76A,0x641c}, // + {0xB76B,0x6414}, // + {0xB76C,0x640d}, // + {0xB76D,0x6436}, // + {0xB76E,0x6416}, // + {0xB76F,0x6417}, // + {0xB770,0x6406}, // + {0xB771,0x656c}, // + {0xB772,0x659f}, // + {0xB773,0x65b0}, // + {0xB774,0x6697}, // + {0xB775,0x6689}, // + {0xB776,0x6687}, // + {0xB777,0x6688}, // + {0xB778,0x6696}, // + {0xB779,0x6684}, // + {0xB77A,0x6698}, // + {0xB77B,0x668d}, // + {0xB77C,0x6703}, // + {0xB77D,0x6994}, // + {0xB77E,0x696d}, // + {0xB7A1,0x695a}, // + {0xB7A2,0x6977}, // + {0xB7A3,0x6960}, // + {0xB7A4,0x6954}, // + {0xB7A5,0x6975}, // + {0xB7A6,0x6930}, // + {0xB7A7,0x6982}, // + {0xB7A8,0x694a}, // + {0xB7A9,0x6968}, // + {0xB7AA,0x696b}, // + {0xB7AB,0x695e}, // + {0xB7AC,0x6953}, // + {0xB7AD,0x6979}, // + {0xB7AE,0x6986}, // + {0xB7AF,0x695d}, // + {0xB7B0,0x6963}, // + {0xB7B1,0x695b}, // + {0xB7B2,0x6b47}, // + {0xB7B3,0x6b72}, // + {0xB7B4,0x6bc0}, // + {0xB7B5,0x6bbf}, // + {0xB7B6,0x6bd3}, // + {0xB7B7,0x6bfd}, // + {0xB7B8,0x6ea2}, // + {0xB7B9,0x6eaf}, // + {0xB7BA,0x6ed3}, // + {0xB7BB,0x6eb6}, // + {0xB7BC,0x6ec2}, // + {0xB7BD,0x6e90}, // + {0xB7BE,0x6e9d}, // + {0xB7BF,0x6ec7}, // + {0xB7C0,0x6ec5}, // + {0xB7C1,0x6ea5}, // + {0xB7C2,0x6e98}, // + {0xB7C3,0x6ebc}, // + {0xB7C4,0x6eba}, // + {0xB7C5,0x6eab}, // + {0xB7C6,0x6ed1}, // + {0xB7C7,0x6e96}, // + {0xB7C8,0x6e9c}, // + {0xB7C9,0x6ec4}, // + {0xB7CA,0x6ed4}, // + {0xB7CB,0x6eaa}, // + {0xB7CC,0x6ea7}, // + {0xB7CD,0x6eb4}, // + {0xB7CE,0x714e}, // + {0xB7CF,0x7159}, // + {0xB7D0,0x7169}, // + {0xB7D1,0x7164}, // + {0xB7D2,0x7149}, // + {0xB7D3,0x7167}, // + {0xB7D4,0x715c}, // + {0xB7D5,0x716c}, // + {0xB7D6,0x7166}, // + {0xB7D7,0x714c}, // + {0xB7D8,0x7165}, // + {0xB7D9,0x715e}, // + {0xB7DA,0x7146}, // + {0xB7DB,0x7168}, // + {0xB7DC,0x7156}, // + {0xB7DD,0x723a}, // + {0xB7DE,0x7252}, // + {0xB7DF,0x7337}, // + {0xB7E0,0x7345}, // + {0xB7E1,0x733f}, // + {0xB7E2,0x733e}, // + {0xB7E3,0x746f}, // + {0xB7E4,0x745a}, // + {0xB7E5,0x7455}, // + {0xB7E6,0x745f}, // + {0xB7E7,0x745e}, // + {0xB7E8,0x7441}, // + {0xB7E9,0x743f}, // + {0xB7EA,0x7459}, // + {0xB7EB,0x745b}, // + {0xB7EC,0x745c}, // + {0xB7ED,0x7576}, // + {0xB7EE,0x7578}, // + {0xB7EF,0x7600}, // + {0xB7F0,0x75f0}, // + {0xB7F1,0x7601}, // + {0xB7F2,0x75f2}, // + {0xB7F3,0x75f1}, // + {0xB7F4,0x75fa}, // + {0xB7F5,0x75ff}, // + {0xB7F6,0x75f4}, // + {0xB7F7,0x75f3}, // + {0xB7F8,0x76de}, // + {0xB7F9,0x76df}, // + {0xB7FA,0x775b}, // + {0xB7FB,0x776b}, // + {0xB7FC,0x7766}, // + {0xB7FD,0x775e}, // + {0xB7FE,0x7763}, // + {0xB840,0x7779}, // + {0xB841,0x776a}, // + {0xB842,0x776c}, // + {0xB843,0x775c}, // + {0xB844,0x7765}, // + {0xB845,0x7768}, // + {0xB846,0x7762}, // + {0xB847,0x77ee}, // + {0xB848,0x788e}, // + {0xB849,0x78b0}, // + {0xB84A,0x7897}, // + {0xB84B,0x7898}, // + {0xB84C,0x788c}, // + {0xB84D,0x7889}, // + {0xB84E,0x787c}, // + {0xB84F,0x7891}, // + {0xB850,0x7893}, // + {0xB851,0x787f}, // + {0xB852,0x797a}, // + {0xB853,0x797f}, // + {0xB854,0x7981}, // + {0xB855,0x842c}, // + {0xB856,0x79bd}, // + {0xB857,0x7a1c}, // + {0xB858,0x7a1a}, // + {0xB859,0x7a20}, // + {0xB85A,0x7a14}, // + {0xB85B,0x7a1f}, // + {0xB85C,0x7a1e}, // + {0xB85D,0x7a9f}, // + {0xB85E,0x7aa0}, // + {0xB85F,0x7b77}, // + {0xB860,0x7bc0}, // + {0xB861,0x7b60}, // + {0xB862,0x7b6e}, // + {0xB863,0x7b67}, // + {0xB864,0x7cb1}, // + {0xB865,0x7cb3}, // + {0xB866,0x7cb5}, // + {0xB867,0x7d93}, // + {0xB868,0x7d79}, // + {0xB869,0x7d91}, // + {0xB86A,0x7d81}, // + {0xB86B,0x7d8f}, // + {0xB86C,0x7d5b}, // + {0xB86D,0x7f6e}, // + {0xB86E,0x7f69}, // + {0xB86F,0x7f6a}, // + {0xB870,0x7f72}, // + {0xB871,0x7fa9}, // + {0xB872,0x7fa8}, // + {0xB873,0x7fa4}, // + {0xB874,0x8056}, // + {0xB875,0x8058}, // + {0xB876,0x8086}, // + {0xB877,0x8084}, // + {0xB878,0x8171}, // + {0xB879,0x8170}, // + {0xB87A,0x8178}, // + {0xB87B,0x8165}, // + {0xB87C,0x816e}, // + {0xB87D,0x8173}, // + {0xB87E,0x816b}, // + {0xB8A1,0x8179}, // + {0xB8A2,0x817a}, // + {0xB8A3,0x8166}, // + {0xB8A4,0x8205}, // + {0xB8A5,0x8247}, // + {0xB8A6,0x8482}, // + {0xB8A7,0x8477}, // + {0xB8A8,0x843d}, // + {0xB8A9,0x8431}, // + {0xB8AA,0x8475}, // + {0xB8AB,0x8466}, // + {0xB8AC,0x846b}, // + {0xB8AD,0x8449}, // + {0xB8AE,0x846c}, // + {0xB8AF,0x845b}, // + {0xB8B0,0x843c}, // + {0xB8B1,0x8435}, // + {0xB8B2,0x8461}, // + {0xB8B3,0x8463}, // + {0xB8B4,0x8469}, // + {0xB8B5,0x846d}, // + {0xB8B6,0x8446}, // + {0xB8B7,0x865e}, // + {0xB8B8,0x865c}, // + {0xB8B9,0x865f}, // + {0xB8BA,0x86f9}, // + {0xB8BB,0x8713}, // + {0xB8BC,0x8708}, // + {0xB8BD,0x8707}, // + {0xB8BE,0x8700}, // + {0xB8BF,0x86fe}, // + {0xB8C0,0x86fb}, // + {0xB8C1,0x8702}, // + {0xB8C2,0x8703}, // + {0xB8C3,0x8706}, // + {0xB8C4,0x870a}, // + {0xB8C5,0x8859}, // + {0xB8C6,0x88df}, // + {0xB8C7,0x88d4}, // + {0xB8C8,0x88d9}, // + {0xB8C9,0x88dc}, // + {0xB8CA,0x88d8}, // + {0xB8CB,0x88dd}, // + {0xB8CC,0x88e1}, // + {0xB8CD,0x88ca}, // + {0xB8CE,0x88d5}, // + {0xB8CF,0x88d2}, // + {0xB8D0,0x899c}, // + {0xB8D1,0x89e3}, // + {0xB8D2,0x8a6b}, // + {0xB8D3,0x8a72}, // + {0xB8D4,0x8a73}, // + {0xB8D5,0x8a66}, // + {0xB8D6,0x8a69}, // + {0xB8D7,0x8a70}, // + {0xB8D8,0x8a87}, // + {0xB8D9,0x8a7c}, // + {0xB8DA,0x8a63}, // + {0xB8DB,0x8aa0}, // + {0xB8DC,0x8a71}, // + {0xB8DD,0x8a85}, // + {0xB8DE,0x8a6d}, // + {0xB8DF,0x8a62}, // + {0xB8E0,0x8a6e}, // + {0xB8E1,0x8a6c}, // + {0xB8E2,0x8a79}, // + {0xB8E3,0x8a7b}, // + {0xB8E4,0x8a3e}, // + {0xB8E5,0x8a68}, // + {0xB8E6,0x8c62}, // + {0xB8E7,0x8c8a}, // + {0xB8E8,0x8c89}, // + {0xB8E9,0x8cca}, // + {0xB8EA,0x8cc7}, // + {0xB8EB,0x8cc8}, // + {0xB8EC,0x8cc4}, // + {0xB8ED,0x8cb2}, // + {0xB8EE,0x8cc3}, // + {0xB8EF,0x8cc2}, // + {0xB8F0,0x8cc5}, // + {0xB8F1,0x8de1}, // + {0xB8F2,0x8ddf}, // + {0xB8F3,0x8de8}, // + {0xB8F4,0x8def}, // + {0xB8F5,0x8df3}, // + {0xB8F6,0x8dfa}, // + {0xB8F7,0x8dea}, // + {0xB8F8,0x8de4}, // + {0xB8F9,0x8de6}, // + {0xB8FA,0x8eb2}, // + {0xB8FB,0x8f03}, // + {0xB8FC,0x8f09}, // + {0xB8FD,0x8efe}, // + {0xB8FE,0x8f0a}, // + {0xB940,0x8f9f}, // + {0xB941,0x8fb2}, // + {0xB942,0x904b}, // + {0xB943,0x904a}, // + {0xB944,0x9053}, // + {0xB945,0x9042}, // + {0xB946,0x9054}, // + {0xB947,0x903c}, // + {0xB948,0x9055}, // + {0xB949,0x9050}, // + {0xB94A,0x9047}, // + {0xB94B,0x904f}, // + {0xB94C,0x904e}, // + {0xB94D,0x904d}, // + {0xB94E,0x9051}, // + {0xB94F,0x903e}, // + {0xB950,0x9041}, // + {0xB951,0x9112}, // + {0xB952,0x9117}, // + {0xB953,0x916c}, // + {0xB954,0x916a}, // + {0xB955,0x9169}, // + {0xB956,0x91c9}, // + {0xB957,0x9237}, // + {0xB958,0x9257}, // + {0xB959,0x9238}, // + {0xB95A,0x923d}, // + {0xB95B,0x9240}, // + {0xB95C,0x923e}, // + {0xB95D,0x925b}, // + {0xB95E,0x924b}, // + {0xB95F,0x9264}, // + {0xB960,0x9251}, // + {0xB961,0x9234}, // + {0xB962,0x9249}, // + {0xB963,0x924d}, // + {0xB964,0x9245}, // + {0xB965,0x9239}, // + {0xB966,0x923f}, // + {0xB967,0x925a}, // + {0xB968,0x9598}, // + {0xB969,0x9698}, // + {0xB96A,0x9694}, // + {0xB96B,0x9695}, // + {0xB96C,0x96cd}, // + {0xB96D,0x96cb}, // + {0xB96E,0x96c9}, // + {0xB96F,0x96ca}, // + {0xB970,0x96f7}, // + {0xB971,0x96fb}, // + {0xB972,0x96f9}, // + {0xB973,0x96f6}, // + {0xB974,0x9756}, // + {0xB975,0x9774}, // + {0xB976,0x9776}, // + {0xB977,0x9810}, // + {0xB978,0x9811}, // + {0xB979,0x9813}, // + {0xB97A,0x980a}, // + {0xB97B,0x9812}, // + {0xB97C,0x980c}, // + {0xB97D,0x98fc}, // + {0xB97E,0x98f4}, // + {0xB9A1,0x98fd}, // + {0xB9A2,0x98fe}, // + {0xB9A3,0x99b3}, // + {0xB9A4,0x99b1}, // + {0xB9A5,0x99b4}, // + {0xB9A6,0x9ae1}, // + {0xB9A7,0x9ce9}, // + {0xB9A8,0x9e82}, // + {0xB9A9,0x9f0e}, // + {0xB9AA,0x9f13}, // + {0xB9AB,0x9f20}, // + {0xB9AC,0x50e7}, // + {0xB9AD,0x50ee}, // + {0xB9AE,0x50e5}, // + {0xB9AF,0x50d6}, // + {0xB9B0,0x50ed}, // + {0xB9B1,0x50da}, // + {0xB9B2,0x50d5}, // + {0xB9B3,0x50cf}, // + {0xB9B4,0x50d1}, // + {0xB9B5,0x50f1}, // + {0xB9B6,0x50ce}, // + {0xB9B7,0x50e9}, // + {0xB9B8,0x5162}, // + {0xB9B9,0x51f3}, // + {0xB9BA,0x5283}, // + {0xB9BB,0x5282}, // + {0xB9BC,0x5331}, // + {0xB9BD,0x53ad}, // + {0xB9BE,0x55fe}, // + {0xB9BF,0x5600}, // + {0xB9C0,0x561b}, // + {0xB9C1,0x5617}, // + {0xB9C2,0x55fd}, // + {0xB9C3,0x5614}, // + {0xB9C4,0x5606}, // + {0xB9C5,0x5609}, // + {0xB9C6,0x560d}, // + {0xB9C7,0x560e}, // + {0xB9C8,0x55f7}, // + {0xB9C9,0x5616}, // + {0xB9CA,0x561f}, // + {0xB9CB,0x5608}, // + {0xB9CC,0x5610}, // + {0xB9CD,0x55f6}, // + {0xB9CE,0x5718}, // + {0xB9CF,0x5716}, // + {0xB9D0,0x5875}, // + {0xB9D1,0x587e}, // + {0xB9D2,0x5883}, // + {0xB9D3,0x5893}, // + {0xB9D4,0x588a}, // + {0xB9D5,0x5879}, // + {0xB9D6,0x5885}, // + {0xB9D7,0x587d}, // + {0xB9D8,0x58fd}, // + {0xB9D9,0x5925}, // + {0xB9DA,0x5922}, // + {0xB9DB,0x5924}, // + {0xB9DC,0x596a}, // + {0xB9DD,0x5969}, // + {0xB9DE,0x5ae1}, // + {0xB9DF,0x5ae6}, // + {0xB9E0,0x5ae9}, // + {0xB9E1,0x5ad7}, // + {0xB9E2,0x5ad6}, // + {0xB9E3,0x5ad8}, // + {0xB9E4,0x5ae3}, // + {0xB9E5,0x5b75}, // + {0xB9E6,0x5bde}, // + {0xB9E7,0x5be7}, // + {0xB9E8,0x5be1}, // + {0xB9E9,0x5be5}, // + {0xB9EA,0x5be6}, // + {0xB9EB,0x5be8}, // + {0xB9EC,0x5be2}, // + {0xB9ED,0x5be4}, // + {0xB9EE,0x5bdf}, // + {0xB9EF,0x5c0d}, // + {0xB9F0,0x5c62}, // + {0xB9F1,0x5d84}, // + {0xB9F2,0x5d87}, // + {0xB9F3,0x5e5b}, // + {0xB9F4,0x5e63}, // + {0xB9F5,0x5e55}, // + {0xB9F6,0x5e57}, // + {0xB9F7,0x5e54}, // + {0xB9F8,0x5ed3}, // + {0xB9F9,0x5ed6}, // + {0xB9FA,0x5f0a}, // + {0xB9FB,0x5f46}, // + {0xB9FC,0x5f70}, // + {0xB9FD,0x5fb9}, // + {0xB9FE,0x6147}, // + {0xBA40,0x613f}, // + {0xBA41,0x614b}, // + {0xBA42,0x6177}, // + {0xBA43,0x6162}, // + {0xBA44,0x6163}, // + {0xBA45,0x615f}, // + {0xBA46,0x615a}, // + {0xBA47,0x6158}, // + {0xBA48,0x6175}, // + {0xBA49,0x622a}, // + {0xBA4A,0x6487}, // + {0xBA4B,0x6458}, // + {0xBA4C,0x6454}, // + {0xBA4D,0x64a4}, // + {0xBA4E,0x6478}, // + {0xBA4F,0x645f}, // + {0xBA50,0x647a}, // + {0xBA51,0x6451}, // + {0xBA52,0x6467}, // + {0xBA53,0x6434}, // + {0xBA54,0x646d}, // + {0xBA55,0x647b}, // + {0xBA56,0x6572}, // + {0xBA57,0x65a1}, // + {0xBA58,0x65d7}, // + {0xBA59,0x65d6}, // + {0xBA5A,0x66a2}, // + {0xBA5B,0x66a8}, // + {0xBA5C,0x669d}, // + {0xBA5D,0x699c}, // + {0xBA5E,0x69a8}, // + {0xBA5F,0x6995}, // + {0xBA60,0x69c1}, // + {0xBA61,0x69ae}, // + {0xBA62,0x69d3}, // + {0xBA63,0x69cb}, // + {0xBA64,0x699b}, // + {0xBA65,0x69b7}, // + {0xBA66,0x69bb}, // + {0xBA67,0x69ab}, // + {0xBA68,0x69b4}, // + {0xBA69,0x69d0}, // + {0xBA6A,0x69cd}, // + {0xBA6B,0x69ad}, // + {0xBA6C,0x69cc}, // + {0xBA6D,0x69a6}, // + {0xBA6E,0x69c3}, // + {0xBA6F,0x69a3}, // + {0xBA70,0x6b49}, // + {0xBA71,0x6b4c}, // + {0xBA72,0x6c33}, // + {0xBA73,0x6f33}, // + {0xBA74,0x6f14}, // + {0xBA75,0x6efe}, // + {0xBA76,0x6f13}, // + {0xBA77,0x6ef4}, // + {0xBA78,0x6f29}, // + {0xBA79,0x6f3e}, // + {0xBA7A,0x6f20}, // + {0xBA7B,0x6f2c}, // + {0xBA7C,0x6f0f}, // + {0xBA7D,0x6f02}, // + {0xBA7E,0x6f22}, // + {0xBAA1,0x6eff}, // + {0xBAA2,0x6eef}, // + {0xBAA3,0x6f06}, // + {0xBAA4,0x6f31}, // + {0xBAA5,0x6f38}, // + {0xBAA6,0x6f32}, // + {0xBAA7,0x6f23}, // + {0xBAA8,0x6f15}, // + {0xBAA9,0x6f2b}, // + {0xBAAA,0x6f2f}, // + {0xBAAB,0x6f88}, // + {0xBAAC,0x6f2a}, // + {0xBAAD,0x6eec}, // + {0xBAAE,0x6f01}, // + {0xBAAF,0x6ef2}, // + {0xBAB0,0x6ecc}, // + {0xBAB1,0x6ef7}, // + {0xBAB2,0x7194}, // + {0xBAB3,0x7199}, // + {0xBAB4,0x717d}, // + {0xBAB5,0x718a}, // + {0xBAB6,0x7184}, // + {0xBAB7,0x7192}, // + {0xBAB8,0x723e}, // + {0xBAB9,0x7292}, // + {0xBABA,0x7296}, // + {0xBABB,0x7344}, // + {0xBABC,0x7350}, // + {0xBABD,0x7464}, // + {0xBABE,0x7463}, // + {0xBABF,0x746a}, // + {0xBAC0,0x7470}, // + {0xBAC1,0x746d}, // + {0xBAC2,0x7504}, // + {0xBAC3,0x7591}, // + {0xBAC4,0x7627}, // + {0xBAC5,0x760d}, // + {0xBAC6,0x760b}, // + {0xBAC7,0x7609}, // + {0xBAC8,0x7613}, // + {0xBAC9,0x76e1}, // + {0xBACA,0x76e3}, // + {0xBACB,0x7784}, // + {0xBACC,0x777d}, // + {0xBACD,0x777f}, // + {0xBACE,0x7761}, // + {0xBACF,0x78c1}, // + {0xBAD0,0x789f}, // + {0xBAD1,0x78a7}, // + {0xBAD2,0x78b3}, // + {0xBAD3,0x78a9}, // + {0xBAD4,0x78a3}, // + {0xBAD5,0x798e}, // + {0xBAD6,0x798f}, // + {0xBAD7,0x798d}, // + {0xBAD8,0x7a2e}, // + {0xBAD9,0x7a31}, // + {0xBADA,0x7aaa}, // + {0xBADB,0x7aa9}, // + {0xBADC,0x7aed}, // + {0xBADD,0x7aef}, // + {0xBADE,0x7ba1}, // + {0xBADF,0x7b95}, // + {0xBAE0,0x7b8b}, // + {0xBAE1,0x7b75}, // + {0xBAE2,0x7b97}, // + {0xBAE3,0x7b9d}, // + {0xBAE4,0x7b94}, // + {0xBAE5,0x7b8f}, // + {0xBAE6,0x7bb8}, // + {0xBAE7,0x7b87}, // + {0xBAE8,0x7b84}, // + {0xBAE9,0x7cb9}, // + {0xBAEA,0x7cbd}, // + {0xBAEB,0x7cbe}, // + {0xBAEC,0x7dbb}, // + {0xBAED,0x7db0}, // + {0xBAEE,0x7d9c}, // + {0xBAEF,0x7dbd}, // + {0xBAF0,0x7dbe}, // + {0xBAF1,0x7da0}, // + {0xBAF2,0x7dca}, // + {0xBAF3,0x7db4}, // + {0xBAF4,0x7db2}, // + {0xBAF5,0x7db1}, // + {0xBAF6,0x7dba}, // + {0xBAF7,0x7da2}, // + {0xBAF8,0x7dbf}, // + {0xBAF9,0x7db5}, // + {0xBAFA,0x7db8}, // + {0xBAFB,0x7dad}, // + {0xBAFC,0x7dd2}, // + {0xBAFD,0x7dc7}, // + {0xBAFE,0x7dac}, // + {0xBB40,0x7f70}, // + {0xBB41,0x7fe0}, // + {0xBB42,0x7fe1}, // + {0xBB43,0x7fdf}, // + {0xBB44,0x805e}, // + {0xBB45,0x805a}, // + {0xBB46,0x8087}, // + {0xBB47,0x8150}, // + {0xBB48,0x8180}, // + {0xBB49,0x818f}, // + {0xBB4A,0x8188}, // + {0xBB4B,0x818a}, // + {0xBB4C,0x817f}, // + {0xBB4D,0x8182}, // + {0xBB4E,0x81e7}, // + {0xBB4F,0x81fa}, // + {0xBB50,0x8207}, // + {0xBB51,0x8214}, // + {0xBB52,0x821e}, // + {0xBB53,0x824b}, // + {0xBB54,0x84c9}, // + {0xBB55,0x84bf}, // + {0xBB56,0x84c6}, // + {0xBB57,0x84c4}, // + {0xBB58,0x8499}, // + {0xBB59,0x849e}, // + {0xBB5A,0x84b2}, // + {0xBB5B,0x849c}, // + {0xBB5C,0x84cb}, // + {0xBB5D,0x84b8}, // + {0xBB5E,0x84c0}, // + {0xBB5F,0x84d3}, // + {0xBB60,0x8490}, // + {0xBB61,0x84bc}, // + {0xBB62,0x84d1}, // + {0xBB63,0x84ca}, // + {0xBB64,0x873f}, // + {0xBB65,0x871c}, // + {0xBB66,0x873b}, // + {0xBB67,0x8722}, // + {0xBB68,0x8725}, // + {0xBB69,0x8734}, // + {0xBB6A,0x8718}, // + {0xBB6B,0x8755}, // + {0xBB6C,0x8737}, // + {0xBB6D,0x8729}, // + {0xBB6E,0x88f3}, // + {0xBB6F,0x8902}, // + {0xBB70,0x88f4}, // + {0xBB71,0x88f9}, // + {0xBB72,0x88f8}, // + {0xBB73,0x88fd}, // + {0xBB74,0x88e8}, // + {0xBB75,0x891a}, // + {0xBB76,0x88ef}, // + {0xBB77,0x8aa6}, // + {0xBB78,0x8a8c}, // + {0xBB79,0x8a9e}, // + {0xBB7A,0x8aa3}, // + {0xBB7B,0x8a8d}, // + {0xBB7C,0x8aa1}, // + {0xBB7D,0x8a93}, // + {0xBB7E,0x8aa4}, // + {0xBBA1,0x8aaa}, // + {0xBBA2,0x8aa5}, // + {0xBBA3,0x8aa8}, // + {0xBBA4,0x8a98}, // + {0xBBA5,0x8a91}, // + {0xBBA6,0x8a9a}, // + {0xBBA7,0x8aa7}, // + {0xBBA8,0x8c6a}, // + {0xBBA9,0x8c8d}, // + {0xBBAA,0x8c8c}, // + {0xBBAB,0x8cd3}, // + {0xBBAC,0x8cd1}, // + {0xBBAD,0x8cd2}, // + {0xBBAE,0x8d6b}, // + {0xBBAF,0x8d99}, // + {0xBBB0,0x8d95}, // + {0xBBB1,0x8dfc}, // + {0xBBB2,0x8f14}, // + {0xBBB3,0x8f12}, // + {0xBBB4,0x8f15}, // + {0xBBB5,0x8f13}, // + {0xBBB6,0x8fa3}, // + {0xBBB7,0x9060}, // + {0xBBB8,0x9058}, // + {0xBBB9,0x905c}, // + {0xBBBA,0x9063}, // + {0xBBBB,0x9059}, // + {0xBBBC,0x905e}, // + {0xBBBD,0x9062}, // + {0xBBBE,0x905d}, // + {0xBBBF,0x905b}, // + {0xBBC0,0x9119}, // + {0xBBC1,0x9118}, // + {0xBBC2,0x911e}, // + {0xBBC3,0x9175}, // + {0xBBC4,0x9178}, // + {0xBBC5,0x9177}, // + {0xBBC6,0x9174}, // + {0xBBC7,0x9278}, // + {0xBBC8,0x9280}, // + {0xBBC9,0x9285}, // + {0xBBCA,0x9298}, // + {0xBBCB,0x9296}, // + {0xBBCC,0x927b}, // + {0xBBCD,0x9293}, // + {0xBBCE,0x929c}, // + {0xBBCF,0x92a8}, // + {0xBBD0,0x927c}, // + {0xBBD1,0x9291}, // + {0xBBD2,0x95a1}, // + {0xBBD3,0x95a8}, // + {0xBBD4,0x95a9}, // + {0xBBD5,0x95a3}, // + {0xBBD6,0x95a5}, // + {0xBBD7,0x95a4}, // + {0xBBD8,0x9699}, // + {0xBBD9,0x969c}, // + {0xBBDA,0x969b}, // + {0xBBDB,0x96cc}, // + {0xBBDC,0x96d2}, // + {0xBBDD,0x9700}, // + {0xBBDE,0x977c}, // + {0xBBDF,0x9785}, // + {0xBBE0,0x97f6}, // + {0xBBE1,0x9817}, // + {0xBBE2,0x9818}, // + {0xBBE3,0x98af}, // + {0xBBE4,0x98b1}, // + {0xBBE5,0x9903}, // + {0xBBE6,0x9905}, // + {0xBBE7,0x990c}, // + {0xBBE8,0x9909}, // + {0xBBE9,0x99c1}, // + {0xBBEA,0x9aaf}, // + {0xBBEB,0x9ab0}, // + {0xBBEC,0x9ae6}, // + {0xBBED,0x9b41}, // + {0xBBEE,0x9b42}, // + {0xBBEF,0x9cf4}, // + {0xBBF0,0x9cf6}, // + {0xBBF1,0x9cf3}, // + {0xBBF2,0x9ebc}, // + {0xBBF3,0x9f3b}, // + {0xBBF4,0x9f4a}, // + {0xBBF5,0x5104}, // + {0xBBF6,0x5100}, // + {0xBBF7,0x50fb}, // + {0xBBF8,0x50f5}, // + {0xBBF9,0x50f9}, // + {0xBBFA,0x5102}, // + {0xBBFB,0x5108}, // + {0xBBFC,0x5109}, // + {0xBBFD,0x5105}, // + {0xBBFE,0x51dc}, // + {0xBC40,0x5287}, // + {0xBC41,0x5288}, // + {0xBC42,0x5289}, // + {0xBC43,0x528d}, // + {0xBC44,0x528a}, // + {0xBC45,0x52f0}, // + {0xBC46,0x53b2}, // + {0xBC47,0x562e}, // + {0xBC48,0x563b}, // + {0xBC49,0x5639}, // + {0xBC4A,0x5632}, // + {0xBC4B,0x563f}, // + {0xBC4C,0x5634}, // + {0xBC4D,0x5629}, // + {0xBC4E,0x5653}, // + {0xBC4F,0x564e}, // + {0xBC50,0x5657}, // + {0xBC51,0x5674}, // + {0xBC52,0x5636}, // + {0xBC53,0x562f}, // + {0xBC54,0x5630}, // + {0xBC55,0x5880}, // + {0xBC56,0x589f}, // + {0xBC57,0x589e}, // + {0xBC58,0x58b3}, // + {0xBC59,0x589c}, // + {0xBC5A,0x58ae}, // + {0xBC5B,0x58a9}, // + {0xBC5C,0x58a6}, // + {0xBC5D,0x596d}, // + {0xBC5E,0x5b09}, // + {0xBC5F,0x5afb}, // + {0xBC60,0x5b0b}, // + {0xBC61,0x5af5}, // + {0xBC62,0x5b0c}, // + {0xBC63,0x5b08}, // + {0xBC64,0x5bee}, // + {0xBC65,0x5bec}, // + {0xBC66,0x5be9}, // + {0xBC67,0x5beb}, // + {0xBC68,0x5c64}, // + {0xBC69,0x5c65}, // + {0xBC6A,0x5d9d}, // + {0xBC6B,0x5d94}, // + {0xBC6C,0x5e62}, // + {0xBC6D,0x5e5f}, // + {0xBC6E,0x5e61}, // + {0xBC6F,0x5ee2}, // + {0xBC70,0x5eda}, // + {0xBC71,0x5edf}, // + {0xBC72,0x5edd}, // + {0xBC73,0x5ee3}, // + {0xBC74,0x5ee0}, // + {0xBC75,0x5f48}, // + {0xBC76,0x5f71}, // + {0xBC77,0x5fb7}, // + {0xBC78,0x5fb5}, // + {0xBC79,0x6176}, // + {0xBC7A,0x6167}, // + {0xBC7B,0x616e}, // + {0xBC7C,0x615d}, // + {0xBC7D,0x6155}, // + {0xBC7E,0x6182}, // + {0xBCA1,0x617c}, // + {0xBCA2,0x6170}, // + {0xBCA3,0x616b}, // + {0xBCA4,0x617e}, // + {0xBCA5,0x61a7}, // + {0xBCA6,0x6190}, // + {0xBCA7,0x61ab}, // + {0xBCA8,0x618e}, // + {0xBCA9,0x61ac}, // + {0xBCAA,0x619a}, // + {0xBCAB,0x61a4}, // + {0xBCAC,0x6194}, // + {0xBCAD,0x61ae}, // + {0xBCAE,0x622e}, // + {0xBCAF,0x6469}, // + {0xBCB0,0x646f}, // + {0xBCB1,0x6479}, // + {0xBCB2,0x649e}, // + {0xBCB3,0x64b2}, // + {0xBCB4,0x6488}, // + {0xBCB5,0x6490}, // + {0xBCB6,0x64b0}, // + {0xBCB7,0x64a5}, // + {0xBCB8,0x6493}, // + {0xBCB9,0x6495}, // + {0xBCBA,0x64a9}, // + {0xBCBB,0x6492}, // + {0xBCBC,0x64ae}, // + {0xBCBD,0x64ad}, // + {0xBCBE,0x64ab}, // + {0xBCBF,0x649a}, // + {0xBCC0,0x64ac}, // + {0xBCC1,0x6499}, // + {0xBCC2,0x64a2}, // + {0xBCC3,0x64b3}, // + {0xBCC4,0x6575}, // + {0xBCC5,0x6577}, // + {0xBCC6,0x6578}, // + {0xBCC7,0x66ae}, // + {0xBCC8,0x66ab}, // + {0xBCC9,0x66b4}, // + {0xBCCA,0x66b1}, // + {0xBCCB,0x6a23}, // + {0xBCCC,0x6a1f}, // + {0xBCCD,0x69e8}, // + {0xBCCE,0x6a01}, // + {0xBCCF,0x6a1e}, // + {0xBCD0,0x6a19}, // + {0xBCD1,0x69fd}, // + {0xBCD2,0x6a21}, // + {0xBCD3,0x6a13}, // + {0xBCD4,0x6a0a}, // + {0xBCD5,0x69f3}, // + {0xBCD6,0x6a02}, // + {0xBCD7,0x6a05}, // + {0xBCD8,0x69ed}, // + {0xBCD9,0x6a11}, // + {0xBCDA,0x6b50}, // + {0xBCDB,0x6b4e}, // + {0xBCDC,0x6ba4}, // + {0xBCDD,0x6bc5}, // + {0xBCDE,0x6bc6}, // + {0xBCDF,0x6f3f}, // + {0xBCE0,0x6f7c}, // + {0xBCE1,0x6f84}, // + {0xBCE2,0x6f51}, // + {0xBCE3,0x6f66}, // + {0xBCE4,0x6f54}, // + {0xBCE5,0x6f86}, // + {0xBCE6,0x6f6d}, // + {0xBCE7,0x6f5b}, // + {0xBCE8,0x6f78}, // + {0xBCE9,0x6f6e}, // + {0xBCEA,0x6f8e}, // + {0xBCEB,0x6f7a}, // + {0xBCEC,0x6f70}, // + {0xBCED,0x6f64}, // + {0xBCEE,0x6f97}, // + {0xBCEF,0x6f58}, // + {0xBCF0,0x6ed5}, // + {0xBCF1,0x6f6f}, // + {0xBCF2,0x6f60}, // + {0xBCF3,0x6f5f}, // + {0xBCF4,0x719f}, // + {0xBCF5,0x71ac}, // + {0xBCF6,0x71b1}, // + {0xBCF7,0x71a8}, // + {0xBCF8,0x7256}, // + {0xBCF9,0x729b}, // + {0xBCFA,0x734e}, // + {0xBCFB,0x7357}, // + {0xBCFC,0x7469}, // + {0xBCFD,0x748b}, // + {0xBCFE,0x7483}, // + {0xBD40,0x747e}, // + {0xBD41,0x7480}, // + {0xBD42,0x757f}, // + {0xBD43,0x7620}, // + {0xBD44,0x7629}, // + {0xBD45,0x761f}, // + {0xBD46,0x7624}, // + {0xBD47,0x7626}, // + {0xBD48,0x7621}, // + {0xBD49,0x7622}, // + {0xBD4A,0x769a}, // + {0xBD4B,0x76ba}, // + {0xBD4C,0x76e4}, // + {0xBD4D,0x778e}, // + {0xBD4E,0x7787}, // + {0xBD4F,0x778c}, // + {0xBD50,0x7791}, // + {0xBD51,0x778b}, // + {0xBD52,0x78cb}, // + {0xBD53,0x78c5}, // + {0xBD54,0x78ba}, // + {0xBD55,0x78ca}, // + {0xBD56,0x78be}, // + {0xBD57,0x78d5}, // + {0xBD58,0x78bc}, // + {0xBD59,0x78d0}, // + {0xBD5A,0x7a3f}, // + {0xBD5B,0x7a3c}, // + {0xBD5C,0x7a40}, // + {0xBD5D,0x7a3d}, // + {0xBD5E,0x7a37}, // + {0xBD5F,0x7a3b}, // + {0xBD60,0x7aaf}, // + {0xBD61,0x7aae}, // + {0xBD62,0x7bad}, // + {0xBD63,0x7bb1}, // + {0xBD64,0x7bc4}, // + {0xBD65,0x7bb4}, // + {0xBD66,0x7bc6}, // + {0xBD67,0x7bc7}, // + {0xBD68,0x7bc1}, // + {0xBD69,0x7ba0}, // + {0xBD6A,0x7bcc}, // + {0xBD6B,0x7cca}, // + {0xBD6C,0x7de0}, // + {0xBD6D,0x7df4}, // + {0xBD6E,0x7def}, // + {0xBD6F,0x7dfb}, // + {0xBD70,0x7dd8}, // + {0xBD71,0x7dec}, // + {0xBD72,0x7ddd}, // + {0xBD73,0x7de8}, // + {0xBD74,0x7de3}, // + {0xBD75,0x7dda}, // + {0xBD76,0x7dde}, // + {0xBD77,0x7de9}, // + {0xBD78,0x7d9e}, // + {0xBD79,0x7dd9}, // + {0xBD7A,0x7df2}, // + {0xBD7B,0x7df9}, // + {0xBD7C,0x7f75}, // + {0xBD7D,0x7f77}, // + {0xBD7E,0x7faf}, // + {0xBDA1,0x7fe9}, // + {0xBDA2,0x8026}, // + {0xBDA3,0x819b}, // + {0xBDA4,0x819c}, // + {0xBDA5,0x819d}, // + {0xBDA6,0x81a0}, // + {0xBDA7,0x819a}, // + {0xBDA8,0x8198}, // + {0xBDA9,0x8517}, // + {0xBDAA,0x853d}, // + {0xBDAB,0x851a}, // + {0xBDAC,0x84ee}, // + {0xBDAD,0x852c}, // + {0xBDAE,0x852d}, // + {0xBDAF,0x8513}, // + {0xBDB0,0x8511}, // + {0xBDB1,0x8523}, // + {0xBDB2,0x8521}, // + {0xBDB3,0x8514}, // + {0xBDB4,0x84ec}, // + {0xBDB5,0x8525}, // + {0xBDB6,0x84ff}, // + {0xBDB7,0x8506}, // + {0xBDB8,0x8782}, // + {0xBDB9,0x8774}, // + {0xBDBA,0x8776}, // + {0xBDBB,0x8760}, // + {0xBDBC,0x8766}, // + {0xBDBD,0x8778}, // + {0xBDBE,0x8768}, // + {0xBDBF,0x8759}, // + {0xBDC0,0x8757}, // + {0xBDC1,0x874c}, // + {0xBDC2,0x8753}, // + {0xBDC3,0x885b}, // + {0xBDC4,0x885d}, // + {0xBDC5,0x8910}, // + {0xBDC6,0x8907}, // + {0xBDC7,0x8912}, // + {0xBDC8,0x8913}, // + {0xBDC9,0x8915}, // + {0xBDCA,0x890a}, // + {0xBDCB,0x8abc}, // + {0xBDCC,0x8ad2}, // + {0xBDCD,0x8ac7}, // + {0xBDCE,0x8ac4}, // + {0xBDCF,0x8a95}, // + {0xBDD0,0x8acb}, // + {0xBDD1,0x8af8}, // + {0xBDD2,0x8ab2}, // + {0xBDD3,0x8ac9}, // + {0xBDD4,0x8ac2}, // + {0xBDD5,0x8abf}, // + {0xBDD6,0x8ab0}, // + {0xBDD7,0x8ad6}, // + {0xBDD8,0x8acd}, // + {0xBDD9,0x8ab6}, // + {0xBDDA,0x8ab9}, // + {0xBDDB,0x8adb}, // + {0xBDDC,0x8c4c}, // + {0xBDDD,0x8c4e}, // + {0xBDDE,0x8c6c}, // + {0xBDDF,0x8ce0}, // + {0xBDE0,0x8cde}, // + {0xBDE1,0x8ce6}, // + {0xBDE2,0x8ce4}, // + {0xBDE3,0x8cec}, // + {0xBDE4,0x8ced}, // + {0xBDE5,0x8ce2}, // + {0xBDE6,0x8ce3}, // + {0xBDE7,0x8cdc}, // + {0xBDE8,0x8cea}, // + {0xBDE9,0x8ce1}, // + {0xBDEA,0x8d6d}, // + {0xBDEB,0x8d9f}, // + {0xBDEC,0x8da3}, // + {0xBDED,0x8e2b}, // + {0xBDEE,0x8e10}, // + {0xBDEF,0x8e1d}, // + {0xBDF0,0x8e22}, // + {0xBDF1,0x8e0f}, // + {0xBDF2,0x8e29}, // + {0xBDF3,0x8e1f}, // + {0xBDF4,0x8e21}, // + {0xBDF5,0x8e1e}, // + {0xBDF6,0x8eba}, // + {0xBDF7,0x8f1d}, // + {0xBDF8,0x8f1b}, // + {0xBDF9,0x8f1f}, // + {0xBDFA,0x8f29}, // + {0xBDFB,0x8f26}, // + {0xBDFC,0x8f2a}, // + {0xBDFD,0x8f1c}, // + {0xBDFE,0x8f1e}, // + {0xBE40,0x8f25}, // + {0xBE41,0x9069}, // + {0xBE42,0x906e}, // + {0xBE43,0x9068}, // + {0xBE44,0x906d}, // + {0xBE45,0x9077}, // + {0xBE46,0x9130}, // + {0xBE47,0x912d}, // + {0xBE48,0x9127}, // + {0xBE49,0x9131}, // + {0xBE4A,0x9187}, // + {0xBE4B,0x9189}, // + {0xBE4C,0x918b}, // + {0xBE4D,0x9183}, // + {0xBE4E,0x92c5}, // + {0xBE4F,0x92bb}, // + {0xBE50,0x92b7}, // + {0xBE51,0x92ea}, // + {0xBE52,0x92ac}, // + {0xBE53,0x92e4}, // + {0xBE54,0x92c1}, // + {0xBE55,0x92b3}, // + {0xBE56,0x92bc}, // + {0xBE57,0x92d2}, // + {0xBE58,0x92c7}, // + {0xBE59,0x92f0}, // + {0xBE5A,0x92b2}, // + {0xBE5B,0x95ad}, // + {0xBE5C,0x95b1}, // + {0xBE5D,0x9704}, // + {0xBE5E,0x9706}, // + {0xBE5F,0x9707}, // + {0xBE60,0x9709}, // + {0xBE61,0x9760}, // + {0xBE62,0x978d}, // + {0xBE63,0x978b}, // + {0xBE64,0x978f}, // + {0xBE65,0x9821}, // + {0xBE66,0x982b}, // + {0xBE67,0x981c}, // + {0xBE68,0x98b3}, // + {0xBE69,0x990a}, // + {0xBE6A,0x9913}, // + {0xBE6B,0x9912}, // + {0xBE6C,0x9918}, // + {0xBE6D,0x99dd}, // + {0xBE6E,0x99d0}, // + {0xBE6F,0x99df}, // + {0xBE70,0x99db}, // + {0xBE71,0x99d1}, // + {0xBE72,0x99d5}, // + {0xBE73,0x99d2}, // + {0xBE74,0x99d9}, // + {0xBE75,0x9ab7}, // + {0xBE76,0x9aee}, // + {0xBE77,0x9aef}, // + {0xBE78,0x9b27}, // + {0xBE79,0x9b45}, // + {0xBE7A,0x9b44}, // + {0xBE7B,0x9b77}, // + {0xBE7C,0x9b6f}, // + {0xBE7D,0x9d06}, // + {0xBE7E,0x9d09}, // + {0xBEA1,0x9d03}, // + {0xBEA2,0x9ea9}, // + {0xBEA3,0x9ebe}, // + {0xBEA4,0x9ece}, // + {0xBEA5,0x58a8}, // + {0xBEA6,0x9f52}, // + {0xBEA7,0x5112}, // + {0xBEA8,0x5118}, // + {0xBEA9,0x5114}, // + {0xBEAA,0x5110}, // + {0xBEAB,0x5115}, // + {0xBEAC,0x5180}, // + {0xBEAD,0x51aa}, // + {0xBEAE,0x51dd}, // + {0xBEAF,0x5291}, // + {0xBEB0,0x5293}, // + {0xBEB1,0x52f3}, // + {0xBEB2,0x5659}, // + {0xBEB3,0x566b}, // + {0xBEB4,0x5679}, // + {0xBEB5,0x5669}, // + {0xBEB6,0x5664}, // + {0xBEB7,0x5678}, // + {0xBEB8,0x566a}, // + {0xBEB9,0x5668}, // + {0xBEBA,0x5665}, // + {0xBEBB,0x5671}, // + {0xBEBC,0x566f}, // + {0xBEBD,0x566c}, // + {0xBEBE,0x5662}, // + {0xBEBF,0x5676}, // + {0xBEC0,0x58c1}, // + {0xBEC1,0x58be}, // + {0xBEC2,0x58c7}, // + {0xBEC3,0x58c5}, // + {0xBEC4,0x596e}, // + {0xBEC5,0x5b1d}, // + {0xBEC6,0x5b34}, // + {0xBEC7,0x5b78}, // + {0xBEC8,0x5bf0}, // + {0xBEC9,0x5c0e}, // + {0xBECA,0x5f4a}, // + {0xBECB,0x61b2}, // + {0xBECC,0x6191}, // + {0xBECD,0x61a9}, // + {0xBECE,0x618a}, // + {0xBECF,0x61cd}, // + {0xBED0,0x61b6}, // + {0xBED1,0x61be}, // + {0xBED2,0x61ca}, // + {0xBED3,0x61c8}, // + {0xBED4,0x6230}, // + {0xBED5,0x64c5}, // + {0xBED6,0x64c1}, // + {0xBED7,0x64cb}, // + {0xBED8,0x64bb}, // + {0xBED9,0x64bc}, // + {0xBEDA,0x64da}, // + {0xBEDB,0x64c4}, // + {0xBEDC,0x64c7}, // + {0xBEDD,0x64c2}, // + {0xBEDE,0x64cd}, // + {0xBEDF,0x64bf}, // + {0xBEE0,0x64d2}, // + {0xBEE1,0x64d4}, // + {0xBEE2,0x64be}, // + {0xBEE3,0x6574}, // + {0xBEE4,0x66c6}, // + {0xBEE5,0x66c9}, // + {0xBEE6,0x66b9}, // + {0xBEE7,0x66c4}, // + {0xBEE8,0x66c7}, // + {0xBEE9,0x66b8}, // + {0xBEEA,0x6a3d}, // + {0xBEEB,0x6a38}, // + {0xBEEC,0x6a3a}, // + {0xBEED,0x6a59}, // + {0xBEEE,0x6a6b}, // + {0xBEEF,0x6a58}, // + {0xBEF0,0x6a39}, // + {0xBEF1,0x6a44}, // + {0xBEF2,0x6a62}, // + {0xBEF3,0x6a61}, // + {0xBEF4,0x6a4b}, // + {0xBEF5,0x6a47}, // + {0xBEF6,0x6a35}, // + {0xBEF7,0x6a5f}, // + {0xBEF8,0x6a48}, // + {0xBEF9,0x6b59}, // + {0xBEFA,0x6b77}, // + {0xBEFB,0x6c05}, // + {0xBEFC,0x6fc2}, // + {0xBEFD,0x6fb1}, // + {0xBEFE,0x6fa1}, // + {0xBF40,0x6fc3}, // + {0xBF41,0x6fa4}, // + {0xBF42,0x6fc1}, // + {0xBF43,0x6fa7}, // + {0xBF44,0x6fb3}, // + {0xBF45,0x6fc0}, // + {0xBF46,0x6fb9}, // + {0xBF47,0x6fb6}, // + {0xBF48,0x6fa6}, // + {0xBF49,0x6fa0}, // + {0xBF4A,0x6fb4}, // + {0xBF4B,0x71be}, // + {0xBF4C,0x71c9}, // + {0xBF4D,0x71d0}, // + {0xBF4E,0x71d2}, // + {0xBF4F,0x71c8}, // + {0xBF50,0x71d5}, // + {0xBF51,0x71b9}, // + {0xBF52,0x71ce}, // + {0xBF53,0x71d9}, // + {0xBF54,0x71dc}, // + {0xBF55,0x71c3}, // + {0xBF56,0x71c4}, // + {0xBF57,0x7368}, // + {0xBF58,0x749c}, // + {0xBF59,0x74a3}, // + {0xBF5A,0x7498}, // + {0xBF5B,0x749f}, // + {0xBF5C,0x749e}, // + {0xBF5D,0x74e2}, // + {0xBF5E,0x750c}, // + {0xBF5F,0x750d}, // + {0xBF60,0x7634}, // + {0xBF61,0x7638}, // + {0xBF62,0x763a}, // + {0xBF63,0x76e7}, // + {0xBF64,0x76e5}, // + {0xBF65,0x77a0}, // + {0xBF66,0x779e}, // + {0xBF67,0x779f}, // + {0xBF68,0x77a5}, // + {0xBF69,0x78e8}, // + {0xBF6A,0x78da}, // + {0xBF6B,0x78ec}, // + {0xBF6C,0x78e7}, // + {0xBF6D,0x79a6}, // + {0xBF6E,0x7a4d}, // + {0xBF6F,0x7a4e}, // + {0xBF70,0x7a46}, // + {0xBF71,0x7a4c}, // + {0xBF72,0x7a4b}, // + {0xBF73,0x7aba}, // + {0xBF74,0x7bd9}, // + {0xBF75,0x7c11}, // + {0xBF76,0x7bc9}, // + {0xBF77,0x7be4}, // + {0xBF78,0x7bdb}, // + {0xBF79,0x7be1}, // + {0xBF7A,0x7be9}, // + {0xBF7B,0x7be6}, // + {0xBF7C,0x7cd5}, // + {0xBF7D,0x7cd6}, // + {0xBF7E,0x7e0a}, // + {0xBFA1,0x7e11}, // + {0xBFA2,0x7e08}, // + {0xBFA3,0x7e1b}, // + {0xBFA4,0x7e23}, // + {0xBFA5,0x7e1e}, // + {0xBFA6,0x7e1d}, // + {0xBFA7,0x7e09}, // + {0xBFA8,0x7e10}, // + {0xBFA9,0x7f79}, // + {0xBFAA,0x7fb2}, // + {0xBFAB,0x7ff0}, // + {0xBFAC,0x7ff1}, // + {0xBFAD,0x7fee}, // + {0xBFAE,0x8028}, // + {0xBFAF,0x81b3}, // + {0xBFB0,0x81a9}, // + {0xBFB1,0x81a8}, // + {0xBFB2,0x81fb}, // + {0xBFB3,0x8208}, // + {0xBFB4,0x8258}, // + {0xBFB5,0x8259}, // + {0xBFB6,0x854a}, // + {0xBFB7,0x8559}, // + {0xBFB8,0x8548}, // + {0xBFB9,0x8568}, // + {0xBFBA,0x8569}, // + {0xBFBB,0x8543}, // + {0xBFBC,0x8549}, // + {0xBFBD,0x856d}, // + {0xBFBE,0x856a}, // + {0xBFBF,0x855e}, // + {0xBFC0,0x8783}, // + {0xBFC1,0x879f}, // + {0xBFC2,0x879e}, // + {0xBFC3,0x87a2}, // + {0xBFC4,0x878d}, // + {0xBFC5,0x8861}, // + {0xBFC6,0x892a}, // + {0xBFC7,0x8932}, // + {0xBFC8,0x8925}, // + {0xBFC9,0x892b}, // + {0xBFCA,0x8921}, // + {0xBFCB,0x89aa}, // + {0xBFCC,0x89a6}, // + {0xBFCD,0x8ae6}, // + {0xBFCE,0x8afa}, // + {0xBFCF,0x8aeb}, // + {0xBFD0,0x8af1}, // + {0xBFD1,0x8b00}, // + {0xBFD2,0x8adc}, // + {0xBFD3,0x8ae7}, // + {0xBFD4,0x8aee}, // + {0xBFD5,0x8afe}, // + {0xBFD6,0x8b01}, // + {0xBFD7,0x8b02}, // + {0xBFD8,0x8af7}, // + {0xBFD9,0x8aed}, // + {0xBFDA,0x8af3}, // + {0xBFDB,0x8af6}, // + {0xBFDC,0x8afc}, // + {0xBFDD,0x8c6b}, // + {0xBFDE,0x8c6d}, // + {0xBFDF,0x8c93}, // + {0xBFE0,0x8cf4}, // + {0xBFE1,0x8e44}, // + {0xBFE2,0x8e31}, // + {0xBFE3,0x8e34}, // + {0xBFE4,0x8e42}, // + {0xBFE5,0x8e39}, // + {0xBFE6,0x8e35}, // + {0xBFE7,0x8f3b}, // + {0xBFE8,0x8f2f}, // + {0xBFE9,0x8f38}, // + {0xBFEA,0x8f33}, // + {0xBFEB,0x8fa8}, // + {0xBFEC,0x8fa6}, // + {0xBFED,0x9075}, // + {0xBFEE,0x9074}, // + {0xBFEF,0x9078}, // + {0xBFF0,0x9072}, // + {0xBFF1,0x907c}, // + {0xBFF2,0x907a}, // + {0xBFF3,0x9134}, // + {0xBFF4,0x9192}, // + {0xBFF5,0x9320}, // + {0xBFF6,0x9336}, // + {0xBFF7,0x92f8}, // + {0xBFF8,0x9333}, // + {0xBFF9,0x932f}, // + {0xBFFA,0x9322}, // + {0xBFFB,0x92fc}, // + {0xBFFC,0x932b}, // + {0xBFFD,0x9304}, // + {0xBFFE,0x931a}, // + {0xC040,0x9310}, // + {0xC041,0x9326}, // + {0xC042,0x9321}, // + {0xC043,0x9315}, // + {0xC044,0x932e}, // + {0xC045,0x9319}, // + {0xC046,0x95bb}, // + {0xC047,0x96a7}, // + {0xC048,0x96a8}, // + {0xC049,0x96aa}, // + {0xC04A,0x96d5}, // + {0xC04B,0x970e}, // + {0xC04C,0x9711}, // + {0xC04D,0x9716}, // + {0xC04E,0x970d}, // + {0xC04F,0x9713}, // + {0xC050,0x970f}, // + {0xC051,0x975b}, // + {0xC052,0x975c}, // + {0xC053,0x9766}, // + {0xC054,0x9798}, // + {0xC055,0x9830}, // + {0xC056,0x9838}, // + {0xC057,0x983b}, // + {0xC058,0x9837}, // + {0xC059,0x982d}, // + {0xC05A,0x9839}, // + {0xC05B,0x9824}, // + {0xC05C,0x9910}, // + {0xC05D,0x9928}, // + {0xC05E,0x991e}, // + {0xC05F,0x991b}, // + {0xC060,0x9921}, // + {0xC061,0x991a}, // + {0xC062,0x99ed}, // + {0xC063,0x99e2}, // + {0xC064,0x99f1}, // + {0xC065,0x9ab8}, // + {0xC066,0x9abc}, // + {0xC067,0x9afb}, // + {0xC068,0x9aed}, // + {0xC069,0x9b28}, // + {0xC06A,0x9b91}, // + {0xC06B,0x9d15}, // + {0xC06C,0x9d23}, // + {0xC06D,0x9d26}, // + {0xC06E,0x9d28}, // + {0xC06F,0x9d12}, // + {0xC070,0x9d1b}, // + {0xC071,0x9ed8}, // + {0xC072,0x9ed4}, // + {0xC073,0x9f8d}, // + {0xC074,0x9f9c}, // + {0xC075,0x512a}, // + {0xC076,0x511f}, // + {0xC077,0x5121}, // + {0xC078,0x5132}, // + {0xC079,0x52f5}, // + {0xC07A,0x568e}, // + {0xC07B,0x5680}, // + {0xC07C,0x5690}, // + {0xC07D,0x5685}, // + {0xC07E,0x5687}, // + {0xC0A1,0x568f}, // + {0xC0A2,0x58d5}, // + {0xC0A3,0x58d3}, // + {0xC0A4,0x58d1}, // + {0xC0A5,0x58ce}, // + {0xC0A6,0x5b30}, // + {0xC0A7,0x5b2a}, // + {0xC0A8,0x5b24}, // + {0xC0A9,0x5b7a}, // + {0xC0AA,0x5c37}, // + {0xC0AB,0x5c68}, // + {0xC0AC,0x5dbc}, // + {0xC0AD,0x5dba}, // + {0xC0AE,0x5dbd}, // + {0xC0AF,0x5db8}, // + {0xC0B0,0x5e6b}, // + {0xC0B1,0x5f4c}, // + {0xC0B2,0x5fbd}, // + {0xC0B3,0x61c9}, // + {0xC0B4,0x61c2}, // + {0xC0B5,0x61c7}, // + {0xC0B6,0x61e6}, // + {0xC0B7,0x61cb}, // + {0xC0B8,0x6232}, // + {0xC0B9,0x6234}, // + {0xC0BA,0x64ce}, // + {0xC0BB,0x64ca}, // + {0xC0BC,0x64d8}, // + {0xC0BD,0x64e0}, // + {0xC0BE,0x64f0}, // + {0xC0BF,0x64e6}, // + {0xC0C0,0x64ec}, // + {0xC0C1,0x64f1}, // + {0xC0C2,0x64e2}, // + {0xC0C3,0x64ed}, // + {0xC0C4,0x6582}, // + {0xC0C5,0x6583}, // + {0xC0C6,0x66d9}, // + {0xC0C7,0x66d6}, // + {0xC0C8,0x6a80}, // + {0xC0C9,0x6a94}, // + {0xC0CA,0x6a84}, // + {0xC0CB,0x6aa2}, // + {0xC0CC,0x6a9c}, // + {0xC0CD,0x6adb}, // + {0xC0CE,0x6aa3}, // + {0xC0CF,0x6a7e}, // + {0xC0D0,0x6a97}, // + {0xC0D1,0x6a90}, // + {0xC0D2,0x6aa0}, // + {0xC0D3,0x6b5c}, // + {0xC0D4,0x6bae}, // + {0xC0D5,0x6bda}, // + {0xC0D6,0x6c08}, // + {0xC0D7,0x6fd8}, // + {0xC0D8,0x6ff1}, // + {0xC0D9,0x6fdf}, // + {0xC0DA,0x6fe0}, // + {0xC0DB,0x6fdb}, // + {0xC0DC,0x6fe4}, // + {0xC0DD,0x6feb}, // + {0xC0DE,0x6fef}, // + {0xC0DF,0x6f80}, // + {0xC0E0,0x6fec}, // + {0xC0E1,0x6fe1}, // + {0xC0E2,0x6fe9}, // + {0xC0E3,0x6fd5}, // + {0xC0E4,0x6fee}, // + {0xC0E5,0x6ff0}, // + {0xC0E6,0x71e7}, // + {0xC0E7,0x71df}, // + {0xC0E8,0x71ee}, // + {0xC0E9,0x71e6}, // + {0xC0EA,0x71e5}, // + {0xC0EB,0x71ed}, // + {0xC0EC,0x71ec}, // + {0xC0ED,0x71f4}, // + {0xC0EE,0x71e0}, // + {0xC0EF,0x7235}, // + {0xC0F0,0x7246}, // + {0xC0F1,0x7370}, // + {0xC0F2,0x7372}, // + {0xC0F3,0x74a9}, // + {0xC0F4,0x74b0}, // + {0xC0F5,0x74a6}, // + {0xC0F6,0x74a8}, // + {0xC0F7,0x7646}, // + {0xC0F8,0x7642}, // + {0xC0F9,0x764c}, // + {0xC0FA,0x76ea}, // + {0xC0FB,0x77b3}, // + {0xC0FC,0x77aa}, // + {0xC0FD,0x77b0}, // + {0xC0FE,0x77ac}, // + {0xC140,0x77a7}, // + {0xC141,0x77ad}, // + {0xC142,0x77ef}, // + {0xC143,0x78f7}, // + {0xC144,0x78fa}, // + {0xC145,0x78f4}, // + {0xC146,0x78ef}, // + {0xC147,0x7901}, // + {0xC148,0x79a7}, // + {0xC149,0x79aa}, // + {0xC14A,0x7a57}, // + {0xC14B,0x7abf}, // + {0xC14C,0x7c07}, // + {0xC14D,0x7c0d}, // + {0xC14E,0x7bfe}, // + {0xC14F,0x7bf7}, // + {0xC150,0x7c0c}, // + {0xC151,0x7be0}, // + {0xC152,0x7ce0}, // + {0xC153,0x7cdc}, // + {0xC154,0x7cde}, // + {0xC155,0x7ce2}, // + {0xC156,0x7cdf}, // + {0xC157,0x7cd9}, // + {0xC158,0x7cdd}, // + {0xC159,0x7e2e}, // + {0xC15A,0x7e3e}, // + {0xC15B,0x7e46}, // + {0xC15C,0x7e37}, // + {0xC15D,0x7e32}, // + {0xC15E,0x7e43}, // + {0xC15F,0x7e2b}, // + {0xC160,0x7e3d}, // + {0xC161,0x7e31}, // + {0xC162,0x7e45}, // + {0xC163,0x7e41}, // + {0xC164,0x7e34}, // + {0xC165,0x7e39}, // + {0xC166,0x7e48}, // + {0xC167,0x7e35}, // + {0xC168,0x7e3f}, // + {0xC169,0x7e2f}, // + {0xC16A,0x7f44}, // + {0xC16B,0x7ff3}, // + {0xC16C,0x7ffc}, // + {0xC16D,0x8071}, // + {0xC16E,0x8072}, // + {0xC16F,0x8070}, // + {0xC170,0x806f}, // + {0xC171,0x8073}, // + {0xC172,0x81c6}, // + {0xC173,0x81c3}, // + {0xC174,0x81ba}, // + {0xC175,0x81c2}, // + {0xC176,0x81c0}, // + {0xC177,0x81bf}, // + {0xC178,0x81bd}, // + {0xC179,0x81c9}, // + {0xC17A,0x81be}, // + {0xC17B,0x81e8}, // + {0xC17C,0x8209}, // + {0xC17D,0x8271}, // + {0xC17E,0x85aa}, // + {0xC1A1,0x8584}, // + {0xC1A2,0x857e}, // + {0xC1A3,0x859c}, // + {0xC1A4,0x8591}, // + {0xC1A5,0x8594}, // + {0xC1A6,0x85af}, // + {0xC1A7,0x859b}, // + {0xC1A8,0x8587}, // + {0xC1A9,0x85a8}, // + {0xC1AA,0x858a}, // + {0xC1AB,0x8667}, // + {0xC1AC,0x87c0}, // + {0xC1AD,0x87d1}, // + {0xC1AE,0x87b3}, // + {0xC1AF,0x87d2}, // + {0xC1B0,0x87c6}, // + {0xC1B1,0x87ab}, // + {0xC1B2,0x87bb}, // + {0xC1B3,0x87ba}, // + {0xC1B4,0x87c8}, // + {0xC1B5,0x87cb}, // + {0xC1B6,0x893b}, // + {0xC1B7,0x8936}, // + {0xC1B8,0x8944}, // + {0xC1B9,0x8938}, // + {0xC1BA,0x893d}, // + {0xC1BB,0x89ac}, // + {0xC1BC,0x8b0e}, // + {0xC1BD,0x8b17}, // + {0xC1BE,0x8b19}, // + {0xC1BF,0x8b1b}, // + {0xC1C0,0x8b0a}, // + {0xC1C1,0x8b20}, // + {0xC1C2,0x8b1d}, // + {0xC1C3,0x8b04}, // + {0xC1C4,0x8b10}, // + {0xC1C5,0x8c41}, // + {0xC1C6,0x8c3f}, // + {0xC1C7,0x8c73}, // + {0xC1C8,0x8cfa}, // + {0xC1C9,0x8cfd}, // + {0xC1CA,0x8cfc}, // + {0xC1CB,0x8cf8}, // + {0xC1CC,0x8cfb}, // + {0xC1CD,0x8da8}, // + {0xC1CE,0x8e49}, // + {0xC1CF,0x8e4b}, // + {0xC1D0,0x8e48}, // + {0xC1D1,0x8e4a}, // + {0xC1D2,0x8f44}, // + {0xC1D3,0x8f3e}, // + {0xC1D4,0x8f42}, // + {0xC1D5,0x8f45}, // + {0xC1D6,0x8f3f}, // + {0xC1D7,0x907f}, // + {0xC1D8,0x907d}, // + {0xC1D9,0x9084}, // + {0xC1DA,0x9081}, // + {0xC1DB,0x9082}, // + {0xC1DC,0x9080}, // + {0xC1DD,0x9139}, // + {0xC1DE,0x91a3}, // + {0xC1DF,0x919e}, // + {0xC1E0,0x919c}, // + {0xC1E1,0x934d}, // + {0xC1E2,0x9382}, // + {0xC1E3,0x9328}, // + {0xC1E4,0x9375}, // + {0xC1E5,0x934a}, // + {0xC1E6,0x9365}, // + {0xC1E7,0x934b}, // + {0xC1E8,0x9318}, // + {0xC1E9,0x937e}, // + {0xC1EA,0x936c}, // + {0xC1EB,0x935b}, // + {0xC1EC,0x9370}, // + {0xC1ED,0x935a}, // + {0xC1EE,0x9354}, // + {0xC1EF,0x95ca}, // + {0xC1F0,0x95cb}, // + {0xC1F1,0x95cc}, // + {0xC1F2,0x95c8}, // + {0xC1F3,0x95c6}, // + {0xC1F4,0x96b1}, // + {0xC1F5,0x96b8}, // + {0xC1F6,0x96d6}, // + {0xC1F7,0x971c}, // + {0xC1F8,0x971e}, // + {0xC1F9,0x97a0}, // + {0xC1FA,0x97d3}, // + {0xC1FB,0x9846}, // + {0xC1FC,0x98b6}, // + {0xC1FD,0x9935}, // + {0xC1FE,0x9a01}, // + {0xC240,0x99ff}, // + {0xC241,0x9bae}, // + {0xC242,0x9bab}, // + {0xC243,0x9baa}, // + {0xC244,0x9bad}, // + {0xC245,0x9d3b}, // + {0xC246,0x9d3f}, // + {0xC247,0x9e8b}, // + {0xC248,0x9ecf}, // + {0xC249,0x9ede}, // + {0xC24A,0x9edc}, // + {0xC24B,0x9edd}, // + {0xC24C,0x9edb}, // + {0xC24D,0x9f3e}, // + {0xC24E,0x9f4b}, // + {0xC24F,0x53e2}, // + {0xC250,0x5695}, // + {0xC251,0x56ae}, // + {0xC252,0x58d9}, // + {0xC253,0x58d8}, // + {0xC254,0x5b38}, // + {0xC255,0x5f5d}, // + {0xC256,0x61e3}, // + {0xC257,0x6233}, // + {0xC258,0x64f4}, // + {0xC259,0x64f2}, // + {0xC25A,0x64fe}, // + {0xC25B,0x6506}, // + {0xC25C,0x64fa}, // + {0xC25D,0x64fb}, // + {0xC25E,0x64f7}, // + {0xC25F,0x65b7}, // + {0xC260,0x66dc}, // + {0xC261,0x6726}, // + {0xC262,0x6ab3}, // + {0xC263,0x6aac}, // + {0xC264,0x6ac3}, // + {0xC265,0x6abb}, // + {0xC266,0x6ab8}, // + {0xC267,0x6ac2}, // + {0xC268,0x6aae}, // + {0xC269,0x6aaf}, // + {0xC26A,0x6b5f}, // + {0xC26B,0x6b78}, // + {0xC26C,0x6baf}, // + {0xC26D,0x7009}, // + {0xC26E,0x700b}, // + {0xC26F,0x6ffe}, // + {0xC270,0x7006}, // + {0xC271,0x6ffa}, // + {0xC272,0x7011}, // + {0xC273,0x700f}, // + {0xC274,0x71fb}, // + {0xC275,0x71fc}, // + {0xC276,0x71fe}, // + {0xC277,0x71f8}, // + {0xC278,0x7377}, // + {0xC279,0x7375}, // + {0xC27A,0x74a7}, // + {0xC27B,0x74bf}, // + {0xC27C,0x7515}, // + {0xC27D,0x7656}, // + {0xC27E,0x7658}, // + {0xC2A1,0x7652}, // + {0xC2A2,0x77bd}, // + {0xC2A3,0x77bf}, // + {0xC2A4,0x77bb}, // + {0xC2A5,0x77bc}, // + {0xC2A6,0x790e}, // + {0xC2A7,0x79ae}, // + {0xC2A8,0x7a61}, // + {0xC2A9,0x7a62}, // + {0xC2AA,0x7a60}, // + {0xC2AB,0x7ac4}, // + {0xC2AC,0x7ac5}, // + {0xC2AD,0x7c2b}, // + {0xC2AE,0x7c27}, // + {0xC2AF,0x7c2a}, // + {0xC2B0,0x7c1e}, // + {0xC2B1,0x7c23}, // + {0xC2B2,0x7c21}, // + {0xC2B3,0x7ce7}, // + {0xC2B4,0x7e54}, // + {0xC2B5,0x7e55}, // + {0xC2B6,0x7e5e}, // + {0xC2B7,0x7e5a}, // + {0xC2B8,0x7e61}, // + {0xC2B9,0x7e52}, // + {0xC2BA,0x7e59}, // + {0xC2BB,0x7f48}, // + {0xC2BC,0x7ff9}, // + {0xC2BD,0x7ffb}, // + {0xC2BE,0x8077}, // + {0xC2BF,0x8076}, // + {0xC2C0,0x81cd}, // + {0xC2C1,0x81cf}, // + {0xC2C2,0x820a}, // + {0xC2C3,0x85cf}, // + {0xC2C4,0x85a9}, // + {0xC2C5,0x85cd}, // + {0xC2C6,0x85d0}, // + {0xC2C7,0x85c9}, // + {0xC2C8,0x85b0}, // + {0xC2C9,0x85ba}, // + {0xC2CA,0x85b9}, // + {0xC2CB,0x85a6}, // + {0xC2CC,0x87ef}, // + {0xC2CD,0x87ec}, // + {0xC2CE,0x87f2}, // + {0xC2CF,0x87e0}, // + {0xC2D0,0x8986}, // + {0xC2D1,0x89b2}, // + {0xC2D2,0x89f4}, // + {0xC2D3,0x8b28}, // + {0xC2D4,0x8b39}, // + {0xC2D5,0x8b2c}, // + {0xC2D6,0x8b2b}, // + {0xC2D7,0x8c50}, // + {0xC2D8,0x8d05}, // + {0xC2D9,0x8e59}, // + {0xC2DA,0x8e63}, // + {0xC2DB,0x8e66}, // + {0xC2DC,0x8e64}, // + {0xC2DD,0x8e5f}, // + {0xC2DE,0x8e55}, // + {0xC2DF,0x8ec0}, // + {0xC2E0,0x8f49}, // + {0xC2E1,0x8f4d}, // + {0xC2E2,0x9087}, // + {0xC2E3,0x9083}, // + {0xC2E4,0x9088}, // + {0xC2E5,0x91ab}, // + {0xC2E6,0x91ac}, // + {0xC2E7,0x91d0}, // + {0xC2E8,0x9394}, // + {0xC2E9,0x938a}, // + {0xC2EA,0x9396}, // + {0xC2EB,0x93a2}, // + {0xC2EC,0x93b3}, // + {0xC2ED,0x93ae}, // + {0xC2EE,0x93ac}, // + {0xC2EF,0x93b0}, // + {0xC2F0,0x9398}, // + {0xC2F1,0x939a}, // + {0xC2F2,0x9397}, // + {0xC2F3,0x95d4}, // + {0xC2F4,0x95d6}, // + {0xC2F5,0x95d0}, // + {0xC2F6,0x95d5}, // + {0xC2F7,0x96e2}, // + {0xC2F8,0x96dc}, // + {0xC2F9,0x96d9}, // + {0xC2FA,0x96db}, // + {0xC2FB,0x96de}, // + {0xC2FC,0x9724}, // + {0xC2FD,0x97a3}, // + {0xC2FE,0x97a6}, // + {0xC340,0x97ad}, // + {0xC341,0x97f9}, // + {0xC342,0x984d}, // + {0xC343,0x984f}, // + {0xC344,0x984c}, // + {0xC345,0x984e}, // + {0xC346,0x9853}, // + {0xC347,0x98ba}, // + {0xC348,0x993e}, // + {0xC349,0x993f}, // + {0xC34A,0x993d}, // + {0xC34B,0x992e}, // + {0xC34C,0x99a5}, // + {0xC34D,0x9a0e}, // + {0xC34E,0x9ac1}, // + {0xC34F,0x9b03}, // + {0xC350,0x9b06}, // + {0xC351,0x9b4f}, // + {0xC352,0x9b4e}, // + {0xC353,0x9b4d}, // + {0xC354,0x9bca}, // + {0xC355,0x9bc9}, // + {0xC356,0x9bfd}, // + {0xC357,0x9bc8}, // + {0xC358,0x9bc0}, // + {0xC359,0x9d51}, // + {0xC35A,0x9d5d}, // + {0xC35B,0x9d60}, // + {0xC35C,0x9ee0}, // + {0xC35D,0x9f15}, // + {0xC35E,0x9f2c}, // + {0xC35F,0x5133}, // + {0xC360,0x56a5}, // + {0xC361,0x58de}, // + {0xC362,0x58df}, // + {0xC363,0x58e2}, // + {0xC364,0x5bf5}, // + {0xC365,0x9f90}, // + {0xC366,0x5eec}, // + {0xC367,0x61f2}, // + {0xC368,0x61f7}, // + {0xC369,0x61f6}, // + {0xC36A,0x61f5}, // + {0xC36B,0x6500}, // + {0xC36C,0x650f}, // + {0xC36D,0x66e0}, // + {0xC36E,0x66dd}, // + {0xC36F,0x6ae5}, // + {0xC370,0x6add}, // + {0xC371,0x6ada}, // + {0xC372,0x6ad3}, // + {0xC373,0x701b}, // + {0xC374,0x701f}, // + {0xC375,0x7028}, // + {0xC376,0x701a}, // + {0xC377,0x701d}, // + {0xC378,0x7015}, // + {0xC379,0x7018}, // + {0xC37A,0x7206}, // + {0xC37B,0x720d}, // + {0xC37C,0x7258}, // + {0xC37D,0x72a2}, // + {0xC37E,0x7378}, // + {0xC3A1,0x737a}, // + {0xC3A2,0x74bd}, // + {0xC3A3,0x74ca}, // + {0xC3A4,0x74e3}, // + {0xC3A5,0x7587}, // + {0xC3A6,0x7586}, // + {0xC3A7,0x765f}, // + {0xC3A8,0x7661}, // + {0xC3A9,0x77c7}, // + {0xC3AA,0x7919}, // + {0xC3AB,0x79b1}, // + {0xC3AC,0x7a6b}, // + {0xC3AD,0x7a69}, // + {0xC3AE,0x7c3e}, // + {0xC3AF,0x7c3f}, // + {0xC3B0,0x7c38}, // + {0xC3B1,0x7c3d}, // + {0xC3B2,0x7c37}, // + {0xC3B3,0x7c40}, // + {0xC3B4,0x7e6b}, // + {0xC3B5,0x7e6d}, // + {0xC3B6,0x7e79}, // + {0xC3B7,0x7e69}, // + {0xC3B8,0x7e6a}, // + {0xC3B9,0x7f85}, // + {0xC3BA,0x7e73}, // + {0xC3BB,0x7fb6}, // + {0xC3BC,0x7fb9}, // + {0xC3BD,0x7fb8}, // + {0xC3BE,0x81d8}, // + {0xC3BF,0x85e9}, // + {0xC3C0,0x85dd}, // + {0xC3C1,0x85ea}, // + {0xC3C2,0x85d5}, // + {0xC3C3,0x85e4}, // + {0xC3C4,0x85e5}, // + {0xC3C5,0x85f7}, // + {0xC3C6,0x87fb}, // + {0xC3C7,0x8805}, // + {0xC3C8,0x880d}, // + {0xC3C9,0x87f9}, // + {0xC3CA,0x87fe}, // + {0xC3CB,0x8960}, // + {0xC3CC,0x895f}, // + {0xC3CD,0x8956}, // + {0xC3CE,0x895e}, // + {0xC3CF,0x8b41}, // + {0xC3D0,0x8b5c}, // + {0xC3D1,0x8b58}, // + {0xC3D2,0x8b49}, // + {0xC3D3,0x8b5a}, // + {0xC3D4,0x8b4e}, // + {0xC3D5,0x8b4f}, // + {0xC3D6,0x8b46}, // + {0xC3D7,0x8b59}, // + {0xC3D8,0x8d08}, // + {0xC3D9,0x8d0a}, // + {0xC3DA,0x8e7c}, // + {0xC3DB,0x8e72}, // + {0xC3DC,0x8e87}, // + {0xC3DD,0x8e76}, // + {0xC3DE,0x8e6c}, // + {0xC3DF,0x8e7a}, // + {0xC3E0,0x8e74}, // + {0xC3E1,0x8f54}, // + {0xC3E2,0x8f4e}, // + {0xC3E3,0x8fad}, // + {0xC3E4,0x908a}, // + {0xC3E5,0x908b}, // + {0xC3E6,0x91b1}, // + {0xC3E7,0x91ae}, // + {0xC3E8,0x93e1}, // + {0xC3E9,0x93d1}, // + {0xC3EA,0x93df}, // + {0xC3EB,0x93c3}, // + {0xC3EC,0x93c8}, // + {0xC3ED,0x93dc}, // + {0xC3EE,0x93dd}, // + {0xC3EF,0x93d6}, // + {0xC3F0,0x93e2}, // + {0xC3F1,0x93cd}, // + {0xC3F2,0x93d8}, // + {0xC3F3,0x93e4}, // + {0xC3F4,0x93d7}, // + {0xC3F5,0x93e8}, // + {0xC3F6,0x95dc}, // + {0xC3F7,0x96b4}, // + {0xC3F8,0x96e3}, // + {0xC3F9,0x972a}, // + {0xC3FA,0x9727}, // + {0xC3FB,0x9761}, // + {0xC3FC,0x97dc}, // + {0xC3FD,0x97fb}, // + {0xC3FE,0x985e}, // + {0xC440,0x9858}, // + {0xC441,0x985b}, // + {0xC442,0x98bc}, // + {0xC443,0x9945}, // + {0xC444,0x9949}, // + {0xC445,0x9a16}, // + {0xC446,0x9a19}, // + {0xC447,0x9b0d}, // + {0xC448,0x9be8}, // + {0xC449,0x9be7}, // + {0xC44A,0x9bd6}, // + {0xC44B,0x9bdb}, // + {0xC44C,0x9d89}, // + {0xC44D,0x9d61}, // + {0xC44E,0x9d72}, // + {0xC44F,0x9d6a}, // + {0xC450,0x9d6c}, // + {0xC451,0x9e92}, // + {0xC452,0x9e97}, // + {0xC453,0x9e93}, // + {0xC454,0x9eb4}, // + {0xC455,0x52f8}, // + {0xC456,0x56a8}, // + {0xC457,0x56b7}, // + {0xC458,0x56b6}, // + {0xC459,0x56b4}, // + {0xC45A,0x56bc}, // + {0xC45B,0x58e4}, // + {0xC45C,0x5b40}, // + {0xC45D,0x5b43}, // + {0xC45E,0x5b7d}, // + {0xC45F,0x5bf6}, // + {0xC460,0x5dc9}, // + {0xC461,0x61f8}, // + {0xC462,0x61fa}, // + {0xC463,0x6518}, // + {0xC464,0x6514}, // + {0xC465,0x6519}, // + {0xC466,0x66e6}, // + {0xC467,0x6727}, // + {0xC468,0x6aec}, // + {0xC469,0x703e}, // + {0xC46A,0x7030}, // + {0xC46B,0x7032}, // + {0xC46C,0x7210}, // + {0xC46D,0x737b}, // + {0xC46E,0x74cf}, // + {0xC46F,0x7662}, // + {0xC470,0x7665}, // + {0xC471,0x7926}, // + {0xC472,0x792a}, // + {0xC473,0x792c}, // + {0xC474,0x792b}, // + {0xC475,0x7ac7}, // + {0xC476,0x7af6}, // + {0xC477,0x7c4c}, // + {0xC478,0x7c43}, // + {0xC479,0x7c4d}, // + {0xC47A,0x7cef}, // + {0xC47B,0x7cf0}, // + {0xC47C,0x8fae}, // + {0xC47D,0x7e7d}, // + {0xC47E,0x7e7c}, // + {0xC4A1,0x7e82}, // + {0xC4A2,0x7f4c}, // + {0xC4A3,0x8000}, // + {0xC4A4,0x81da}, // + {0xC4A5,0x8266}, // + {0xC4A6,0x85fb}, // + {0xC4A7,0x85f9}, // + {0xC4A8,0x8611}, // + {0xC4A9,0x85fa}, // + {0xC4AA,0x8606}, // + {0xC4AB,0x860b}, // + {0xC4AC,0x8607}, // + {0xC4AD,0x860a}, // + {0xC4AE,0x8814}, // + {0xC4AF,0x8815}, // + {0xC4B0,0x8964}, // + {0xC4B1,0x89ba}, // + {0xC4B2,0x89f8}, // + {0xC4B3,0x8b70}, // + {0xC4B4,0x8b6c}, // + {0xC4B5,0x8b66}, // + {0xC4B6,0x8b6f}, // + {0xC4B7,0x8b5f}, // + {0xC4B8,0x8b6b}, // + {0xC4B9,0x8d0f}, // + {0xC4BA,0x8d0d}, // + {0xC4BB,0x8e89}, // + {0xC4BC,0x8e81}, // + {0xC4BD,0x8e85}, // + {0xC4BE,0x8e82}, // + {0xC4BF,0x91b4}, // + {0xC4C0,0x91cb}, // + {0xC4C1,0x9418}, // + {0xC4C2,0x9403}, // + {0xC4C3,0x93fd}, // + {0xC4C4,0x95e1}, // + {0xC4C5,0x9730}, // + {0xC4C6,0x98c4}, // + {0xC4C7,0x9952}, // + {0xC4C8,0x9951}, // + {0xC4C9,0x99a8}, // + {0xC4CA,0x9a2b}, // + {0xC4CB,0x9a30}, // + {0xC4CC,0x9a37}, // + {0xC4CD,0x9a35}, // + {0xC4CE,0x9c13}, // + {0xC4CF,0x9c0d}, // + {0xC4D0,0x9e79}, // + {0xC4D1,0x9eb5}, // + {0xC4D2,0x9ee8}, // + {0xC4D3,0x9f2f}, // + {0xC4D4,0x9f5f}, // + {0xC4D5,0x9f63}, // + {0xC4D6,0x9f61}, // + {0xC4D7,0x5137}, // + {0xC4D8,0x5138}, // + {0xC4D9,0x56c1}, // + {0xC4DA,0x56c0}, // + {0xC4DB,0x56c2}, // + {0xC4DC,0x5914}, // + {0xC4DD,0x5c6c}, // + {0xC4DE,0x5dcd}, // + {0xC4DF,0x61fc}, // + {0xC4E0,0x61fe}, // + {0xC4E1,0x651d}, // + {0xC4E2,0x651c}, // + {0xC4E3,0x6595}, // + {0xC4E4,0x66e9}, // + {0xC4E5,0x6afb}, // + {0xC4E6,0x6b04}, // + {0xC4E7,0x6afa}, // + {0xC4E8,0x6bb2}, // + {0xC4E9,0x704c}, // + {0xC4EA,0x721b}, // + {0xC4EB,0x72a7}, // + {0xC4EC,0x74d6}, // + {0xC4ED,0x74d4}, // + {0xC4EE,0x7669}, // + {0xC4EF,0x77d3}, // + {0xC4F0,0x7c50}, // + {0xC4F1,0x7e8f}, // + {0xC4F2,0x7e8c}, // + {0xC4F3,0x7fbc}, // + {0xC4F4,0x8617}, // + {0xC4F5,0x862d}, // + {0xC4F6,0x861a}, // + {0xC4F7,0x8823}, // + {0xC4F8,0x8822}, // + {0xC4F9,0x8821}, // + {0xC4FA,0x881f}, // + {0xC4FB,0x896a}, // + {0xC4FC,0x896c}, // + {0xC4FD,0x89bd}, // + {0xC4FE,0x8b74}, // + {0xC540,0x8b77}, // + {0xC541,0x8b7d}, // + {0xC542,0x8d13}, // + {0xC543,0x8e8a}, // + {0xC544,0x8e8d}, // + {0xC545,0x8e8b}, // + {0xC546,0x8f5f}, // + {0xC547,0x8faf}, // + {0xC548,0x91ba}, // + {0xC549,0x942e}, // + {0xC54A,0x9433}, // + {0xC54B,0x9435}, // + {0xC54C,0x943a}, // + {0xC54D,0x9438}, // + {0xC54E,0x9432}, // + {0xC54F,0x942b}, // + {0xC550,0x95e2}, // + {0xC551,0x9738}, // + {0xC552,0x9739}, // + {0xC553,0x9732}, // + {0xC554,0x97ff}, // + {0xC555,0x9867}, // + {0xC556,0x9865}, // + {0xC557,0x9957}, // + {0xC558,0x9a45}, // + {0xC559,0x9a43}, // + {0xC55A,0x9a40}, // + {0xC55B,0x9a3e}, // + {0xC55C,0x9acf}, // + {0xC55D,0x9b54}, // + {0xC55E,0x9b51}, // + {0xC55F,0x9c2d}, // + {0xC560,0x9c25}, // + {0xC561,0x9daf}, // + {0xC562,0x9db4}, // + {0xC563,0x9dc2}, // + {0xC564,0x9db8}, // + {0xC565,0x9e9d}, // + {0xC566,0x9eef}, // + {0xC567,0x9f19}, // + {0xC568,0x9f5c}, // + {0xC569,0x9f66}, // + {0xC56A,0x9f67}, // + {0xC56B,0x513c}, // + {0xC56C,0x513b}, // + {0xC56D,0x56c8}, // + {0xC56E,0x56ca}, // + {0xC56F,0x56c9}, // + {0xC570,0x5b7f}, // + {0xC571,0x5dd4}, // + {0xC572,0x5dd2}, // + {0xC573,0x5f4e}, // + {0xC574,0x61ff}, // + {0xC575,0x6524}, // + {0xC576,0x6b0a}, // + {0xC577,0x6b61}, // + {0xC578,0x7051}, // + {0xC579,0x7058}, // + {0xC57A,0x7380}, // + {0xC57B,0x74e4}, // + {0xC57C,0x758a}, // + {0xC57D,0x766e}, // + {0xC57E,0x766c}, // + {0xC5A1,0x79b3}, // + {0xC5A2,0x7c60}, // + {0xC5A3,0x7c5f}, // + {0xC5A4,0x807e}, // + {0xC5A5,0x807d}, // + {0xC5A6,0x81df}, // + {0xC5A7,0x8972}, // + {0xC5A8,0x896f}, // + {0xC5A9,0x89fc}, // + {0xC5AA,0x8b80}, // + {0xC5AB,0x8d16}, // + {0xC5AC,0x8d17}, // + {0xC5AD,0x8e91}, // + {0xC5AE,0x8e93}, // + {0xC5AF,0x8f61}, // + {0xC5B0,0x9148}, // + {0xC5B1,0x9444}, // + {0xC5B2,0x9451}, // + {0xC5B3,0x9452}, // + {0xC5B4,0x973d}, // + {0xC5B5,0x973e}, // + {0xC5B6,0x97c3}, // + {0xC5B7,0x97c1}, // + {0xC5B8,0x986b}, // + {0xC5B9,0x9955}, // + {0xC5BA,0x9a55}, // + {0xC5BB,0x9a4d}, // + {0xC5BC,0x9ad2}, // + {0xC5BD,0x9b1a}, // + {0xC5BE,0x9c49}, // + {0xC5BF,0x9c31}, // + {0xC5C0,0x9c3e}, // + {0xC5C1,0x9c3b}, // + {0xC5C2,0x9dd3}, // + {0xC5C3,0x9dd7}, // + {0xC5C4,0x9f34}, // + {0xC5C5,0x9f6c}, // + {0xC5C6,0x9f6a}, // + {0xC5C7,0x9f94}, // + {0xC5C8,0x56cc}, // + {0xC5C9,0x5dd6}, // + {0xC5CA,0x6200}, // + {0xC5CB,0x6523}, // + {0xC5CC,0x652b}, // + {0xC5CD,0x652a}, // + {0xC5CE,0x66ec}, // + {0xC5CF,0x6b10}, // + {0xC5D0,0x74da}, // + {0xC5D1,0x7aca}, // + {0xC5D2,0x7c64}, // + {0xC5D3,0x7c63}, // + {0xC5D4,0x7c65}, // + {0xC5D5,0x7e93}, // + {0xC5D6,0x7e96}, // + {0xC5D7,0x7e94}, // + {0xC5D8,0x81e2}, // + {0xC5D9,0x8638}, // + {0xC5DA,0x863f}, // + {0xC5DB,0x8831}, // + {0xC5DC,0x8b8a}, // + {0xC5DD,0x9090}, // + {0xC5DE,0x908f}, // + {0xC5DF,0x9463}, // + {0xC5E0,0x9460}, // + {0xC5E1,0x9464}, // + {0xC5E2,0x9768}, // + {0xC5E3,0x986f}, // + {0xC5E4,0x995c}, // + {0xC5E5,0x9a5a}, // + {0xC5E6,0x9a5b}, // + {0xC5E7,0x9a57}, // + {0xC5E8,0x9ad3}, // + {0xC5E9,0x9ad4}, // + {0xC5EA,0x9ad1}, // + {0xC5EB,0x9c54}, // + {0xC5EC,0x9c57}, // + {0xC5ED,0x9c56}, // + {0xC5EE,0x9de5}, // + {0xC5EF,0x9e9f}, // + {0xC5F0,0x9ef4}, // + {0xC5F1,0x56d1}, // + {0xC5F2,0x58e9}, // + {0xC5F3,0x652c}, // + {0xC5F4,0x705e}, // + {0xC5F5,0x7671}, // + {0xC5F6,0x7672}, // + {0xC5F7,0x77d7}, // + {0xC5F8,0x7f50}, // + {0xC5F9,0x7f88}, // + {0xC5FA,0x8836}, // + {0xC5FB,0x8839}, // + {0xC5FC,0x8862}, // + {0xC5FD,0x8b93}, // + {0xC5FE,0x8b92}, // + {0xC640,0x8b96}, // + {0xC641,0x8277}, // + {0xC642,0x8d1b}, // + {0xC643,0x91c0}, // + {0xC644,0x946a}, // + {0xC645,0x9742}, // + {0xC646,0x9748}, // + {0xC647,0x9744}, // + {0xC648,0x97c6}, // + {0xC649,0x9870}, // + {0xC64A,0x9a5f}, // + {0xC64B,0x9b22}, // + {0xC64C,0x9b58}, // + {0xC64D,0x9c5f}, // + {0xC64E,0x9df9}, // + {0xC64F,0x9dfa}, // + {0xC650,0x9e7c}, // + {0xC651,0x9e7d}, // + {0xC652,0x9f07}, // + {0xC653,0x9f77}, // + {0xC654,0x9f72}, // + {0xC655,0x5ef3}, // + {0xC656,0x6b16}, // + {0xC657,0x7063}, // + {0xC658,0x7c6c}, // + {0xC659,0x7c6e}, // + {0xC65A,0x883b}, // + {0xC65B,0x89c0}, // + {0xC65C,0x8ea1}, // + {0xC65D,0x91c1}, // + {0xC65E,0x9472}, // + {0xC65F,0x9470}, // + {0xC660,0x9871}, // + {0xC661,0x995e}, // + {0xC662,0x9ad6}, // + {0xC663,0x9b23}, // + {0xC664,0x9ecc}, // + {0xC665,0x7064}, // + {0xC666,0x77da}, // + {0xC667,0x8b9a}, // + {0xC668,0x9477}, // + {0xC669,0x97c9}, // + {0xC66A,0x9a62}, // + {0xC66B,0x9a65}, // + {0xC66C,0x7e9c}, // + {0xC66D,0x8b9c}, // + {0xC66E,0x8eaa}, // + {0xC66F,0x91c5}, // + {0xC670,0x947d}, // + {0xC671,0x947e}, // + {0xC672,0x947c}, // + {0xC673,0x9c77}, // + {0xC674,0x9c78}, // + {0xC675,0x9ef7}, // + {0xC676,0x8c54}, // + {0xC677,0x947f}, // + {0xC678,0x9e1a}, // + {0xC679,0x7228}, // + {0xC67A,0x9a6a}, // + {0xC67B,0x9b31}, // + {0xC67C,0x9e1b}, // + {0xC67D,0x9e1e}, // + {0xC67E,0x7c72}, // + {0xC6A1,0x30fe}, // KATAKANA VOICED ITERATION MARK + {0xC6A2,0x309d}, // HIRAGANA ITERATION MARK + {0xC6A3,0x309e}, // HIRAGANA VOICED ITERATION MARK + {0xC6A4,0x3005}, // IDEOGRAPHIC ITERATION MARK + {0xC6A5,0x3041}, // HIRAGANA LETTER SMALL A + {0xC6A6,0x3042}, // HIRAGANA LETTER A + {0xC6A7,0x3043}, // HIRAGANA LETTER SMALL I + {0xC6A8,0x3044}, // HIRAGANA LETTER I + {0xC6A9,0x3045}, // HIRAGANA LETTER SMALL U + {0xC6AA,0x3046}, // HIRAGANA LETTER U + {0xC6AB,0x3047}, // HIRAGANA LETTER SMALL E + {0xC6AC,0x3048}, // HIRAGANA LETTER E + {0xC6AD,0x3049}, // HIRAGANA LETTER SMALL O + {0xC6AE,0x304a}, // HIRAGANA LETTER O + {0xC6AF,0x304b}, // HIRAGANA LETTER KA + {0xC6B0,0x304c}, // HIRAGANA LETTER GA + {0xC6B1,0x304d}, // HIRAGANA LETTER KI + {0xC6B2,0x304e}, // HIRAGANA LETTER GI + {0xC6B3,0x304f}, // HIRAGANA LETTER KU + {0xC6B4,0x3050}, // HIRAGANA LETTER GU + {0xC6B5,0x3051}, // HIRAGANA LETTER KE + {0xC6B6,0x3052}, // HIRAGANA LETTER GE + {0xC6B7,0x3053}, // HIRAGANA LETTER KO + {0xC6B8,0x3054}, // HIRAGANA LETTER GO + {0xC6B9,0x3055}, // HIRAGANA LETTER SA + {0xC6BA,0x3056}, // HIRAGANA LETTER ZA + {0xC6BB,0x3057}, // HIRAGANA LETTER SI + {0xC6BC,0x3058}, // HIRAGANA LETTER ZI + {0xC6BD,0x3059}, // HIRAGANA LETTER SU + {0xC6BE,0x305a}, // HIRAGANA LETTER ZU + {0xC6BF,0x305b}, // HIRAGANA LETTER SE + {0xC6C0,0x305c}, // HIRAGANA LETTER ZE + {0xC6C1,0x305d}, // HIRAGANA LETTER SO + {0xC6C2,0x305e}, // HIRAGANA LETTER ZO + {0xC6C3,0x305f}, // HIRAGANA LETTER TA + {0xC6C4,0x3060}, // HIRAGANA LETTER DA + {0xC6C5,0x3061}, // HIRAGANA LETTER TI + {0xC6C6,0x3062}, // HIRAGANA LETTER DI + {0xC6C7,0x3063}, // HIRAGANA LETTER SMALL TU + {0xC6C8,0x3064}, // HIRAGANA LETTER TU + {0xC6C9,0x3065}, // HIRAGANA LETTER DU + {0xC6CA,0x3066}, // HIRAGANA LETTER TE + {0xC6CB,0x3067}, // HIRAGANA LETTER DE + {0xC6CC,0x3068}, // HIRAGANA LETTER TO + {0xC6CD,0x3069}, // HIRAGANA LETTER DO + {0xC6CE,0x306a}, // HIRAGANA LETTER NA + {0xC6CF,0x306b}, // HIRAGANA LETTER NI + {0xC6D0,0x306c}, // HIRAGANA LETTER NU + {0xC6D1,0x306d}, // HIRAGANA LETTER NE + {0xC6D2,0x306e}, // HIRAGANA LETTER NO + {0xC6D3,0x306f}, // HIRAGANA LETTER HA + {0xC6D4,0x3070}, // HIRAGANA LETTER BA + {0xC6D5,0x3071}, // HIRAGANA LETTER PA + {0xC6D6,0x3072}, // HIRAGANA LETTER HI + {0xC6D7,0x3073}, // HIRAGANA LETTER BI + {0xC6D8,0x3074}, // HIRAGANA LETTER PI + {0xC6D9,0x3075}, // HIRAGANA LETTER HU + {0xC6DA,0x3076}, // HIRAGANA LETTER BU + {0xC6DB,0x3077}, // HIRAGANA LETTER PU + {0xC6DC,0x3078}, // HIRAGANA LETTER HE + {0xC6DD,0x3079}, // HIRAGANA LETTER BE + {0xC6DE,0x307a}, // HIRAGANA LETTER PE + {0xC6DF,0x307b}, // HIRAGANA LETTER HO + {0xC6E0,0x307c}, // HIRAGANA LETTER BO + {0xC6E1,0x307d}, // HIRAGANA LETTER PO + {0xC6E2,0x307e}, // HIRAGANA LETTER MA + {0xC6E3,0x307f}, // HIRAGANA LETTER MI + {0xC6E4,0x3080}, // HIRAGANA LETTER MU + {0xC6E5,0x3081}, // HIRAGANA LETTER ME + {0xC6E6,0x3082}, // HIRAGANA LETTER MO + {0xC6E7,0x3083}, // HIRAGANA LETTER SMALL YA + {0xC6E8,0x3084}, // HIRAGANA LETTER YA + {0xC6E9,0x3085}, // HIRAGANA LETTER SMALL YU + {0xC6EA,0x3086}, // HIRAGANA LETTER YU + {0xC6EB,0x3087}, // HIRAGANA LETTER SMALL YO + {0xC6EC,0x3088}, // HIRAGANA LETTER YO + {0xC6ED,0x3089}, // HIRAGANA LETTER RA + {0xC6EE,0x308a}, // HIRAGANA LETTER RI + {0xC6EF,0x308b}, // HIRAGANA LETTER RU + {0xC6F0,0x308c}, // HIRAGANA LETTER RE + {0xC6F1,0x308d}, // HIRAGANA LETTER RO + {0xC6F2,0x308e}, // HIRAGANA LETTER SMALL WA + {0xC6F3,0x308f}, // HIRAGANA LETTER WA + {0xC6F4,0x3090}, // HIRAGANA LETTER WI + {0xC6F5,0x3091}, // HIRAGANA LETTER WE + {0xC6F6,0x3092}, // HIRAGANA LETTER WO + {0xC6F7,0x3093}, // HIRAGANA LETTER N + {0xC6F8,0x30a1}, // KATAKANA LETTER SMALL A + {0xC6F9,0x30a2}, // KATAKANA LETTER A + {0xC6FA,0x30a3}, // KATAKANA LETTER SMALL I + {0xC6FB,0x30a4}, // KATAKANA LETTER I + {0xC6FC,0x30a5}, // KATAKANA LETTER SMALL U + {0xC6FD,0x30a6}, // KATAKANA LETTER U + {0xC6FE,0x30a7}, // KATAKANA LETTER SMALL E + {0xC740,0x30a8}, // KATAKANA LETTER E + {0xC741,0x30a9}, // KATAKANA LETTER SMALL O + {0xC742,0x30aa}, // KATAKANA LETTER O + {0xC743,0x30ab}, // KATAKANA LETTER KA + {0xC744,0x30ac}, // KATAKANA LETTER GA + {0xC745,0x30ad}, // KATAKANA LETTER KI + {0xC746,0x30ae}, // KATAKANA LETTER GI + {0xC747,0x30af}, // KATAKANA LETTER KU + {0xC748,0x30b0}, // KATAKANA LETTER GU + {0xC749,0x30b1}, // KATAKANA LETTER KE + {0xC74A,0x30b2}, // KATAKANA LETTER GE + {0xC74B,0x30b3}, // KATAKANA LETTER KO + {0xC74C,0x30b4}, // KATAKANA LETTER GO + {0xC74D,0x30b5}, // KATAKANA LETTER SA + {0xC74E,0x30b6}, // KATAKANA LETTER ZA + {0xC74F,0x30b7}, // KATAKANA LETTER SI + {0xC750,0x30b8}, // KATAKANA LETTER ZI + {0xC751,0x30b9}, // KATAKANA LETTER SU + {0xC752,0x30ba}, // KATAKANA LETTER ZU + {0xC753,0x30bb}, // KATAKANA LETTER SE + {0xC754,0x30bc}, // KATAKANA LETTER ZE + {0xC755,0x30bd}, // KATAKANA LETTER SO + {0xC756,0x30be}, // KATAKANA LETTER ZO + {0xC757,0x30bf}, // KATAKANA LETTER TA + {0xC758,0x30c0}, // KATAKANA LETTER DA + {0xC759,0x30c1}, // KATAKANA LETTER TI + {0xC75A,0x30c2}, // KATAKANA LETTER DI + {0xC75B,0x30c3}, // KATAKANA LETTER SMALL TU + {0xC75C,0x30c4}, // KATAKANA LETTER TU + {0xC75D,0x30c5}, // KATAKANA LETTER DU + {0xC75E,0x30c6}, // KATAKANA LETTER TE + {0xC75F,0x30c7}, // KATAKANA LETTER DE + {0xC760,0x30c8}, // KATAKANA LETTER TO + {0xC761,0x30c9}, // KATAKANA LETTER DO + {0xC762,0x30ca}, // KATAKANA LETTER NA + {0xC763,0x30cb}, // KATAKANA LETTER NI + {0xC764,0x30cc}, // KATAKANA LETTER NU + {0xC765,0x30cd}, // KATAKANA LETTER NE + {0xC766,0x30ce}, // KATAKANA LETTER NO + {0xC767,0x30cf}, // KATAKANA LETTER HA + {0xC768,0x30d0}, // KATAKANA LETTER BA + {0xC769,0x30d1}, // KATAKANA LETTER PA + {0xC76A,0x30d2}, // KATAKANA LETTER HI + {0xC76B,0x30d3}, // KATAKANA LETTER BI + {0xC76C,0x30d4}, // KATAKANA LETTER PI + {0xC76D,0x30d5}, // KATAKANA LETTER HU + {0xC76E,0x30d6}, // KATAKANA LETTER BU + {0xC76F,0x30d7}, // KATAKANA LETTER PU + {0xC770,0x30d8}, // KATAKANA LETTER HE + {0xC771,0x30d9}, // KATAKANA LETTER BE + {0xC772,0x30da}, // KATAKANA LETTER PE + {0xC773,0x30db}, // KATAKANA LETTER HO + {0xC774,0x30dc}, // KATAKANA LETTER BO + {0xC775,0x30dd}, // KATAKANA LETTER PO + {0xC776,0x30de}, // KATAKANA LETTER MA + {0xC777,0x30df}, // KATAKANA LETTER MI + {0xC778,0x30e0}, // KATAKANA LETTER MU + {0xC779,0x30e1}, // KATAKANA LETTER ME + {0xC77A,0x30e2}, // KATAKANA LETTER MO + {0xC77B,0x30e3}, // KATAKANA LETTER SMALL YA + {0xC77C,0x30e4}, // KATAKANA LETTER YA + {0xC77D,0x30e5}, // KATAKANA LETTER SMALL YU + {0xC77E,0x30e6}, // KATAKANA LETTER YU + {0xC7A1,0x30e7}, // KATAKANA LETTER SMALL YO + {0xC7A2,0x30e8}, // KATAKANA LETTER YO + {0xC7A3,0x30e9}, // KATAKANA LETTER RA + {0xC7A4,0x30ea}, // KATAKANA LETTER RI + {0xC7A5,0x30eb}, // KATAKANA LETTER RU + {0xC7A6,0x30ec}, // KATAKANA LETTER RE + {0xC7A7,0x30ed}, // KATAKANA LETTER RO + {0xC7A8,0x30ee}, // KATAKANA LETTER SMALL WA + {0xC7A9,0x30ef}, // KATAKANA LETTER WA + {0xC7AA,0x30f0}, // KATAKANA LETTER WI + {0xC7AB,0x30f1}, // KATAKANA LETTER WE + {0xC7AC,0x30f2}, // KATAKANA LETTER WO + {0xC7AD,0x30f3}, // KATAKANA LETTER N + {0xC7AE,0x30f4}, // KATAKANA LETTER VU + {0xC7AF,0x30f5}, // KATAKANA LETTER SMALL KA + {0xC7B0,0x30f6}, // KATAKANA LETTER SMALL KE + {0xC7B1,0x0414}, // CYRILLIC CAPITAL LETTER DE + {0xC7B2,0x0415}, // CYRILLIC CAPITAL LETTER IE + {0xC7B3,0x0401}, // CYRILLIC CAPITAL LETTER IO + {0xC7B4,0x0416}, // CYRILLIC CAPITAL LETTER ZHE + {0xC7B5,0x0417}, // CYRILLIC CAPITAL LETTER ZE + {0xC7B6,0x0418}, // CYRILLIC CAPITAL LETTER I + {0xC7B7,0x0419}, // CYRILLIC CAPITAL LETTER SHORT I + {0xC7B8,0x041a}, // CYRILLIC CAPITAL LETTER KA + {0xC7B9,0x041b}, // CYRILLIC CAPITAL LETTER EL + {0xC7BA,0x041c}, // CYRILLIC CAPITAL LETTER EM + {0xC7BB,0x0423}, // CYRILLIC CAPITAL LETTER U + {0xC7BC,0x0424}, // CYRILLIC CAPITAL LETTER EF + {0xC7BD,0x0425}, // CYRILLIC CAPITAL LETTER HA + {0xC7BE,0x0426}, // CYRILLIC CAPITAL LETTER TSE + {0xC7BF,0x0427}, // CYRILLIC CAPITAL LETTER CHE + {0xC7C0,0x0428}, // CYRILLIC CAPITAL LETTER SHA + {0xC7C1,0x0429}, // CYRILLIC CAPITAL LETTER SHCHA + {0xC7C2,0x042a}, // CYRILLIC CAPITAL LETTER HARD SIGN + {0xC7C3,0x042b}, // CYRILLIC CAPITAL LETTER YERU + {0xC7C4,0x042c}, // CYRILLIC CAPITAL LETTER SOFT SIGN + {0xC7C5,0x042d}, // CYRILLIC CAPITAL LETTER E + {0xC7C6,0x042e}, // CYRILLIC CAPITAL LETTER YU + {0xC7C7,0x042f}, // CYRILLIC CAPITAL LETTER YA + {0xC7C8,0x0430}, // CYRILLIC SMALL LETTER A + {0xC7C9,0x0431}, // CYRILLIC SMALL LETTER BE + {0xC7CA,0x0432}, // CYRILLIC SMALL LETTER VE + {0xC7CB,0x0433}, // CYRILLIC SMALL LETTER GHE + {0xC7CC,0x0434}, // CYRILLIC SMALL LETTER DE + {0xC7CD,0x0435}, // CYRILLIC SMALL LETTER IE + {0xC7CE,0x0451}, // CYRILLIC SMALL LETTER IO + {0xC7CF,0x0436}, // CYRILLIC SMALL LETTER ZHE + {0xC7D0,0x0437}, // CYRILLIC SMALL LETTER ZE + {0xC7D1,0x0438}, // CYRILLIC SMALL LETTER I + {0xC7D2,0x0439}, // CYRILLIC SMALL LETTER SHORT I + {0xC7D3,0x043a}, // CYRILLIC SMALL LETTER KA + {0xC7D4,0x043b}, // CYRILLIC SMALL LETTER EL + {0xC7D5,0x043c}, // CYRILLIC SMALL LETTER EM + {0xC7D6,0x043d}, // CYRILLIC SMALL LETTER EN + {0xC7D7,0x043e}, // CYRILLIC SMALL LETTER O + {0xC7D8,0x043f}, // CYRILLIC SMALL LETTER PE + {0xC7D9,0x0440}, // CYRILLIC SMALL LETTER ER + {0xC7DA,0x0441}, // CYRILLIC SMALL LETTER ES + {0xC7DB,0x0442}, // CYRILLIC SMALL LETTER TE + {0xC7DC,0x0443}, // CYRILLIC SMALL LETTER U + {0xC7DD,0x0444}, // CYRILLIC SMALL LETTER EF + {0xC7DE,0x0445}, // CYRILLIC SMALL LETTER HA + {0xC7DF,0x0446}, // CYRILLIC SMALL LETTER TSE + {0xC7E0,0x0447}, // CYRILLIC SMALL LETTER CHE + {0xC7E1,0x0448}, // CYRILLIC SMALL LETTER SHA + {0xC7E2,0x0449}, // CYRILLIC SMALL LETTER SHCHA + {0xC7E3,0x044a}, // CYRILLIC SMALL LETTER HARD SIGN + {0xC7E4,0x044b}, // CYRILLIC SMALL LETTER YERU + {0xC7E5,0x044c}, // CYRILLIC SMALL LETTER SOFT SIGN + {0xC7E6,0x044d}, // CYRILLIC SMALL LETTER E + {0xC7E7,0x044e}, // CYRILLIC SMALL LETTER YU + {0xC7E8,0x044f}, // CYRILLIC SMALL LETTER YA + {0xC7E9,0x2460}, // CIRCLED DIGIT ONE + {0xC7EA,0x2461}, // CIRCLED DIGIT TWO + {0xC7EB,0x2462}, // CIRCLED DIGIT THREE + {0xC7EC,0x2463}, // CIRCLED DIGIT FOUR + {0xC7ED,0x2464}, // CIRCLED DIGIT FIVE + {0xC7EE,0x2465}, // CIRCLED DIGIT SIX + {0xC7EF,0x2466}, // CIRCLED DIGIT SEVEN + {0xC7F0,0x2467}, // CIRCLED DIGIT EIGHT + {0xC7F1,0x2468}, // CIRCLED DIGIT NINE + {0xC7F2,0x2469}, // CIRCLED NUMBER TEN + {0xC7F3,0x2474}, // PARENTHESIZED DIGIT ONE + {0xC7F4,0x2475}, // PARENTHESIZED DIGIT TWO + {0xC7F5,0x2476}, // PARENTHESIZED DIGIT THREE + {0xC7F6,0x2477}, // PARENTHESIZED DIGIT FOUR + {0xC7F7,0x2478}, // PARENTHESIZED DIGIT FIVE + {0xC7F8,0x2479}, // PARENTHESIZED DIGIT SIX + {0xC7F9,0x247a}, // PARENTHESIZED DIGIT SEVEN + {0xC7FA,0x247b}, // PARENTHESIZED DIGIT EIGHT + {0xC7FB,0x247c}, // PARENTHESIZED DIGIT NINE + {0xC7FC,0x247d}, // PARENTHESIZED NUMBER TEN + {0xC940,0x4e42}, // + {0xC941,0x4e5c}, // + {0xC942,0x51f5}, // + {0xC943,0x531a}, // + {0xC944,0x5382}, // + {0xC945,0x4e07}, // + {0xC946,0x4e0c}, // + {0xC947,0x4e47}, // + {0xC948,0x4e8d}, // + {0xC949,0x56d7}, // + {0xC94A,0xfa0c}, // CJK COMPATIBILITY IDEOGRAPH-FA0C + {0xC94B,0x5c6e}, // + {0xC94C,0x5f73}, // + {0xC94D,0x4e0f}, // + {0xC94E,0x5187}, // + {0xC94F,0x4e0e}, // + {0xC950,0x4e2e}, // + {0xC951,0x4e93}, // + {0xC952,0x4ec2}, // + {0xC953,0x4ec9}, // + {0xC954,0x4ec8}, // + {0xC955,0x5198}, // + {0xC956,0x52fc}, // + {0xC957,0x536c}, // + {0xC958,0x53b9}, // + {0xC959,0x5720}, // + {0xC95A,0x5903}, // + {0xC95B,0x592c}, // + {0xC95C,0x5c10}, // + {0xC95D,0x5dff}, // + {0xC95E,0x65e1}, // + {0xC95F,0x6bb3}, // + {0xC960,0x6bcc}, // + {0xC961,0x6c14}, // + {0xC962,0x723f}, // + {0xC963,0x4e31}, // + {0xC964,0x4e3c}, // + {0xC965,0x4ee8}, // + {0xC966,0x4edc}, // + {0xC967,0x4ee9}, // + {0xC968,0x4ee1}, // + {0xC969,0x4edd}, // + {0xC96A,0x4eda}, // + {0xC96B,0x520c}, // + {0xC96C,0x531c}, // + {0xC96D,0x534c}, // + {0xC96E,0x5722}, // + {0xC96F,0x5723}, // + {0xC970,0x5917}, // + {0xC971,0x592f}, // + {0xC972,0x5b81}, // + {0xC973,0x5b84}, // + {0xC974,0x5c12}, // + {0xC975,0x5c3b}, // + {0xC976,0x5c74}, // + {0xC977,0x5c73}, // + {0xC978,0x5e04}, // + {0xC979,0x5e80}, // + {0xC97A,0x5e82}, // + {0xC97B,0x5fc9}, // + {0xC97C,0x6209}, // + {0xC97D,0x6250}, // + {0xC97E,0x6c15}, // + {0xC9A1,0x6c36}, // + {0xC9A2,0x6c43}, // + {0xC9A3,0x6c3f}, // + {0xC9A4,0x6c3b}, // + {0xC9A5,0x72ae}, // + {0xC9A6,0x72b0}, // + {0xC9A7,0x738a}, // + {0xC9A8,0x79b8}, // + {0xC9A9,0x808a}, // + {0xC9AA,0x961e}, // + {0xC9AB,0x4f0e}, // + {0xC9AC,0x4f18}, // + {0xC9AD,0x4f2c}, // + {0xC9AE,0x4ef5}, // + {0xC9AF,0x4f14}, // + {0xC9B0,0x4ef1}, // + {0xC9B1,0x4f00}, // + {0xC9B2,0x4ef7}, // + {0xC9B3,0x4f08}, // + {0xC9B4,0x4f1d}, // + {0xC9B5,0x4f02}, // + {0xC9B6,0x4f05}, // + {0xC9B7,0x4f22}, // + {0xC9B8,0x4f13}, // + {0xC9B9,0x4f04}, // + {0xC9BA,0x4ef4}, // + {0xC9BB,0x4f12}, // + {0xC9BC,0x51b1}, // + {0xC9BD,0x5213}, // + {0xC9BE,0x5209}, // + {0xC9BF,0x5210}, // + {0xC9C0,0x52a6}, // + {0xC9C1,0x5322}, // + {0xC9C2,0x531f}, // + {0xC9C3,0x534d}, // + {0xC9C4,0x538a}, // + {0xC9C5,0x5407}, // + {0xC9C6,0x56e1}, // + {0xC9C7,0x56df}, // + {0xC9C8,0x572e}, // + {0xC9C9,0x572a}, // + {0xC9CA,0x5734}, // + {0xC9CB,0x593c}, // + {0xC9CC,0x5980}, // + {0xC9CD,0x597c}, // + {0xC9CE,0x5985}, // + {0xC9CF,0x597b}, // + {0xC9D0,0x597e}, // + {0xC9D1,0x5977}, // + {0xC9D2,0x597f}, // + {0xC9D3,0x5b56}, // + {0xC9D4,0x5c15}, // + {0xC9D5,0x5c25}, // + {0xC9D6,0x5c7c}, // + {0xC9D7,0x5c7a}, // + {0xC9D8,0x5c7b}, // + {0xC9D9,0x5c7e}, // + {0xC9DA,0x5ddf}, // + {0xC9DB,0x5e75}, // + {0xC9DC,0x5e84}, // + {0xC9DD,0x5f02}, // + {0xC9DE,0x5f1a}, // + {0xC9DF,0x5f74}, // + {0xC9E0,0x5fd5}, // + {0xC9E1,0x5fd4}, // + {0xC9E2,0x5fcf}, // + {0xC9E3,0x625c}, // + {0xC9E4,0x625e}, // + {0xC9E5,0x6264}, // + {0xC9E6,0x6261}, // + {0xC9E7,0x6266}, // + {0xC9E8,0x6262}, // + {0xC9E9,0x6259}, // + {0xC9EA,0x6260}, // + {0xC9EB,0x625a}, // + {0xC9EC,0x6265}, // + {0xC9ED,0x65ef}, // + {0xC9EE,0x65ee}, // + {0xC9EF,0x673e}, // + {0xC9F0,0x6739}, // + {0xC9F1,0x6738}, // + {0xC9F2,0x673b}, // + {0xC9F3,0x673a}, // + {0xC9F4,0x673f}, // + {0xC9F5,0x673c}, // + {0xC9F6,0x6733}, // + {0xC9F7,0x6c18}, // + {0xC9F8,0x6c46}, // + {0xC9F9,0x6c52}, // + {0xC9FA,0x6c5c}, // + {0xC9FB,0x6c4f}, // + {0xC9FC,0x6c4a}, // + {0xC9FD,0x6c54}, // + {0xC9FE,0x6c4b}, // + {0xCA40,0x6c4c}, // + {0xCA41,0x7071}, // + {0xCA42,0x725e}, // + {0xCA43,0x72b4}, // + {0xCA44,0x72b5}, // + {0xCA45,0x738e}, // + {0xCA46,0x752a}, // + {0xCA47,0x767f}, // + {0xCA48,0x7a75}, // + {0xCA49,0x7f51}, // + {0xCA4A,0x8278}, // + {0xCA4B,0x827c}, // + {0xCA4C,0x8280}, // + {0xCA4D,0x827d}, // + {0xCA4E,0x827f}, // + {0xCA4F,0x864d}, // + {0xCA50,0x897e}, // + {0xCA51,0x9099}, // + {0xCA52,0x9097}, // + {0xCA53,0x9098}, // + {0xCA54,0x909b}, // + {0xCA55,0x9094}, // + {0xCA56,0x9622}, // + {0xCA57,0x9624}, // + {0xCA58,0x9620}, // + {0xCA59,0x9623}, // + {0xCA5A,0x4f56}, // + {0xCA5B,0x4f3b}, // + {0xCA5C,0x4f62}, // + {0xCA5D,0x4f49}, // + {0xCA5E,0x4f53}, // + {0xCA5F,0x4f64}, // + {0xCA60,0x4f3e}, // + {0xCA61,0x4f67}, // + {0xCA62,0x4f52}, // + {0xCA63,0x4f5f}, // + {0xCA64,0x4f41}, // + {0xCA65,0x4f58}, // + {0xCA66,0x4f2d}, // + {0xCA67,0x4f33}, // + {0xCA68,0x4f3f}, // + {0xCA69,0x4f61}, // + {0xCA6A,0x518f}, // + {0xCA6B,0x51b9}, // + {0xCA6C,0x521c}, // + {0xCA6D,0x521e}, // + {0xCA6E,0x5221}, // + {0xCA6F,0x52ad}, // + {0xCA70,0x52ae}, // + {0xCA71,0x5309}, // + {0xCA72,0x5363}, // + {0xCA73,0x5372}, // + {0xCA74,0x538e}, // + {0xCA75,0x538f}, // + {0xCA76,0x5430}, // + {0xCA77,0x5437}, // + {0xCA78,0x542a}, // + {0xCA79,0x5454}, // + {0xCA7A,0x5445}, // + {0xCA7B,0x5419}, // + {0xCA7C,0x541c}, // + {0xCA7D,0x5425}, // + {0xCA7E,0x5418}, // + {0xCAA1,0x543d}, // + {0xCAA2,0x544f}, // + {0xCAA3,0x5441}, // + {0xCAA4,0x5428}, // + {0xCAA5,0x5424}, // + {0xCAA6,0x5447}, // + {0xCAA7,0x56ee}, // + {0xCAA8,0x56e7}, // + {0xCAA9,0x56e5}, // + {0xCAAA,0x5741}, // + {0xCAAB,0x5745}, // + {0xCAAC,0x574c}, // + {0xCAAD,0x5749}, // + {0xCAAE,0x574b}, // + {0xCAAF,0x5752}, // + {0xCAB0,0x5906}, // + {0xCAB1,0x5940}, // + {0xCAB2,0x59a6}, // + {0xCAB3,0x5998}, // + {0xCAB4,0x59a0}, // + {0xCAB5,0x5997}, // + {0xCAB6,0x598e}, // + {0xCAB7,0x59a2}, // + {0xCAB8,0x5990}, // + {0xCAB9,0x598f}, // + {0xCABA,0x59a7}, // + {0xCABB,0x59a1}, // + {0xCABC,0x5b8e}, // + {0xCABD,0x5b92}, // + {0xCABE,0x5c28}, // + {0xCABF,0x5c2a}, // + {0xCAC0,0x5c8d}, // + {0xCAC1,0x5c8f}, // + {0xCAC2,0x5c88}, // + {0xCAC3,0x5c8b}, // + {0xCAC4,0x5c89}, // + {0xCAC5,0x5c92}, // + {0xCAC6,0x5c8a}, // + {0xCAC7,0x5c86}, // + {0xCAC8,0x5c93}, // + {0xCAC9,0x5c95}, // + {0xCACA,0x5de0}, // + {0xCACB,0x5e0a}, // + {0xCACC,0x5e0e}, // + {0xCACD,0x5e8b}, // + {0xCACE,0x5e89}, // + {0xCACF,0x5e8c}, // + {0xCAD0,0x5e88}, // + {0xCAD1,0x5e8d}, // + {0xCAD2,0x5f05}, // + {0xCAD3,0x5f1d}, // + {0xCAD4,0x5f78}, // + {0xCAD5,0x5f76}, // + {0xCAD6,0x5fd2}, // + {0xCAD7,0x5fd1}, // + {0xCAD8,0x5fd0}, // + {0xCAD9,0x5fed}, // + {0xCADA,0x5fe8}, // + {0xCADB,0x5fee}, // + {0xCADC,0x5ff3}, // + {0xCADD,0x5fe1}, // + {0xCADE,0x5fe4}, // + {0xCADF,0x5fe3}, // + {0xCAE0,0x5ffa}, // + {0xCAE1,0x5fef}, // + {0xCAE2,0x5ff7}, // + {0xCAE3,0x5ffb}, // + {0xCAE4,0x6000}, // + {0xCAE5,0x5ff4}, // + {0xCAE6,0x623a}, // + {0xCAE7,0x6283}, // + {0xCAE8,0x628c}, // + {0xCAE9,0x628e}, // + {0xCAEA,0x628f}, // + {0xCAEB,0x6294}, // + {0xCAEC,0x6287}, // + {0xCAED,0x6271}, // + {0xCAEE,0x627b}, // + {0xCAEF,0x627a}, // + {0xCAF0,0x6270}, // + {0xCAF1,0x6281}, // + {0xCAF2,0x6288}, // + {0xCAF3,0x6277}, // + {0xCAF4,0x627d}, // + {0xCAF5,0x6272}, // + {0xCAF6,0x6274}, // + {0xCAF7,0x6537}, // + {0xCAF8,0x65f0}, // + {0xCAF9,0x65f4}, // + {0xCAFA,0x65f3}, // + {0xCAFB,0x65f2}, // + {0xCAFC,0x65f5}, // + {0xCAFD,0x6745}, // + {0xCAFE,0x6747}, // + {0xCB40,0x6759}, // + {0xCB41,0x6755}, // + {0xCB42,0x674c}, // + {0xCB43,0x6748}, // + {0xCB44,0x675d}, // + {0xCB45,0x674d}, // + {0xCB46,0x675a}, // + {0xCB47,0x674b}, // + {0xCB48,0x6bd0}, // + {0xCB49,0x6c19}, // + {0xCB4A,0x6c1a}, // + {0xCB4B,0x6c78}, // + {0xCB4C,0x6c67}, // + {0xCB4D,0x6c6b}, // + {0xCB4E,0x6c84}, // + {0xCB4F,0x6c8b}, // + {0xCB50,0x6c8f}, // + {0xCB51,0x6c71}, // + {0xCB52,0x6c6f}, // + {0xCB53,0x6c69}, // + {0xCB54,0x6c9a}, // + {0xCB55,0x6c6d}, // + {0xCB56,0x6c87}, // + {0xCB57,0x6c95}, // + {0xCB58,0x6c9c}, // + {0xCB59,0x6c66}, // + {0xCB5A,0x6c73}, // + {0xCB5B,0x6c65}, // + {0xCB5C,0x6c7b}, // + {0xCB5D,0x6c8e}, // + {0xCB5E,0x7074}, // + {0xCB5F,0x707a}, // + {0xCB60,0x7263}, // + {0xCB61,0x72bf}, // + {0xCB62,0x72bd}, // + {0xCB63,0x72c3}, // + {0xCB64,0x72c6}, // + {0xCB65,0x72c1}, // + {0xCB66,0x72ba}, // + {0xCB67,0x72c5}, // + {0xCB68,0x7395}, // + {0xCB69,0x7397}, // + {0xCB6A,0x7393}, // + {0xCB6B,0x7394}, // + {0xCB6C,0x7392}, // + {0xCB6D,0x753a}, // + {0xCB6E,0x7539}, // + {0xCB6F,0x7594}, // + {0xCB70,0x7595}, // + {0xCB71,0x7681}, // + {0xCB72,0x793d}, // + {0xCB73,0x8034}, // + {0xCB74,0x8095}, // + {0xCB75,0x8099}, // + {0xCB76,0x8090}, // + {0xCB77,0x8092}, // + {0xCB78,0x809c}, // + {0xCB79,0x8290}, // + {0xCB7A,0x828f}, // + {0xCB7B,0x8285}, // + {0xCB7C,0x828e}, // + {0xCB7D,0x8291}, // + {0xCB7E,0x8293}, // + {0xCBA1,0x828a}, // + {0xCBA2,0x8283}, // + {0xCBA3,0x8284}, // + {0xCBA4,0x8c78}, // + {0xCBA5,0x8fc9}, // + {0xCBA6,0x8fbf}, // + {0xCBA7,0x909f}, // + {0xCBA8,0x90a1}, // + {0xCBA9,0x90a5}, // + {0xCBAA,0x909e}, // + {0xCBAB,0x90a7}, // + {0xCBAC,0x90a0}, // + {0xCBAD,0x9630}, // + {0xCBAE,0x9628}, // + {0xCBAF,0x962f}, // + {0xCBB0,0x962d}, // + {0xCBB1,0x4e33}, // + {0xCBB2,0x4f98}, // + {0xCBB3,0x4f7c}, // + {0xCBB4,0x4f85}, // + {0xCBB5,0x4f7d}, // + {0xCBB6,0x4f80}, // + {0xCBB7,0x4f87}, // + {0xCBB8,0x4f76}, // + {0xCBB9,0x4f74}, // + {0xCBBA,0x4f89}, // + {0xCBBB,0x4f84}, // + {0xCBBC,0x4f77}, // + {0xCBBD,0x4f4c}, // + {0xCBBE,0x4f97}, // + {0xCBBF,0x4f6a}, // + {0xCBC0,0x4f9a}, // + {0xCBC1,0x4f79}, // + {0xCBC2,0x4f81}, // + {0xCBC3,0x4f78}, // + {0xCBC4,0x4f90}, // + {0xCBC5,0x4f9c}, // + {0xCBC6,0x4f94}, // + {0xCBC7,0x4f9e}, // + {0xCBC8,0x4f92}, // + {0xCBC9,0x4f82}, // + {0xCBCA,0x4f95}, // + {0xCBCB,0x4f6b}, // + {0xCBCC,0x4f6e}, // + {0xCBCD,0x519e}, // + {0xCBCE,0x51bc}, // + {0xCBCF,0x51be}, // + {0xCBD0,0x5235}, // + {0xCBD1,0x5232}, // + {0xCBD2,0x5233}, // + {0xCBD3,0x5246}, // + {0xCBD4,0x5231}, // + {0xCBD5,0x52bc}, // + {0xCBD6,0x530a}, // + {0xCBD7,0x530b}, // + {0xCBD8,0x533c}, // + {0xCBD9,0x5392}, // + {0xCBDA,0x5394}, // + {0xCBDB,0x5487}, // + {0xCBDC,0x547f}, // + {0xCBDD,0x5481}, // + {0xCBDE,0x5491}, // + {0xCBDF,0x5482}, // + {0xCBE0,0x5488}, // + {0xCBE1,0x546b}, // + {0xCBE2,0x547a}, // + {0xCBE3,0x547e}, // + {0xCBE4,0x5465}, // + {0xCBE5,0x546c}, // + {0xCBE6,0x5474}, // + {0xCBE7,0x5466}, // + {0xCBE8,0x548d}, // + {0xCBE9,0x546f}, // + {0xCBEA,0x5461}, // + {0xCBEB,0x5460}, // + {0xCBEC,0x5498}, // + {0xCBED,0x5463}, // + {0xCBEE,0x5467}, // + {0xCBEF,0x5464}, // + {0xCBF0,0x56f7}, // + {0xCBF1,0x56f9}, // + {0xCBF2,0x576f}, // + {0xCBF3,0x5772}, // + {0xCBF4,0x576d}, // + {0xCBF5,0x576b}, // + {0xCBF6,0x5771}, // + {0xCBF7,0x5770}, // + {0xCBF8,0x5776}, // + {0xCBF9,0x5780}, // + {0xCBFA,0x5775}, // + {0xCBFB,0x577b}, // + {0xCBFC,0x5773}, // + {0xCBFD,0x5774}, // + {0xCBFE,0x5762}, // + {0xCC40,0x5768}, // + {0xCC41,0x577d}, // + {0xCC42,0x590c}, // + {0xCC43,0x5945}, // + {0xCC44,0x59b5}, // + {0xCC45,0x59ba}, // + {0xCC46,0x59cf}, // + {0xCC47,0x59ce}, // + {0xCC48,0x59b2}, // + {0xCC49,0x59cc}, // + {0xCC4A,0x59c1}, // + {0xCC4B,0x59b6}, // + {0xCC4C,0x59bc}, // + {0xCC4D,0x59c3}, // + {0xCC4E,0x59d6}, // + {0xCC4F,0x59b1}, // + {0xCC50,0x59bd}, // + {0xCC51,0x59c0}, // + {0xCC52,0x59c8}, // + {0xCC53,0x59b4}, // + {0xCC54,0x59c7}, // + {0xCC55,0x5b62}, // + {0xCC56,0x5b65}, // + {0xCC57,0x5b93}, // + {0xCC58,0x5b95}, // + {0xCC59,0x5c44}, // + {0xCC5A,0x5c47}, // + {0xCC5B,0x5cae}, // + {0xCC5C,0x5ca4}, // + {0xCC5D,0x5ca0}, // + {0xCC5E,0x5cb5}, // + {0xCC5F,0x5caf}, // + {0xCC60,0x5ca8}, // + {0xCC61,0x5cac}, // + {0xCC62,0x5c9f}, // + {0xCC63,0x5ca3}, // + {0xCC64,0x5cad}, // + {0xCC65,0x5ca2}, // + {0xCC66,0x5caa}, // + {0xCC67,0x5ca7}, // + {0xCC68,0x5c9d}, // + {0xCC69,0x5ca5}, // + {0xCC6A,0x5cb6}, // + {0xCC6B,0x5cb0}, // + {0xCC6C,0x5ca6}, // + {0xCC6D,0x5e17}, // + {0xCC6E,0x5e14}, // + {0xCC6F,0x5e19}, // + {0xCC70,0x5f28}, // + {0xCC71,0x5f22}, // + {0xCC72,0x5f23}, // + {0xCC73,0x5f24}, // + {0xCC74,0x5f54}, // + {0xCC75,0x5f82}, // + {0xCC76,0x5f7e}, // + {0xCC77,0x5f7d}, // + {0xCC78,0x5fde}, // + {0xCC79,0x5fe5}, // + {0xCC7A,0x602d}, // + {0xCC7B,0x6026}, // + {0xCC7C,0x6019}, // + {0xCC7D,0x6032}, // + {0xCC7E,0x600b}, // + {0xCCA1,0x6034}, // + {0xCCA2,0x600a}, // + {0xCCA3,0x6017}, // + {0xCCA4,0x6033}, // + {0xCCA5,0x601a}, // + {0xCCA6,0x601e}, // + {0xCCA7,0x602c}, // + {0xCCA8,0x6022}, // + {0xCCA9,0x600d}, // + {0xCCAA,0x6010}, // + {0xCCAB,0x602e}, // + {0xCCAC,0x6013}, // + {0xCCAD,0x6011}, // + {0xCCAE,0x600c}, // + {0xCCAF,0x6009}, // + {0xCCB0,0x601c}, // + {0xCCB1,0x6214}, // + {0xCCB2,0x623d}, // + {0xCCB3,0x62ad}, // + {0xCCB4,0x62b4}, // + {0xCCB5,0x62d1}, // + {0xCCB6,0x62be}, // + {0xCCB7,0x62aa}, // + {0xCCB8,0x62b6}, // + {0xCCB9,0x62ca}, // + {0xCCBA,0x62ae}, // + {0xCCBB,0x62b3}, // + {0xCCBC,0x62af}, // + {0xCCBD,0x62bb}, // + {0xCCBE,0x62a9}, // + {0xCCBF,0x62b0}, // + {0xCCC0,0x62b8}, // + {0xCCC1,0x653d}, // + {0xCCC2,0x65a8}, // + {0xCCC3,0x65bb}, // + {0xCCC4,0x6609}, // + {0xCCC5,0x65fc}, // + {0xCCC6,0x6604}, // + {0xCCC7,0x6612}, // + {0xCCC8,0x6608}, // + {0xCCC9,0x65fb}, // + {0xCCCA,0x6603}, // + {0xCCCB,0x660b}, // + {0xCCCC,0x660d}, // + {0xCCCD,0x6605}, // + {0xCCCE,0x65fd}, // + {0xCCCF,0x6611}, // + {0xCCD0,0x6610}, // + {0xCCD1,0x66f6}, // + {0xCCD2,0x670a}, // + {0xCCD3,0x6785}, // + {0xCCD4,0x676c}, // + {0xCCD5,0x678e}, // + {0xCCD6,0x6792}, // + {0xCCD7,0x6776}, // + {0xCCD8,0x677b}, // + {0xCCD9,0x6798}, // + {0xCCDA,0x6786}, // + {0xCCDB,0x6784}, // + {0xCCDC,0x6774}, // + {0xCCDD,0x678d}, // + {0xCCDE,0x678c}, // + {0xCCDF,0x677a}, // + {0xCCE0,0x679f}, // + {0xCCE1,0x6791}, // + {0xCCE2,0x6799}, // + {0xCCE3,0x6783}, // + {0xCCE4,0x677d}, // + {0xCCE5,0x6781}, // + {0xCCE6,0x6778}, // + {0xCCE7,0x6779}, // + {0xCCE8,0x6794}, // + {0xCCE9,0x6b25}, // + {0xCCEA,0x6b80}, // + {0xCCEB,0x6b7e}, // + {0xCCEC,0x6bde}, // + {0xCCED,0x6c1d}, // + {0xCCEE,0x6c93}, // + {0xCCEF,0x6cec}, // + {0xCCF0,0x6ceb}, // + {0xCCF1,0x6cee}, // + {0xCCF2,0x6cd9}, // + {0xCCF3,0x6cb6}, // + {0xCCF4,0x6cd4}, // + {0xCCF5,0x6cad}, // + {0xCCF6,0x6ce7}, // + {0xCCF7,0x6cb7}, // + {0xCCF8,0x6cd0}, // + {0xCCF9,0x6cc2}, // + {0xCCFA,0x6cba}, // + {0xCCFB,0x6cc3}, // + {0xCCFC,0x6cc6}, // + {0xCCFD,0x6ced}, // + {0xCCFE,0x6cf2}, // + {0xCD40,0x6cd2}, // + {0xCD41,0x6cdd}, // + {0xCD42,0x6cb4}, // + {0xCD43,0x6c8a}, // + {0xCD44,0x6c9d}, // + {0xCD45,0x6c80}, // + {0xCD46,0x6cde}, // + {0xCD47,0x6cc0}, // + {0xCD48,0x6d30}, // + {0xCD49,0x6ccd}, // + {0xCD4A,0x6cc7}, // + {0xCD4B,0x6cb0}, // + {0xCD4C,0x6cf9}, // + {0xCD4D,0x6ccf}, // + {0xCD4E,0x6ce9}, // + {0xCD4F,0x6cd1}, // + {0xCD50,0x7094}, // + {0xCD51,0x7098}, // + {0xCD52,0x7085}, // + {0xCD53,0x7093}, // + {0xCD54,0x7086}, // + {0xCD55,0x7084}, // + {0xCD56,0x7091}, // + {0xCD57,0x7096}, // + {0xCD58,0x7082}, // + {0xCD59,0x709a}, // + {0xCD5A,0x7083}, // + {0xCD5B,0x726a}, // + {0xCD5C,0x72d6}, // + {0xCD5D,0x72cb}, // + {0xCD5E,0x72d8}, // + {0xCD5F,0x72c9}, // + {0xCD60,0x72dc}, // + {0xCD61,0x72d2}, // + {0xCD62,0x72d4}, // + {0xCD63,0x72da}, // + {0xCD64,0x72cc}, // + {0xCD65,0x72d1}, // + {0xCD66,0x73a4}, // + {0xCD67,0x73a1}, // + {0xCD68,0x73ad}, // + {0xCD69,0x73a6}, // + {0xCD6A,0x73a2}, // + {0xCD6B,0x73a0}, // + {0xCD6C,0x73ac}, // + {0xCD6D,0x739d}, // + {0xCD6E,0x74dd}, // + {0xCD6F,0x74e8}, // + {0xCD70,0x753f}, // + {0xCD71,0x7540}, // + {0xCD72,0x753e}, // + {0xCD73,0x758c}, // + {0xCD74,0x7598}, // + {0xCD75,0x76af}, // + {0xCD76,0x76f3}, // + {0xCD77,0x76f1}, // + {0xCD78,0x76f0}, // + {0xCD79,0x76f5}, // + {0xCD7A,0x77f8}, // + {0xCD7B,0x77fc}, // + {0xCD7C,0x77f9}, // + {0xCD7D,0x77fb}, // + {0xCD7E,0x77fa}, // + {0xCDA1,0x77f7}, // + {0xCDA2,0x7942}, // + {0xCDA3,0x793f}, // + {0xCDA4,0x79c5}, // + {0xCDA5,0x7a78}, // + {0xCDA6,0x7a7b}, // + {0xCDA7,0x7afb}, // + {0xCDA8,0x7c75}, // + {0xCDA9,0x7cfd}, // + {0xCDAA,0x8035}, // + {0xCDAB,0x808f}, // + {0xCDAC,0x80ae}, // + {0xCDAD,0x80a3}, // + {0xCDAE,0x80b8}, // + {0xCDAF,0x80b5}, // + {0xCDB0,0x80ad}, // + {0xCDB1,0x8220}, // + {0xCDB2,0x82a0}, // + {0xCDB3,0x82c0}, // + {0xCDB4,0x82ab}, // + {0xCDB5,0x829a}, // + {0xCDB6,0x8298}, // + {0xCDB7,0x829b}, // + {0xCDB8,0x82b5}, // + {0xCDB9,0x82a7}, // + {0xCDBA,0x82ae}, // + {0xCDBB,0x82bc}, // + {0xCDBC,0x829e}, // + {0xCDBD,0x82ba}, // + {0xCDBE,0x82b4}, // + {0xCDBF,0x82a8}, // + {0xCDC0,0x82a1}, // + {0xCDC1,0x82a9}, // + {0xCDC2,0x82c2}, // + {0xCDC3,0x82a4}, // + {0xCDC4,0x82c3}, // + {0xCDC5,0x82b6}, // + {0xCDC6,0x82a2}, // + {0xCDC7,0x8670}, // + {0xCDC8,0x866f}, // + {0xCDC9,0x866d}, // + {0xCDCA,0x866e}, // + {0xCDCB,0x8c56}, // + {0xCDCC,0x8fd2}, // + {0xCDCD,0x8fcb}, // + {0xCDCE,0x8fd3}, // + {0xCDCF,0x8fcd}, // + {0xCDD0,0x8fd6}, // + {0xCDD1,0x8fd5}, // + {0xCDD2,0x8fd7}, // + {0xCDD3,0x90b2}, // + {0xCDD4,0x90b4}, // + {0xCDD5,0x90af}, // + {0xCDD6,0x90b3}, // + {0xCDD7,0x90b0}, // + {0xCDD8,0x9639}, // + {0xCDD9,0x963d}, // + {0xCDDA,0x963c}, // + {0xCDDB,0x963a}, // + {0xCDDC,0x9643}, // + {0xCDDD,0x4fcd}, // + {0xCDDE,0x4fc5}, // + {0xCDDF,0x4fd3}, // + {0xCDE0,0x4fb2}, // + {0xCDE1,0x4fc9}, // + {0xCDE2,0x4fcb}, // + {0xCDE3,0x4fc1}, // + {0xCDE4,0x4fd4}, // + {0xCDE5,0x4fdc}, // + {0xCDE6,0x4fd9}, // + {0xCDE7,0x4fbb}, // + {0xCDE8,0x4fb3}, // + {0xCDE9,0x4fdb}, // + {0xCDEA,0x4fc7}, // + {0xCDEB,0x4fd6}, // + {0xCDEC,0x4fba}, // + {0xCDED,0x4fc0}, // + {0xCDEE,0x4fb9}, // + {0xCDEF,0x4fec}, // + {0xCDF0,0x5244}, // + {0xCDF1,0x5249}, // + {0xCDF2,0x52c0}, // + {0xCDF3,0x52c2}, // + {0xCDF4,0x533d}, // + {0xCDF5,0x537c}, // + {0xCDF6,0x5397}, // + {0xCDF7,0x5396}, // + {0xCDF8,0x5399}, // + {0xCDF9,0x5398}, // + {0xCDFA,0x54ba}, // + {0xCDFB,0x54a1}, // + {0xCDFC,0x54ad}, // + {0xCDFD,0x54a5}, // + {0xCDFE,0x54cf}, // + {0xCE40,0x54c3}, // + {0xCE41,0x830d}, // + {0xCE42,0x54b7}, // + {0xCE43,0x54ae}, // + {0xCE44,0x54d6}, // + {0xCE45,0x54b6}, // + {0xCE46,0x54c5}, // + {0xCE47,0x54c6}, // + {0xCE48,0x54a0}, // + {0xCE49,0x5470}, // + {0xCE4A,0x54bc}, // + {0xCE4B,0x54a2}, // + {0xCE4C,0x54be}, // + {0xCE4D,0x5472}, // + {0xCE4E,0x54de}, // + {0xCE4F,0x54b0}, // + {0xCE50,0x57b5}, // + {0xCE51,0x579e}, // + {0xCE52,0x579f}, // + {0xCE53,0x57a4}, // + {0xCE54,0x578c}, // + {0xCE55,0x5797}, // + {0xCE56,0x579d}, // + {0xCE57,0x579b}, // + {0xCE58,0x5794}, // + {0xCE59,0x5798}, // + {0xCE5A,0x578f}, // + {0xCE5B,0x5799}, // + {0xCE5C,0x57a5}, // + {0xCE5D,0x579a}, // + {0xCE5E,0x5795}, // + {0xCE5F,0x58f4}, // + {0xCE60,0x590d}, // + {0xCE61,0x5953}, // + {0xCE62,0x59e1}, // + {0xCE63,0x59de}, // + {0xCE64,0x59ee}, // + {0xCE65,0x5a00}, // + {0xCE66,0x59f1}, // + {0xCE67,0x59dd}, // + {0xCE68,0x59fa}, // + {0xCE69,0x59fd}, // + {0xCE6A,0x59fc}, // + {0xCE6B,0x59f6}, // + {0xCE6C,0x59e4}, // + {0xCE6D,0x59f2}, // + {0xCE6E,0x59f7}, // + {0xCE6F,0x59db}, // + {0xCE70,0x59e9}, // + {0xCE71,0x59f3}, // + {0xCE72,0x59f5}, // + {0xCE73,0x59e0}, // + {0xCE74,0x59fe}, // + {0xCE75,0x59f4}, // + {0xCE76,0x59ed}, // + {0xCE77,0x5ba8}, // + {0xCE78,0x5c4c}, // + {0xCE79,0x5cd0}, // + {0xCE7A,0x5cd8}, // + {0xCE7B,0x5ccc}, // + {0xCE7C,0x5cd7}, // + {0xCE7D,0x5ccb}, // + {0xCE7E,0x5cdb}, // + {0xCEA1,0x5cde}, // + {0xCEA2,0x5cda}, // + {0xCEA3,0x5cc9}, // + {0xCEA4,0x5cc7}, // + {0xCEA5,0x5cca}, // + {0xCEA6,0x5cd6}, // + {0xCEA7,0x5cd3}, // + {0xCEA8,0x5cd4}, // + {0xCEA9,0x5ccf}, // + {0xCEAA,0x5cc8}, // + {0xCEAB,0x5cc6}, // + {0xCEAC,0x5cce}, // + {0xCEAD,0x5cdf}, // + {0xCEAE,0x5cf8}, // + {0xCEAF,0x5df9}, // + {0xCEB0,0x5e21}, // + {0xCEB1,0x5e22}, // + {0xCEB2,0x5e23}, // + {0xCEB3,0x5e20}, // + {0xCEB4,0x5e24}, // + {0xCEB5,0x5eb0}, // + {0xCEB6,0x5ea4}, // + {0xCEB7,0x5ea2}, // + {0xCEB8,0x5e9b}, // + {0xCEB9,0x5ea3}, // + {0xCEBA,0x5ea5}, // + {0xCEBB,0x5f07}, // + {0xCEBC,0x5f2e}, // + {0xCEBD,0x5f56}, // + {0xCEBE,0x5f86}, // + {0xCEBF,0x6037}, // + {0xCEC0,0x6039}, // + {0xCEC1,0x6054}, // + {0xCEC2,0x6072}, // + {0xCEC3,0x605e}, // + {0xCEC4,0x6045}, // + {0xCEC5,0x6053}, // + {0xCEC6,0x6047}, // + {0xCEC7,0x6049}, // + {0xCEC8,0x605b}, // + {0xCEC9,0x604c}, // + {0xCECA,0x6040}, // + {0xCECB,0x6042}, // + {0xCECC,0x605f}, // + {0xCECD,0x6024}, // + {0xCECE,0x6044}, // + {0xCECF,0x6058}, // + {0xCED0,0x6066}, // + {0xCED1,0x606e}, // + {0xCED2,0x6242}, // + {0xCED3,0x6243}, // + {0xCED4,0x62cf}, // + {0xCED5,0x630d}, // + {0xCED6,0x630b}, // + {0xCED7,0x62f5}, // + {0xCED8,0x630e}, // + {0xCED9,0x6303}, // + {0xCEDA,0x62eb}, // + {0xCEDB,0x62f9}, // + {0xCEDC,0x630f}, // + {0xCEDD,0x630c}, // + {0xCEDE,0x62f8}, // + {0xCEDF,0x62f6}, // + {0xCEE0,0x6300}, // + {0xCEE1,0x6313}, // + {0xCEE2,0x6314}, // + {0xCEE3,0x62fa}, // + {0xCEE4,0x6315}, // + {0xCEE5,0x62fb}, // + {0xCEE6,0x62f0}, // + {0xCEE7,0x6541}, // + {0xCEE8,0x6543}, // + {0xCEE9,0x65aa}, // + {0xCEEA,0x65bf}, // + {0xCEEB,0x6636}, // + {0xCEEC,0x6621}, // + {0xCEED,0x6632}, // + {0xCEEE,0x6635}, // + {0xCEEF,0x661c}, // + {0xCEF0,0x6626}, // + {0xCEF1,0x6622}, // + {0xCEF2,0x6633}, // + {0xCEF3,0x662b}, // + {0xCEF4,0x663a}, // + {0xCEF5,0x661d}, // + {0xCEF6,0x6634}, // + {0xCEF7,0x6639}, // + {0xCEF8,0x662e}, // + {0xCEF9,0x670f}, // + {0xCEFA,0x6710}, // + {0xCEFB,0x67c1}, // + {0xCEFC,0x67f2}, // + {0xCEFD,0x67c8}, // + {0xCEFE,0x67ba}, // + {0xCF40,0x67dc}, // + {0xCF41,0x67bb}, // + {0xCF42,0x67f8}, // + {0xCF43,0x67d8}, // + {0xCF44,0x67c0}, // + {0xCF45,0x67b7}, // + {0xCF46,0x67c5}, // + {0xCF47,0x67eb}, // + {0xCF48,0x67e4}, // + {0xCF49,0x67df}, // + {0xCF4A,0x67b5}, // + {0xCF4B,0x67cd}, // + {0xCF4C,0x67b3}, // + {0xCF4D,0x67f7}, // + {0xCF4E,0x67f6}, // + {0xCF4F,0x67ee}, // + {0xCF50,0x67e3}, // + {0xCF51,0x67c2}, // + {0xCF52,0x67b9}, // + {0xCF53,0x67ce}, // + {0xCF54,0x67e7}, // + {0xCF55,0x67f0}, // + {0xCF56,0x67b2}, // + {0xCF57,0x67fc}, // + {0xCF58,0x67c6}, // + {0xCF59,0x67ed}, // + {0xCF5A,0x67cc}, // + {0xCF5B,0x67ae}, // + {0xCF5C,0x67e6}, // + {0xCF5D,0x67db}, // + {0xCF5E,0x67fa}, // + {0xCF5F,0x67c9}, // + {0xCF60,0x67ca}, // + {0xCF61,0x67c3}, // + {0xCF62,0x67ea}, // + {0xCF63,0x67cb}, // + {0xCF64,0x6b28}, // + {0xCF65,0x6b82}, // + {0xCF66,0x6b84}, // + {0xCF67,0x6bb6}, // + {0xCF68,0x6bd6}, // + {0xCF69,0x6bd8}, // + {0xCF6A,0x6be0}, // + {0xCF6B,0x6c20}, // + {0xCF6C,0x6c21}, // + {0xCF6D,0x6d28}, // + {0xCF6E,0x6d34}, // + {0xCF6F,0x6d2d}, // + {0xCF70,0x6d1f}, // + {0xCF71,0x6d3c}, // + {0xCF72,0x6d3f}, // + {0xCF73,0x6d12}, // + {0xCF74,0x6d0a}, // + {0xCF75,0x6cda}, // + {0xCF76,0x6d33}, // + {0xCF77,0x6d04}, // + {0xCF78,0x6d19}, // + {0xCF79,0x6d3a}, // + {0xCF7A,0x6d1a}, // + {0xCF7B,0x6d11}, // + {0xCF7C,0x6d00}, // + {0xCF7D,0x6d1d}, // + {0xCF7E,0x6d42}, // + {0xCFA1,0x6d01}, // + {0xCFA2,0x6d18}, // + {0xCFA3,0x6d37}, // + {0xCFA4,0x6d03}, // + {0xCFA5,0x6d0f}, // + {0xCFA6,0x6d40}, // + {0xCFA7,0x6d07}, // + {0xCFA8,0x6d20}, // + {0xCFA9,0x6d2c}, // + {0xCFAA,0x6d08}, // + {0xCFAB,0x6d22}, // + {0xCFAC,0x6d09}, // + {0xCFAD,0x6d10}, // + {0xCFAE,0x70b7}, // + {0xCFAF,0x709f}, // + {0xCFB0,0x70be}, // + {0xCFB1,0x70b1}, // + {0xCFB2,0x70b0}, // + {0xCFB3,0x70a1}, // + {0xCFB4,0x70b4}, // + {0xCFB5,0x70b5}, // + {0xCFB6,0x70a9}, // + {0xCFB7,0x7241}, // + {0xCFB8,0x7249}, // + {0xCFB9,0x724a}, // + {0xCFBA,0x726c}, // + {0xCFBB,0x7270}, // + {0xCFBC,0x7273}, // + {0xCFBD,0x726e}, // + {0xCFBE,0x72ca}, // + {0xCFBF,0x72e4}, // + {0xCFC0,0x72e8}, // + {0xCFC1,0x72eb}, // + {0xCFC2,0x72df}, // + {0xCFC3,0x72ea}, // + {0xCFC4,0x72e6}, // + {0xCFC5,0x72e3}, // + {0xCFC6,0x7385}, // + {0xCFC7,0x73cc}, // + {0xCFC8,0x73c2}, // + {0xCFC9,0x73c8}, // + {0xCFCA,0x73c5}, // + {0xCFCB,0x73b9}, // + {0xCFCC,0x73b6}, // + {0xCFCD,0x73b5}, // + {0xCFCE,0x73b4}, // + {0xCFCF,0x73eb}, // + {0xCFD0,0x73bf}, // + {0xCFD1,0x73c7}, // + {0xCFD2,0x73be}, // + {0xCFD3,0x73c3}, // + {0xCFD4,0x73c6}, // + {0xCFD5,0x73b8}, // + {0xCFD6,0x73cb}, // + {0xCFD7,0x74ec}, // + {0xCFD8,0x74ee}, // + {0xCFD9,0x752e}, // + {0xCFDA,0x7547}, // + {0xCFDB,0x7548}, // + {0xCFDC,0x75a7}, // + {0xCFDD,0x75aa}, // + {0xCFDE,0x7679}, // + {0xCFDF,0x76c4}, // + {0xCFE0,0x7708}, // + {0xCFE1,0x7703}, // + {0xCFE2,0x7704}, // + {0xCFE3,0x7705}, // + {0xCFE4,0x770a}, // + {0xCFE5,0x76f7}, // + {0xCFE6,0x76fb}, // + {0xCFE7,0x76fa}, // + {0xCFE8,0x77e7}, // + {0xCFE9,0x77e8}, // + {0xCFEA,0x7806}, // + {0xCFEB,0x7811}, // + {0xCFEC,0x7812}, // + {0xCFED,0x7805}, // + {0xCFEE,0x7810}, // + {0xCFEF,0x780f}, // + {0xCFF0,0x780e}, // + {0xCFF1,0x7809}, // + {0xCFF2,0x7803}, // + {0xCFF3,0x7813}, // + {0xCFF4,0x794a}, // + {0xCFF5,0x794c}, // + {0xCFF6,0x794b}, // + {0xCFF7,0x7945}, // + {0xCFF8,0x7944}, // + {0xCFF9,0x79d5}, // + {0xCFFA,0x79cd}, // + {0xCFFB,0x79cf}, // + {0xCFFC,0x79d6}, // + {0xCFFD,0x79ce}, // + {0xCFFE,0x7a80}, // + {0xD040,0x7a7e}, // + {0xD041,0x7ad1}, // + {0xD042,0x7b00}, // + {0xD043,0x7b01}, // + {0xD044,0x7c7a}, // + {0xD045,0x7c78}, // + {0xD046,0x7c79}, // + {0xD047,0x7c7f}, // + {0xD048,0x7c80}, // + {0xD049,0x7c81}, // + {0xD04A,0x7d03}, // + {0xD04B,0x7d08}, // + {0xD04C,0x7d01}, // + {0xD04D,0x7f58}, // + {0xD04E,0x7f91}, // + {0xD04F,0x7f8d}, // + {0xD050,0x7fbe}, // + {0xD051,0x8007}, // + {0xD052,0x800e}, // + {0xD053,0x800f}, // + {0xD054,0x8014}, // + {0xD055,0x8037}, // + {0xD056,0x80d8}, // + {0xD057,0x80c7}, // + {0xD058,0x80e0}, // + {0xD059,0x80d1}, // + {0xD05A,0x80c8}, // + {0xD05B,0x80c2}, // + {0xD05C,0x80d0}, // + {0xD05D,0x80c5}, // + {0xD05E,0x80e3}, // + {0xD05F,0x80d9}, // + {0xD060,0x80dc}, // + {0xD061,0x80ca}, // + {0xD062,0x80d5}, // + {0xD063,0x80c9}, // + {0xD064,0x80cf}, // + {0xD065,0x80d7}, // + {0xD066,0x80e6}, // + {0xD067,0x80cd}, // + {0xD068,0x81ff}, // + {0xD069,0x8221}, // + {0xD06A,0x8294}, // + {0xD06B,0x82d9}, // + {0xD06C,0x82fe}, // + {0xD06D,0x82f9}, // + {0xD06E,0x8307}, // + {0xD06F,0x82e8}, // + {0xD070,0x8300}, // + {0xD071,0x82d5}, // + {0xD072,0x833a}, // + {0xD073,0x82eb}, // + {0xD074,0x82d6}, // + {0xD075,0x82f4}, // + {0xD076,0x82ec}, // + {0xD077,0x82e1}, // + {0xD078,0x82f2}, // + {0xD079,0x82f5}, // + {0xD07A,0x830c}, // + {0xD07B,0x82fb}, // + {0xD07C,0x82f6}, // + {0xD07D,0x82f0}, // + {0xD07E,0x82ea}, // + {0xD0A1,0x82e4}, // + {0xD0A2,0x82e0}, // + {0xD0A3,0x82fa}, // + {0xD0A4,0x82f3}, // + {0xD0A5,0x82ed}, // + {0xD0A6,0x8677}, // + {0xD0A7,0x8674}, // + {0xD0A8,0x867c}, // + {0xD0A9,0x8673}, // + {0xD0AA,0x8841}, // + {0xD0AB,0x884e}, // + {0xD0AC,0x8867}, // + {0xD0AD,0x886a}, // + {0xD0AE,0x8869}, // + {0xD0AF,0x89d3}, // + {0xD0B0,0x8a04}, // + {0xD0B1,0x8a07}, // + {0xD0B2,0x8d72}, // + {0xD0B3,0x8fe3}, // + {0xD0B4,0x8fe1}, // + {0xD0B5,0x8fee}, // + {0xD0B6,0x8fe0}, // + {0xD0B7,0x90f1}, // + {0xD0B8,0x90bd}, // + {0xD0B9,0x90bf}, // + {0xD0BA,0x90d5}, // + {0xD0BB,0x90c5}, // + {0xD0BC,0x90be}, // + {0xD0BD,0x90c7}, // + {0xD0BE,0x90cb}, // + {0xD0BF,0x90c8}, // + {0xD0C0,0x91d4}, // + {0xD0C1,0x91d3}, // + {0xD0C2,0x9654}, // + {0xD0C3,0x964f}, // + {0xD0C4,0x9651}, // + {0xD0C5,0x9653}, // + {0xD0C6,0x964a}, // + {0xD0C7,0x964e}, // + {0xD0C8,0x501e}, // + {0xD0C9,0x5005}, // + {0xD0CA,0x5007}, // + {0xD0CB,0x5013}, // + {0xD0CC,0x5022}, // + {0xD0CD,0x5030}, // + {0xD0CE,0x501b}, // + {0xD0CF,0x4ff5}, // + {0xD0D0,0x4ff4}, // + {0xD0D1,0x5033}, // + {0xD0D2,0x5037}, // + {0xD0D3,0x502c}, // + {0xD0D4,0x4ff6}, // + {0xD0D5,0x4ff7}, // + {0xD0D6,0x5017}, // + {0xD0D7,0x501c}, // + {0xD0D8,0x5020}, // + {0xD0D9,0x5027}, // + {0xD0DA,0x5035}, // + {0xD0DB,0x502f}, // + {0xD0DC,0x5031}, // + {0xD0DD,0x500e}, // + {0xD0DE,0x515a}, // + {0xD0DF,0x5194}, // + {0xD0E0,0x5193}, // + {0xD0E1,0x51ca}, // + {0xD0E2,0x51c4}, // + {0xD0E3,0x51c5}, // + {0xD0E4,0x51c8}, // + {0xD0E5,0x51ce}, // + {0xD0E6,0x5261}, // + {0xD0E7,0x525a}, // + {0xD0E8,0x5252}, // + {0xD0E9,0x525e}, // + {0xD0EA,0x525f}, // + {0xD0EB,0x5255}, // + {0xD0EC,0x5262}, // + {0xD0ED,0x52cd}, // + {0xD0EE,0x530e}, // + {0xD0EF,0x539e}, // + {0xD0F0,0x5526}, // + {0xD0F1,0x54e2}, // + {0xD0F2,0x5517}, // + {0xD0F3,0x5512}, // + {0xD0F4,0x54e7}, // + {0xD0F5,0x54f3}, // + {0xD0F6,0x54e4}, // + {0xD0F7,0x551a}, // + {0xD0F8,0x54ff}, // + {0xD0F9,0x5504}, // + {0xD0FA,0x5508}, // + {0xD0FB,0x54eb}, // + {0xD0FC,0x5511}, // + {0xD0FD,0x5505}, // + {0xD0FE,0x54f1}, // + {0xD140,0x550a}, // + {0xD141,0x54fb}, // + {0xD142,0x54f7}, // + {0xD143,0x54f8}, // + {0xD144,0x54e0}, // + {0xD145,0x550e}, // + {0xD146,0x5503}, // + {0xD147,0x550b}, // + {0xD148,0x5701}, // + {0xD149,0x5702}, // + {0xD14A,0x57cc}, // + {0xD14B,0x5832}, // + {0xD14C,0x57d5}, // + {0xD14D,0x57d2}, // + {0xD14E,0x57ba}, // + {0xD14F,0x57c6}, // + {0xD150,0x57bd}, // + {0xD151,0x57bc}, // + {0xD152,0x57b8}, // + {0xD153,0x57b6}, // + {0xD154,0x57bf}, // + {0xD155,0x57c7}, // + {0xD156,0x57d0}, // + {0xD157,0x57b9}, // + {0xD158,0x57c1}, // + {0xD159,0x590e}, // + {0xD15A,0x594a}, // + {0xD15B,0x5a19}, // + {0xD15C,0x5a16}, // + {0xD15D,0x5a2d}, // + {0xD15E,0x5a2e}, // + {0xD15F,0x5a15}, // + {0xD160,0x5a0f}, // + {0xD161,0x5a17}, // + {0xD162,0x5a0a}, // + {0xD163,0x5a1e}, // + {0xD164,0x5a33}, // + {0xD165,0x5b6c}, // + {0xD166,0x5ba7}, // + {0xD167,0x5bad}, // + {0xD168,0x5bac}, // + {0xD169,0x5c03}, // + {0xD16A,0x5c56}, // + {0xD16B,0x5c54}, // + {0xD16C,0x5cec}, // + {0xD16D,0x5cff}, // + {0xD16E,0x5cee}, // + {0xD16F,0x5cf1}, // + {0xD170,0x5cf7}, // + {0xD171,0x5d00}, // + {0xD172,0x5cf9}, // + {0xD173,0x5e29}, // + {0xD174,0x5e28}, // + {0xD175,0x5ea8}, // + {0xD176,0x5eae}, // + {0xD177,0x5eaa}, // + {0xD178,0x5eac}, // + {0xD179,0x5f33}, // + {0xD17A,0x5f30}, // + {0xD17B,0x5f67}, // + {0xD17C,0x605d}, // + {0xD17D,0x605a}, // + {0xD17E,0x6067}, // + {0xD1A1,0x6041}, // + {0xD1A2,0x60a2}, // + {0xD1A3,0x6088}, // + {0xD1A4,0x6080}, // + {0xD1A5,0x6092}, // + {0xD1A6,0x6081}, // + {0xD1A7,0x609d}, // + {0xD1A8,0x6083}, // + {0xD1A9,0x6095}, // + {0xD1AA,0x609b}, // + {0xD1AB,0x6097}, // + {0xD1AC,0x6087}, // + {0xD1AD,0x609c}, // + {0xD1AE,0x608e}, // + {0xD1AF,0x6219}, // + {0xD1B0,0x6246}, // + {0xD1B1,0x62f2}, // + {0xD1B2,0x6310}, // + {0xD1B3,0x6356}, // + {0xD1B4,0x632c}, // + {0xD1B5,0x6344}, // + {0xD1B6,0x6345}, // + {0xD1B7,0x6336}, // + {0xD1B8,0x6343}, // + {0xD1B9,0x63e4}, // + {0xD1BA,0x6339}, // + {0xD1BB,0x634b}, // + {0xD1BC,0x634a}, // + {0xD1BD,0x633c}, // + {0xD1BE,0x6329}, // + {0xD1BF,0x6341}, // + {0xD1C0,0x6334}, // + {0xD1C1,0x6358}, // + {0xD1C2,0x6354}, // + {0xD1C3,0x6359}, // + {0xD1C4,0x632d}, // + {0xD1C5,0x6347}, // + {0xD1C6,0x6333}, // + {0xD1C7,0x635a}, // + {0xD1C8,0x6351}, // + {0xD1C9,0x6338}, // + {0xD1CA,0x6357}, // + {0xD1CB,0x6340}, // + {0xD1CC,0x6348}, // + {0xD1CD,0x654a}, // + {0xD1CE,0x6546}, // + {0xD1CF,0x65c6}, // + {0xD1D0,0x65c3}, // + {0xD1D1,0x65c4}, // + {0xD1D2,0x65c2}, // + {0xD1D3,0x664a}, // + {0xD1D4,0x665f}, // + {0xD1D5,0x6647}, // + {0xD1D6,0x6651}, // + {0xD1D7,0x6712}, // + {0xD1D8,0x6713}, // + {0xD1D9,0x681f}, // + {0xD1DA,0x681a}, // + {0xD1DB,0x6849}, // + {0xD1DC,0x6832}, // + {0xD1DD,0x6833}, // + {0xD1DE,0x683b}, // + {0xD1DF,0x684b}, // + {0xD1E0,0x684f}, // + {0xD1E1,0x6816}, // + {0xD1E2,0x6831}, // + {0xD1E3,0x681c}, // + {0xD1E4,0x6835}, // + {0xD1E5,0x682b}, // + {0xD1E6,0x682d}, // + {0xD1E7,0x682f}, // + {0xD1E8,0x684e}, // + {0xD1E9,0x6844}, // + {0xD1EA,0x6834}, // + {0xD1EB,0x681d}, // + {0xD1EC,0x6812}, // + {0xD1ED,0x6814}, // + {0xD1EE,0x6826}, // + {0xD1EF,0x6828}, // + {0xD1F0,0x682e}, // + {0xD1F1,0x684d}, // + {0xD1F2,0x683a}, // + {0xD1F3,0x6825}, // + {0xD1F4,0x6820}, // + {0xD1F5,0x6b2c}, // + {0xD1F6,0x6b2f}, // + {0xD1F7,0x6b2d}, // + {0xD1F8,0x6b31}, // + {0xD1F9,0x6b34}, // + {0xD1FA,0x6b6d}, // + {0xD1FB,0x8082}, // + {0xD1FC,0x6b88}, // + {0xD1FD,0x6be6}, // + {0xD1FE,0x6be4}, // + {0xD240,0x6be8}, // + {0xD241,0x6be3}, // + {0xD242,0x6be2}, // + {0xD243,0x6be7}, // + {0xD244,0x6c25}, // + {0xD245,0x6d7a}, // + {0xD246,0x6d63}, // + {0xD247,0x6d64}, // + {0xD248,0x6d76}, // + {0xD249,0x6d0d}, // + {0xD24A,0x6d61}, // + {0xD24B,0x6d92}, // + {0xD24C,0x6d58}, // + {0xD24D,0x6d62}, // + {0xD24E,0x6d6d}, // + {0xD24F,0x6d6f}, // + {0xD250,0x6d91}, // + {0xD251,0x6d8d}, // + {0xD252,0x6def}, // + {0xD253,0x6d7f}, // + {0xD254,0x6d86}, // + {0xD255,0x6d5e}, // + {0xD256,0x6d67}, // + {0xD257,0x6d60}, // + {0xD258,0x6d97}, // + {0xD259,0x6d70}, // + {0xD25A,0x6d7c}, // + {0xD25B,0x6d5f}, // + {0xD25C,0x6d82}, // + {0xD25D,0x6d98}, // + {0xD25E,0x6d2f}, // + {0xD25F,0x6d68}, // + {0xD260,0x6d8b}, // + {0xD261,0x6d7e}, // + {0xD262,0x6d80}, // + {0xD263,0x6d84}, // + {0xD264,0x6d16}, // + {0xD265,0x6d83}, // + {0xD266,0x6d7b}, // + {0xD267,0x6d7d}, // + {0xD268,0x6d75}, // + {0xD269,0x6d90}, // + {0xD26A,0x70dc}, // + {0xD26B,0x70d3}, // + {0xD26C,0x70d1}, // + {0xD26D,0x70dd}, // + {0xD26E,0x70cb}, // + {0xD26F,0x7f39}, // + {0xD270,0x70e2}, // + {0xD271,0x70d7}, // + {0xD272,0x70d2}, // + {0xD273,0x70de}, // + {0xD274,0x70e0}, // + {0xD275,0x70d4}, // + {0xD276,0x70cd}, // + {0xD277,0x70c5}, // + {0xD278,0x70c6}, // + {0xD279,0x70c7}, // + {0xD27A,0x70da}, // + {0xD27B,0x70ce}, // + {0xD27C,0x70e1}, // + {0xD27D,0x7242}, // + {0xD27E,0x7278}, // + {0xD2A1,0x7277}, // + {0xD2A2,0x7276}, // + {0xD2A3,0x7300}, // + {0xD2A4,0x72fa}, // + {0xD2A5,0x72f4}, // + {0xD2A6,0x72fe}, // + {0xD2A7,0x72f6}, // + {0xD2A8,0x72f3}, // + {0xD2A9,0x72fb}, // + {0xD2AA,0x7301}, // + {0xD2AB,0x73d3}, // + {0xD2AC,0x73d9}, // + {0xD2AD,0x73e5}, // + {0xD2AE,0x73d6}, // + {0xD2AF,0x73bc}, // + {0xD2B0,0x73e7}, // + {0xD2B1,0x73e3}, // + {0xD2B2,0x73e9}, // + {0xD2B3,0x73dc}, // + {0xD2B4,0x73d2}, // + {0xD2B5,0x73db}, // + {0xD2B6,0x73d4}, // + {0xD2B7,0x73dd}, // + {0xD2B8,0x73da}, // + {0xD2B9,0x73d7}, // + {0xD2BA,0x73d8}, // + {0xD2BB,0x73e8}, // + {0xD2BC,0x74de}, // + {0xD2BD,0x74df}, // + {0xD2BE,0x74f4}, // + {0xD2BF,0x74f5}, // + {0xD2C0,0x7521}, // + {0xD2C1,0x755b}, // + {0xD2C2,0x755f}, // + {0xD2C3,0x75b0}, // + {0xD2C4,0x75c1}, // + {0xD2C5,0x75bb}, // + {0xD2C6,0x75c4}, // + {0xD2C7,0x75c0}, // + {0xD2C8,0x75bf}, // + {0xD2C9,0x75b6}, // + {0xD2CA,0x75ba}, // + {0xD2CB,0x768a}, // + {0xD2CC,0x76c9}, // + {0xD2CD,0x771d}, // + {0xD2CE,0x771b}, // + {0xD2CF,0x7710}, // + {0xD2D0,0x7713}, // + {0xD2D1,0x7712}, // + {0xD2D2,0x7723}, // + {0xD2D3,0x7711}, // + {0xD2D4,0x7715}, // + {0xD2D5,0x7719}, // + {0xD2D6,0x771a}, // + {0xD2D7,0x7722}, // + {0xD2D8,0x7727}, // + {0xD2D9,0x7823}, // + {0xD2DA,0x782c}, // + {0xD2DB,0x7822}, // + {0xD2DC,0x7835}, // + {0xD2DD,0x782f}, // + {0xD2DE,0x7828}, // + {0xD2DF,0x782e}, // + {0xD2E0,0x782b}, // + {0xD2E1,0x7821}, // + {0xD2E2,0x7829}, // + {0xD2E3,0x7833}, // + {0xD2E4,0x782a}, // + {0xD2E5,0x7831}, // + {0xD2E6,0x7954}, // + {0xD2E7,0x795b}, // + {0xD2E8,0x794f}, // + {0xD2E9,0x795c}, // + {0xD2EA,0x7953}, // + {0xD2EB,0x7952}, // + {0xD2EC,0x7951}, // + {0xD2ED,0x79eb}, // + {0xD2EE,0x79ec}, // + {0xD2EF,0x79e0}, // + {0xD2F0,0x79ee}, // + {0xD2F1,0x79ed}, // + {0xD2F2,0x79ea}, // + {0xD2F3,0x79dc}, // + {0xD2F4,0x79de}, // + {0xD2F5,0x79dd}, // + {0xD2F6,0x7a86}, // + {0xD2F7,0x7a89}, // + {0xD2F8,0x7a85}, // + {0xD2F9,0x7a8b}, // + {0xD2FA,0x7a8c}, // + {0xD2FB,0x7a8a}, // + {0xD2FC,0x7a87}, // + {0xD2FD,0x7ad8}, // + {0xD2FE,0x7b10}, // + {0xD340,0x7b04}, // + {0xD341,0x7b13}, // + {0xD342,0x7b05}, // + {0xD343,0x7b0f}, // + {0xD344,0x7b08}, // + {0xD345,0x7b0a}, // + {0xD346,0x7b0e}, // + {0xD347,0x7b09}, // + {0xD348,0x7b12}, // + {0xD349,0x7c84}, // + {0xD34A,0x7c91}, // + {0xD34B,0x7c8a}, // + {0xD34C,0x7c8c}, // + {0xD34D,0x7c88}, // + {0xD34E,0x7c8d}, // + {0xD34F,0x7c85}, // + {0xD350,0x7d1e}, // + {0xD351,0x7d1d}, // + {0xD352,0x7d11}, // + {0xD353,0x7d0e}, // + {0xD354,0x7d18}, // + {0xD355,0x7d16}, // + {0xD356,0x7d13}, // + {0xD357,0x7d1f}, // + {0xD358,0x7d12}, // + {0xD359,0x7d0f}, // + {0xD35A,0x7d0c}, // + {0xD35B,0x7f5c}, // + {0xD35C,0x7f61}, // + {0xD35D,0x7f5e}, // + {0xD35E,0x7f60}, // + {0xD35F,0x7f5d}, // + {0xD360,0x7f5b}, // + {0xD361,0x7f96}, // + {0xD362,0x7f92}, // + {0xD363,0x7fc3}, // + {0xD364,0x7fc2}, // + {0xD365,0x7fc0}, // + {0xD366,0x8016}, // + {0xD367,0x803e}, // + {0xD368,0x8039}, // + {0xD369,0x80fa}, // + {0xD36A,0x80f2}, // + {0xD36B,0x80f9}, // + {0xD36C,0x80f5}, // + {0xD36D,0x8101}, // + {0xD36E,0x80fb}, // + {0xD36F,0x8100}, // + {0xD370,0x8201}, // + {0xD371,0x822f}, // + {0xD372,0x8225}, // + {0xD373,0x8333}, // + {0xD374,0x832d}, // + {0xD375,0x8344}, // + {0xD376,0x8319}, // + {0xD377,0x8351}, // + {0xD378,0x8325}, // + {0xD379,0x8356}, // + {0xD37A,0x833f}, // + {0xD37B,0x8341}, // + {0xD37C,0x8326}, // + {0xD37D,0x831c}, // + {0xD37E,0x8322}, // + {0xD3A1,0x8342}, // + {0xD3A2,0x834e}, // + {0xD3A3,0x831b}, // + {0xD3A4,0x832a}, // + {0xD3A5,0x8308}, // + {0xD3A6,0x833c}, // + {0xD3A7,0x834d}, // + {0xD3A8,0x8316}, // + {0xD3A9,0x8324}, // + {0xD3AA,0x8320}, // + {0xD3AB,0x8337}, // + {0xD3AC,0x832f}, // + {0xD3AD,0x8329}, // + {0xD3AE,0x8347}, // + {0xD3AF,0x8345}, // + {0xD3B0,0x834c}, // + {0xD3B1,0x8353}, // + {0xD3B2,0x831e}, // + {0xD3B3,0x832c}, // + {0xD3B4,0x834b}, // + {0xD3B5,0x8327}, // + {0xD3B6,0x8348}, // + {0xD3B7,0x8653}, // + {0xD3B8,0x8652}, // + {0xD3B9,0x86a2}, // + {0xD3BA,0x86a8}, // + {0xD3BB,0x8696}, // + {0xD3BC,0x868d}, // + {0xD3BD,0x8691}, // + {0xD3BE,0x869e}, // + {0xD3BF,0x8687}, // + {0xD3C0,0x8697}, // + {0xD3C1,0x8686}, // + {0xD3C2,0x868b}, // + {0xD3C3,0x869a}, // + {0xD3C4,0x8685}, // + {0xD3C5,0x86a5}, // + {0xD3C6,0x8699}, // + {0xD3C7,0x86a1}, // + {0xD3C8,0x86a7}, // + {0xD3C9,0x8695}, // + {0xD3CA,0x8698}, // + {0xD3CB,0x868e}, // + {0xD3CC,0x869d}, // + {0xD3CD,0x8690}, // + {0xD3CE,0x8694}, // + {0xD3CF,0x8843}, // + {0xD3D0,0x8844}, // + {0xD3D1,0x886d}, // + {0xD3D2,0x8875}, // + {0xD3D3,0x8876}, // + {0xD3D4,0x8872}, // + {0xD3D5,0x8880}, // + {0xD3D6,0x8871}, // + {0xD3D7,0x887f}, // + {0xD3D8,0x886f}, // + {0xD3D9,0x8883}, // + {0xD3DA,0x887e}, // + {0xD3DB,0x8874}, // + {0xD3DC,0x887c}, // + {0xD3DD,0x8a12}, // + {0xD3DE,0x8c47}, // + {0xD3DF,0x8c57}, // + {0xD3E0,0x8c7b}, // + {0xD3E1,0x8ca4}, // + {0xD3E2,0x8ca3}, // + {0xD3E3,0x8d76}, // + {0xD3E4,0x8d78}, // + {0xD3E5,0x8db5}, // + {0xD3E6,0x8db7}, // + {0xD3E7,0x8db6}, // + {0xD3E8,0x8ed1}, // + {0xD3E9,0x8ed3}, // + {0xD3EA,0x8ffe}, // + {0xD3EB,0x8ff5}, // + {0xD3EC,0x9002}, // + {0xD3ED,0x8fff}, // + {0xD3EE,0x8ffb}, // + {0xD3EF,0x9004}, // + {0xD3F0,0x8ffc}, // + {0xD3F1,0x8ff6}, // + {0xD3F2,0x90d6}, // + {0xD3F3,0x90e0}, // + {0xD3F4,0x90d9}, // + {0xD3F5,0x90da}, // + {0xD3F6,0x90e3}, // + {0xD3F7,0x90df}, // + {0xD3F8,0x90e5}, // + {0xD3F9,0x90d8}, // + {0xD3FA,0x90db}, // + {0xD3FB,0x90d7}, // + {0xD3FC,0x90dc}, // + {0xD3FD,0x90e4}, // + {0xD3FE,0x9150}, // + {0xD440,0x914e}, // + {0xD441,0x914f}, // + {0xD442,0x91d5}, // + {0xD443,0x91e2}, // + {0xD444,0x91da}, // + {0xD445,0x965c}, // + {0xD446,0x965f}, // + {0xD447,0x96bc}, // + {0xD448,0x98e3}, // + {0xD449,0x9adf}, // + {0xD44A,0x9b2f}, // + {0xD44B,0x4e7f}, // + {0xD44C,0x5070}, // + {0xD44D,0x506a}, // + {0xD44E,0x5061}, // + {0xD44F,0x505e}, // + {0xD450,0x5060}, // + {0xD451,0x5053}, // + {0xD452,0x504b}, // + {0xD453,0x505d}, // + {0xD454,0x5072}, // + {0xD455,0x5048}, // + {0xD456,0x504d}, // + {0xD457,0x5041}, // + {0xD458,0x505b}, // + {0xD459,0x504a}, // + {0xD45A,0x5062}, // + {0xD45B,0x5015}, // + {0xD45C,0x5045}, // + {0xD45D,0x505f}, // + {0xD45E,0x5069}, // + {0xD45F,0x506b}, // + {0xD460,0x5063}, // + {0xD461,0x5064}, // + {0xD462,0x5046}, // + {0xD463,0x5040}, // + {0xD464,0x506e}, // + {0xD465,0x5073}, // + {0xD466,0x5057}, // + {0xD467,0x5051}, // + {0xD468,0x51d0}, // + {0xD469,0x526b}, // + {0xD46A,0x526d}, // + {0xD46B,0x526c}, // + {0xD46C,0x526e}, // + {0xD46D,0x52d6}, // + {0xD46E,0x52d3}, // + {0xD46F,0x532d}, // + {0xD470,0x539c}, // + {0xD471,0x5575}, // + {0xD472,0x5576}, // + {0xD473,0x553c}, // + {0xD474,0x554d}, // + {0xD475,0x5550}, // + {0xD476,0x5534}, // + {0xD477,0x552a}, // + {0xD478,0x5551}, // + {0xD479,0x5562}, // + {0xD47A,0x5536}, // + {0xD47B,0x5535}, // + {0xD47C,0x5530}, // + {0xD47D,0x5552}, // + {0xD47E,0x5545}, // + {0xD4A1,0x550c}, // + {0xD4A2,0x5532}, // + {0xD4A3,0x5565}, // + {0xD4A4,0x554e}, // + {0xD4A5,0x5539}, // + {0xD4A6,0x5548}, // + {0xD4A7,0x552d}, // + {0xD4A8,0x553b}, // + {0xD4A9,0x5540}, // + {0xD4AA,0x554b}, // + {0xD4AB,0x570a}, // + {0xD4AC,0x5707}, // + {0xD4AD,0x57fb}, // + {0xD4AE,0x5814}, // + {0xD4AF,0x57e2}, // + {0xD4B0,0x57f6}, // + {0xD4B1,0x57dc}, // + {0xD4B2,0x57f4}, // + {0xD4B3,0x5800}, // + {0xD4B4,0x57ed}, // + {0xD4B5,0x57fd}, // + {0xD4B6,0x5808}, // + {0xD4B7,0x57f8}, // + {0xD4B8,0x580b}, // + {0xD4B9,0x57f3}, // + {0xD4BA,0x57cf}, // + {0xD4BB,0x5807}, // + {0xD4BC,0x57ee}, // + {0xD4BD,0x57e3}, // + {0xD4BE,0x57f2}, // + {0xD4BF,0x57e5}, // + {0xD4C0,0x57ec}, // + {0xD4C1,0x57e1}, // + {0xD4C2,0x580e}, // + {0xD4C3,0x57fc}, // + {0xD4C4,0x5810}, // + {0xD4C5,0x57e7}, // + {0xD4C6,0x5801}, // + {0xD4C7,0x580c}, // + {0xD4C8,0x57f1}, // + {0xD4C9,0x57e9}, // + {0xD4CA,0x57f0}, // + {0xD4CB,0x580d}, // + {0xD4CC,0x5804}, // + {0xD4CD,0x595c}, // + {0xD4CE,0x5a60}, // + {0xD4CF,0x5a58}, // + {0xD4D0,0x5a55}, // + {0xD4D1,0x5a67}, // + {0xD4D2,0x5a5e}, // + {0xD4D3,0x5a38}, // + {0xD4D4,0x5a35}, // + {0xD4D5,0x5a6d}, // + {0xD4D6,0x5a50}, // + {0xD4D7,0x5a5f}, // + {0xD4D8,0x5a65}, // + {0xD4D9,0x5a6c}, // + {0xD4DA,0x5a53}, // + {0xD4DB,0x5a64}, // + {0xD4DC,0x5a57}, // + {0xD4DD,0x5a43}, // + {0xD4DE,0x5a5d}, // + {0xD4DF,0x5a52}, // + {0xD4E0,0x5a44}, // + {0xD4E1,0x5a5b}, // + {0xD4E2,0x5a48}, // + {0xD4E3,0x5a8e}, // + {0xD4E4,0x5a3e}, // + {0xD4E5,0x5a4d}, // + {0xD4E6,0x5a39}, // + {0xD4E7,0x5a4c}, // + {0xD4E8,0x5a70}, // + {0xD4E9,0x5a69}, // + {0xD4EA,0x5a47}, // + {0xD4EB,0x5a51}, // + {0xD4EC,0x5a56}, // + {0xD4ED,0x5a42}, // + {0xD4EE,0x5a5c}, // + {0xD4EF,0x5b72}, // + {0xD4F0,0x5b6e}, // + {0xD4F1,0x5bc1}, // + {0xD4F2,0x5bc0}, // + {0xD4F3,0x5c59}, // + {0xD4F4,0x5d1e}, // + {0xD4F5,0x5d0b}, // + {0xD4F6,0x5d1d}, // + {0xD4F7,0x5d1a}, // + {0xD4F8,0x5d20}, // + {0xD4F9,0x5d0c}, // + {0xD4FA,0x5d28}, // + {0xD4FB,0x5d0d}, // + {0xD4FC,0x5d26}, // + {0xD4FD,0x5d25}, // + {0xD4FE,0x5d0f}, // + {0xD540,0x5d30}, // + {0xD541,0x5d12}, // + {0xD542,0x5d23}, // + {0xD543,0x5d1f}, // + {0xD544,0x5d2e}, // + {0xD545,0x5e3e}, // + {0xD546,0x5e34}, // + {0xD547,0x5eb1}, // + {0xD548,0x5eb4}, // + {0xD549,0x5eb9}, // + {0xD54A,0x5eb2}, // + {0xD54B,0x5eb3}, // + {0xD54C,0x5f36}, // + {0xD54D,0x5f38}, // + {0xD54E,0x5f9b}, // + {0xD54F,0x5f96}, // + {0xD550,0x5f9f}, // + {0xD551,0x608a}, // + {0xD552,0x6090}, // + {0xD553,0x6086}, // + {0xD554,0x60be}, // + {0xD555,0x60b0}, // + {0xD556,0x60ba}, // + {0xD557,0x60d3}, // + {0xD558,0x60d4}, // + {0xD559,0x60cf}, // + {0xD55A,0x60e4}, // + {0xD55B,0x60d9}, // + {0xD55C,0x60dd}, // + {0xD55D,0x60c8}, // + {0xD55E,0x60b1}, // + {0xD55F,0x60db}, // + {0xD560,0x60b7}, // + {0xD561,0x60ca}, // + {0xD562,0x60bf}, // + {0xD563,0x60c3}, // + {0xD564,0x60cd}, // + {0xD565,0x60c0}, // + {0xD566,0x6332}, // + {0xD567,0x6365}, // + {0xD568,0x638a}, // + {0xD569,0x6382}, // + {0xD56A,0x637d}, // + {0xD56B,0x63bd}, // + {0xD56C,0x639e}, // + {0xD56D,0x63ad}, // + {0xD56E,0x639d}, // + {0xD56F,0x6397}, // + {0xD570,0x63ab}, // + {0xD571,0x638e}, // + {0xD572,0x636f}, // + {0xD573,0x6387}, // + {0xD574,0x6390}, // + {0xD575,0x636e}, // + {0xD576,0x63af}, // + {0xD577,0x6375}, // + {0xD578,0x639c}, // + {0xD579,0x636d}, // + {0xD57A,0x63ae}, // + {0xD57B,0x637c}, // + {0xD57C,0x63a4}, // + {0xD57D,0x633b}, // + {0xD57E,0x639f}, // + {0xD5A1,0x6378}, // + {0xD5A2,0x6385}, // + {0xD5A3,0x6381}, // + {0xD5A4,0x6391}, // + {0xD5A5,0x638d}, // + {0xD5A6,0x6370}, // + {0xD5A7,0x6553}, // + {0xD5A8,0x65cd}, // + {0xD5A9,0x6665}, // + {0xD5AA,0x6661}, // + {0xD5AB,0x665b}, // + {0xD5AC,0x6659}, // + {0xD5AD,0x665c}, // + {0xD5AE,0x6662}, // + {0xD5AF,0x6718}, // + {0xD5B0,0x6879}, // + {0xD5B1,0x6887}, // + {0xD5B2,0x6890}, // + {0xD5B3,0x689c}, // + {0xD5B4,0x686d}, // + {0xD5B5,0x686e}, // + {0xD5B6,0x68ae}, // + {0xD5B7,0x68ab}, // + {0xD5B8,0x6956}, // + {0xD5B9,0x686f}, // + {0xD5BA,0x68a3}, // + {0xD5BB,0x68ac}, // + {0xD5BC,0x68a9}, // + {0xD5BD,0x6875}, // + {0xD5BE,0x6874}, // + {0xD5BF,0x68b2}, // + {0xD5C0,0x688f}, // + {0xD5C1,0x6877}, // + {0xD5C2,0x6892}, // + {0xD5C3,0x687c}, // + {0xD5C4,0x686b}, // + {0xD5C5,0x6872}, // + {0xD5C6,0x68aa}, // + {0xD5C7,0x6880}, // + {0xD5C8,0x6871}, // + {0xD5C9,0x687e}, // + {0xD5CA,0x689b}, // + {0xD5CB,0x6896}, // + {0xD5CC,0x688b}, // + {0xD5CD,0x68a0}, // + {0xD5CE,0x6889}, // + {0xD5CF,0x68a4}, // + {0xD5D0,0x6878}, // + {0xD5D1,0x687b}, // + {0xD5D2,0x6891}, // + {0xD5D3,0x688c}, // + {0xD5D4,0x688a}, // + {0xD5D5,0x687d}, // + {0xD5D6,0x6b36}, // + {0xD5D7,0x6b33}, // + {0xD5D8,0x6b37}, // + {0xD5D9,0x6b38}, // + {0xD5DA,0x6b91}, // + {0xD5DB,0x6b8f}, // + {0xD5DC,0x6b8d}, // + {0xD5DD,0x6b8e}, // + {0xD5DE,0x6b8c}, // + {0xD5DF,0x6c2a}, // + {0xD5E0,0x6dc0}, // + {0xD5E1,0x6dab}, // + {0xD5E2,0x6db4}, // + {0xD5E3,0x6db3}, // + {0xD5E4,0x6e74}, // + {0xD5E5,0x6dac}, // + {0xD5E6,0x6de9}, // + {0xD5E7,0x6de2}, // + {0xD5E8,0x6db7}, // + {0xD5E9,0x6df6}, // + {0xD5EA,0x6dd4}, // + {0xD5EB,0x6e00}, // + {0xD5EC,0x6dc8}, // + {0xD5ED,0x6de0}, // + {0xD5EE,0x6ddf}, // + {0xD5EF,0x6dd6}, // + {0xD5F0,0x6dbe}, // + {0xD5F1,0x6de5}, // + {0xD5F2,0x6ddc}, // + {0xD5F3,0x6ddd}, // + {0xD5F4,0x6ddb}, // + {0xD5F5,0x6df4}, // + {0xD5F6,0x6dca}, // + {0xD5F7,0x6dbd}, // + {0xD5F8,0x6ded}, // + {0xD5F9,0x6df0}, // + {0xD5FA,0x6dba}, // + {0xD5FB,0x6dd5}, // + {0xD5FC,0x6dc2}, // + {0xD5FD,0x6dcf}, // + {0xD5FE,0x6dc9}, // + {0xD640,0x6dd0}, // + {0xD641,0x6df2}, // + {0xD642,0x6dd3}, // + {0xD643,0x6dfd}, // + {0xD644,0x6dd7}, // + {0xD645,0x6dcd}, // + {0xD646,0x6de3}, // + {0xD647,0x6dbb}, // + {0xD648,0x70fa}, // + {0xD649,0x710d}, // + {0xD64A,0x70f7}, // + {0xD64B,0x7117}, // + {0xD64C,0x70f4}, // + {0xD64D,0x710c}, // + {0xD64E,0x70f0}, // + {0xD64F,0x7104}, // + {0xD650,0x70f3}, // + {0xD651,0x7110}, // + {0xD652,0x70fc}, // + {0xD653,0x70ff}, // + {0xD654,0x7106}, // + {0xD655,0x7113}, // + {0xD656,0x7100}, // + {0xD657,0x70f8}, // + {0xD658,0x70f6}, // + {0xD659,0x710b}, // + {0xD65A,0x7102}, // + {0xD65B,0x710e}, // + {0xD65C,0x727e}, // + {0xD65D,0x727b}, // + {0xD65E,0x727c}, // + {0xD65F,0x727f}, // + {0xD660,0x731d}, // + {0xD661,0x7317}, // + {0xD662,0x7307}, // + {0xD663,0x7311}, // + {0xD664,0x7318}, // + {0xD665,0x730a}, // + {0xD666,0x7308}, // + {0xD667,0x72ff}, // + {0xD668,0x730f}, // + {0xD669,0x731e}, // + {0xD66A,0x7388}, // + {0xD66B,0x73f6}, // + {0xD66C,0x73f8}, // + {0xD66D,0x73f5}, // + {0xD66E,0x7404}, // + {0xD66F,0x7401}, // + {0xD670,0x73fd}, // + {0xD671,0x7407}, // + {0xD672,0x7400}, // + {0xD673,0x73fa}, // + {0xD674,0x73fc}, // + {0xD675,0x73ff}, // + {0xD676,0x740c}, // + {0xD677,0x740b}, // + {0xD678,0x73f4}, // + {0xD679,0x7408}, // + {0xD67A,0x7564}, // + {0xD67B,0x7563}, // + {0xD67C,0x75ce}, // + {0xD67D,0x75d2}, // + {0xD67E,0x75cf}, // + {0xD6A1,0x75cb}, // + {0xD6A2,0x75cc}, // + {0xD6A3,0x75d1}, // + {0xD6A4,0x75d0}, // + {0xD6A5,0x768f}, // + {0xD6A6,0x7689}, // + {0xD6A7,0x76d3}, // + {0xD6A8,0x7739}, // + {0xD6A9,0x772f}, // + {0xD6AA,0x772d}, // + {0xD6AB,0x7731}, // + {0xD6AC,0x7732}, // + {0xD6AD,0x7734}, // + {0xD6AE,0x7733}, // + {0xD6AF,0x773d}, // + {0xD6B0,0x7725}, // + {0xD6B1,0x773b}, // + {0xD6B2,0x7735}, // + {0xD6B3,0x7848}, // + {0xD6B4,0x7852}, // + {0xD6B5,0x7849}, // + {0xD6B6,0x784d}, // + {0xD6B7,0x784a}, // + {0xD6B8,0x784c}, // + {0xD6B9,0x7826}, // + {0xD6BA,0x7845}, // + {0xD6BB,0x7850}, // + {0xD6BC,0x7964}, // + {0xD6BD,0x7967}, // + {0xD6BE,0x7969}, // + {0xD6BF,0x796a}, // + {0xD6C0,0x7963}, // + {0xD6C1,0x796b}, // + {0xD6C2,0x7961}, // + {0xD6C3,0x79bb}, // + {0xD6C4,0x79fa}, // + {0xD6C5,0x79f8}, // + {0xD6C6,0x79f6}, // + {0xD6C7,0x79f7}, // + {0xD6C8,0x7a8f}, // + {0xD6C9,0x7a94}, // + {0xD6CA,0x7a90}, // + {0xD6CB,0x7b35}, // + {0xD6CC,0x7b47}, // + {0xD6CD,0x7b34}, // + {0xD6CE,0x7b25}, // + {0xD6CF,0x7b30}, // + {0xD6D0,0x7b22}, // + {0xD6D1,0x7b24}, // + {0xD6D2,0x7b33}, // + {0xD6D3,0x7b18}, // + {0xD6D4,0x7b2a}, // + {0xD6D5,0x7b1d}, // + {0xD6D6,0x7b31}, // + {0xD6D7,0x7b2b}, // + {0xD6D8,0x7b2d}, // + {0xD6D9,0x7b2f}, // + {0xD6DA,0x7b32}, // + {0xD6DB,0x7b38}, // + {0xD6DC,0x7b1a}, // + {0xD6DD,0x7b23}, // + {0xD6DE,0x7c94}, // + {0xD6DF,0x7c98}, // + {0xD6E0,0x7c96}, // + {0xD6E1,0x7ca3}, // + {0xD6E2,0x7d35}, // + {0xD6E3,0x7d3d}, // + {0xD6E4,0x7d38}, // + {0xD6E5,0x7d36}, // + {0xD6E6,0x7d3a}, // + {0xD6E7,0x7d45}, // + {0xD6E8,0x7d2c}, // + {0xD6E9,0x7d29}, // + {0xD6EA,0x7d41}, // + {0xD6EB,0x7d47}, // + {0xD6EC,0x7d3e}, // + {0xD6ED,0x7d3f}, // + {0xD6EE,0x7d4a}, // + {0xD6EF,0x7d3b}, // + {0xD6F0,0x7d28}, // + {0xD6F1,0x7f63}, // + {0xD6F2,0x7f95}, // + {0xD6F3,0x7f9c}, // + {0xD6F4,0x7f9d}, // + {0xD6F5,0x7f9b}, // + {0xD6F6,0x7fca}, // + {0xD6F7,0x7fcb}, // + {0xD6F8,0x7fcd}, // + {0xD6F9,0x7fd0}, // + {0xD6FA,0x7fd1}, // + {0xD6FB,0x7fc7}, // + {0xD6FC,0x7fcf}, // + {0xD6FD,0x7fc9}, // + {0xD6FE,0x801f}, // + {0xD740,0x801e}, // + {0xD741,0x801b}, // + {0xD742,0x8047}, // + {0xD743,0x8043}, // + {0xD744,0x8048}, // + {0xD745,0x8118}, // + {0xD746,0x8125}, // + {0xD747,0x8119}, // + {0xD748,0x811b}, // + {0xD749,0x812d}, // + {0xD74A,0x811f}, // + {0xD74B,0x812c}, // + {0xD74C,0x811e}, // + {0xD74D,0x8121}, // + {0xD74E,0x8115}, // + {0xD74F,0x8127}, // + {0xD750,0x811d}, // + {0xD751,0x8122}, // + {0xD752,0x8211}, // + {0xD753,0x8238}, // + {0xD754,0x8233}, // + {0xD755,0x823a}, // + {0xD756,0x8234}, // + {0xD757,0x8232}, // + {0xD758,0x8274}, // + {0xD759,0x8390}, // + {0xD75A,0x83a3}, // + {0xD75B,0x83a8}, // + {0xD75C,0x838d}, // + {0xD75D,0x837a}, // + {0xD75E,0x8373}, // + {0xD75F,0x83a4}, // + {0xD760,0x8374}, // + {0xD761,0x838f}, // + {0xD762,0x8381}, // + {0xD763,0x8395}, // + {0xD764,0x8399}, // + {0xD765,0x8375}, // + {0xD766,0x8394}, // + {0xD767,0x83a9}, // + {0xD768,0x837d}, // + {0xD769,0x8383}, // + {0xD76A,0x838c}, // + {0xD76B,0x839d}, // + {0xD76C,0x839b}, // + {0xD76D,0x83aa}, // + {0xD76E,0x838b}, // + {0xD76F,0x837e}, // + {0xD770,0x83a5}, // + {0xD771,0x83af}, // + {0xD772,0x8388}, // + {0xD773,0x8397}, // + {0xD774,0x83b0}, // + {0xD775,0x837f}, // + {0xD776,0x83a6}, // + {0xD777,0x8387}, // + {0xD778,0x83ae}, // + {0xD779,0x8376}, // + {0xD77A,0x839a}, // + {0xD77B,0x8659}, // + {0xD77C,0x8656}, // + {0xD77D,0x86bf}, // + {0xD77E,0x86b7}, // + {0xD7A1,0x86c2}, // + {0xD7A2,0x86c1}, // + {0xD7A3,0x86c5}, // + {0xD7A4,0x86ba}, // + {0xD7A5,0x86b0}, // + {0xD7A6,0x86c8}, // + {0xD7A7,0x86b9}, // + {0xD7A8,0x86b3}, // + {0xD7A9,0x86b8}, // + {0xD7AA,0x86cc}, // + {0xD7AB,0x86b4}, // + {0xD7AC,0x86bb}, // + {0xD7AD,0x86bc}, // + {0xD7AE,0x86c3}, // + {0xD7AF,0x86bd}, // + {0xD7B0,0x86be}, // + {0xD7B1,0x8852}, // + {0xD7B2,0x8889}, // + {0xD7B3,0x8895}, // + {0xD7B4,0x88a8}, // + {0xD7B5,0x88a2}, // + {0xD7B6,0x88aa}, // + {0xD7B7,0x889a}, // + {0xD7B8,0x8891}, // + {0xD7B9,0x88a1}, // + {0xD7BA,0x889f}, // + {0xD7BB,0x8898}, // + {0xD7BC,0x88a7}, // + {0xD7BD,0x8899}, // + {0xD7BE,0x889b}, // + {0xD7BF,0x8897}, // + {0xD7C0,0x88a4}, // + {0xD7C1,0x88ac}, // + {0xD7C2,0x888c}, // + {0xD7C3,0x8893}, // + {0xD7C4,0x888e}, // + {0xD7C5,0x8982}, // + {0xD7C6,0x89d6}, // + {0xD7C7,0x89d9}, // + {0xD7C8,0x89d5}, // + {0xD7C9,0x8a30}, // + {0xD7CA,0x8a27}, // + {0xD7CB,0x8a2c}, // + {0xD7CC,0x8a1e}, // + {0xD7CD,0x8c39}, // + {0xD7CE,0x8c3b}, // + {0xD7CF,0x8c5c}, // + {0xD7D0,0x8c5d}, // + {0xD7D1,0x8c7d}, // + {0xD7D2,0x8ca5}, // + {0xD7D3,0x8d7d}, // + {0xD7D4,0x8d7b}, // + {0xD7D5,0x8d79}, // + {0xD7D6,0x8dbc}, // + {0xD7D7,0x8dc2}, // + {0xD7D8,0x8db9}, // + {0xD7D9,0x8dbf}, // + {0xD7DA,0x8dc1}, // + {0xD7DB,0x8ed8}, // + {0xD7DC,0x8ede}, // + {0xD7DD,0x8edd}, // + {0xD7DE,0x8edc}, // + {0xD7DF,0x8ed7}, // + {0xD7E0,0x8ee0}, // + {0xD7E1,0x8ee1}, // + {0xD7E2,0x9024}, // + {0xD7E3,0x900b}, // + {0xD7E4,0x9011}, // + {0xD7E5,0x901c}, // + {0xD7E6,0x900c}, // + {0xD7E7,0x9021}, // + {0xD7E8,0x90ef}, // + {0xD7E9,0x90ea}, // + {0xD7EA,0x90f0}, // + {0xD7EB,0x90f4}, // + {0xD7EC,0x90f2}, // + {0xD7ED,0x90f3}, // + {0xD7EE,0x90d4}, // + {0xD7EF,0x90eb}, // + {0xD7F0,0x90ec}, // + {0xD7F1,0x90e9}, // + {0xD7F2,0x9156}, // + {0xD7F3,0x9158}, // + {0xD7F4,0x915a}, // + {0xD7F5,0x9153}, // + {0xD7F6,0x9155}, // + {0xD7F7,0x91ec}, // + {0xD7F8,0x91f4}, // + {0xD7F9,0x91f1}, // + {0xD7FA,0x91f3}, // + {0xD7FB,0x91f8}, // + {0xD7FC,0x91e4}, // + {0xD7FD,0x91f9}, // + {0xD7FE,0x91ea}, // + {0xD840,0x91eb}, // + {0xD841,0x91f7}, // + {0xD842,0x91e8}, // + {0xD843,0x91ee}, // + {0xD844,0x957a}, // + {0xD845,0x9586}, // + {0xD846,0x9588}, // + {0xD847,0x967c}, // + {0xD848,0x966d}, // + {0xD849,0x966b}, // + {0xD84A,0x9671}, // + {0xD84B,0x966f}, // + {0xD84C,0x96bf}, // + {0xD84D,0x976a}, // + {0xD84E,0x9804}, // + {0xD84F,0x98e5}, // + {0xD850,0x9997}, // + {0xD851,0x509b}, // + {0xD852,0x5095}, // + {0xD853,0x5094}, // + {0xD854,0x509e}, // + {0xD855,0x508b}, // + {0xD856,0x50a3}, // + {0xD857,0x5083}, // + {0xD858,0x508c}, // + {0xD859,0x508e}, // + {0xD85A,0x509d}, // + {0xD85B,0x5068}, // + {0xD85C,0x509c}, // + {0xD85D,0x5092}, // + {0xD85E,0x5082}, // + {0xD85F,0x5087}, // + {0xD860,0x515f}, // + {0xD861,0x51d4}, // + {0xD862,0x5312}, // + {0xD863,0x5311}, // + {0xD864,0x53a4}, // + {0xD865,0x53a7}, // + {0xD866,0x5591}, // + {0xD867,0x55a8}, // + {0xD868,0x55a5}, // + {0xD869,0x55ad}, // + {0xD86A,0x5577}, // + {0xD86B,0x5645}, // + {0xD86C,0x55a2}, // + {0xD86D,0x5593}, // + {0xD86E,0x5588}, // + {0xD86F,0x558f}, // + {0xD870,0x55b5}, // + {0xD871,0x5581}, // + {0xD872,0x55a3}, // + {0xD873,0x5592}, // + {0xD874,0x55a4}, // + {0xD875,0x557d}, // + {0xD876,0x558c}, // + {0xD877,0x55a6}, // + {0xD878,0x557f}, // + {0xD879,0x5595}, // + {0xD87A,0x55a1}, // + {0xD87B,0x558e}, // + {0xD87C,0x570c}, // + {0xD87D,0x5829}, // + {0xD87E,0x5837}, // + {0xD8A1,0x5819}, // + {0xD8A2,0x581e}, // + {0xD8A3,0x5827}, // + {0xD8A4,0x5823}, // + {0xD8A5,0x5828}, // + {0xD8A6,0x57f5}, // + {0xD8A7,0x5848}, // + {0xD8A8,0x5825}, // + {0xD8A9,0x581c}, // + {0xD8AA,0x581b}, // + {0xD8AB,0x5833}, // + {0xD8AC,0x583f}, // + {0xD8AD,0x5836}, // + {0xD8AE,0x582e}, // + {0xD8AF,0x5839}, // + {0xD8B0,0x5838}, // + {0xD8B1,0x582d}, // + {0xD8B2,0x582c}, // + {0xD8B3,0x583b}, // + {0xD8B4,0x5961}, // + {0xD8B5,0x5aaf}, // + {0xD8B6,0x5a94}, // + {0xD8B7,0x5a9f}, // + {0xD8B8,0x5a7a}, // + {0xD8B9,0x5aa2}, // + {0xD8BA,0x5a9e}, // + {0xD8BB,0x5a78}, // + {0xD8BC,0x5aa6}, // + {0xD8BD,0x5a7c}, // + {0xD8BE,0x5aa5}, // + {0xD8BF,0x5aac}, // + {0xD8C0,0x5a95}, // + {0xD8C1,0x5aae}, // + {0xD8C2,0x5a37}, // + {0xD8C3,0x5a84}, // + {0xD8C4,0x5a8a}, // + {0xD8C5,0x5a97}, // + {0xD8C6,0x5a83}, // + {0xD8C7,0x5a8b}, // + {0xD8C8,0x5aa9}, // + {0xD8C9,0x5a7b}, // + {0xD8CA,0x5a7d}, // + {0xD8CB,0x5a8c}, // + {0xD8CC,0x5a9c}, // + {0xD8CD,0x5a8f}, // + {0xD8CE,0x5a93}, // + {0xD8CF,0x5a9d}, // + {0xD8D0,0x5bea}, // + {0xD8D1,0x5bcd}, // + {0xD8D2,0x5bcb}, // + {0xD8D3,0x5bd4}, // + {0xD8D4,0x5bd1}, // + {0xD8D5,0x5bca}, // + {0xD8D6,0x5bce}, // + {0xD8D7,0x5c0c}, // + {0xD8D8,0x5c30}, // + {0xD8D9,0x5d37}, // + {0xD8DA,0x5d43}, // + {0xD8DB,0x5d6b}, // + {0xD8DC,0x5d41}, // + {0xD8DD,0x5d4b}, // + {0xD8DE,0x5d3f}, // + {0xD8DF,0x5d35}, // + {0xD8E0,0x5d51}, // + {0xD8E1,0x5d4e}, // + {0xD8E2,0x5d55}, // + {0xD8E3,0x5d33}, // + {0xD8E4,0x5d3a}, // + {0xD8E5,0x5d52}, // + {0xD8E6,0x5d3d}, // + {0xD8E7,0x5d31}, // + {0xD8E8,0x5d59}, // + {0xD8E9,0x5d42}, // + {0xD8EA,0x5d39}, // + {0xD8EB,0x5d49}, // + {0xD8EC,0x5d38}, // + {0xD8ED,0x5d3c}, // + {0xD8EE,0x5d32}, // + {0xD8EF,0x5d36}, // + {0xD8F0,0x5d40}, // + {0xD8F1,0x5d45}, // + {0xD8F2,0x5e44}, // + {0xD8F3,0x5e41}, // + {0xD8F4,0x5f58}, // + {0xD8F5,0x5fa6}, // + {0xD8F6,0x5fa5}, // + {0xD8F7,0x5fab}, // + {0xD8F8,0x60c9}, // + {0xD8F9,0x60b9}, // + {0xD8FA,0x60cc}, // + {0xD8FB,0x60e2}, // + {0xD8FC,0x60ce}, // + {0xD8FD,0x60c4}, // + {0xD8FE,0x6114}, // + {0xD940,0x60f2}, // + {0xD941,0x610a}, // + {0xD942,0x6116}, // + {0xD943,0x6105}, // + {0xD944,0x60f5}, // + {0xD945,0x6113}, // + {0xD946,0x60f8}, // + {0xD947,0x60fc}, // + {0xD948,0x60fe}, // + {0xD949,0x60c1}, // + {0xD94A,0x6103}, // + {0xD94B,0x6118}, // + {0xD94C,0x611d}, // + {0xD94D,0x6110}, // + {0xD94E,0x60ff}, // + {0xD94F,0x6104}, // + {0xD950,0x610b}, // + {0xD951,0x624a}, // + {0xD952,0x6394}, // + {0xD953,0x63b1}, // + {0xD954,0x63b0}, // + {0xD955,0x63ce}, // + {0xD956,0x63e5}, // + {0xD957,0x63e8}, // + {0xD958,0x63ef}, // + {0xD959,0x63c3}, // + {0xD95A,0x649d}, // + {0xD95B,0x63f3}, // + {0xD95C,0x63ca}, // + {0xD95D,0x63e0}, // + {0xD95E,0x63f6}, // + {0xD95F,0x63d5}, // + {0xD960,0x63f2}, // + {0xD961,0x63f5}, // + {0xD962,0x6461}, // + {0xD963,0x63df}, // + {0xD964,0x63be}, // + {0xD965,0x63dd}, // + {0xD966,0x63dc}, // + {0xD967,0x63c4}, // + {0xD968,0x63d8}, // + {0xD969,0x63d3}, // + {0xD96A,0x63c2}, // + {0xD96B,0x63c7}, // + {0xD96C,0x63cc}, // + {0xD96D,0x63cb}, // + {0xD96E,0x63c8}, // + {0xD96F,0x63f0}, // + {0xD970,0x63d7}, // + {0xD971,0x63d9}, // + {0xD972,0x6532}, // + {0xD973,0x6567}, // + {0xD974,0x656a}, // + {0xD975,0x6564}, // + {0xD976,0x655c}, // + {0xD977,0x6568}, // + {0xD978,0x6565}, // + {0xD979,0x658c}, // + {0xD97A,0x659d}, // + {0xD97B,0x659e}, // + {0xD97C,0x65ae}, // + {0xD97D,0x65d0}, // + {0xD97E,0x65d2}, // + {0xD9A1,0x667c}, // + {0xD9A2,0x666c}, // + {0xD9A3,0x667b}, // + {0xD9A4,0x6680}, // + {0xD9A5,0x6671}, // + {0xD9A6,0x6679}, // + {0xD9A7,0x666a}, // + {0xD9A8,0x6672}, // + {0xD9A9,0x6701}, // + {0xD9AA,0x690c}, // + {0xD9AB,0x68d3}, // + {0xD9AC,0x6904}, // + {0xD9AD,0x68dc}, // + {0xD9AE,0x692a}, // + {0xD9AF,0x68ec}, // + {0xD9B0,0x68ea}, // + {0xD9B1,0x68f1}, // + {0xD9B2,0x690f}, // + {0xD9B3,0x68d6}, // + {0xD9B4,0x68f7}, // + {0xD9B5,0x68eb}, // + {0xD9B6,0x68e4}, // + {0xD9B7,0x68f6}, // + {0xD9B8,0x6913}, // + {0xD9B9,0x6910}, // + {0xD9BA,0x68f3}, // + {0xD9BB,0x68e1}, // + {0xD9BC,0x6907}, // + {0xD9BD,0x68cc}, // + {0xD9BE,0x6908}, // + {0xD9BF,0x6970}, // + {0xD9C0,0x68b4}, // + {0xD9C1,0x6911}, // + {0xD9C2,0x68ef}, // + {0xD9C3,0x68c6}, // + {0xD9C4,0x6914}, // + {0xD9C5,0x68f8}, // + {0xD9C6,0x68d0}, // + {0xD9C7,0x68fd}, // + {0xD9C8,0x68fc}, // + {0xD9C9,0x68e8}, // + {0xD9CA,0x690b}, // + {0xD9CB,0x690a}, // + {0xD9CC,0x6917}, // + {0xD9CD,0x68ce}, // + {0xD9CE,0x68c8}, // + {0xD9CF,0x68dd}, // + {0xD9D0,0x68de}, // + {0xD9D1,0x68e6}, // + {0xD9D2,0x68f4}, // + {0xD9D3,0x68d1}, // + {0xD9D4,0x6906}, // + {0xD9D5,0x68d4}, // + {0xD9D6,0x68e9}, // + {0xD9D7,0x6915}, // + {0xD9D8,0x6925}, // + {0xD9D9,0x68c7}, // + {0xD9DA,0x6b39}, // + {0xD9DB,0x6b3b}, // + {0xD9DC,0x6b3f}, // + {0xD9DD,0x6b3c}, // + {0xD9DE,0x6b94}, // + {0xD9DF,0x6b97}, // + {0xD9E0,0x6b99}, // + {0xD9E1,0x6b95}, // + {0xD9E2,0x6bbd}, // + {0xD9E3,0x6bf0}, // + {0xD9E4,0x6bf2}, // + {0xD9E5,0x6bf3}, // + {0xD9E6,0x6c30}, // + {0xD9E7,0x6dfc}, // + {0xD9E8,0x6e46}, // + {0xD9E9,0x6e47}, // + {0xD9EA,0x6e1f}, // + {0xD9EB,0x6e49}, // + {0xD9EC,0x6e88}, // + {0xD9ED,0x6e3c}, // + {0xD9EE,0x6e3d}, // + {0xD9EF,0x6e45}, // + {0xD9F0,0x6e62}, // + {0xD9F1,0x6e2b}, // + {0xD9F2,0x6e3f}, // + {0xD9F3,0x6e41}, // + {0xD9F4,0x6e5d}, // + {0xD9F5,0x6e73}, // + {0xD9F6,0x6e1c}, // + {0xD9F7,0x6e33}, // + {0xD9F8,0x6e4b}, // + {0xD9F9,0x6e40}, // + {0xD9FA,0x6e51}, // + {0xD9FB,0x6e3b}, // + {0xD9FC,0x6e03}, // + {0xD9FD,0x6e2e}, // + {0xD9FE,0x6e5e}, // + {0xDA40,0x6e68}, // + {0xDA41,0x6e5c}, // + {0xDA42,0x6e61}, // + {0xDA43,0x6e31}, // + {0xDA44,0x6e28}, // + {0xDA45,0x6e60}, // + {0xDA46,0x6e71}, // + {0xDA47,0x6e6b}, // + {0xDA48,0x6e39}, // + {0xDA49,0x6e22}, // + {0xDA4A,0x6e30}, // + {0xDA4B,0x6e53}, // + {0xDA4C,0x6e65}, // + {0xDA4D,0x6e27}, // + {0xDA4E,0x6e78}, // + {0xDA4F,0x6e64}, // + {0xDA50,0x6e77}, // + {0xDA51,0x6e55}, // + {0xDA52,0x6e79}, // + {0xDA53,0x6e52}, // + {0xDA54,0x6e66}, // + {0xDA55,0x6e35}, // + {0xDA56,0x6e36}, // + {0xDA57,0x6e5a}, // + {0xDA58,0x7120}, // + {0xDA59,0x711e}, // + {0xDA5A,0x712f}, // + {0xDA5B,0x70fb}, // + {0xDA5C,0x712e}, // + {0xDA5D,0x7131}, // + {0xDA5E,0x7123}, // + {0xDA5F,0x7125}, // + {0xDA60,0x7122}, // + {0xDA61,0x7132}, // + {0xDA62,0x711f}, // + {0xDA63,0x7128}, // + {0xDA64,0x713a}, // + {0xDA65,0x711b}, // + {0xDA66,0x724b}, // + {0xDA67,0x725a}, // + {0xDA68,0x7288}, // + {0xDA69,0x7289}, // + {0xDA6A,0x7286}, // + {0xDA6B,0x7285}, // + {0xDA6C,0x728b}, // + {0xDA6D,0x7312}, // + {0xDA6E,0x730b}, // + {0xDA6F,0x7330}, // + {0xDA70,0x7322}, // + {0xDA71,0x7331}, // + {0xDA72,0x7333}, // + {0xDA73,0x7327}, // + {0xDA74,0x7332}, // + {0xDA75,0x732d}, // + {0xDA76,0x7326}, // + {0xDA77,0x7323}, // + {0xDA78,0x7335}, // + {0xDA79,0x730c}, // + {0xDA7A,0x742e}, // + {0xDA7B,0x742c}, // + {0xDA7C,0x7430}, // + {0xDA7D,0x742b}, // + {0xDA7E,0x7416}, // + {0xDAA1,0x741a}, // + {0xDAA2,0x7421}, // + {0xDAA3,0x742d}, // + {0xDAA4,0x7431}, // + {0xDAA5,0x7424}, // + {0xDAA6,0x7423}, // + {0xDAA7,0x741d}, // + {0xDAA8,0x7429}, // + {0xDAA9,0x7420}, // + {0xDAAA,0x7432}, // + {0xDAAB,0x74fb}, // + {0xDAAC,0x752f}, // + {0xDAAD,0x756f}, // + {0xDAAE,0x756c}, // + {0xDAAF,0x75e7}, // + {0xDAB0,0x75da}, // + {0xDAB1,0x75e1}, // + {0xDAB2,0x75e6}, // + {0xDAB3,0x75dd}, // + {0xDAB4,0x75df}, // + {0xDAB5,0x75e4}, // + {0xDAB6,0x75d7}, // + {0xDAB7,0x7695}, // + {0xDAB8,0x7692}, // + {0xDAB9,0x76da}, // + {0xDABA,0x7746}, // + {0xDABB,0x7747}, // + {0xDABC,0x7744}, // + {0xDABD,0x774d}, // + {0xDABE,0x7745}, // + {0xDABF,0x774a}, // + {0xDAC0,0x774e}, // + {0xDAC1,0x774b}, // + {0xDAC2,0x774c}, // + {0xDAC3,0x77de}, // + {0xDAC4,0x77ec}, // + {0xDAC5,0x7860}, // + {0xDAC6,0x7864}, // + {0xDAC7,0x7865}, // + {0xDAC8,0x785c}, // + {0xDAC9,0x786d}, // + {0xDACA,0x7871}, // + {0xDACB,0x786a}, // + {0xDACC,0x786e}, // + {0xDACD,0x7870}, // + {0xDACE,0x7869}, // + {0xDACF,0x7868}, // + {0xDAD0,0x785e}, // + {0xDAD1,0x7862}, // + {0xDAD2,0x7974}, // + {0xDAD3,0x7973}, // + {0xDAD4,0x7972}, // + {0xDAD5,0x7970}, // + {0xDAD6,0x7a02}, // + {0xDAD7,0x7a0a}, // + {0xDAD8,0x7a03}, // + {0xDAD9,0x7a0c}, // + {0xDADA,0x7a04}, // + {0xDADB,0x7a99}, // + {0xDADC,0x7ae6}, // + {0xDADD,0x7ae4}, // + {0xDADE,0x7b4a}, // + {0xDADF,0x7b3b}, // + {0xDAE0,0x7b44}, // + {0xDAE1,0x7b48}, // + {0xDAE2,0x7b4c}, // + {0xDAE3,0x7b4e}, // + {0xDAE4,0x7b40}, // + {0xDAE5,0x7b58}, // + {0xDAE6,0x7b45}, // + {0xDAE7,0x7ca2}, // + {0xDAE8,0x7c9e}, // + {0xDAE9,0x7ca8}, // + {0xDAEA,0x7ca1}, // + {0xDAEB,0x7d58}, // + {0xDAEC,0x7d6f}, // + {0xDAED,0x7d63}, // + {0xDAEE,0x7d53}, // + {0xDAEF,0x7d56}, // + {0xDAF0,0x7d67}, // + {0xDAF1,0x7d6a}, // + {0xDAF2,0x7d4f}, // + {0xDAF3,0x7d6d}, // + {0xDAF4,0x7d5c}, // + {0xDAF5,0x7d6b}, // + {0xDAF6,0x7d52}, // + {0xDAF7,0x7d54}, // + {0xDAF8,0x7d69}, // + {0xDAF9,0x7d51}, // + {0xDAFA,0x7d5f}, // + {0xDAFB,0x7d4e}, // + {0xDAFC,0x7f3e}, // + {0xDAFD,0x7f3f}, // + {0xDAFE,0x7f65}, // + {0xDB40,0x7f66}, // + {0xDB41,0x7fa2}, // + {0xDB42,0x7fa0}, // + {0xDB43,0x7fa1}, // + {0xDB44,0x7fd7}, // + {0xDB45,0x8051}, // + {0xDB46,0x804f}, // + {0xDB47,0x8050}, // + {0xDB48,0x80fe}, // + {0xDB49,0x80d4}, // + {0xDB4A,0x8143}, // + {0xDB4B,0x814a}, // + {0xDB4C,0x8152}, // + {0xDB4D,0x814f}, // + {0xDB4E,0x8147}, // + {0xDB4F,0x813d}, // + {0xDB50,0x814d}, // + {0xDB51,0x813a}, // + {0xDB52,0x81e6}, // + {0xDB53,0x81ee}, // + {0xDB54,0x81f7}, // + {0xDB55,0x81f8}, // + {0xDB56,0x81f9}, // + {0xDB57,0x8204}, // + {0xDB58,0x823c}, // + {0xDB59,0x823d}, // + {0xDB5A,0x823f}, // + {0xDB5B,0x8275}, // + {0xDB5C,0x833b}, // + {0xDB5D,0x83cf}, // + {0xDB5E,0x83f9}, // + {0xDB5F,0x8423}, // + {0xDB60,0x83c0}, // + {0xDB61,0x83e8}, // + {0xDB62,0x8412}, // + {0xDB63,0x83e7}, // + {0xDB64,0x83e4}, // + {0xDB65,0x83fc}, // + {0xDB66,0x83f6}, // + {0xDB67,0x8410}, // + {0xDB68,0x83c6}, // + {0xDB69,0x83c8}, // + {0xDB6A,0x83eb}, // + {0xDB6B,0x83e3}, // + {0xDB6C,0x83bf}, // + {0xDB6D,0x8401}, // + {0xDB6E,0x83dd}, // + {0xDB6F,0x83e5}, // + {0xDB70,0x83d8}, // + {0xDB71,0x83ff}, // + {0xDB72,0x83e1}, // + {0xDB73,0x83cb}, // + {0xDB74,0x83ce}, // + {0xDB75,0x83d6}, // + {0xDB76,0x83f5}, // + {0xDB77,0x83c9}, // + {0xDB78,0x8409}, // + {0xDB79,0x840f}, // + {0xDB7A,0x83de}, // + {0xDB7B,0x8411}, // + {0xDB7C,0x8406}, // + {0xDB7D,0x83c2}, // + {0xDB7E,0x83f3}, // + {0xDBA1,0x83d5}, // + {0xDBA2,0x83fa}, // + {0xDBA3,0x83c7}, // + {0xDBA4,0x83d1}, // + {0xDBA5,0x83ea}, // + {0xDBA6,0x8413}, // + {0xDBA7,0x83c3}, // + {0xDBA8,0x83ec}, // + {0xDBA9,0x83ee}, // + {0xDBAA,0x83c4}, // + {0xDBAB,0x83fb}, // + {0xDBAC,0x83d7}, // + {0xDBAD,0x83e2}, // + {0xDBAE,0x841b}, // + {0xDBAF,0x83db}, // + {0xDBB0,0x83fe}, // + {0xDBB1,0x86d8}, // + {0xDBB2,0x86e2}, // + {0xDBB3,0x86e6}, // + {0xDBB4,0x86d3}, // + {0xDBB5,0x86e3}, // + {0xDBB6,0x86da}, // + {0xDBB7,0x86ea}, // + {0xDBB8,0x86dd}, // + {0xDBB9,0x86eb}, // + {0xDBBA,0x86dc}, // + {0xDBBB,0x86ec}, // + {0xDBBC,0x86e9}, // + {0xDBBD,0x86d7}, // + {0xDBBE,0x86e8}, // + {0xDBBF,0x86d1}, // + {0xDBC0,0x8848}, // + {0xDBC1,0x8856}, // + {0xDBC2,0x8855}, // + {0xDBC3,0x88ba}, // + {0xDBC4,0x88d7}, // + {0xDBC5,0x88b9}, // + {0xDBC6,0x88b8}, // + {0xDBC7,0x88c0}, // + {0xDBC8,0x88be}, // + {0xDBC9,0x88b6}, // + {0xDBCA,0x88bc}, // + {0xDBCB,0x88b7}, // + {0xDBCC,0x88bd}, // + {0xDBCD,0x88b2}, // + {0xDBCE,0x8901}, // + {0xDBCF,0x88c9}, // + {0xDBD0,0x8995}, // + {0xDBD1,0x8998}, // + {0xDBD2,0x8997}, // + {0xDBD3,0x89dd}, // + {0xDBD4,0x89da}, // + {0xDBD5,0x89db}, // + {0xDBD6,0x8a4e}, // + {0xDBD7,0x8a4d}, // + {0xDBD8,0x8a39}, // + {0xDBD9,0x8a59}, // + {0xDBDA,0x8a40}, // + {0xDBDB,0x8a57}, // + {0xDBDC,0x8a58}, // + {0xDBDD,0x8a44}, // + {0xDBDE,0x8a45}, // + {0xDBDF,0x8a52}, // + {0xDBE0,0x8a48}, // + {0xDBE1,0x8a51}, // + {0xDBE2,0x8a4a}, // + {0xDBE3,0x8a4c}, // + {0xDBE4,0x8a4f}, // + {0xDBE5,0x8c5f}, // + {0xDBE6,0x8c81}, // + {0xDBE7,0x8c80}, // + {0xDBE8,0x8cba}, // + {0xDBE9,0x8cbe}, // + {0xDBEA,0x8cb0}, // + {0xDBEB,0x8cb9}, // + {0xDBEC,0x8cb5}, // + {0xDBED,0x8d84}, // + {0xDBEE,0x8d80}, // + {0xDBEF,0x8d89}, // + {0xDBF0,0x8dd8}, // + {0xDBF1,0x8dd3}, // + {0xDBF2,0x8dcd}, // + {0xDBF3,0x8dc7}, // + {0xDBF4,0x8dd6}, // + {0xDBF5,0x8ddc}, // + {0xDBF6,0x8dcf}, // + {0xDBF7,0x8dd5}, // + {0xDBF8,0x8dd9}, // + {0xDBF9,0x8dc8}, // + {0xDBFA,0x8dd7}, // + {0xDBFB,0x8dc5}, // + {0xDBFC,0x8eef}, // + {0xDBFD,0x8ef7}, // + {0xDBFE,0x8efa}, // + {0xDC40,0x8ef9}, // + {0xDC41,0x8ee6}, // + {0xDC42,0x8eee}, // + {0xDC43,0x8ee5}, // + {0xDC44,0x8ef5}, // + {0xDC45,0x8ee7}, // + {0xDC46,0x8ee8}, // + {0xDC47,0x8ef6}, // + {0xDC48,0x8eeb}, // + {0xDC49,0x8ef1}, // + {0xDC4A,0x8eec}, // + {0xDC4B,0x8ef4}, // + {0xDC4C,0x8ee9}, // + {0xDC4D,0x902d}, // + {0xDC4E,0x9034}, // + {0xDC4F,0x902f}, // + {0xDC50,0x9106}, // + {0xDC51,0x912c}, // + {0xDC52,0x9104}, // + {0xDC53,0x90ff}, // + {0xDC54,0x90fc}, // + {0xDC55,0x9108}, // + {0xDC56,0x90f9}, // + {0xDC57,0x90fb}, // + {0xDC58,0x9101}, // + {0xDC59,0x9100}, // + {0xDC5A,0x9107}, // + {0xDC5B,0x9105}, // + {0xDC5C,0x9103}, // + {0xDC5D,0x9161}, // + {0xDC5E,0x9164}, // + {0xDC5F,0x915f}, // + {0xDC60,0x9162}, // + {0xDC61,0x9160}, // + {0xDC62,0x9201}, // + {0xDC63,0x920a}, // + {0xDC64,0x9225}, // + {0xDC65,0x9203}, // + {0xDC66,0x921a}, // + {0xDC67,0x9226}, // + {0xDC68,0x920f}, // + {0xDC69,0x920c}, // + {0xDC6A,0x9200}, // + {0xDC6B,0x9212}, // + {0xDC6C,0x91ff}, // + {0xDC6D,0x91fd}, // + {0xDC6E,0x9206}, // + {0xDC6F,0x9204}, // + {0xDC70,0x9227}, // + {0xDC71,0x9202}, // + {0xDC72,0x921c}, // + {0xDC73,0x9224}, // + {0xDC74,0x9219}, // + {0xDC75,0x9217}, // + {0xDC76,0x9205}, // + {0xDC77,0x9216}, // + {0xDC78,0x957b}, // + {0xDC79,0x958d}, // + {0xDC7A,0x958c}, // + {0xDC7B,0x9590}, // + {0xDC7C,0x9687}, // + {0xDC7D,0x967e}, // + {0xDC7E,0x9688}, // + {0xDCA1,0x9689}, // + {0xDCA2,0x9683}, // + {0xDCA3,0x9680}, // + {0xDCA4,0x96c2}, // + {0xDCA5,0x96c8}, // + {0xDCA6,0x96c3}, // + {0xDCA7,0x96f1}, // + {0xDCA8,0x96f0}, // + {0xDCA9,0x976c}, // + {0xDCAA,0x9770}, // + {0xDCAB,0x976e}, // + {0xDCAC,0x9807}, // + {0xDCAD,0x98a9}, // + {0xDCAE,0x98eb}, // + {0xDCAF,0x9ce6}, // + {0xDCB0,0x9ef9}, // + {0xDCB1,0x4e83}, // + {0xDCB2,0x4e84}, // + {0xDCB3,0x4eb6}, // + {0xDCB4,0x50bd}, // + {0xDCB5,0x50bf}, // + {0xDCB6,0x50c6}, // + {0xDCB7,0x50ae}, // + {0xDCB8,0x50c4}, // + {0xDCB9,0x50ca}, // + {0xDCBA,0x50b4}, // + {0xDCBB,0x50c8}, // + {0xDCBC,0x50c2}, // + {0xDCBD,0x50b0}, // + {0xDCBE,0x50c1}, // + {0xDCBF,0x50ba}, // + {0xDCC0,0x50b1}, // + {0xDCC1,0x50cb}, // + {0xDCC2,0x50c9}, // + {0xDCC3,0x50b6}, // + {0xDCC4,0x50b8}, // + {0xDCC5,0x51d7}, // + {0xDCC6,0x527a}, // + {0xDCC7,0x5278}, // + {0xDCC8,0x527b}, // + {0xDCC9,0x527c}, // + {0xDCCA,0x55c3}, // + {0xDCCB,0x55db}, // + {0xDCCC,0x55cc}, // + {0xDCCD,0x55d0}, // + {0xDCCE,0x55cb}, // + {0xDCCF,0x55ca}, // + {0xDCD0,0x55dd}, // + {0xDCD1,0x55c0}, // + {0xDCD2,0x55d4}, // + {0xDCD3,0x55c4}, // + {0xDCD4,0x55e9}, // + {0xDCD5,0x55bf}, // + {0xDCD6,0x55d2}, // + {0xDCD7,0x558d}, // + {0xDCD8,0x55cf}, // + {0xDCD9,0x55d5}, // + {0xDCDA,0x55e2}, // + {0xDCDB,0x55d6}, // + {0xDCDC,0x55c8}, // + {0xDCDD,0x55f2}, // + {0xDCDE,0x55cd}, // + {0xDCDF,0x55d9}, // + {0xDCE0,0x55c2}, // + {0xDCE1,0x5714}, // + {0xDCE2,0x5853}, // + {0xDCE3,0x5868}, // + {0xDCE4,0x5864}, // + {0xDCE5,0x584f}, // + {0xDCE6,0x584d}, // + {0xDCE7,0x5849}, // + {0xDCE8,0x586f}, // + {0xDCE9,0x5855}, // + {0xDCEA,0x584e}, // + {0xDCEB,0x585d}, // + {0xDCEC,0x5859}, // + {0xDCED,0x5865}, // + {0xDCEE,0x585b}, // + {0xDCEF,0x583d}, // + {0xDCF0,0x5863}, // + {0xDCF1,0x5871}, // + {0xDCF2,0x58fc}, // + {0xDCF3,0x5ac7}, // + {0xDCF4,0x5ac4}, // + {0xDCF5,0x5acb}, // + {0xDCF6,0x5aba}, // + {0xDCF7,0x5ab8}, // + {0xDCF8,0x5ab1}, // + {0xDCF9,0x5ab5}, // + {0xDCFA,0x5ab0}, // + {0xDCFB,0x5abf}, // + {0xDCFC,0x5ac8}, // + {0xDCFD,0x5abb}, // + {0xDCFE,0x5ac6}, // + {0xDD40,0x5ab7}, // + {0xDD41,0x5ac0}, // + {0xDD42,0x5aca}, // + {0xDD43,0x5ab4}, // + {0xDD44,0x5ab6}, // + {0xDD45,0x5acd}, // + {0xDD46,0x5ab9}, // + {0xDD47,0x5a90}, // + {0xDD48,0x5bd6}, // + {0xDD49,0x5bd8}, // + {0xDD4A,0x5bd9}, // + {0xDD4B,0x5c1f}, // + {0xDD4C,0x5c33}, // + {0xDD4D,0x5d71}, // + {0xDD4E,0x5d63}, // + {0xDD4F,0x5d4a}, // + {0xDD50,0x5d65}, // + {0xDD51,0x5d72}, // + {0xDD52,0x5d6c}, // + {0xDD53,0x5d5e}, // + {0xDD54,0x5d68}, // + {0xDD55,0x5d67}, // + {0xDD56,0x5d62}, // + {0xDD57,0x5df0}, // + {0xDD58,0x5e4f}, // + {0xDD59,0x5e4e}, // + {0xDD5A,0x5e4a}, // + {0xDD5B,0x5e4d}, // + {0xDD5C,0x5e4b}, // + {0xDD5D,0x5ec5}, // + {0xDD5E,0x5ecc}, // + {0xDD5F,0x5ec6}, // + {0xDD60,0x5ecb}, // + {0xDD61,0x5ec7}, // + {0xDD62,0x5f40}, // + {0xDD63,0x5faf}, // + {0xDD64,0x5fad}, // + {0xDD65,0x60f7}, // + {0xDD66,0x6149}, // + {0xDD67,0x614a}, // + {0xDD68,0x612b}, // + {0xDD69,0x6145}, // + {0xDD6A,0x6136}, // + {0xDD6B,0x6132}, // + {0xDD6C,0x612e}, // + {0xDD6D,0x6146}, // + {0xDD6E,0x612f}, // + {0xDD6F,0x614f}, // + {0xDD70,0x6129}, // + {0xDD71,0x6140}, // + {0xDD72,0x6220}, // + {0xDD73,0x9168}, // + {0xDD74,0x6223}, // + {0xDD75,0x6225}, // + {0xDD76,0x6224}, // + {0xDD77,0x63c5}, // + {0xDD78,0x63f1}, // + {0xDD79,0x63eb}, // + {0xDD7A,0x6410}, // + {0xDD7B,0x6412}, // + {0xDD7C,0x6409}, // + {0xDD7D,0x6420}, // + {0xDD7E,0x6424}, // + {0xDDA1,0x6433}, // + {0xDDA2,0x6443}, // + {0xDDA3,0x641f}, // + {0xDDA4,0x6415}, // + {0xDDA5,0x6418}, // + {0xDDA6,0x6439}, // + {0xDDA7,0x6437}, // + {0xDDA8,0x6422}, // + {0xDDA9,0x6423}, // + {0xDDAA,0x640c}, // + {0xDDAB,0x6426}, // + {0xDDAC,0x6430}, // + {0xDDAD,0x6428}, // + {0xDDAE,0x6441}, // + {0xDDAF,0x6435}, // + {0xDDB0,0x642f}, // + {0xDDB1,0x640a}, // + {0xDDB2,0x641a}, // + {0xDDB3,0x6440}, // + {0xDDB4,0x6425}, // + {0xDDB5,0x6427}, // + {0xDDB6,0x640b}, // + {0xDDB7,0x63e7}, // + {0xDDB8,0x641b}, // + {0xDDB9,0x642e}, // + {0xDDBA,0x6421}, // + {0xDDBB,0x640e}, // + {0xDDBC,0x656f}, // + {0xDDBD,0x6592}, // + {0xDDBE,0x65d3}, // + {0xDDBF,0x6686}, // + {0xDDC0,0x668c}, // + {0xDDC1,0x6695}, // + {0xDDC2,0x6690}, // + {0xDDC3,0x668b}, // + {0xDDC4,0x668a}, // + {0xDDC5,0x6699}, // + {0xDDC6,0x6694}, // + {0xDDC7,0x6678}, // + {0xDDC8,0x6720}, // + {0xDDC9,0x6966}, // + {0xDDCA,0x695f}, // + {0xDDCB,0x6938}, // + {0xDDCC,0x694e}, // + {0xDDCD,0x6962}, // + {0xDDCE,0x6971}, // + {0xDDCF,0x693f}, // + {0xDDD0,0x6945}, // + {0xDDD1,0x696a}, // + {0xDDD2,0x6939}, // + {0xDDD3,0x6942}, // + {0xDDD4,0x6957}, // + {0xDDD5,0x6959}, // + {0xDDD6,0x697a}, // + {0xDDD7,0x6948}, // + {0xDDD8,0x6949}, // + {0xDDD9,0x6935}, // + {0xDDDA,0x696c}, // + {0xDDDB,0x6933}, // + {0xDDDC,0x693d}, // + {0xDDDD,0x6965}, // + {0xDDDE,0x68f0}, // + {0xDDDF,0x6978}, // + {0xDDE0,0x6934}, // + {0xDDE1,0x6969}, // + {0xDDE2,0x6940}, // + {0xDDE3,0x696f}, // + {0xDDE4,0x6944}, // + {0xDDE5,0x6976}, // + {0xDDE6,0x6958}, // + {0xDDE7,0x6941}, // + {0xDDE8,0x6974}, // + {0xDDE9,0x694c}, // + {0xDDEA,0x693b}, // + {0xDDEB,0x694b}, // + {0xDDEC,0x6937}, // + {0xDDED,0x695c}, // + {0xDDEE,0x694f}, // + {0xDDEF,0x6951}, // + {0xDDF0,0x6932}, // + {0xDDF1,0x6952}, // + {0xDDF2,0x692f}, // + {0xDDF3,0x697b}, // + {0xDDF4,0x693c}, // + {0xDDF5,0x6b46}, // + {0xDDF6,0x6b45}, // + {0xDDF7,0x6b43}, // + {0xDDF8,0x6b42}, // + {0xDDF9,0x6b48}, // + {0xDDFA,0x6b41}, // + {0xDDFB,0x6b9b}, // + {0xDDFC,0xfa0d}, // CJK COMPATIBILITY IDEOGRAPH-FA0D + {0xDDFD,0x6bfb}, // + {0xDDFE,0x6bfc}, // + {0xDE40,0x6bf9}, // + {0xDE41,0x6bf7}, // + {0xDE42,0x6bf8}, // + {0xDE43,0x6e9b}, // + {0xDE44,0x6ed6}, // + {0xDE45,0x6ec8}, // + {0xDE46,0x6e8f}, // + {0xDE47,0x6ec0}, // + {0xDE48,0x6e9f}, // + {0xDE49,0x6e93}, // + {0xDE4A,0x6e94}, // + {0xDE4B,0x6ea0}, // + {0xDE4C,0x6eb1}, // + {0xDE4D,0x6eb9}, // + {0xDE4E,0x6ec6}, // + {0xDE4F,0x6ed2}, // + {0xDE50,0x6ebd}, // + {0xDE51,0x6ec1}, // + {0xDE52,0x6e9e}, // + {0xDE53,0x6ec9}, // + {0xDE54,0x6eb7}, // + {0xDE55,0x6eb0}, // + {0xDE56,0x6ecd}, // + {0xDE57,0x6ea6}, // + {0xDE58,0x6ecf}, // + {0xDE59,0x6eb2}, // + {0xDE5A,0x6ebe}, // + {0xDE5B,0x6ec3}, // + {0xDE5C,0x6edc}, // + {0xDE5D,0x6ed8}, // + {0xDE5E,0x6e99}, // + {0xDE5F,0x6e92}, // + {0xDE60,0x6e8e}, // + {0xDE61,0x6e8d}, // + {0xDE62,0x6ea4}, // + {0xDE63,0x6ea1}, // + {0xDE64,0x6ebf}, // + {0xDE65,0x6eb3}, // + {0xDE66,0x6ed0}, // + {0xDE67,0x6eca}, // + {0xDE68,0x6e97}, // + {0xDE69,0x6eae}, // + {0xDE6A,0x6ea3}, // + {0xDE6B,0x7147}, // + {0xDE6C,0x7154}, // + {0xDE6D,0x7152}, // + {0xDE6E,0x7163}, // + {0xDE6F,0x7160}, // + {0xDE70,0x7141}, // + {0xDE71,0x715d}, // + {0xDE72,0x7162}, // + {0xDE73,0x7172}, // + {0xDE74,0x7178}, // + {0xDE75,0x716a}, // + {0xDE76,0x7161}, // + {0xDE77,0x7142}, // + {0xDE78,0x7158}, // + {0xDE79,0x7143}, // + {0xDE7A,0x714b}, // + {0xDE7B,0x7170}, // + {0xDE7C,0x715f}, // + {0xDE7D,0x7150}, // + {0xDE7E,0x7153}, // + {0xDEA1,0x7144}, // + {0xDEA2,0x714d}, // + {0xDEA3,0x715a}, // + {0xDEA4,0x724f}, // + {0xDEA5,0x728d}, // + {0xDEA6,0x728c}, // + {0xDEA7,0x7291}, // + {0xDEA8,0x7290}, // + {0xDEA9,0x728e}, // + {0xDEAA,0x733c}, // + {0xDEAB,0x7342}, // + {0xDEAC,0x733b}, // + {0xDEAD,0x733a}, // + {0xDEAE,0x7340}, // + {0xDEAF,0x734a}, // + {0xDEB0,0x7349}, // + {0xDEB1,0x7444}, // + {0xDEB2,0x744a}, // + {0xDEB3,0x744b}, // + {0xDEB4,0x7452}, // + {0xDEB5,0x7451}, // + {0xDEB6,0x7457}, // + {0xDEB7,0x7440}, // + {0xDEB8,0x744f}, // + {0xDEB9,0x7450}, // + {0xDEBA,0x744e}, // + {0xDEBB,0x7442}, // + {0xDEBC,0x7446}, // + {0xDEBD,0x744d}, // + {0xDEBE,0x7454}, // + {0xDEBF,0x74e1}, // + {0xDEC0,0x74ff}, // + {0xDEC1,0x74fe}, // + {0xDEC2,0x74fd}, // + {0xDEC3,0x751d}, // + {0xDEC4,0x7579}, // + {0xDEC5,0x7577}, // + {0xDEC6,0x6983}, // + {0xDEC7,0x75ef}, // + {0xDEC8,0x760f}, // + {0xDEC9,0x7603}, // + {0xDECA,0x75f7}, // + {0xDECB,0x75fe}, // + {0xDECC,0x75fc}, // + {0xDECD,0x75f9}, // + {0xDECE,0x75f8}, // + {0xDECF,0x7610}, // + {0xDED0,0x75fb}, // + {0xDED1,0x75f6}, // + {0xDED2,0x75ed}, // + {0xDED3,0x75f5}, // + {0xDED4,0x75fd}, // + {0xDED5,0x7699}, // + {0xDED6,0x76b5}, // + {0xDED7,0x76dd}, // + {0xDED8,0x7755}, // + {0xDED9,0x775f}, // + {0xDEDA,0x7760}, // + {0xDEDB,0x7752}, // + {0xDEDC,0x7756}, // + {0xDEDD,0x775a}, // + {0xDEDE,0x7769}, // + {0xDEDF,0x7767}, // + {0xDEE0,0x7754}, // + {0xDEE1,0x7759}, // + {0xDEE2,0x776d}, // + {0xDEE3,0x77e0}, // + {0xDEE4,0x7887}, // + {0xDEE5,0x789a}, // + {0xDEE6,0x7894}, // + {0xDEE7,0x788f}, // + {0xDEE8,0x7884}, // + {0xDEE9,0x7895}, // + {0xDEEA,0x7885}, // + {0xDEEB,0x7886}, // + {0xDEEC,0x78a1}, // + {0xDEED,0x7883}, // + {0xDEEE,0x7879}, // + {0xDEEF,0x7899}, // + {0xDEF0,0x7880}, // + {0xDEF1,0x7896}, // + {0xDEF2,0x787b}, // + {0xDEF3,0x797c}, // + {0xDEF4,0x7982}, // + {0xDEF5,0x797d}, // + {0xDEF6,0x7979}, // + {0xDEF7,0x7a11}, // + {0xDEF8,0x7a18}, // + {0xDEF9,0x7a19}, // + {0xDEFA,0x7a12}, // + {0xDEFB,0x7a17}, // + {0xDEFC,0x7a15}, // + {0xDEFD,0x7a22}, // + {0xDEFE,0x7a13}, // + {0xDF40,0x7a1b}, // + {0xDF41,0x7a10}, // + {0xDF42,0x7aa3}, // + {0xDF43,0x7aa2}, // + {0xDF44,0x7a9e}, // + {0xDF45,0x7aeb}, // + {0xDF46,0x7b66}, // + {0xDF47,0x7b64}, // + {0xDF48,0x7b6d}, // + {0xDF49,0x7b74}, // + {0xDF4A,0x7b69}, // + {0xDF4B,0x7b72}, // + {0xDF4C,0x7b65}, // + {0xDF4D,0x7b73}, // + {0xDF4E,0x7b71}, // + {0xDF4F,0x7b70}, // + {0xDF50,0x7b61}, // + {0xDF51,0x7b78}, // + {0xDF52,0x7b76}, // + {0xDF53,0x7b63}, // + {0xDF54,0x7cb2}, // + {0xDF55,0x7cb4}, // + {0xDF56,0x7caf}, // + {0xDF57,0x7d88}, // + {0xDF58,0x7d86}, // + {0xDF59,0x7d80}, // + {0xDF5A,0x7d8d}, // + {0xDF5B,0x7d7f}, // + {0xDF5C,0x7d85}, // + {0xDF5D,0x7d7a}, // + {0xDF5E,0x7d8e}, // + {0xDF5F,0x7d7b}, // + {0xDF60,0x7d83}, // + {0xDF61,0x7d7c}, // + {0xDF62,0x7d8c}, // + {0xDF63,0x7d94}, // + {0xDF64,0x7d84}, // + {0xDF65,0x7d7d}, // + {0xDF66,0x7d92}, // + {0xDF67,0x7f6d}, // + {0xDF68,0x7f6b}, // + {0xDF69,0x7f67}, // + {0xDF6A,0x7f68}, // + {0xDF6B,0x7f6c}, // + {0xDF6C,0x7fa6}, // + {0xDF6D,0x7fa5}, // + {0xDF6E,0x7fa7}, // + {0xDF6F,0x7fdb}, // + {0xDF70,0x7fdc}, // + {0xDF71,0x8021}, // + {0xDF72,0x8164}, // + {0xDF73,0x8160}, // + {0xDF74,0x8177}, // + {0xDF75,0x815c}, // + {0xDF76,0x8169}, // + {0xDF77,0x815b}, // + {0xDF78,0x8162}, // + {0xDF79,0x8172}, // + {0xDF7A,0x6721}, // + {0xDF7B,0x815e}, // + {0xDF7C,0x8176}, // + {0xDF7D,0x8167}, // + {0xDF7E,0x816f}, // + {0xDFA1,0x8144}, // + {0xDFA2,0x8161}, // + {0xDFA3,0x821d}, // + {0xDFA4,0x8249}, // + {0xDFA5,0x8244}, // + {0xDFA6,0x8240}, // + {0xDFA7,0x8242}, // + {0xDFA8,0x8245}, // + {0xDFA9,0x84f1}, // + {0xDFAA,0x843f}, // + {0xDFAB,0x8456}, // + {0xDFAC,0x8476}, // + {0xDFAD,0x8479}, // + {0xDFAE,0x848f}, // + {0xDFAF,0x848d}, // + {0xDFB0,0x8465}, // + {0xDFB1,0x8451}, // + {0xDFB2,0x8440}, // + {0xDFB3,0x8486}, // + {0xDFB4,0x8467}, // + {0xDFB5,0x8430}, // + {0xDFB6,0x844d}, // + {0xDFB7,0x847d}, // + {0xDFB8,0x845a}, // + {0xDFB9,0x8459}, // + {0xDFBA,0x8474}, // + {0xDFBB,0x8473}, // + {0xDFBC,0x845d}, // + {0xDFBD,0x8507}, // + {0xDFBE,0x845e}, // + {0xDFBF,0x8437}, // + {0xDFC0,0x843a}, // + {0xDFC1,0x8434}, // + {0xDFC2,0x847a}, // + {0xDFC3,0x8443}, // + {0xDFC4,0x8478}, // + {0xDFC5,0x8432}, // + {0xDFC6,0x8445}, // + {0xDFC7,0x8429}, // + {0xDFC8,0x83d9}, // + {0xDFC9,0x844b}, // + {0xDFCA,0x842f}, // + {0xDFCB,0x8442}, // + {0xDFCC,0x842d}, // + {0xDFCD,0x845f}, // + {0xDFCE,0x8470}, // + {0xDFCF,0x8439}, // + {0xDFD0,0x844e}, // + {0xDFD1,0x844c}, // + {0xDFD2,0x8452}, // + {0xDFD3,0x846f}, // + {0xDFD4,0x84c5}, // + {0xDFD5,0x848e}, // + {0xDFD6,0x843b}, // + {0xDFD7,0x8447}, // + {0xDFD8,0x8436}, // + {0xDFD9,0x8433}, // + {0xDFDA,0x8468}, // + {0xDFDB,0x847e}, // + {0xDFDC,0x8444}, // + {0xDFDD,0x842b}, // + {0xDFDE,0x8460}, // + {0xDFDF,0x8454}, // + {0xDFE0,0x846e}, // + {0xDFE1,0x8450}, // + {0xDFE2,0x870b}, // + {0xDFE3,0x8704}, // + {0xDFE4,0x86f7}, // + {0xDFE5,0x870c}, // + {0xDFE6,0x86fa}, // + {0xDFE7,0x86d6}, // + {0xDFE8,0x86f5}, // + {0xDFE9,0x874d}, // + {0xDFEA,0x86f8}, // + {0xDFEB,0x870e}, // + {0xDFEC,0x8709}, // + {0xDFED,0x8701}, // + {0xDFEE,0x86f6}, // + {0xDFEF,0x870d}, // + {0xDFF0,0x8705}, // + {0xDFF1,0x88d6}, // + {0xDFF2,0x88cb}, // + {0xDFF3,0x88cd}, // + {0xDFF4,0x88ce}, // + {0xDFF5,0x88de}, // + {0xDFF6,0x88db}, // + {0xDFF7,0x88da}, // + {0xDFF8,0x88cc}, // + {0xDFF9,0x88d0}, // + {0xDFFA,0x8985}, // + {0xDFFB,0x899b}, // + {0xDFFC,0x89df}, // + {0xDFFD,0x89e5}, // + {0xDFFE,0x89e4}, // + {0xE040,0x89e1}, // + {0xE041,0x89e0}, // + {0xE042,0x89e2}, // + {0xE043,0x89dc}, // + {0xE044,0x89e6}, // + {0xE045,0x8a76}, // + {0xE046,0x8a86}, // + {0xE047,0x8a7f}, // + {0xE048,0x8a61}, // + {0xE049,0x8a3f}, // + {0xE04A,0x8a77}, // + {0xE04B,0x8a82}, // + {0xE04C,0x8a84}, // + {0xE04D,0x8a75}, // + {0xE04E,0x8a83}, // + {0xE04F,0x8a81}, // + {0xE050,0x8a74}, // + {0xE051,0x8a7a}, // + {0xE052,0x8c3c}, // + {0xE053,0x8c4b}, // + {0xE054,0x8c4a}, // + {0xE055,0x8c65}, // + {0xE056,0x8c64}, // + {0xE057,0x8c66}, // + {0xE058,0x8c86}, // + {0xE059,0x8c84}, // + {0xE05A,0x8c85}, // + {0xE05B,0x8ccc}, // + {0xE05C,0x8d68}, // + {0xE05D,0x8d69}, // + {0xE05E,0x8d91}, // + {0xE05F,0x8d8c}, // + {0xE060,0x8d8e}, // + {0xE061,0x8d8f}, // + {0xE062,0x8d8d}, // + {0xE063,0x8d93}, // + {0xE064,0x8d94}, // + {0xE065,0x8d90}, // + {0xE066,0x8d92}, // + {0xE067,0x8df0}, // + {0xE068,0x8de0}, // + {0xE069,0x8dec}, // + {0xE06A,0x8df1}, // + {0xE06B,0x8dee}, // + {0xE06C,0x8dd0}, // + {0xE06D,0x8de9}, // + {0xE06E,0x8de3}, // + {0xE06F,0x8de2}, // + {0xE070,0x8de7}, // + {0xE071,0x8df2}, // + {0xE072,0x8deb}, // + {0xE073,0x8df4}, // + {0xE074,0x8f06}, // + {0xE075,0x8eff}, // + {0xE076,0x8f01}, // + {0xE077,0x8f00}, // + {0xE078,0x8f05}, // + {0xE079,0x8f07}, // + {0xE07A,0x8f08}, // + {0xE07B,0x8f02}, // + {0xE07C,0x8f0b}, // + {0xE07D,0x9052}, // + {0xE07E,0x903f}, // + {0xE0A1,0x9044}, // + {0xE0A2,0x9049}, // + {0xE0A3,0x903d}, // + {0xE0A4,0x9110}, // + {0xE0A5,0x910d}, // + {0xE0A6,0x910f}, // + {0xE0A7,0x9111}, // + {0xE0A8,0x9116}, // + {0xE0A9,0x9114}, // + {0xE0AA,0x910b}, // + {0xE0AB,0x910e}, // + {0xE0AC,0x916e}, // + {0xE0AD,0x916f}, // + {0xE0AE,0x9248}, // + {0xE0AF,0x9252}, // + {0xE0B0,0x9230}, // + {0xE0B1,0x923a}, // + {0xE0B2,0x9266}, // + {0xE0B3,0x9233}, // + {0xE0B4,0x9265}, // + {0xE0B5,0x925e}, // + {0xE0B6,0x9283}, // + {0xE0B7,0x922e}, // + {0xE0B8,0x924a}, // + {0xE0B9,0x9246}, // + {0xE0BA,0x926d}, // + {0xE0BB,0x926c}, // + {0xE0BC,0x924f}, // + {0xE0BD,0x9260}, // + {0xE0BE,0x9267}, // + {0xE0BF,0x926f}, // + {0xE0C0,0x9236}, // + {0xE0C1,0x9261}, // + {0xE0C2,0x9270}, // + {0xE0C3,0x9231}, // + {0xE0C4,0x9254}, // + {0xE0C5,0x9263}, // + {0xE0C6,0x9250}, // + {0xE0C7,0x9272}, // + {0xE0C8,0x924e}, // + {0xE0C9,0x9253}, // + {0xE0CA,0x924c}, // + {0xE0CB,0x9256}, // + {0xE0CC,0x9232}, // + {0xE0CD,0x959f}, // + {0xE0CE,0x959c}, // + {0xE0CF,0x959e}, // + {0xE0D0,0x959b}, // + {0xE0D1,0x9692}, // + {0xE0D2,0x9693}, // + {0xE0D3,0x9691}, // + {0xE0D4,0x9697}, // + {0xE0D5,0x96ce}, // + {0xE0D6,0x96fa}, // + {0xE0D7,0x96fd}, // + {0xE0D8,0x96f8}, // + {0xE0D9,0x96f5}, // + {0xE0DA,0x9773}, // + {0xE0DB,0x9777}, // + {0xE0DC,0x9778}, // + {0xE0DD,0x9772}, // + {0xE0DE,0x980f}, // + {0xE0DF,0x980d}, // + {0xE0E0,0x980e}, // + {0xE0E1,0x98ac}, // + {0xE0E2,0x98f6}, // + {0xE0E3,0x98f9}, // + {0xE0E4,0x99af}, // + {0xE0E5,0x99b2}, // + {0xE0E6,0x99b0}, // + {0xE0E7,0x99b5}, // + {0xE0E8,0x9aad}, // + {0xE0E9,0x9aab}, // + {0xE0EA,0x9b5b}, // + {0xE0EB,0x9cea}, // + {0xE0EC,0x9ced}, // + {0xE0ED,0x9ce7}, // + {0xE0EE,0x9e80}, // + {0xE0EF,0x9efd}, // + {0xE0F0,0x50e6}, // + {0xE0F1,0x50d4}, // + {0xE0F2,0x50d7}, // + {0xE0F3,0x50e8}, // + {0xE0F4,0x50f3}, // + {0xE0F5,0x50db}, // + {0xE0F6,0x50ea}, // + {0xE0F7,0x50dd}, // + {0xE0F8,0x50e4}, // + {0xE0F9,0x50d3}, // + {0xE0FA,0x50ec}, // + {0xE0FB,0x50f0}, // + {0xE0FC,0x50ef}, // + {0xE0FD,0x50e3}, // + {0xE0FE,0x50e0}, // + {0xE140,0x51d8}, // + {0xE141,0x5280}, // + {0xE142,0x5281}, // + {0xE143,0x52e9}, // + {0xE144,0x52eb}, // + {0xE145,0x5330}, // + {0xE146,0x53ac}, // + {0xE147,0x5627}, // + {0xE148,0x5615}, // + {0xE149,0x560c}, // + {0xE14A,0x5612}, // + {0xE14B,0x55fc}, // + {0xE14C,0x560f}, // + {0xE14D,0x561c}, // + {0xE14E,0x5601}, // + {0xE14F,0x5613}, // + {0xE150,0x5602}, // + {0xE151,0x55fa}, // + {0xE152,0x561d}, // + {0xE153,0x5604}, // + {0xE154,0x55ff}, // + {0xE155,0x55f9}, // + {0xE156,0x5889}, // + {0xE157,0x587c}, // + {0xE158,0x5890}, // + {0xE159,0x5898}, // + {0xE15A,0x5886}, // + {0xE15B,0x5881}, // + {0xE15C,0x587f}, // + {0xE15D,0x5874}, // + {0xE15E,0x588b}, // + {0xE15F,0x587a}, // + {0xE160,0x5887}, // + {0xE161,0x5891}, // + {0xE162,0x588e}, // + {0xE163,0x5876}, // + {0xE164,0x5882}, // + {0xE165,0x5888}, // + {0xE166,0x587b}, // + {0xE167,0x5894}, // + {0xE168,0x588f}, // + {0xE169,0x58fe}, // + {0xE16A,0x596b}, // + {0xE16B,0x5adc}, // + {0xE16C,0x5aee}, // + {0xE16D,0x5ae5}, // + {0xE16E,0x5ad5}, // + {0xE16F,0x5aea}, // + {0xE170,0x5ada}, // + {0xE171,0x5aed}, // + {0xE172,0x5aeb}, // + {0xE173,0x5af3}, // + {0xE174,0x5ae2}, // + {0xE175,0x5ae0}, // + {0xE176,0x5adb}, // + {0xE177,0x5aec}, // + {0xE178,0x5ade}, // + {0xE179,0x5add}, // + {0xE17A,0x5ad9}, // + {0xE17B,0x5ae8}, // + {0xE17C,0x5adf}, // + {0xE17D,0x5b77}, // + {0xE17E,0x5be0}, // + {0xE1A1,0x5be3}, // + {0xE1A2,0x5c63}, // + {0xE1A3,0x5d82}, // + {0xE1A4,0x5d80}, // + {0xE1A5,0x5d7d}, // + {0xE1A6,0x5d86}, // + {0xE1A7,0x5d7a}, // + {0xE1A8,0x5d81}, // + {0xE1A9,0x5d77}, // + {0xE1AA,0x5d8a}, // + {0xE1AB,0x5d89}, // + {0xE1AC,0x5d88}, // + {0xE1AD,0x5d7e}, // + {0xE1AE,0x5d7c}, // + {0xE1AF,0x5d8d}, // + {0xE1B0,0x5d79}, // + {0xE1B1,0x5d7f}, // + {0xE1B2,0x5e58}, // + {0xE1B3,0x5e59}, // + {0xE1B4,0x5e53}, // + {0xE1B5,0x5ed8}, // + {0xE1B6,0x5ed1}, // + {0xE1B7,0x5ed7}, // + {0xE1B8,0x5ece}, // + {0xE1B9,0x5edc}, // + {0xE1BA,0x5ed5}, // + {0xE1BB,0x5ed9}, // + {0xE1BC,0x5ed2}, // + {0xE1BD,0x5ed4}, // + {0xE1BE,0x5f44}, // + {0xE1BF,0x5f43}, // + {0xE1C0,0x5f6f}, // + {0xE1C1,0x5fb6}, // + {0xE1C2,0x612c}, // + {0xE1C3,0x6128}, // + {0xE1C4,0x6141}, // + {0xE1C5,0x615e}, // + {0xE1C6,0x6171}, // + {0xE1C7,0x6173}, // + {0xE1C8,0x6152}, // + {0xE1C9,0x6153}, // + {0xE1CA,0x6172}, // + {0xE1CB,0x616c}, // + {0xE1CC,0x6180}, // + {0xE1CD,0x6174}, // + {0xE1CE,0x6154}, // + {0xE1CF,0x617a}, // + {0xE1D0,0x615b}, // + {0xE1D1,0x6165}, // + {0xE1D2,0x613b}, // + {0xE1D3,0x616a}, // + {0xE1D4,0x6161}, // + {0xE1D5,0x6156}, // + {0xE1D6,0x6229}, // + {0xE1D7,0x6227}, // + {0xE1D8,0x622b}, // + {0xE1D9,0x642b}, // + {0xE1DA,0x644d}, // + {0xE1DB,0x645b}, // + {0xE1DC,0x645d}, // + {0xE1DD,0x6474}, // + {0xE1DE,0x6476}, // + {0xE1DF,0x6472}, // + {0xE1E0,0x6473}, // + {0xE1E1,0x647d}, // + {0xE1E2,0x6475}, // + {0xE1E3,0x6466}, // + {0xE1E4,0x64a6}, // + {0xE1E5,0x644e}, // + {0xE1E6,0x6482}, // + {0xE1E7,0x645e}, // + {0xE1E8,0x645c}, // + {0xE1E9,0x644b}, // + {0xE1EA,0x6453}, // + {0xE1EB,0x6460}, // + {0xE1EC,0x6450}, // + {0xE1ED,0x647f}, // + {0xE1EE,0x643f}, // + {0xE1EF,0x646c}, // + {0xE1F0,0x646b}, // + {0xE1F1,0x6459}, // + {0xE1F2,0x6465}, // + {0xE1F3,0x6477}, // + {0xE1F4,0x6573}, // + {0xE1F5,0x65a0}, // + {0xE1F6,0x66a1}, // + {0xE1F7,0x66a0}, // + {0xE1F8,0x669f}, // + {0xE1F9,0x6705}, // + {0xE1FA,0x6704}, // + {0xE1FB,0x6722}, // + {0xE1FC,0x69b1}, // + {0xE1FD,0x69b6}, // + {0xE1FE,0x69c9}, // + {0xE240,0x69a0}, // + {0xE241,0x69ce}, // + {0xE242,0x6996}, // + {0xE243,0x69b0}, // + {0xE244,0x69ac}, // + {0xE245,0x69bc}, // + {0xE246,0x6991}, // + {0xE247,0x6999}, // + {0xE248,0x698e}, // + {0xE249,0x69a7}, // + {0xE24A,0x698d}, // + {0xE24B,0x69a9}, // + {0xE24C,0x69be}, // + {0xE24D,0x69af}, // + {0xE24E,0x69bf}, // + {0xE24F,0x69c4}, // + {0xE250,0x69bd}, // + {0xE251,0x69a4}, // + {0xE252,0x69d4}, // + {0xE253,0x69b9}, // + {0xE254,0x69ca}, // + {0xE255,0x699a}, // + {0xE256,0x69cf}, // + {0xE257,0x69b3}, // + {0xE258,0x6993}, // + {0xE259,0x69aa}, // + {0xE25A,0x69a1}, // + {0xE25B,0x699e}, // + {0xE25C,0x69d9}, // + {0xE25D,0x6997}, // + {0xE25E,0x6990}, // + {0xE25F,0x69c2}, // + {0xE260,0x69b5}, // + {0xE261,0x69a5}, // + {0xE262,0x69c6}, // + {0xE263,0x6b4a}, // + {0xE264,0x6b4d}, // + {0xE265,0x6b4b}, // + {0xE266,0x6b9e}, // + {0xE267,0x6b9f}, // + {0xE268,0x6ba0}, // + {0xE269,0x6bc3}, // + {0xE26A,0x6bc4}, // + {0xE26B,0x6bfe}, // + {0xE26C,0x6ece}, // + {0xE26D,0x6ef5}, // + {0xE26E,0x6ef1}, // + {0xE26F,0x6f03}, // + {0xE270,0x6f25}, // + {0xE271,0x6ef8}, // + {0xE272,0x6f37}, // + {0xE273,0x6efb}, // + {0xE274,0x6f2e}, // + {0xE275,0x6f09}, // + {0xE276,0x6f4e}, // + {0xE277,0x6f19}, // + {0xE278,0x6f1a}, // + {0xE279,0x6f27}, // + {0xE27A,0x6f18}, // + {0xE27B,0x6f3b}, // + {0xE27C,0x6f12}, // + {0xE27D,0x6eed}, // + {0xE27E,0x6f0a}, // + {0xE2A1,0x6f36}, // + {0xE2A2,0x6f73}, // + {0xE2A3,0x6ef9}, // + {0xE2A4,0x6eee}, // + {0xE2A5,0x6f2d}, // + {0xE2A6,0x6f40}, // + {0xE2A7,0x6f30}, // + {0xE2A8,0x6f3c}, // + {0xE2A9,0x6f35}, // + {0xE2AA,0x6eeb}, // + {0xE2AB,0x6f07}, // + {0xE2AC,0x6f0e}, // + {0xE2AD,0x6f43}, // + {0xE2AE,0x6f05}, // + {0xE2AF,0x6efd}, // + {0xE2B0,0x6ef6}, // + {0xE2B1,0x6f39}, // + {0xE2B2,0x6f1c}, // + {0xE2B3,0x6efc}, // + {0xE2B4,0x6f3a}, // + {0xE2B5,0x6f1f}, // + {0xE2B6,0x6f0d}, // + {0xE2B7,0x6f1e}, // + {0xE2B8,0x6f08}, // + {0xE2B9,0x6f21}, // + {0xE2BA,0x7187}, // + {0xE2BB,0x7190}, // + {0xE2BC,0x7189}, // + {0xE2BD,0x7180}, // + {0xE2BE,0x7185}, // + {0xE2BF,0x7182}, // + {0xE2C0,0x718f}, // + {0xE2C1,0x717b}, // + {0xE2C2,0x7186}, // + {0xE2C3,0x7181}, // + {0xE2C4,0x7197}, // + {0xE2C5,0x7244}, // + {0xE2C6,0x7253}, // + {0xE2C7,0x7297}, // + {0xE2C8,0x7295}, // + {0xE2C9,0x7293}, // + {0xE2CA,0x7343}, // + {0xE2CB,0x734d}, // + {0xE2CC,0x7351}, // + {0xE2CD,0x734c}, // + {0xE2CE,0x7462}, // + {0xE2CF,0x7473}, // + {0xE2D0,0x7471}, // + {0xE2D1,0x7475}, // + {0xE2D2,0x7472}, // + {0xE2D3,0x7467}, // + {0xE2D4,0x746e}, // + {0xE2D5,0x7500}, // + {0xE2D6,0x7502}, // + {0xE2D7,0x7503}, // + {0xE2D8,0x757d}, // + {0xE2D9,0x7590}, // + {0xE2DA,0x7616}, // + {0xE2DB,0x7608}, // + {0xE2DC,0x760c}, // + {0xE2DD,0x7615}, // + {0xE2DE,0x7611}, // + {0xE2DF,0x760a}, // + {0xE2E0,0x7614}, // + {0xE2E1,0x76b8}, // + {0xE2E2,0x7781}, // + {0xE2E3,0x777c}, // + {0xE2E4,0x7785}, // + {0xE2E5,0x7782}, // + {0xE2E6,0x776e}, // + {0xE2E7,0x7780}, // + {0xE2E8,0x776f}, // + {0xE2E9,0x777e}, // + {0xE2EA,0x7783}, // + {0xE2EB,0x78b2}, // + {0xE2EC,0x78aa}, // + {0xE2ED,0x78b4}, // + {0xE2EE,0x78ad}, // + {0xE2EF,0x78a8}, // + {0xE2F0,0x787e}, // + {0xE2F1,0x78ab}, // + {0xE2F2,0x789e}, // + {0xE2F3,0x78a5}, // + {0xE2F4,0x78a0}, // + {0xE2F5,0x78ac}, // + {0xE2F6,0x78a2}, // + {0xE2F7,0x78a4}, // + {0xE2F8,0x7998}, // + {0xE2F9,0x798a}, // + {0xE2FA,0x798b}, // + {0xE2FB,0x7996}, // + {0xE2FC,0x7995}, // + {0xE2FD,0x7994}, // + {0xE2FE,0x7993}, // + {0xE340,0x7997}, // + {0xE341,0x7988}, // + {0xE342,0x7992}, // + {0xE343,0x7990}, // + {0xE344,0x7a2b}, // + {0xE345,0x7a4a}, // + {0xE346,0x7a30}, // + {0xE347,0x7a2f}, // + {0xE348,0x7a28}, // + {0xE349,0x7a26}, // + {0xE34A,0x7aa8}, // + {0xE34B,0x7aab}, // + {0xE34C,0x7aac}, // + {0xE34D,0x7aee}, // + {0xE34E,0x7b88}, // + {0xE34F,0x7b9c}, // + {0xE350,0x7b8a}, // + {0xE351,0x7b91}, // + {0xE352,0x7b90}, // + {0xE353,0x7b96}, // + {0xE354,0x7b8d}, // + {0xE355,0x7b8c}, // + {0xE356,0x7b9b}, // + {0xE357,0x7b8e}, // + {0xE358,0x7b85}, // + {0xE359,0x7b98}, // + {0xE35A,0x5284}, // + {0xE35B,0x7b99}, // + {0xE35C,0x7ba4}, // + {0xE35D,0x7b82}, // + {0xE35E,0x7cbb}, // + {0xE35F,0x7cbf}, // + {0xE360,0x7cbc}, // + {0xE361,0x7cba}, // + {0xE362,0x7da7}, // + {0xE363,0x7db7}, // + {0xE364,0x7dc2}, // + {0xE365,0x7da3}, // + {0xE366,0x7daa}, // + {0xE367,0x7dc1}, // + {0xE368,0x7dc0}, // + {0xE369,0x7dc5}, // + {0xE36A,0x7d9d}, // + {0xE36B,0x7dce}, // + {0xE36C,0x7dc4}, // + {0xE36D,0x7dc6}, // + {0xE36E,0x7dcb}, // + {0xE36F,0x7dcc}, // + {0xE370,0x7daf}, // + {0xE371,0x7db9}, // + {0xE372,0x7d96}, // + {0xE373,0x7dbc}, // + {0xE374,0x7d9f}, // + {0xE375,0x7da6}, // + {0xE376,0x7dae}, // + {0xE377,0x7da9}, // + {0xE378,0x7da1}, // + {0xE379,0x7dc9}, // + {0xE37A,0x7f73}, // + {0xE37B,0x7fe2}, // + {0xE37C,0x7fe3}, // + {0xE37D,0x7fe5}, // + {0xE37E,0x7fde}, // + {0xE3A1,0x8024}, // + {0xE3A2,0x805d}, // + {0xE3A3,0x805c}, // + {0xE3A4,0x8189}, // + {0xE3A5,0x8186}, // + {0xE3A6,0x8183}, // + {0xE3A7,0x8187}, // + {0xE3A8,0x818d}, // + {0xE3A9,0x818c}, // + {0xE3AA,0x818b}, // + {0xE3AB,0x8215}, // + {0xE3AC,0x8497}, // + {0xE3AD,0x84a4}, // + {0xE3AE,0x84a1}, // + {0xE3AF,0x849f}, // + {0xE3B0,0x84ba}, // + {0xE3B1,0x84ce}, // + {0xE3B2,0x84c2}, // + {0xE3B3,0x84ac}, // + {0xE3B4,0x84ae}, // + {0xE3B5,0x84ab}, // + {0xE3B6,0x84b9}, // + {0xE3B7,0x84b4}, // + {0xE3B8,0x84c1}, // + {0xE3B9,0x84cd}, // + {0xE3BA,0x84aa}, // + {0xE3BB,0x849a}, // + {0xE3BC,0x84b1}, // + {0xE3BD,0x84d0}, // + {0xE3BE,0x849d}, // + {0xE3BF,0x84a7}, // + {0xE3C0,0x84bb}, // + {0xE3C1,0x84a2}, // + {0xE3C2,0x8494}, // + {0xE3C3,0x84c7}, // + {0xE3C4,0x84cc}, // + {0xE3C5,0x849b}, // + {0xE3C6,0x84a9}, // + {0xE3C7,0x84af}, // + {0xE3C8,0x84a8}, // + {0xE3C9,0x84d6}, // + {0xE3CA,0x8498}, // + {0xE3CB,0x84b6}, // + {0xE3CC,0x84cf}, // + {0xE3CD,0x84a0}, // + {0xE3CE,0x84d7}, // + {0xE3CF,0x84d4}, // + {0xE3D0,0x84d2}, // + {0xE3D1,0x84db}, // + {0xE3D2,0x84b0}, // + {0xE3D3,0x8491}, // + {0xE3D4,0x8661}, // + {0xE3D5,0x8733}, // + {0xE3D6,0x8723}, // + {0xE3D7,0x8728}, // + {0xE3D8,0x876b}, // + {0xE3D9,0x8740}, // + {0xE3DA,0x872e}, // + {0xE3DB,0x871e}, // + {0xE3DC,0x8721}, // + {0xE3DD,0x8719}, // + {0xE3DE,0x871b}, // + {0xE3DF,0x8743}, // + {0xE3E0,0x872c}, // + {0xE3E1,0x8741}, // + {0xE3E2,0x873e}, // + {0xE3E3,0x8746}, // + {0xE3E4,0x8720}, // + {0xE3E5,0x8732}, // + {0xE3E6,0x872a}, // + {0xE3E7,0x872d}, // + {0xE3E8,0x873c}, // + {0xE3E9,0x8712}, // + {0xE3EA,0x873a}, // + {0xE3EB,0x8731}, // + {0xE3EC,0x8735}, // + {0xE3ED,0x8742}, // + {0xE3EE,0x8726}, // + {0xE3EF,0x8727}, // + {0xE3F0,0x8738}, // + {0xE3F1,0x8724}, // + {0xE3F2,0x871a}, // + {0xE3F3,0x8730}, // + {0xE3F4,0x8711}, // + {0xE3F5,0x88f7}, // + {0xE3F6,0x88e7}, // + {0xE3F7,0x88f1}, // + {0xE3F8,0x88f2}, // + {0xE3F9,0x88fa}, // + {0xE3FA,0x88fe}, // + {0xE3FB,0x88ee}, // + {0xE3FC,0x88fc}, // + {0xE3FD,0x88f6}, // + {0xE3FE,0x88fb}, // + {0xE440,0x88f0}, // + {0xE441,0x88ec}, // + {0xE442,0x88eb}, // + {0xE443,0x899d}, // + {0xE444,0x89a1}, // + {0xE445,0x899f}, // + {0xE446,0x899e}, // + {0xE447,0x89e9}, // + {0xE448,0x89eb}, // + {0xE449,0x89e8}, // + {0xE44A,0x8aab}, // + {0xE44B,0x8a99}, // + {0xE44C,0x8a8b}, // + {0xE44D,0x8a92}, // + {0xE44E,0x8a8f}, // + {0xE44F,0x8a96}, // + {0xE450,0x8c3d}, // + {0xE451,0x8c68}, // + {0xE452,0x8c69}, // + {0xE453,0x8cd5}, // + {0xE454,0x8ccf}, // + {0xE455,0x8cd7}, // + {0xE456,0x8d96}, // + {0xE457,0x8e09}, // + {0xE458,0x8e02}, // + {0xE459,0x8dff}, // + {0xE45A,0x8e0d}, // + {0xE45B,0x8dfd}, // + {0xE45C,0x8e0a}, // + {0xE45D,0x8e03}, // + {0xE45E,0x8e07}, // + {0xE45F,0x8e06}, // + {0xE460,0x8e05}, // + {0xE461,0x8dfe}, // + {0xE462,0x8e00}, // + {0xE463,0x8e04}, // + {0xE464,0x8f10}, // + {0xE465,0x8f11}, // + {0xE466,0x8f0e}, // + {0xE467,0x8f0d}, // + {0xE468,0x9123}, // + {0xE469,0x911c}, // + {0xE46A,0x9120}, // + {0xE46B,0x9122}, // + {0xE46C,0x911f}, // + {0xE46D,0x911d}, // + {0xE46E,0x911a}, // + {0xE46F,0x9124}, // + {0xE470,0x9121}, // + {0xE471,0x911b}, // + {0xE472,0x917a}, // + {0xE473,0x9172}, // + {0xE474,0x9179}, // + {0xE475,0x9173}, // + {0xE476,0x92a5}, // + {0xE477,0x92a4}, // + {0xE478,0x9276}, // + {0xE479,0x929b}, // + {0xE47A,0x927a}, // + {0xE47B,0x92a0}, // + {0xE47C,0x9294}, // + {0xE47D,0x92aa}, // + {0xE47E,0x928d}, // + {0xE4A1,0x92a6}, // + {0xE4A2,0x929a}, // + {0xE4A3,0x92ab}, // + {0xE4A4,0x9279}, // + {0xE4A5,0x9297}, // + {0xE4A6,0x927f}, // + {0xE4A7,0x92a3}, // + {0xE4A8,0x92ee}, // + {0xE4A9,0x928e}, // + {0xE4AA,0x9282}, // + {0xE4AB,0x9295}, // + {0xE4AC,0x92a2}, // + {0xE4AD,0x927d}, // + {0xE4AE,0x9288}, // + {0xE4AF,0x92a1}, // + {0xE4B0,0x928a}, // + {0xE4B1,0x9286}, // + {0xE4B2,0x928c}, // + {0xE4B3,0x9299}, // + {0xE4B4,0x92a7}, // + {0xE4B5,0x927e}, // + {0xE4B6,0x9287}, // + {0xE4B7,0x92a9}, // + {0xE4B8,0x929d}, // + {0xE4B9,0x928b}, // + {0xE4BA,0x922d}, // + {0xE4BB,0x969e}, // + {0xE4BC,0x96a1}, // + {0xE4BD,0x96ff}, // + {0xE4BE,0x9758}, // + {0xE4BF,0x977d}, // + {0xE4C0,0x977a}, // + {0xE4C1,0x977e}, // + {0xE4C2,0x9783}, // + {0xE4C3,0x9780}, // + {0xE4C4,0x9782}, // + {0xE4C5,0x977b}, // + {0xE4C6,0x9784}, // + {0xE4C7,0x9781}, // + {0xE4C8,0x977f}, // + {0xE4C9,0x97ce}, // + {0xE4CA,0x97cd}, // + {0xE4CB,0x9816}, // + {0xE4CC,0x98ad}, // + {0xE4CD,0x98ae}, // + {0xE4CE,0x9902}, // + {0xE4CF,0x9900}, // + {0xE4D0,0x9907}, // + {0xE4D1,0x999d}, // + {0xE4D2,0x999c}, // + {0xE4D3,0x99c3}, // + {0xE4D4,0x99b9}, // + {0xE4D5,0x99bb}, // + {0xE4D6,0x99ba}, // + {0xE4D7,0x99c2}, // + {0xE4D8,0x99bd}, // + {0xE4D9,0x99c7}, // + {0xE4DA,0x9ab1}, // + {0xE4DB,0x9ae3}, // + {0xE4DC,0x9ae7}, // + {0xE4DD,0x9b3e}, // + {0xE4DE,0x9b3f}, // + {0xE4DF,0x9b60}, // + {0xE4E0,0x9b61}, // + {0xE4E1,0x9b5f}, // + {0xE4E2,0x9cf1}, // + {0xE4E3,0x9cf2}, // + {0xE4E4,0x9cf5}, // + {0xE4E5,0x9ea7}, // + {0xE4E6,0x50ff}, // + {0xE4E7,0x5103}, // + {0xE4E8,0x5130}, // + {0xE4E9,0x50f8}, // + {0xE4EA,0x5106}, // + {0xE4EB,0x5107}, // + {0xE4EC,0x50f6}, // + {0xE4ED,0x50fe}, // + {0xE4EE,0x510b}, // + {0xE4EF,0x510c}, // + {0xE4F0,0x50fd}, // + {0xE4F1,0x510a}, // + {0xE4F2,0x528b}, // + {0xE4F3,0x528c}, // + {0xE4F4,0x52f1}, // + {0xE4F5,0x52ef}, // + {0xE4F6,0x5648}, // + {0xE4F7,0x5642}, // + {0xE4F8,0x564c}, // + {0xE4F9,0x5635}, // + {0xE4FA,0x5641}, // + {0xE4FB,0x564a}, // + {0xE4FC,0x5649}, // + {0xE4FD,0x5646}, // + {0xE4FE,0x5658}, // + {0xE540,0x565a}, // + {0xE541,0x5640}, // + {0xE542,0x5633}, // + {0xE543,0x563d}, // + {0xE544,0x562c}, // + {0xE545,0x563e}, // + {0xE546,0x5638}, // + {0xE547,0x562a}, // + {0xE548,0x563a}, // + {0xE549,0x571a}, // + {0xE54A,0x58ab}, // + {0xE54B,0x589d}, // + {0xE54C,0x58b1}, // + {0xE54D,0x58a0}, // + {0xE54E,0x58a3}, // + {0xE54F,0x58af}, // + {0xE550,0x58ac}, // + {0xE551,0x58a5}, // + {0xE552,0x58a1}, // + {0xE553,0x58ff}, // + {0xE554,0x5aff}, // + {0xE555,0x5af4}, // + {0xE556,0x5afd}, // + {0xE557,0x5af7}, // + {0xE558,0x5af6}, // + {0xE559,0x5b03}, // + {0xE55A,0x5af8}, // + {0xE55B,0x5b02}, // + {0xE55C,0x5af9}, // + {0xE55D,0x5b01}, // + {0xE55E,0x5b07}, // + {0xE55F,0x5b05}, // + {0xE560,0x5b0f}, // + {0xE561,0x5c67}, // + {0xE562,0x5d99}, // + {0xE563,0x5d97}, // + {0xE564,0x5d9f}, // + {0xE565,0x5d92}, // + {0xE566,0x5da2}, // + {0xE567,0x5d93}, // + {0xE568,0x5d95}, // + {0xE569,0x5da0}, // + {0xE56A,0x5d9c}, // + {0xE56B,0x5da1}, // + {0xE56C,0x5d9a}, // + {0xE56D,0x5d9e}, // + {0xE56E,0x5e69}, // + {0xE56F,0x5e5d}, // + {0xE570,0x5e60}, // + {0xE571,0x5e5c}, // + {0xE572,0x7df3}, // + {0xE573,0x5edb}, // + {0xE574,0x5ede}, // + {0xE575,0x5ee1}, // + {0xE576,0x5f49}, // + {0xE577,0x5fb2}, // + {0xE578,0x618b}, // + {0xE579,0x6183}, // + {0xE57A,0x6179}, // + {0xE57B,0x61b1}, // + {0xE57C,0x61b0}, // + {0xE57D,0x61a2}, // + {0xE57E,0x6189}, // + {0xE5A1,0x619b}, // + {0xE5A2,0x6193}, // + {0xE5A3,0x61af}, // + {0xE5A4,0x61ad}, // + {0xE5A5,0x619f}, // + {0xE5A6,0x6192}, // + {0xE5A7,0x61aa}, // + {0xE5A8,0x61a1}, // + {0xE5A9,0x618d}, // + {0xE5AA,0x6166}, // + {0xE5AB,0x61b3}, // + {0xE5AC,0x622d}, // + {0xE5AD,0x646e}, // + {0xE5AE,0x6470}, // + {0xE5AF,0x6496}, // + {0xE5B0,0x64a0}, // + {0xE5B1,0x6485}, // + {0xE5B2,0x6497}, // + {0xE5B3,0x649c}, // + {0xE5B4,0x648f}, // + {0xE5B5,0x648b}, // + {0xE5B6,0x648a}, // + {0xE5B7,0x648c}, // + {0xE5B8,0x64a3}, // + {0xE5B9,0x649f}, // + {0xE5BA,0x6468}, // + {0xE5BB,0x64b1}, // + {0xE5BC,0x6498}, // + {0xE5BD,0x6576}, // + {0xE5BE,0x657a}, // + {0xE5BF,0x6579}, // + {0xE5C0,0x657b}, // + {0xE5C1,0x65b2}, // + {0xE5C2,0x65b3}, // + {0xE5C3,0x66b5}, // + {0xE5C4,0x66b0}, // + {0xE5C5,0x66a9}, // + {0xE5C6,0x66b2}, // + {0xE5C7,0x66b7}, // + {0xE5C8,0x66aa}, // + {0xE5C9,0x66af}, // + {0xE5CA,0x6a00}, // + {0xE5CB,0x6a06}, // + {0xE5CC,0x6a17}, // + {0xE5CD,0x69e5}, // + {0xE5CE,0x69f8}, // + {0xE5CF,0x6a15}, // + {0xE5D0,0x69f1}, // + {0xE5D1,0x69e4}, // + {0xE5D2,0x6a20}, // + {0xE5D3,0x69ff}, // + {0xE5D4,0x69ec}, // + {0xE5D5,0x69e2}, // + {0xE5D6,0x6a1b}, // + {0xE5D7,0x6a1d}, // + {0xE5D8,0x69fe}, // + {0xE5D9,0x6a27}, // + {0xE5DA,0x69f2}, // + {0xE5DB,0x69ee}, // + {0xE5DC,0x6a14}, // + {0xE5DD,0x69f7}, // + {0xE5DE,0x69e7}, // + {0xE5DF,0x6a40}, // + {0xE5E0,0x6a08}, // + {0xE5E1,0x69e6}, // + {0xE5E2,0x69fb}, // + {0xE5E3,0x6a0d}, // + {0xE5E4,0x69fc}, // + {0xE5E5,0x69eb}, // + {0xE5E6,0x6a09}, // + {0xE5E7,0x6a04}, // + {0xE5E8,0x6a18}, // + {0xE5E9,0x6a25}, // + {0xE5EA,0x6a0f}, // + {0xE5EB,0x69f6}, // + {0xE5EC,0x6a26}, // + {0xE5ED,0x6a07}, // + {0xE5EE,0x69f4}, // + {0xE5EF,0x6a16}, // + {0xE5F0,0x6b51}, // + {0xE5F1,0x6ba5}, // + {0xE5F2,0x6ba3}, // + {0xE5F3,0x6ba2}, // + {0xE5F4,0x6ba6}, // + {0xE5F5,0x6c01}, // + {0xE5F6,0x6c00}, // + {0xE5F7,0x6bff}, // + {0xE5F8,0x6c02}, // + {0xE5F9,0x6f41}, // + {0xE5FA,0x6f26}, // + {0xE5FB,0x6f7e}, // + {0xE5FC,0x6f87}, // + {0xE5FD,0x6fc6}, // + {0xE5FE,0x6f92}, // + {0xE640,0x6f8d}, // + {0xE641,0x6f89}, // + {0xE642,0x6f8c}, // + {0xE643,0x6f62}, // + {0xE644,0x6f4f}, // + {0xE645,0x6f85}, // + {0xE646,0x6f5a}, // + {0xE647,0x6f96}, // + {0xE648,0x6f76}, // + {0xE649,0x6f6c}, // + {0xE64A,0x6f82}, // + {0xE64B,0x6f55}, // + {0xE64C,0x6f72}, // + {0xE64D,0x6f52}, // + {0xE64E,0x6f50}, // + {0xE64F,0x6f57}, // + {0xE650,0x6f94}, // + {0xE651,0x6f93}, // + {0xE652,0x6f5d}, // + {0xE653,0x6f00}, // + {0xE654,0x6f61}, // + {0xE655,0x6f6b}, // + {0xE656,0x6f7d}, // + {0xE657,0x6f67}, // + {0xE658,0x6f90}, // + {0xE659,0x6f53}, // + {0xE65A,0x6f8b}, // + {0xE65B,0x6f69}, // + {0xE65C,0x6f7f}, // + {0xE65D,0x6f95}, // + {0xE65E,0x6f63}, // + {0xE65F,0x6f77}, // + {0xE660,0x6f6a}, // + {0xE661,0x6f7b}, // + {0xE662,0x71b2}, // + {0xE663,0x71af}, // + {0xE664,0x719b}, // + {0xE665,0x71b0}, // + {0xE666,0x71a0}, // + {0xE667,0x719a}, // + {0xE668,0x71a9}, // + {0xE669,0x71b5}, // + {0xE66A,0x719d}, // + {0xE66B,0x71a5}, // + {0xE66C,0x719e}, // + {0xE66D,0x71a4}, // + {0xE66E,0x71a1}, // + {0xE66F,0x71aa}, // + {0xE670,0x719c}, // + {0xE671,0x71a7}, // + {0xE672,0x71b3}, // + {0xE673,0x7298}, // + {0xE674,0x729a}, // + {0xE675,0x7358}, // + {0xE676,0x7352}, // + {0xE677,0x735e}, // + {0xE678,0x735f}, // + {0xE679,0x7360}, // + {0xE67A,0x735d}, // + {0xE67B,0x735b}, // + {0xE67C,0x7361}, // + {0xE67D,0x735a}, // + {0xE67E,0x7359}, // + {0xE6A1,0x7362}, // + {0xE6A2,0x7487}, // + {0xE6A3,0x7489}, // + {0xE6A4,0x748a}, // + {0xE6A5,0x7486}, // + {0xE6A6,0x7481}, // + {0xE6A7,0x747d}, // + {0xE6A8,0x7485}, // + {0xE6A9,0x7488}, // + {0xE6AA,0x747c}, // + {0xE6AB,0x7479}, // + {0xE6AC,0x7508}, // + {0xE6AD,0x7507}, // + {0xE6AE,0x757e}, // + {0xE6AF,0x7625}, // + {0xE6B0,0x761e}, // + {0xE6B1,0x7619}, // + {0xE6B2,0x761d}, // + {0xE6B3,0x761c}, // + {0xE6B4,0x7623}, // + {0xE6B5,0x761a}, // + {0xE6B6,0x7628}, // + {0xE6B7,0x761b}, // + {0xE6B8,0x769c}, // + {0xE6B9,0x769d}, // + {0xE6BA,0x769e}, // + {0xE6BB,0x769b}, // + {0xE6BC,0x778d}, // + {0xE6BD,0x778f}, // + {0xE6BE,0x7789}, // + {0xE6BF,0x7788}, // + {0xE6C0,0x78cd}, // + {0xE6C1,0x78bb}, // + {0xE6C2,0x78cf}, // + {0xE6C3,0x78cc}, // + {0xE6C4,0x78d1}, // + {0xE6C5,0x78ce}, // + {0xE6C6,0x78d4}, // + {0xE6C7,0x78c8}, // + {0xE6C8,0x78c3}, // + {0xE6C9,0x78c4}, // + {0xE6CA,0x78c9}, // + {0xE6CB,0x799a}, // + {0xE6CC,0x79a1}, // + {0xE6CD,0x79a0}, // + {0xE6CE,0x799c}, // + {0xE6CF,0x79a2}, // + {0xE6D0,0x799b}, // + {0xE6D1,0x6b76}, // + {0xE6D2,0x7a39}, // + {0xE6D3,0x7ab2}, // + {0xE6D4,0x7ab4}, // + {0xE6D5,0x7ab3}, // + {0xE6D6,0x7bb7}, // + {0xE6D7,0x7bcb}, // + {0xE6D8,0x7bbe}, // + {0xE6D9,0x7bac}, // + {0xE6DA,0x7bce}, // + {0xE6DB,0x7baf}, // + {0xE6DC,0x7bb9}, // + {0xE6DD,0x7bca}, // + {0xE6DE,0x7bb5}, // + {0xE6DF,0x7cc5}, // + {0xE6E0,0x7cc8}, // + {0xE6E1,0x7ccc}, // + {0xE6E2,0x7ccb}, // + {0xE6E3,0x7df7}, // + {0xE6E4,0x7ddb}, // + {0xE6E5,0x7dea}, // + {0xE6E6,0x7de7}, // + {0xE6E7,0x7dd7}, // + {0xE6E8,0x7de1}, // + {0xE6E9,0x7e03}, // + {0xE6EA,0x7dfa}, // + {0xE6EB,0x7de6}, // + {0xE6EC,0x7df6}, // + {0xE6ED,0x7df1}, // + {0xE6EE,0x7df0}, // + {0xE6EF,0x7dee}, // + {0xE6F0,0x7ddf}, // + {0xE6F1,0x7f76}, // + {0xE6F2,0x7fac}, // + {0xE6F3,0x7fb0}, // + {0xE6F4,0x7fad}, // + {0xE6F5,0x7fed}, // + {0xE6F6,0x7feb}, // + {0xE6F7,0x7fea}, // + {0xE6F8,0x7fec}, // + {0xE6F9,0x7fe6}, // + {0xE6FA,0x7fe8}, // + {0xE6FB,0x8064}, // + {0xE6FC,0x8067}, // + {0xE6FD,0x81a3}, // + {0xE6FE,0x819f}, // + {0xE740,0x819e}, // + {0xE741,0x8195}, // + {0xE742,0x81a2}, // + {0xE743,0x8199}, // + {0xE744,0x8197}, // + {0xE745,0x8216}, // + {0xE746,0x824f}, // + {0xE747,0x8253}, // + {0xE748,0x8252}, // + {0xE749,0x8250}, // + {0xE74A,0x824e}, // + {0xE74B,0x8251}, // + {0xE74C,0x8524}, // + {0xE74D,0x853b}, // + {0xE74E,0x850f}, // + {0xE74F,0x8500}, // + {0xE750,0x8529}, // + {0xE751,0x850e}, // + {0xE752,0x8509}, // + {0xE753,0x850d}, // + {0xE754,0x851f}, // + {0xE755,0x850a}, // + {0xE756,0x8527}, // + {0xE757,0x851c}, // + {0xE758,0x84fb}, // + {0xE759,0x852b}, // + {0xE75A,0x84fa}, // + {0xE75B,0x8508}, // + {0xE75C,0x850c}, // + {0xE75D,0x84f4}, // + {0xE75E,0x852a}, // + {0xE75F,0x84f2}, // + {0xE760,0x8515}, // + {0xE761,0x84f7}, // + {0xE762,0x84eb}, // + {0xE763,0x84f3}, // + {0xE764,0x84fc}, // + {0xE765,0x8512}, // + {0xE766,0x84ea}, // + {0xE767,0x84e9}, // + {0xE768,0x8516}, // + {0xE769,0x84fe}, // + {0xE76A,0x8528}, // + {0xE76B,0x851d}, // + {0xE76C,0x852e}, // + {0xE76D,0x8502}, // + {0xE76E,0x84fd}, // + {0xE76F,0x851e}, // + {0xE770,0x84f6}, // + {0xE771,0x8531}, // + {0xE772,0x8526}, // + {0xE773,0x84e7}, // + {0xE774,0x84e8}, // + {0xE775,0x84f0}, // + {0xE776,0x84ef}, // + {0xE777,0x84f9}, // + {0xE778,0x8518}, // + {0xE779,0x8520}, // + {0xE77A,0x8530}, // + {0xE77B,0x850b}, // + {0xE77C,0x8519}, // + {0xE77D,0x852f}, // + {0xE77E,0x8662}, // + {0xE7A1,0x8756}, // + {0xE7A2,0x8763}, // + {0xE7A3,0x8764}, // + {0xE7A4,0x8777}, // + {0xE7A5,0x87e1}, // + {0xE7A6,0x8773}, // + {0xE7A7,0x8758}, // + {0xE7A8,0x8754}, // + {0xE7A9,0x875b}, // + {0xE7AA,0x8752}, // + {0xE7AB,0x8761}, // + {0xE7AC,0x875a}, // + {0xE7AD,0x8751}, // + {0xE7AE,0x875e}, // + {0xE7AF,0x876d}, // + {0xE7B0,0x876a}, // + {0xE7B1,0x8750}, // + {0xE7B2,0x874e}, // + {0xE7B3,0x875f}, // + {0xE7B4,0x875d}, // + {0xE7B5,0x876f}, // + {0xE7B6,0x876c}, // + {0xE7B7,0x877a}, // + {0xE7B8,0x876e}, // + {0xE7B9,0x875c}, // + {0xE7BA,0x8765}, // + {0xE7BB,0x874f}, // + {0xE7BC,0x877b}, // + {0xE7BD,0x8775}, // + {0xE7BE,0x8762}, // + {0xE7BF,0x8767}, // + {0xE7C0,0x8769}, // + {0xE7C1,0x885a}, // + {0xE7C2,0x8905}, // + {0xE7C3,0x890c}, // + {0xE7C4,0x8914}, // + {0xE7C5,0x890b}, // + {0xE7C6,0x8917}, // + {0xE7C7,0x8918}, // + {0xE7C8,0x8919}, // + {0xE7C9,0x8906}, // + {0xE7CA,0x8916}, // + {0xE7CB,0x8911}, // + {0xE7CC,0x890e}, // + {0xE7CD,0x8909}, // + {0xE7CE,0x89a2}, // + {0xE7CF,0x89a4}, // + {0xE7D0,0x89a3}, // + {0xE7D1,0x89ed}, // + {0xE7D2,0x89f0}, // + {0xE7D3,0x89ec}, // + {0xE7D4,0x8acf}, // + {0xE7D5,0x8ac6}, // + {0xE7D6,0x8ab8}, // + {0xE7D7,0x8ad3}, // + {0xE7D8,0x8ad1}, // + {0xE7D9,0x8ad4}, // + {0xE7DA,0x8ad5}, // + {0xE7DB,0x8abb}, // + {0xE7DC,0x8ad7}, // + {0xE7DD,0x8abe}, // + {0xE7DE,0x8ac0}, // + {0xE7DF,0x8ac5}, // + {0xE7E0,0x8ad8}, // + {0xE7E1,0x8ac3}, // + {0xE7E2,0x8aba}, // + {0xE7E3,0x8abd}, // + {0xE7E4,0x8ad9}, // + {0xE7E5,0x8c3e}, // + {0xE7E6,0x8c4d}, // + {0xE7E7,0x8c8f}, // + {0xE7E8,0x8ce5}, // + {0xE7E9,0x8cdf}, // + {0xE7EA,0x8cd9}, // + {0xE7EB,0x8ce8}, // + {0xE7EC,0x8cda}, // + {0xE7ED,0x8cdd}, // + {0xE7EE,0x8ce7}, // + {0xE7EF,0x8da0}, // + {0xE7F0,0x8d9c}, // + {0xE7F1,0x8da1}, // + {0xE7F2,0x8d9b}, // + {0xE7F3,0x8e20}, // + {0xE7F4,0x8e23}, // + {0xE7F5,0x8e25}, // + {0xE7F6,0x8e24}, // + {0xE7F7,0x8e2e}, // + {0xE7F8,0x8e15}, // + {0xE7F9,0x8e1b}, // + {0xE7FA,0x8e16}, // + {0xE7FB,0x8e11}, // + {0xE7FC,0x8e19}, // + {0xE7FD,0x8e26}, // + {0xE7FE,0x8e27}, // + {0xE840,0x8e14}, // + {0xE841,0x8e12}, // + {0xE842,0x8e18}, // + {0xE843,0x8e13}, // + {0xE844,0x8e1c}, // + {0xE845,0x8e17}, // + {0xE846,0x8e1a}, // + {0xE847,0x8f2c}, // + {0xE848,0x8f24}, // + {0xE849,0x8f18}, // + {0xE84A,0x8f1a}, // + {0xE84B,0x8f20}, // + {0xE84C,0x8f23}, // + {0xE84D,0x8f16}, // + {0xE84E,0x8f17}, // + {0xE84F,0x9073}, // + {0xE850,0x9070}, // + {0xE851,0x906f}, // + {0xE852,0x9067}, // + {0xE853,0x906b}, // + {0xE854,0x912f}, // + {0xE855,0x912b}, // + {0xE856,0x9129}, // + {0xE857,0x912a}, // + {0xE858,0x9132}, // + {0xE859,0x9126}, // + {0xE85A,0x912e}, // + {0xE85B,0x9185}, // + {0xE85C,0x9186}, // + {0xE85D,0x918a}, // + {0xE85E,0x9181}, // + {0xE85F,0x9182}, // + {0xE860,0x9184}, // + {0xE861,0x9180}, // + {0xE862,0x92d0}, // + {0xE863,0x92c3}, // + {0xE864,0x92c4}, // + {0xE865,0x92c0}, // + {0xE866,0x92d9}, // + {0xE867,0x92b6}, // + {0xE868,0x92cf}, // + {0xE869,0x92f1}, // + {0xE86A,0x92df}, // + {0xE86B,0x92d8}, // + {0xE86C,0x92e9}, // + {0xE86D,0x92d7}, // + {0xE86E,0x92dd}, // + {0xE86F,0x92cc}, // + {0xE870,0x92ef}, // + {0xE871,0x92c2}, // + {0xE872,0x92e8}, // + {0xE873,0x92ca}, // + {0xE874,0x92c8}, // + {0xE875,0x92ce}, // + {0xE876,0x92e6}, // + {0xE877,0x92cd}, // + {0xE878,0x92d5}, // + {0xE879,0x92c9}, // + {0xE87A,0x92e0}, // + {0xE87B,0x92de}, // + {0xE87C,0x92e7}, // + {0xE87D,0x92d1}, // + {0xE87E,0x92d3}, // + {0xE8A1,0x92b5}, // + {0xE8A2,0x92e1}, // + {0xE8A3,0x92c6}, // + {0xE8A4,0x92b4}, // + {0xE8A5,0x957c}, // + {0xE8A6,0x95ac}, // + {0xE8A7,0x95ab}, // + {0xE8A8,0x95ae}, // + {0xE8A9,0x95b0}, // + {0xE8AA,0x96a4}, // + {0xE8AB,0x96a2}, // + {0xE8AC,0x96d3}, // + {0xE8AD,0x9705}, // + {0xE8AE,0x9708}, // + {0xE8AF,0x9702}, // + {0xE8B0,0x975a}, // + {0xE8B1,0x978a}, // + {0xE8B2,0x978e}, // + {0xE8B3,0x9788}, // + {0xE8B4,0x97d0}, // + {0xE8B5,0x97cf}, // + {0xE8B6,0x981e}, // + {0xE8B7,0x981d}, // + {0xE8B8,0x9826}, // + {0xE8B9,0x9829}, // + {0xE8BA,0x9828}, // + {0xE8BB,0x9820}, // + {0xE8BC,0x981b}, // + {0xE8BD,0x9827}, // + {0xE8BE,0x98b2}, // + {0xE8BF,0x9908}, // + {0xE8C0,0x98fa}, // + {0xE8C1,0x9911}, // + {0xE8C2,0x9914}, // + {0xE8C3,0x9916}, // + {0xE8C4,0x9917}, // + {0xE8C5,0x9915}, // + {0xE8C6,0x99dc}, // + {0xE8C7,0x99cd}, // + {0xE8C8,0x99cf}, // + {0xE8C9,0x99d3}, // + {0xE8CA,0x99d4}, // + {0xE8CB,0x99ce}, // + {0xE8CC,0x99c9}, // + {0xE8CD,0x99d6}, // + {0xE8CE,0x99d8}, // + {0xE8CF,0x99cb}, // + {0xE8D0,0x99d7}, // + {0xE8D1,0x99cc}, // + {0xE8D2,0x9ab3}, // + {0xE8D3,0x9aec}, // + {0xE8D4,0x9aeb}, // + {0xE8D5,0x9af3}, // + {0xE8D6,0x9af2}, // + {0xE8D7,0x9af1}, // + {0xE8D8,0x9b46}, // + {0xE8D9,0x9b43}, // + {0xE8DA,0x9b67}, // + {0xE8DB,0x9b74}, // + {0xE8DC,0x9b71}, // + {0xE8DD,0x9b66}, // + {0xE8DE,0x9b76}, // + {0xE8DF,0x9b75}, // + {0xE8E0,0x9b70}, // + {0xE8E1,0x9b68}, // + {0xE8E2,0x9b64}, // + {0xE8E3,0x9b6c}, // + {0xE8E4,0x9cfc}, // + {0xE8E5,0x9cfa}, // + {0xE8E6,0x9cfd}, // + {0xE8E7,0x9cff}, // + {0xE8E8,0x9cf7}, // + {0xE8E9,0x9d07}, // + {0xE8EA,0x9d00}, // + {0xE8EB,0x9cf9}, // + {0xE8EC,0x9cfb}, // + {0xE8ED,0x9d08}, // + {0xE8EE,0x9d05}, // + {0xE8EF,0x9d04}, // + {0xE8F0,0x9e83}, // + {0xE8F1,0x9ed3}, // + {0xE8F2,0x9f0f}, // + {0xE8F3,0x9f10}, // + {0xE8F4,0x511c}, // + {0xE8F5,0x5113}, // + {0xE8F6,0x5117}, // + {0xE8F7,0x511a}, // + {0xE8F8,0x5111}, // + {0xE8F9,0x51de}, // + {0xE8FA,0x5334}, // + {0xE8FB,0x53e1}, // + {0xE8FC,0x5670}, // + {0xE8FD,0x5660}, // + {0xE8FE,0x566e}, // + {0xE940,0x5673}, // + {0xE941,0x5666}, // + {0xE942,0x5663}, // + {0xE943,0x566d}, // + {0xE944,0x5672}, // + {0xE945,0x565e}, // + {0xE946,0x5677}, // + {0xE947,0x571c}, // + {0xE948,0x571b}, // + {0xE949,0x58c8}, // + {0xE94A,0x58bd}, // + {0xE94B,0x58c9}, // + {0xE94C,0x58bf}, // + {0xE94D,0x58ba}, // + {0xE94E,0x58c2}, // + {0xE94F,0x58bc}, // + {0xE950,0x58c6}, // + {0xE951,0x5b17}, // + {0xE952,0x5b19}, // + {0xE953,0x5b1b}, // + {0xE954,0x5b21}, // + {0xE955,0x5b14}, // + {0xE956,0x5b13}, // + {0xE957,0x5b10}, // + {0xE958,0x5b16}, // + {0xE959,0x5b28}, // + {0xE95A,0x5b1a}, // + {0xE95B,0x5b20}, // + {0xE95C,0x5b1e}, // + {0xE95D,0x5bef}, // + {0xE95E,0x5dac}, // + {0xE95F,0x5db1}, // + {0xE960,0x5da9}, // + {0xE961,0x5da7}, // + {0xE962,0x5db5}, // + {0xE963,0x5db0}, // + {0xE964,0x5dae}, // + {0xE965,0x5daa}, // + {0xE966,0x5da8}, // + {0xE967,0x5db2}, // + {0xE968,0x5dad}, // + {0xE969,0x5daf}, // + {0xE96A,0x5db4}, // + {0xE96B,0x5e67}, // + {0xE96C,0x5e68}, // + {0xE96D,0x5e66}, // + {0xE96E,0x5e6f}, // + {0xE96F,0x5ee9}, // + {0xE970,0x5ee7}, // + {0xE971,0x5ee6}, // + {0xE972,0x5ee8}, // + {0xE973,0x5ee5}, // + {0xE974,0x5f4b}, // + {0xE975,0x5fbc}, // + {0xE976,0x619d}, // + {0xE977,0x61a8}, // + {0xE978,0x6196}, // + {0xE979,0x61c5}, // + {0xE97A,0x61b4}, // + {0xE97B,0x61c6}, // + {0xE97C,0x61c1}, // + {0xE97D,0x61cc}, // + {0xE97E,0x61ba}, // + {0xE9A1,0x61bf}, // + {0xE9A2,0x61b8}, // + {0xE9A3,0x618c}, // + {0xE9A4,0x64d7}, // + {0xE9A5,0x64d6}, // + {0xE9A6,0x64d0}, // + {0xE9A7,0x64cf}, // + {0xE9A8,0x64c9}, // + {0xE9A9,0x64bd}, // + {0xE9AA,0x6489}, // + {0xE9AB,0x64c3}, // + {0xE9AC,0x64db}, // + {0xE9AD,0x64f3}, // + {0xE9AE,0x64d9}, // + {0xE9AF,0x6533}, // + {0xE9B0,0x657f}, // + {0xE9B1,0x657c}, // + {0xE9B2,0x65a2}, // + {0xE9B3,0x66c8}, // + {0xE9B4,0x66be}, // + {0xE9B5,0x66c0}, // + {0xE9B6,0x66ca}, // + {0xE9B7,0x66cb}, // + {0xE9B8,0x66cf}, // + {0xE9B9,0x66bd}, // + {0xE9BA,0x66bb}, // + {0xE9BB,0x66ba}, // + {0xE9BC,0x66cc}, // + {0xE9BD,0x6723}, // + {0xE9BE,0x6a34}, // + {0xE9BF,0x6a66}, // + {0xE9C0,0x6a49}, // + {0xE9C1,0x6a67}, // + {0xE9C2,0x6a32}, // + {0xE9C3,0x6a68}, // + {0xE9C4,0x6a3e}, // + {0xE9C5,0x6a5d}, // + {0xE9C6,0x6a6d}, // + {0xE9C7,0x6a76}, // + {0xE9C8,0x6a5b}, // + {0xE9C9,0x6a51}, // + {0xE9CA,0x6a28}, // + {0xE9CB,0x6a5a}, // + {0xE9CC,0x6a3b}, // + {0xE9CD,0x6a3f}, // + {0xE9CE,0x6a41}, // + {0xE9CF,0x6a6a}, // + {0xE9D0,0x6a64}, // + {0xE9D1,0x6a50}, // + {0xE9D2,0x6a4f}, // + {0xE9D3,0x6a54}, // + {0xE9D4,0x6a6f}, // + {0xE9D5,0x6a69}, // + {0xE9D6,0x6a60}, // + {0xE9D7,0x6a3c}, // + {0xE9D8,0x6a5e}, // + {0xE9D9,0x6a56}, // + {0xE9DA,0x6a55}, // + {0xE9DB,0x6a4d}, // + {0xE9DC,0x6a4e}, // + {0xE9DD,0x6a46}, // + {0xE9DE,0x6b55}, // + {0xE9DF,0x6b54}, // + {0xE9E0,0x6b56}, // + {0xE9E1,0x6ba7}, // + {0xE9E2,0x6baa}, // + {0xE9E3,0x6bab}, // + {0xE9E4,0x6bc8}, // + {0xE9E5,0x6bc7}, // + {0xE9E6,0x6c04}, // + {0xE9E7,0x6c03}, // + {0xE9E8,0x6c06}, // + {0xE9E9,0x6fad}, // + {0xE9EA,0x6fcb}, // + {0xE9EB,0x6fa3}, // + {0xE9EC,0x6fc7}, // + {0xE9ED,0x6fbc}, // + {0xE9EE,0x6fce}, // + {0xE9EF,0x6fc8}, // + {0xE9F0,0x6f5e}, // + {0xE9F1,0x6fc4}, // + {0xE9F2,0x6fbd}, // + {0xE9F3,0x6f9e}, // + {0xE9F4,0x6fca}, // + {0xE9F5,0x6fa8}, // + {0xE9F6,0x7004}, // + {0xE9F7,0x6fa5}, // + {0xE9F8,0x6fae}, // + {0xE9F9,0x6fba}, // + {0xE9FA,0x6fac}, // + {0xE9FB,0x6faa}, // + {0xE9FC,0x6fcf}, // + {0xE9FD,0x6fbf}, // + {0xE9FE,0x6fb8}, // + {0xEA40,0x6fa2}, // + {0xEA41,0x6fc9}, // + {0xEA42,0x6fab}, // + {0xEA43,0x6fcd}, // + {0xEA44,0x6faf}, // + {0xEA45,0x6fb2}, // + {0xEA46,0x6fb0}, // + {0xEA47,0x71c5}, // + {0xEA48,0x71c2}, // + {0xEA49,0x71bf}, // + {0xEA4A,0x71b8}, // + {0xEA4B,0x71d6}, // + {0xEA4C,0x71c0}, // + {0xEA4D,0x71c1}, // + {0xEA4E,0x71cb}, // + {0xEA4F,0x71d4}, // + {0xEA50,0x71ca}, // + {0xEA51,0x71c7}, // + {0xEA52,0x71cf}, // + {0xEA53,0x71bd}, // + {0xEA54,0x71d8}, // + {0xEA55,0x71bc}, // + {0xEA56,0x71c6}, // + {0xEA57,0x71da}, // + {0xEA58,0x71db}, // + {0xEA59,0x729d}, // + {0xEA5A,0x729e}, // + {0xEA5B,0x7369}, // + {0xEA5C,0x7366}, // + {0xEA5D,0x7367}, // + {0xEA5E,0x736c}, // + {0xEA5F,0x7365}, // + {0xEA60,0x736b}, // + {0xEA61,0x736a}, // + {0xEA62,0x747f}, // + {0xEA63,0x749a}, // + {0xEA64,0x74a0}, // + {0xEA65,0x7494}, // + {0xEA66,0x7492}, // + {0xEA67,0x7495}, // + {0xEA68,0x74a1}, // + {0xEA69,0x750b}, // + {0xEA6A,0x7580}, // + {0xEA6B,0x762f}, // + {0xEA6C,0x762d}, // + {0xEA6D,0x7631}, // + {0xEA6E,0x763d}, // + {0xEA6F,0x7633}, // + {0xEA70,0x763c}, // + {0xEA71,0x7635}, // + {0xEA72,0x7632}, // + {0xEA73,0x7630}, // + {0xEA74,0x76bb}, // + {0xEA75,0x76e6}, // + {0xEA76,0x779a}, // + {0xEA77,0x779d}, // + {0xEA78,0x77a1}, // + {0xEA79,0x779c}, // + {0xEA7A,0x779b}, // + {0xEA7B,0x77a2}, // + {0xEA7C,0x77a3}, // + {0xEA7D,0x7795}, // + {0xEA7E,0x7799}, // + {0xEAA1,0x7797}, // + {0xEAA2,0x78dd}, // + {0xEAA3,0x78e9}, // + {0xEAA4,0x78e5}, // + {0xEAA5,0x78ea}, // + {0xEAA6,0x78de}, // + {0xEAA7,0x78e3}, // + {0xEAA8,0x78db}, // + {0xEAA9,0x78e1}, // + {0xEAAA,0x78e2}, // + {0xEAAB,0x78ed}, // + {0xEAAC,0x78df}, // + {0xEAAD,0x78e0}, // + {0xEAAE,0x79a4}, // + {0xEAAF,0x7a44}, // + {0xEAB0,0x7a48}, // + {0xEAB1,0x7a47}, // + {0xEAB2,0x7ab6}, // + {0xEAB3,0x7ab8}, // + {0xEAB4,0x7ab5}, // + {0xEAB5,0x7ab1}, // + {0xEAB6,0x7ab7}, // + {0xEAB7,0x7bde}, // + {0xEAB8,0x7be3}, // + {0xEAB9,0x7be7}, // + {0xEABA,0x7bdd}, // + {0xEABB,0x7bd5}, // + {0xEABC,0x7be5}, // + {0xEABD,0x7bda}, // + {0xEABE,0x7be8}, // + {0xEABF,0x7bf9}, // + {0xEAC0,0x7bd4}, // + {0xEAC1,0x7bea}, // + {0xEAC2,0x7be2}, // + {0xEAC3,0x7bdc}, // + {0xEAC4,0x7beb}, // + {0xEAC5,0x7bd8}, // + {0xEAC6,0x7bdf}, // + {0xEAC7,0x7cd2}, // + {0xEAC8,0x7cd4}, // + {0xEAC9,0x7cd7}, // + {0xEACA,0x7cd0}, // + {0xEACB,0x7cd1}, // + {0xEACC,0x7e12}, // + {0xEACD,0x7e21}, // + {0xEACE,0x7e17}, // + {0xEACF,0x7e0c}, // + {0xEAD0,0x7e1f}, // + {0xEAD1,0x7e20}, // + {0xEAD2,0x7e13}, // + {0xEAD3,0x7e0e}, // + {0xEAD4,0x7e1c}, // + {0xEAD5,0x7e15}, // + {0xEAD6,0x7e1a}, // + {0xEAD7,0x7e22}, // + {0xEAD8,0x7e0b}, // + {0xEAD9,0x7e0f}, // + {0xEADA,0x7e16}, // + {0xEADB,0x7e0d}, // + {0xEADC,0x7e14}, // + {0xEADD,0x7e25}, // + {0xEADE,0x7e24}, // + {0xEADF,0x7f43}, // + {0xEAE0,0x7f7b}, // + {0xEAE1,0x7f7c}, // + {0xEAE2,0x7f7a}, // + {0xEAE3,0x7fb1}, // + {0xEAE4,0x7fef}, // + {0xEAE5,0x802a}, // + {0xEAE6,0x8029}, // + {0xEAE7,0x806c}, // + {0xEAE8,0x81b1}, // + {0xEAE9,0x81a6}, // + {0xEAEA,0x81ae}, // + {0xEAEB,0x81b9}, // + {0xEAEC,0x81b5}, // + {0xEAED,0x81ab}, // + {0xEAEE,0x81b0}, // + {0xEAEF,0x81ac}, // + {0xEAF0,0x81b4}, // + {0xEAF1,0x81b2}, // + {0xEAF2,0x81b7}, // + {0xEAF3,0x81a7}, // + {0xEAF4,0x81f2}, // + {0xEAF5,0x8255}, // + {0xEAF6,0x8256}, // + {0xEAF7,0x8257}, // + {0xEAF8,0x8556}, // + {0xEAF9,0x8545}, // + {0xEAFA,0x856b}, // + {0xEAFB,0x854d}, // + {0xEAFC,0x8553}, // + {0xEAFD,0x8561}, // + {0xEAFE,0x8558}, // + {0xEB40,0x8540}, // + {0xEB41,0x8546}, // + {0xEB42,0x8564}, // + {0xEB43,0x8541}, // + {0xEB44,0x8562}, // + {0xEB45,0x8544}, // + {0xEB46,0x8551}, // + {0xEB47,0x8547}, // + {0xEB48,0x8563}, // + {0xEB49,0x853e}, // + {0xEB4A,0x855b}, // + {0xEB4B,0x8571}, // + {0xEB4C,0x854e}, // + {0xEB4D,0x856e}, // + {0xEB4E,0x8575}, // + {0xEB4F,0x8555}, // + {0xEB50,0x8567}, // + {0xEB51,0x8560}, // + {0xEB52,0x858c}, // + {0xEB53,0x8566}, // + {0xEB54,0x855d}, // + {0xEB55,0x8554}, // + {0xEB56,0x8565}, // + {0xEB57,0x856c}, // + {0xEB58,0x8663}, // + {0xEB59,0x8665}, // + {0xEB5A,0x8664}, // + {0xEB5B,0x879b}, // + {0xEB5C,0x878f}, // + {0xEB5D,0x8797}, // + {0xEB5E,0x8793}, // + {0xEB5F,0x8792}, // + {0xEB60,0x8788}, // + {0xEB61,0x8781}, // + {0xEB62,0x8796}, // + {0xEB63,0x8798}, // + {0xEB64,0x8779}, // + {0xEB65,0x8787}, // + {0xEB66,0x87a3}, // + {0xEB67,0x8785}, // + {0xEB68,0x8790}, // + {0xEB69,0x8791}, // + {0xEB6A,0x879d}, // + {0xEB6B,0x8784}, // + {0xEB6C,0x8794}, // + {0xEB6D,0x879c}, // + {0xEB6E,0x879a}, // + {0xEB6F,0x8789}, // + {0xEB70,0x891e}, // + {0xEB71,0x8926}, // + {0xEB72,0x8930}, // + {0xEB73,0x892d}, // + {0xEB74,0x892e}, // + {0xEB75,0x8927}, // + {0xEB76,0x8931}, // + {0xEB77,0x8922}, // + {0xEB78,0x8929}, // + {0xEB79,0x8923}, // + {0xEB7A,0x892f}, // + {0xEB7B,0x892c}, // + {0xEB7C,0x891f}, // + {0xEB7D,0x89f1}, // + {0xEB7E,0x8ae0}, // + {0xEBA1,0x8ae2}, // + {0xEBA2,0x8af2}, // + {0xEBA3,0x8af4}, // + {0xEBA4,0x8af5}, // + {0xEBA5,0x8add}, // + {0xEBA6,0x8b14}, // + {0xEBA7,0x8ae4}, // + {0xEBA8,0x8adf}, // + {0xEBA9,0x8af0}, // + {0xEBAA,0x8ac8}, // + {0xEBAB,0x8ade}, // + {0xEBAC,0x8ae1}, // + {0xEBAD,0x8ae8}, // + {0xEBAE,0x8aff}, // + {0xEBAF,0x8aef}, // + {0xEBB0,0x8afb}, // + {0xEBB1,0x8c91}, // + {0xEBB2,0x8c92}, // + {0xEBB3,0x8c90}, // + {0xEBB4,0x8cf5}, // + {0xEBB5,0x8cee}, // + {0xEBB6,0x8cf1}, // + {0xEBB7,0x8cf0}, // + {0xEBB8,0x8cf3}, // + {0xEBB9,0x8d6c}, // + {0xEBBA,0x8d6e}, // + {0xEBBB,0x8da5}, // + {0xEBBC,0x8da7}, // + {0xEBBD,0x8e33}, // + {0xEBBE,0x8e3e}, // + {0xEBBF,0x8e38}, // + {0xEBC0,0x8e40}, // + {0xEBC1,0x8e45}, // + {0xEBC2,0x8e36}, // + {0xEBC3,0x8e3c}, // + {0xEBC4,0x8e3d}, // + {0xEBC5,0x8e41}, // + {0xEBC6,0x8e30}, // + {0xEBC7,0x8e3f}, // + {0xEBC8,0x8ebd}, // + {0xEBC9,0x8f36}, // + {0xEBCA,0x8f2e}, // + {0xEBCB,0x8f35}, // + {0xEBCC,0x8f32}, // + {0xEBCD,0x8f39}, // + {0xEBCE,0x8f37}, // + {0xEBCF,0x8f34}, // + {0xEBD0,0x9076}, // + {0xEBD1,0x9079}, // + {0xEBD2,0x907b}, // + {0xEBD3,0x9086}, // + {0xEBD4,0x90fa}, // + {0xEBD5,0x9133}, // + {0xEBD6,0x9135}, // + {0xEBD7,0x9136}, // + {0xEBD8,0x9193}, // + {0xEBD9,0x9190}, // + {0xEBDA,0x9191}, // + {0xEBDB,0x918d}, // + {0xEBDC,0x918f}, // + {0xEBDD,0x9327}, // + {0xEBDE,0x931e}, // + {0xEBDF,0x9308}, // + {0xEBE0,0x931f}, // + {0xEBE1,0x9306}, // + {0xEBE2,0x930f}, // + {0xEBE3,0x937a}, // + {0xEBE4,0x9338}, // + {0xEBE5,0x933c}, // + {0xEBE6,0x931b}, // + {0xEBE7,0x9323}, // + {0xEBE8,0x9312}, // + {0xEBE9,0x9301}, // + {0xEBEA,0x9346}, // + {0xEBEB,0x932d}, // + {0xEBEC,0x930e}, // + {0xEBED,0x930d}, // + {0xEBEE,0x92cb}, // + {0xEBEF,0x931d}, // + {0xEBF0,0x92fa}, // + {0xEBF1,0x9325}, // + {0xEBF2,0x9313}, // + {0xEBF3,0x92f9}, // + {0xEBF4,0x92f7}, // + {0xEBF5,0x9334}, // + {0xEBF6,0x9302}, // + {0xEBF7,0x9324}, // + {0xEBF8,0x92ff}, // + {0xEBF9,0x9329}, // + {0xEBFA,0x9339}, // + {0xEBFB,0x9335}, // + {0xEBFC,0x932a}, // + {0xEBFD,0x9314}, // + {0xEBFE,0x930c}, // + {0xEC40,0x930b}, // + {0xEC41,0x92fe}, // + {0xEC42,0x9309}, // + {0xEC43,0x9300}, // + {0xEC44,0x92fb}, // + {0xEC45,0x9316}, // + {0xEC46,0x95bc}, // + {0xEC47,0x95cd}, // + {0xEC48,0x95be}, // + {0xEC49,0x95b9}, // + {0xEC4A,0x95ba}, // + {0xEC4B,0x95b6}, // + {0xEC4C,0x95bf}, // + {0xEC4D,0x95b5}, // + {0xEC4E,0x95bd}, // + {0xEC4F,0x96a9}, // + {0xEC50,0x96d4}, // + {0xEC51,0x970b}, // + {0xEC52,0x9712}, // + {0xEC53,0x9710}, // + {0xEC54,0x9799}, // + {0xEC55,0x9797}, // + {0xEC56,0x9794}, // + {0xEC57,0x97f0}, // + {0xEC58,0x97f8}, // + {0xEC59,0x9835}, // + {0xEC5A,0x982f}, // + {0xEC5B,0x9832}, // + {0xEC5C,0x9924}, // + {0xEC5D,0x991f}, // + {0xEC5E,0x9927}, // + {0xEC5F,0x9929}, // + {0xEC60,0x999e}, // + {0xEC61,0x99ee}, // + {0xEC62,0x99ec}, // + {0xEC63,0x99e5}, // + {0xEC64,0x99e4}, // + {0xEC65,0x99f0}, // + {0xEC66,0x99e3}, // + {0xEC67,0x99ea}, // + {0xEC68,0x99e9}, // + {0xEC69,0x99e7}, // + {0xEC6A,0x9ab9}, // + {0xEC6B,0x9abf}, // + {0xEC6C,0x9ab4}, // + {0xEC6D,0x9abb}, // + {0xEC6E,0x9af6}, // + {0xEC6F,0x9afa}, // + {0xEC70,0x9af9}, // + {0xEC71,0x9af7}, // + {0xEC72,0x9b33}, // + {0xEC73,0x9b80}, // + {0xEC74,0x9b85}, // + {0xEC75,0x9b87}, // + {0xEC76,0x9b7c}, // + {0xEC77,0x9b7e}, // + {0xEC78,0x9b7b}, // + {0xEC79,0x9b82}, // + {0xEC7A,0x9b93}, // + {0xEC7B,0x9b92}, // + {0xEC7C,0x9b90}, // + {0xEC7D,0x9b7a}, // + {0xEC7E,0x9b95}, // + {0xECA1,0x9b7d}, // + {0xECA2,0x9b88}, // + {0xECA3,0x9d25}, // + {0xECA4,0x9d17}, // + {0xECA5,0x9d20}, // + {0xECA6,0x9d1e}, // + {0xECA7,0x9d14}, // + {0xECA8,0x9d29}, // + {0xECA9,0x9d1d}, // + {0xECAA,0x9d18}, // + {0xECAB,0x9d22}, // + {0xECAC,0x9d10}, // + {0xECAD,0x9d19}, // + {0xECAE,0x9d1f}, // + {0xECAF,0x9e88}, // + {0xECB0,0x9e86}, // + {0xECB1,0x9e87}, // + {0xECB2,0x9eae}, // + {0xECB3,0x9ead}, // + {0xECB4,0x9ed5}, // + {0xECB5,0x9ed6}, // + {0xECB6,0x9efa}, // + {0xECB7,0x9f12}, // + {0xECB8,0x9f3d}, // + {0xECB9,0x5126}, // + {0xECBA,0x5125}, // + {0xECBB,0x5122}, // + {0xECBC,0x5124}, // + {0xECBD,0x5120}, // + {0xECBE,0x5129}, // + {0xECBF,0x52f4}, // + {0xECC0,0x5693}, // + {0xECC1,0x568c}, // + {0xECC2,0x568d}, // + {0xECC3,0x5686}, // + {0xECC4,0x5684}, // + {0xECC5,0x5683}, // + {0xECC6,0x567e}, // + {0xECC7,0x5682}, // + {0xECC8,0x567f}, // + {0xECC9,0x5681}, // + {0xECCA,0x58d6}, // + {0xECCB,0x58d4}, // + {0xECCC,0x58cf}, // + {0xECCD,0x58d2}, // + {0xECCE,0x5b2d}, // + {0xECCF,0x5b25}, // + {0xECD0,0x5b32}, // + {0xECD1,0x5b23}, // + {0xECD2,0x5b2c}, // + {0xECD3,0x5b27}, // + {0xECD4,0x5b26}, // + {0xECD5,0x5b2f}, // + {0xECD6,0x5b2e}, // + {0xECD7,0x5b7b}, // + {0xECD8,0x5bf1}, // + {0xECD9,0x5bf2}, // + {0xECDA,0x5db7}, // + {0xECDB,0x5e6c}, // + {0xECDC,0x5e6a}, // + {0xECDD,0x5fbe}, // + {0xECDE,0x5fbb}, // + {0xECDF,0x61c3}, // + {0xECE0,0x61b5}, // + {0xECE1,0x61bc}, // + {0xECE2,0x61e7}, // + {0xECE3,0x61e0}, // + {0xECE4,0x61e5}, // + {0xECE5,0x61e4}, // + {0xECE6,0x61e8}, // + {0xECE7,0x61de}, // + {0xECE8,0x64ef}, // + {0xECE9,0x64e9}, // + {0xECEA,0x64e3}, // + {0xECEB,0x64eb}, // + {0xECEC,0x64e4}, // + {0xECED,0x64e8}, // + {0xECEE,0x6581}, // + {0xECEF,0x6580}, // + {0xECF0,0x65b6}, // + {0xECF1,0x65da}, // + {0xECF2,0x66d2}, // + {0xECF3,0x6a8d}, // + {0xECF4,0x6a96}, // + {0xECF5,0x6a81}, // + {0xECF6,0x6aa5}, // + {0xECF7,0x6a89}, // + {0xECF8,0x6a9f}, // + {0xECF9,0x6a9b}, // + {0xECFA,0x6aa1}, // + {0xECFB,0x6a9e}, // + {0xECFC,0x6a87}, // + {0xECFD,0x6a93}, // + {0xECFE,0x6a8e}, // + {0xED40,0x6a95}, // + {0xED41,0x6a83}, // + {0xED42,0x6aa8}, // + {0xED43,0x6aa4}, // + {0xED44,0x6a91}, // + {0xED45,0x6a7f}, // + {0xED46,0x6aa6}, // + {0xED47,0x6a9a}, // + {0xED48,0x6a85}, // + {0xED49,0x6a8c}, // + {0xED4A,0x6a92}, // + {0xED4B,0x6b5b}, // + {0xED4C,0x6bad}, // + {0xED4D,0x6c09}, // + {0xED4E,0x6fcc}, // + {0xED4F,0x6fa9}, // + {0xED50,0x6ff4}, // + {0xED51,0x6fd4}, // + {0xED52,0x6fe3}, // + {0xED53,0x6fdc}, // + {0xED54,0x6fed}, // + {0xED55,0x6fe7}, // + {0xED56,0x6fe6}, // + {0xED57,0x6fde}, // + {0xED58,0x6ff2}, // + {0xED59,0x6fdd}, // + {0xED5A,0x6fe2}, // + {0xED5B,0x6fe8}, // + {0xED5C,0x71e1}, // + {0xED5D,0x71f1}, // + {0xED5E,0x71e8}, // + {0xED5F,0x71f2}, // + {0xED60,0x71e4}, // + {0xED61,0x71f0}, // + {0xED62,0x71e2}, // + {0xED63,0x7373}, // + {0xED64,0x736e}, // + {0xED65,0x736f}, // + {0xED66,0x7497}, // + {0xED67,0x74b2}, // + {0xED68,0x74ab}, // + {0xED69,0x7490}, // + {0xED6A,0x74aa}, // + {0xED6B,0x74ad}, // + {0xED6C,0x74b1}, // + {0xED6D,0x74a5}, // + {0xED6E,0x74af}, // + {0xED6F,0x7510}, // + {0xED70,0x7511}, // + {0xED71,0x7512}, // + {0xED72,0x750f}, // + {0xED73,0x7584}, // + {0xED74,0x7643}, // + {0xED75,0x7648}, // + {0xED76,0x7649}, // + {0xED77,0x7647}, // + {0xED78,0x76a4}, // + {0xED79,0x76e9}, // + {0xED7A,0x77b5}, // + {0xED7B,0x77ab}, // + {0xED7C,0x77b2}, // + {0xED7D,0x77b7}, // + {0xED7E,0x77b6}, // + {0xEDA1,0x77b4}, // + {0xEDA2,0x77b1}, // + {0xEDA3,0x77a8}, // + {0xEDA4,0x77f0}, // + {0xEDA5,0x78f3}, // + {0xEDA6,0x78fd}, // + {0xEDA7,0x7902}, // + {0xEDA8,0x78fb}, // + {0xEDA9,0x78fc}, // + {0xEDAA,0x78f2}, // + {0xEDAB,0x7905}, // + {0xEDAC,0x78f9}, // + {0xEDAD,0x78fe}, // + {0xEDAE,0x7904}, // + {0xEDAF,0x79ab}, // + {0xEDB0,0x79a8}, // + {0xEDB1,0x7a5c}, // + {0xEDB2,0x7a5b}, // + {0xEDB3,0x7a56}, // + {0xEDB4,0x7a58}, // + {0xEDB5,0x7a54}, // + {0xEDB6,0x7a5a}, // + {0xEDB7,0x7abe}, // + {0xEDB8,0x7ac0}, // + {0xEDB9,0x7ac1}, // + {0xEDBA,0x7c05}, // + {0xEDBB,0x7c0f}, // + {0xEDBC,0x7bf2}, // + {0xEDBD,0x7c00}, // + {0xEDBE,0x7bff}, // + {0xEDBF,0x7bfb}, // + {0xEDC0,0x7c0e}, // + {0xEDC1,0x7bf4}, // + {0xEDC2,0x7c0b}, // + {0xEDC3,0x7bf3}, // + {0xEDC4,0x7c02}, // + {0xEDC5,0x7c09}, // + {0xEDC6,0x7c03}, // + {0xEDC7,0x7c01}, // + {0xEDC8,0x7bf8}, // + {0xEDC9,0x7bfd}, // + {0xEDCA,0x7c06}, // + {0xEDCB,0x7bf0}, // + {0xEDCC,0x7bf1}, // + {0xEDCD,0x7c10}, // + {0xEDCE,0x7c0a}, // + {0xEDCF,0x7ce8}, // + {0xEDD0,0x7e2d}, // + {0xEDD1,0x7e3c}, // + {0xEDD2,0x7e42}, // + {0xEDD3,0x7e33}, // + {0xEDD4,0x9848}, // + {0xEDD5,0x7e38}, // + {0xEDD6,0x7e2a}, // + {0xEDD7,0x7e49}, // + {0xEDD8,0x7e40}, // + {0xEDD9,0x7e47}, // + {0xEDDA,0x7e29}, // + {0xEDDB,0x7e4c}, // + {0xEDDC,0x7e30}, // + {0xEDDD,0x7e3b}, // + {0xEDDE,0x7e36}, // + {0xEDDF,0x7e44}, // + {0xEDE0,0x7e3a}, // + {0xEDE1,0x7f45}, // + {0xEDE2,0x7f7f}, // + {0xEDE3,0x7f7e}, // + {0xEDE4,0x7f7d}, // + {0xEDE5,0x7ff4}, // + {0xEDE6,0x7ff2}, // + {0xEDE7,0x802c}, // + {0xEDE8,0x81bb}, // + {0xEDE9,0x81c4}, // + {0xEDEA,0x81cc}, // + {0xEDEB,0x81ca}, // + {0xEDEC,0x81c5}, // + {0xEDED,0x81c7}, // + {0xEDEE,0x81bc}, // + {0xEDEF,0x81e9}, // + {0xEDF0,0x825b}, // + {0xEDF1,0x825a}, // + {0xEDF2,0x825c}, // + {0xEDF3,0x8583}, // + {0xEDF4,0x8580}, // + {0xEDF5,0x858f}, // + {0xEDF6,0x85a7}, // + {0xEDF7,0x8595}, // + {0xEDF8,0x85a0}, // + {0xEDF9,0x858b}, // + {0xEDFA,0x85a3}, // + {0xEDFB,0x857b}, // + {0xEDFC,0x85a4}, // + {0xEDFD,0x859a}, // + {0xEDFE,0x859e}, // + {0xEE40,0x8577}, // + {0xEE41,0x857c}, // + {0xEE42,0x8589}, // + {0xEE43,0x85a1}, // + {0xEE44,0x857a}, // + {0xEE45,0x8578}, // + {0xEE46,0x8557}, // + {0xEE47,0x858e}, // + {0xEE48,0x8596}, // + {0xEE49,0x8586}, // + {0xEE4A,0x858d}, // + {0xEE4B,0x8599}, // + {0xEE4C,0x859d}, // + {0xEE4D,0x8581}, // + {0xEE4E,0x85a2}, // + {0xEE4F,0x8582}, // + {0xEE50,0x8588}, // + {0xEE51,0x8585}, // + {0xEE52,0x8579}, // + {0xEE53,0x8576}, // + {0xEE54,0x8598}, // + {0xEE55,0x8590}, // + {0xEE56,0x859f}, // + {0xEE57,0x8668}, // + {0xEE58,0x87be}, // + {0xEE59,0x87aa}, // + {0xEE5A,0x87ad}, // + {0xEE5B,0x87c5}, // + {0xEE5C,0x87b0}, // + {0xEE5D,0x87ac}, // + {0xEE5E,0x87b9}, // + {0xEE5F,0x87b5}, // + {0xEE60,0x87bc}, // + {0xEE61,0x87ae}, // + {0xEE62,0x87c9}, // + {0xEE63,0x87c3}, // + {0xEE64,0x87c2}, // + {0xEE65,0x87cc}, // + {0xEE66,0x87b7}, // + {0xEE67,0x87af}, // + {0xEE68,0x87c4}, // + {0xEE69,0x87ca}, // + {0xEE6A,0x87b4}, // + {0xEE6B,0x87b6}, // + {0xEE6C,0x87bf}, // + {0xEE6D,0x87b8}, // + {0xEE6E,0x87bd}, // + {0xEE6F,0x87de}, // + {0xEE70,0x87b2}, // + {0xEE71,0x8935}, // + {0xEE72,0x8933}, // + {0xEE73,0x893c}, // + {0xEE74,0x893e}, // + {0xEE75,0x8941}, // + {0xEE76,0x8952}, // + {0xEE77,0x8937}, // + {0xEE78,0x8942}, // + {0xEE79,0x89ad}, // + {0xEE7A,0x89af}, // + {0xEE7B,0x89ae}, // + {0xEE7C,0x89f2}, // + {0xEE7D,0x89f3}, // + {0xEE7E,0x8b1e}, // + {0xEEA1,0x8b18}, // + {0xEEA2,0x8b16}, // + {0xEEA3,0x8b11}, // + {0xEEA4,0x8b05}, // + {0xEEA5,0x8b0b}, // + {0xEEA6,0x8b22}, // + {0xEEA7,0x8b0f}, // + {0xEEA8,0x8b12}, // + {0xEEA9,0x8b15}, // + {0xEEAA,0x8b07}, // + {0xEEAB,0x8b0d}, // + {0xEEAC,0x8b08}, // + {0xEEAD,0x8b06}, // + {0xEEAE,0x8b1c}, // + {0xEEAF,0x8b13}, // + {0xEEB0,0x8b1a}, // + {0xEEB1,0x8c4f}, // + {0xEEB2,0x8c70}, // + {0xEEB3,0x8c72}, // + {0xEEB4,0x8c71}, // + {0xEEB5,0x8c6f}, // + {0xEEB6,0x8c95}, // + {0xEEB7,0x8c94}, // + {0xEEB8,0x8cf9}, // + {0xEEB9,0x8d6f}, // + {0xEEBA,0x8e4e}, // + {0xEEBB,0x8e4d}, // + {0xEEBC,0x8e53}, // + {0xEEBD,0x8e50}, // + {0xEEBE,0x8e4c}, // + {0xEEBF,0x8e47}, // + {0xEEC0,0x8f43}, // + {0xEEC1,0x8f40}, // + {0xEEC2,0x9085}, // + {0xEEC3,0x907e}, // + {0xEEC4,0x9138}, // + {0xEEC5,0x919a}, // + {0xEEC6,0x91a2}, // + {0xEEC7,0x919b}, // + {0xEEC8,0x9199}, // + {0xEEC9,0x919f}, // + {0xEECA,0x91a1}, // + {0xEECB,0x919d}, // + {0xEECC,0x91a0}, // + {0xEECD,0x93a1}, // + {0xEECE,0x9383}, // + {0xEECF,0x93af}, // + {0xEED0,0x9364}, // + {0xEED1,0x9356}, // + {0xEED2,0x9347}, // + {0xEED3,0x937c}, // + {0xEED4,0x9358}, // + {0xEED5,0x935c}, // + {0xEED6,0x9376}, // + {0xEED7,0x9349}, // + {0xEED8,0x9350}, // + {0xEED9,0x9351}, // + {0xEEDA,0x9360}, // + {0xEEDB,0x936d}, // + {0xEEDC,0x938f}, // + {0xEEDD,0x934c}, // + {0xEEDE,0x936a}, // + {0xEEDF,0x9379}, // + {0xEEE0,0x9357}, // + {0xEEE1,0x9355}, // + {0xEEE2,0x9352}, // + {0xEEE3,0x934f}, // + {0xEEE4,0x9371}, // + {0xEEE5,0x9377}, // + {0xEEE6,0x937b}, // + {0xEEE7,0x9361}, // + {0xEEE8,0x935e}, // + {0xEEE9,0x9363}, // + {0xEEEA,0x9367}, // + {0xEEEB,0x9380}, // + {0xEEEC,0x934e}, // + {0xEEED,0x9359}, // + {0xEEEE,0x95c7}, // + {0xEEEF,0x95c0}, // + {0xEEF0,0x95c9}, // + {0xEEF1,0x95c3}, // + {0xEEF2,0x95c5}, // + {0xEEF3,0x95b7}, // + {0xEEF4,0x96ae}, // + {0xEEF5,0x96b0}, // + {0xEEF6,0x96ac}, // + {0xEEF7,0x9720}, // + {0xEEF8,0x971f}, // + {0xEEF9,0x9718}, // + {0xEEFA,0x971d}, // + {0xEEFB,0x9719}, // + {0xEEFC,0x979a}, // + {0xEEFD,0x97a1}, // + {0xEEFE,0x979c}, // + {0xEF40,0x979e}, // + {0xEF41,0x979d}, // + {0xEF42,0x97d5}, // + {0xEF43,0x97d4}, // + {0xEF44,0x97f1}, // + {0xEF45,0x9841}, // + {0xEF46,0x9844}, // + {0xEF47,0x984a}, // + {0xEF48,0x9849}, // + {0xEF49,0x9845}, // + {0xEF4A,0x9843}, // + {0xEF4B,0x9925}, // + {0xEF4C,0x992b}, // + {0xEF4D,0x992c}, // + {0xEF4E,0x992a}, // + {0xEF4F,0x9933}, // + {0xEF50,0x9932}, // + {0xEF51,0x992f}, // + {0xEF52,0x992d}, // + {0xEF53,0x9931}, // + {0xEF54,0x9930}, // + {0xEF55,0x9998}, // + {0xEF56,0x99a3}, // + {0xEF57,0x99a1}, // + {0xEF58,0x9a02}, // + {0xEF59,0x99fa}, // + {0xEF5A,0x99f4}, // + {0xEF5B,0x99f7}, // + {0xEF5C,0x99f9}, // + {0xEF5D,0x99f8}, // + {0xEF5E,0x99f6}, // + {0xEF5F,0x99fb}, // + {0xEF60,0x99fd}, // + {0xEF61,0x99fe}, // + {0xEF62,0x99fc}, // + {0xEF63,0x9a03}, // + {0xEF64,0x9abe}, // + {0xEF65,0x9afe}, // + {0xEF66,0x9afd}, // + {0xEF67,0x9b01}, // + {0xEF68,0x9afc}, // + {0xEF69,0x9b48}, // + {0xEF6A,0x9b9a}, // + {0xEF6B,0x9ba8}, // + {0xEF6C,0x9b9e}, // + {0xEF6D,0x9b9b}, // + {0xEF6E,0x9ba6}, // + {0xEF6F,0x9ba1}, // + {0xEF70,0x9ba5}, // + {0xEF71,0x9ba4}, // + {0xEF72,0x9b86}, // + {0xEF73,0x9ba2}, // + {0xEF74,0x9ba0}, // + {0xEF75,0x9baf}, // + {0xEF76,0x9d33}, // + {0xEF77,0x9d41}, // + {0xEF78,0x9d67}, // + {0xEF79,0x9d36}, // + {0xEF7A,0x9d2e}, // + {0xEF7B,0x9d2f}, // + {0xEF7C,0x9d31}, // + {0xEF7D,0x9d38}, // + {0xEF7E,0x9d30}, // + {0xEFA1,0x9d45}, // + {0xEFA2,0x9d42}, // + {0xEFA3,0x9d43}, // + {0xEFA4,0x9d3e}, // + {0xEFA5,0x9d37}, // + {0xEFA6,0x9d40}, // + {0xEFA7,0x9d3d}, // + {0xEFA8,0x7ff5}, // + {0xEFA9,0x9d2d}, // + {0xEFAA,0x9e8a}, // + {0xEFAB,0x9e89}, // + {0xEFAC,0x9e8d}, // + {0xEFAD,0x9eb0}, // + {0xEFAE,0x9ec8}, // + {0xEFAF,0x9eda}, // + {0xEFB0,0x9efb}, // + {0xEFB1,0x9eff}, // + {0xEFB2,0x9f24}, // + {0xEFB3,0x9f23}, // + {0xEFB4,0x9f22}, // + {0xEFB5,0x9f54}, // + {0xEFB6,0x9fa0}, // + {0xEFB7,0x5131}, // + {0xEFB8,0x512d}, // + {0xEFB9,0x512e}, // + {0xEFBA,0x5698}, // + {0xEFBB,0x569c}, // + {0xEFBC,0x5697}, // + {0xEFBD,0x569a}, // + {0xEFBE,0x569d}, // + {0xEFBF,0x5699}, // + {0xEFC0,0x5970}, // + {0xEFC1,0x5b3c}, // + {0xEFC2,0x5c69}, // + {0xEFC3,0x5c6a}, // + {0xEFC4,0x5dc0}, // + {0xEFC5,0x5e6d}, // + {0xEFC6,0x5e6e}, // + {0xEFC7,0x61d8}, // + {0xEFC8,0x61df}, // + {0xEFC9,0x61ed}, // + {0xEFCA,0x61ee}, // + {0xEFCB,0x61f1}, // + {0xEFCC,0x61ea}, // + {0xEFCD,0x61f0}, // + {0xEFCE,0x61eb}, // + {0xEFCF,0x61d6}, // + {0xEFD0,0x61e9}, // + {0xEFD1,0x64ff}, // + {0xEFD2,0x6504}, // + {0xEFD3,0x64fd}, // + {0xEFD4,0x64f8}, // + {0xEFD5,0x6501}, // + {0xEFD6,0x6503}, // + {0xEFD7,0x64fc}, // + {0xEFD8,0x6594}, // + {0xEFD9,0x65db}, // + {0xEFDA,0x66da}, // + {0xEFDB,0x66db}, // + {0xEFDC,0x66d8}, // + {0xEFDD,0x6ac5}, // + {0xEFDE,0x6ab9}, // + {0xEFDF,0x6abd}, // + {0xEFE0,0x6ae1}, // + {0xEFE1,0x6ac6}, // + {0xEFE2,0x6aba}, // + {0xEFE3,0x6ab6}, // + {0xEFE4,0x6ab7}, // + {0xEFE5,0x6ac7}, // + {0xEFE6,0x6ab4}, // + {0xEFE7,0x6aad}, // + {0xEFE8,0x6b5e}, // + {0xEFE9,0x6bc9}, // + {0xEFEA,0x6c0b}, // + {0xEFEB,0x7007}, // + {0xEFEC,0x700c}, // + {0xEFED,0x700d}, // + {0xEFEE,0x7001}, // + {0xEFEF,0x7005}, // + {0xEFF0,0x7014}, // + {0xEFF1,0x700e}, // + {0xEFF2,0x6fff}, // + {0xEFF3,0x7000}, // + {0xEFF4,0x6ffb}, // + {0xEFF5,0x7026}, // + {0xEFF6,0x6ffc}, // + {0xEFF7,0x6ff7}, // + {0xEFF8,0x700a}, // + {0xEFF9,0x7201}, // + {0xEFFA,0x71ff}, // + {0xEFFB,0x71f9}, // + {0xEFFC,0x7203}, // + {0xEFFD,0x71fd}, // + {0xEFFE,0x7376}, // + {0xF040,0x74b8}, // + {0xF041,0x74c0}, // + {0xF042,0x74b5}, // + {0xF043,0x74c1}, // + {0xF044,0x74be}, // + {0xF045,0x74b6}, // + {0xF046,0x74bb}, // + {0xF047,0x74c2}, // + {0xF048,0x7514}, // + {0xF049,0x7513}, // + {0xF04A,0x765c}, // + {0xF04B,0x7664}, // + {0xF04C,0x7659}, // + {0xF04D,0x7650}, // + {0xF04E,0x7653}, // + {0xF04F,0x7657}, // + {0xF050,0x765a}, // + {0xF051,0x76a6}, // + {0xF052,0x76bd}, // + {0xF053,0x76ec}, // + {0xF054,0x77c2}, // + {0xF055,0x77ba}, // + {0xF056,0x78ff}, // + {0xF057,0x790c}, // + {0xF058,0x7913}, // + {0xF059,0x7914}, // + {0xF05A,0x7909}, // + {0xF05B,0x7910}, // + {0xF05C,0x7912}, // + {0xF05D,0x7911}, // + {0xF05E,0x79ad}, // + {0xF05F,0x79ac}, // + {0xF060,0x7a5f}, // + {0xF061,0x7c1c}, // + {0xF062,0x7c29}, // + {0xF063,0x7c19}, // + {0xF064,0x7c20}, // + {0xF065,0x7c1f}, // + {0xF066,0x7c2d}, // + {0xF067,0x7c1d}, // + {0xF068,0x7c26}, // + {0xF069,0x7c28}, // + {0xF06A,0x7c22}, // + {0xF06B,0x7c25}, // + {0xF06C,0x7c30}, // + {0xF06D,0x7e5c}, // + {0xF06E,0x7e50}, // + {0xF06F,0x7e56}, // + {0xF070,0x7e63}, // + {0xF071,0x7e58}, // + {0xF072,0x7e62}, // + {0xF073,0x7e5f}, // + {0xF074,0x7e51}, // + {0xF075,0x7e60}, // + {0xF076,0x7e57}, // + {0xF077,0x7e53}, // + {0xF078,0x7fb5}, // + {0xF079,0x7fb3}, // + {0xF07A,0x7ff7}, // + {0xF07B,0x7ff8}, // + {0xF07C,0x8075}, // + {0xF07D,0x81d1}, // + {0xF07E,0x81d2}, // + {0xF0A1,0x81d0}, // + {0xF0A2,0x825f}, // + {0xF0A3,0x825e}, // + {0xF0A4,0x85b4}, // + {0xF0A5,0x85c6}, // + {0xF0A6,0x85c0}, // + {0xF0A7,0x85c3}, // + {0xF0A8,0x85c2}, // + {0xF0A9,0x85b3}, // + {0xF0AA,0x85b5}, // + {0xF0AB,0x85bd}, // + {0xF0AC,0x85c7}, // + {0xF0AD,0x85c4}, // + {0xF0AE,0x85bf}, // + {0xF0AF,0x85cb}, // + {0xF0B0,0x85ce}, // + {0xF0B1,0x85c8}, // + {0xF0B2,0x85c5}, // + {0xF0B3,0x85b1}, // + {0xF0B4,0x85b6}, // + {0xF0B5,0x85d2}, // + {0xF0B6,0x8624}, // + {0xF0B7,0x85b8}, // + {0xF0B8,0x85b7}, // + {0xF0B9,0x85be}, // + {0xF0BA,0x8669}, // + {0xF0BB,0x87e7}, // + {0xF0BC,0x87e6}, // + {0xF0BD,0x87e2}, // + {0xF0BE,0x87db}, // + {0xF0BF,0x87eb}, // + {0xF0C0,0x87ea}, // + {0xF0C1,0x87e5}, // + {0xF0C2,0x87df}, // + {0xF0C3,0x87f3}, // + {0xF0C4,0x87e4}, // + {0xF0C5,0x87d4}, // + {0xF0C6,0x87dc}, // + {0xF0C7,0x87d3}, // + {0xF0C8,0x87ed}, // + {0xF0C9,0x87d8}, // + {0xF0CA,0x87e3}, // + {0xF0CB,0x87a4}, // + {0xF0CC,0x87d7}, // + {0xF0CD,0x87d9}, // + {0xF0CE,0x8801}, // + {0xF0CF,0x87f4}, // + {0xF0D0,0x87e8}, // + {0xF0D1,0x87dd}, // + {0xF0D2,0x8953}, // + {0xF0D3,0x894b}, // + {0xF0D4,0x894f}, // + {0xF0D5,0x894c}, // + {0xF0D6,0x8946}, // + {0xF0D7,0x8950}, // + {0xF0D8,0x8951}, // + {0xF0D9,0x8949}, // + {0xF0DA,0x8b2a}, // + {0xF0DB,0x8b27}, // + {0xF0DC,0x8b23}, // + {0xF0DD,0x8b33}, // + {0xF0DE,0x8b30}, // + {0xF0DF,0x8b35}, // + {0xF0E0,0x8b47}, // + {0xF0E1,0x8b2f}, // + {0xF0E2,0x8b3c}, // + {0xF0E3,0x8b3e}, // + {0xF0E4,0x8b31}, // + {0xF0E5,0x8b25}, // + {0xF0E6,0x8b37}, // + {0xF0E7,0x8b26}, // + {0xF0E8,0x8b36}, // + {0xF0E9,0x8b2e}, // + {0xF0EA,0x8b24}, // + {0xF0EB,0x8b3b}, // + {0xF0EC,0x8b3d}, // + {0xF0ED,0x8b3a}, // + {0xF0EE,0x8c42}, // + {0xF0EF,0x8c75}, // + {0xF0F0,0x8c99}, // + {0xF0F1,0x8c98}, // + {0xF0F2,0x8c97}, // + {0xF0F3,0x8cfe}, // + {0xF0F4,0x8d04}, // + {0xF0F5,0x8d02}, // + {0xF0F6,0x8d00}, // + {0xF0F7,0x8e5c}, // + {0xF0F8,0x8e62}, // + {0xF0F9,0x8e60}, // + {0xF0FA,0x8e57}, // + {0xF0FB,0x8e56}, // + {0xF0FC,0x8e5e}, // + {0xF0FD,0x8e65}, // + {0xF0FE,0x8e67}, // + {0xF140,0x8e5b}, // + {0xF141,0x8e5a}, // + {0xF142,0x8e61}, // + {0xF143,0x8e5d}, // + {0xF144,0x8e69}, // + {0xF145,0x8e54}, // + {0xF146,0x8f46}, // + {0xF147,0x8f47}, // + {0xF148,0x8f48}, // + {0xF149,0x8f4b}, // + {0xF14A,0x9128}, // + {0xF14B,0x913a}, // + {0xF14C,0x913b}, // + {0xF14D,0x913e}, // + {0xF14E,0x91a8}, // + {0xF14F,0x91a5}, // + {0xF150,0x91a7}, // + {0xF151,0x91af}, // + {0xF152,0x91aa}, // + {0xF153,0x93b5}, // + {0xF154,0x938c}, // + {0xF155,0x9392}, // + {0xF156,0x93b7}, // + {0xF157,0x939b}, // + {0xF158,0x939d}, // + {0xF159,0x9389}, // + {0xF15A,0x93a7}, // + {0xF15B,0x938e}, // + {0xF15C,0x93aa}, // + {0xF15D,0x939e}, // + {0xF15E,0x93a6}, // + {0xF15F,0x9395}, // + {0xF160,0x9388}, // + {0xF161,0x9399}, // + {0xF162,0x939f}, // + {0xF163,0x938d}, // + {0xF164,0x93b1}, // + {0xF165,0x9391}, // + {0xF166,0x93b2}, // + {0xF167,0x93a4}, // + {0xF168,0x93a8}, // + {0xF169,0x93b4}, // + {0xF16A,0x93a3}, // + {0xF16B,0x93a5}, // + {0xF16C,0x95d2}, // + {0xF16D,0x95d3}, // + {0xF16E,0x95d1}, // + {0xF16F,0x96b3}, // + {0xF170,0x96d7}, // + {0xF171,0x96da}, // + {0xF172,0x5dc2}, // + {0xF173,0x96df}, // + {0xF174,0x96d8}, // + {0xF175,0x96dd}, // + {0xF176,0x9723}, // + {0xF177,0x9722}, // + {0xF178,0x9725}, // + {0xF179,0x97ac}, // + {0xF17A,0x97ae}, // + {0xF17B,0x97a8}, // + {0xF17C,0x97ab}, // + {0xF17D,0x97a4}, // + {0xF17E,0x97aa}, // + {0xF1A1,0x97a2}, // + {0xF1A2,0x97a5}, // + {0xF1A3,0x97d7}, // + {0xF1A4,0x97d9}, // + {0xF1A5,0x97d6}, // + {0xF1A6,0x97d8}, // + {0xF1A7,0x97fa}, // + {0xF1A8,0x9850}, // + {0xF1A9,0x9851}, // + {0xF1AA,0x9852}, // + {0xF1AB,0x98b8}, // + {0xF1AC,0x9941}, // + {0xF1AD,0x993c}, // + {0xF1AE,0x993a}, // + {0xF1AF,0x9a0f}, // + {0xF1B0,0x9a0b}, // + {0xF1B1,0x9a09}, // + {0xF1B2,0x9a0d}, // + {0xF1B3,0x9a04}, // + {0xF1B4,0x9a11}, // + {0xF1B5,0x9a0a}, // + {0xF1B6,0x9a05}, // + {0xF1B7,0x9a07}, // + {0xF1B8,0x9a06}, // + {0xF1B9,0x9ac0}, // + {0xF1BA,0x9adc}, // + {0xF1BB,0x9b08}, // + {0xF1BC,0x9b04}, // + {0xF1BD,0x9b05}, // + {0xF1BE,0x9b29}, // + {0xF1BF,0x9b35}, // + {0xF1C0,0x9b4a}, // + {0xF1C1,0x9b4c}, // + {0xF1C2,0x9b4b}, // + {0xF1C3,0x9bc7}, // + {0xF1C4,0x9bc6}, // + {0xF1C5,0x9bc3}, // + {0xF1C6,0x9bbf}, // + {0xF1C7,0x9bc1}, // + {0xF1C8,0x9bb5}, // + {0xF1C9,0x9bb8}, // + {0xF1CA,0x9bd3}, // + {0xF1CB,0x9bb6}, // + {0xF1CC,0x9bc4}, // + {0xF1CD,0x9bb9}, // + {0xF1CE,0x9bbd}, // + {0xF1CF,0x9d5c}, // + {0xF1D0,0x9d53}, // + {0xF1D1,0x9d4f}, // + {0xF1D2,0x9d4a}, // + {0xF1D3,0x9d5b}, // + {0xF1D4,0x9d4b}, // + {0xF1D5,0x9d59}, // + {0xF1D6,0x9d56}, // + {0xF1D7,0x9d4c}, // + {0xF1D8,0x9d57}, // + {0xF1D9,0x9d52}, // + {0xF1DA,0x9d54}, // + {0xF1DB,0x9d5f}, // + {0xF1DC,0x9d58}, // + {0xF1DD,0x9d5a}, // + {0xF1DE,0x9e8e}, // + {0xF1DF,0x9e8c}, // + {0xF1E0,0x9edf}, // + {0xF1E1,0x9f01}, // + {0xF1E2,0x9f00}, // + {0xF1E3,0x9f16}, // + {0xF1E4,0x9f25}, // + {0xF1E5,0x9f2b}, // + {0xF1E6,0x9f2a}, // + {0xF1E7,0x9f29}, // + {0xF1E8,0x9f28}, // + {0xF1E9,0x9f4c}, // + {0xF1EA,0x9f55}, // + {0xF1EB,0x5134}, // + {0xF1EC,0x5135}, // + {0xF1ED,0x5296}, // + {0xF1EE,0x52f7}, // + {0xF1EF,0x53b4}, // + {0xF1F0,0x56ab}, // + {0xF1F1,0x56ad}, // + {0xF1F2,0x56a6}, // + {0xF1F3,0x56a7}, // + {0xF1F4,0x56aa}, // + {0xF1F5,0x56ac}, // + {0xF1F6,0x58da}, // + {0xF1F7,0x58dd}, // + {0xF1F8,0x58db}, // + {0xF1F9,0x5912}, // + {0xF1FA,0x5b3d}, // + {0xF1FB,0x5b3e}, // + {0xF1FC,0x5b3f}, // + {0xF1FD,0x5dc3}, // + {0xF1FE,0x5e70}, // + {0xF240,0x5fbf}, // + {0xF241,0x61fb}, // + {0xF242,0x6507}, // + {0xF243,0x6510}, // + {0xF244,0x650d}, // + {0xF245,0x6509}, // + {0xF246,0x650c}, // + {0xF247,0x650e}, // + {0xF248,0x6584}, // + {0xF249,0x65de}, // + {0xF24A,0x65dd}, // + {0xF24B,0x66de}, // + {0xF24C,0x6ae7}, // + {0xF24D,0x6ae0}, // + {0xF24E,0x6acc}, // + {0xF24F,0x6ad1}, // + {0xF250,0x6ad9}, // + {0xF251,0x6acb}, // + {0xF252,0x6adf}, // + {0xF253,0x6adc}, // + {0xF254,0x6ad0}, // + {0xF255,0x6aeb}, // + {0xF256,0x6acf}, // + {0xF257,0x6acd}, // + {0xF258,0x6ade}, // + {0xF259,0x6b60}, // + {0xF25A,0x6bb0}, // + {0xF25B,0x6c0c}, // + {0xF25C,0x7019}, // + {0xF25D,0x7027}, // + {0xF25E,0x7020}, // + {0xF25F,0x7016}, // + {0xF260,0x702b}, // + {0xF261,0x7021}, // + {0xF262,0x7022}, // + {0xF263,0x7023}, // + {0xF264,0x7029}, // + {0xF265,0x7017}, // + {0xF266,0x7024}, // + {0xF267,0x701c}, // + {0xF268,0x702a}, // + {0xF269,0x720c}, // + {0xF26A,0x720a}, // + {0xF26B,0x7207}, // + {0xF26C,0x7202}, // + {0xF26D,0x7205}, // + {0xF26E,0x72a5}, // + {0xF26F,0x72a6}, // + {0xF270,0x72a4}, // + {0xF271,0x72a3}, // + {0xF272,0x72a1}, // + {0xF273,0x74cb}, // + {0xF274,0x74c5}, // + {0xF275,0x74b7}, // + {0xF276,0x74c3}, // + {0xF277,0x7516}, // + {0xF278,0x7660}, // + {0xF279,0x77c9}, // + {0xF27A,0x77ca}, // + {0xF27B,0x77c4}, // + {0xF27C,0x77f1}, // + {0xF27D,0x791d}, // + {0xF27E,0x791b}, // + {0xF2A1,0x7921}, // + {0xF2A2,0x791c}, // + {0xF2A3,0x7917}, // + {0xF2A4,0x791e}, // + {0xF2A5,0x79b0}, // + {0xF2A6,0x7a67}, // + {0xF2A7,0x7a68}, // + {0xF2A8,0x7c33}, // + {0xF2A9,0x7c3c}, // + {0xF2AA,0x7c39}, // + {0xF2AB,0x7c2c}, // + {0xF2AC,0x7c3b}, // + {0xF2AD,0x7cec}, // + {0xF2AE,0x7cea}, // + {0xF2AF,0x7e76}, // + {0xF2B0,0x7e75}, // + {0xF2B1,0x7e78}, // + {0xF2B2,0x7e70}, // + {0xF2B3,0x7e77}, // + {0xF2B4,0x7e6f}, // + {0xF2B5,0x7e7a}, // + {0xF2B6,0x7e72}, // + {0xF2B7,0x7e74}, // + {0xF2B8,0x7e68}, // + {0xF2B9,0x7f4b}, // + {0xF2BA,0x7f4a}, // + {0xF2BB,0x7f83}, // + {0xF2BC,0x7f86}, // + {0xF2BD,0x7fb7}, // + {0xF2BE,0x7ffd}, // + {0xF2BF,0x7ffe}, // + {0xF2C0,0x8078}, // + {0xF2C1,0x81d7}, // + {0xF2C2,0x81d5}, // + {0xF2C3,0x8264}, // + {0xF2C4,0x8261}, // + {0xF2C5,0x8263}, // + {0xF2C6,0x85eb}, // + {0xF2C7,0x85f1}, // + {0xF2C8,0x85ed}, // + {0xF2C9,0x85d9}, // + {0xF2CA,0x85e1}, // + {0xF2CB,0x85e8}, // + {0xF2CC,0x85da}, // + {0xF2CD,0x85d7}, // + {0xF2CE,0x85ec}, // + {0xF2CF,0x85f2}, // + {0xF2D0,0x85f8}, // + {0xF2D1,0x85d8}, // + {0xF2D2,0x85df}, // + {0xF2D3,0x85e3}, // + {0xF2D4,0x85dc}, // + {0xF2D5,0x85d1}, // + {0xF2D6,0x85f0}, // + {0xF2D7,0x85e6}, // + {0xF2D8,0x85ef}, // + {0xF2D9,0x85de}, // + {0xF2DA,0x85e2}, // + {0xF2DB,0x8800}, // + {0xF2DC,0x87fa}, // + {0xF2DD,0x8803}, // + {0xF2DE,0x87f6}, // + {0xF2DF,0x87f7}, // + {0xF2E0,0x8809}, // + {0xF2E1,0x880c}, // + {0xF2E2,0x880b}, // + {0xF2E3,0x8806}, // + {0xF2E4,0x87fc}, // + {0xF2E5,0x8808}, // + {0xF2E6,0x87ff}, // + {0xF2E7,0x880a}, // + {0xF2E8,0x8802}, // + {0xF2E9,0x8962}, // + {0xF2EA,0x895a}, // + {0xF2EB,0x895b}, // + {0xF2EC,0x8957}, // + {0xF2ED,0x8961}, // + {0xF2EE,0x895c}, // + {0xF2EF,0x8958}, // + {0xF2F0,0x895d}, // + {0xF2F1,0x8959}, // + {0xF2F2,0x8988}, // + {0xF2F3,0x89b7}, // + {0xF2F4,0x89b6}, // + {0xF2F5,0x89f6}, // + {0xF2F6,0x8b50}, // + {0xF2F7,0x8b48}, // + {0xF2F8,0x8b4a}, // + {0xF2F9,0x8b40}, // + {0xF2FA,0x8b53}, // + {0xF2FB,0x8b56}, // + {0xF2FC,0x8b54}, // + {0xF2FD,0x8b4b}, // + {0xF2FE,0x8b55}, // + {0xF340,0x8b51}, // + {0xF341,0x8b42}, // + {0xF342,0x8b52}, // + {0xF343,0x8b57}, // + {0xF344,0x8c43}, // + {0xF345,0x8c77}, // + {0xF346,0x8c76}, // + {0xF347,0x8c9a}, // + {0xF348,0x8d06}, // + {0xF349,0x8d07}, // + {0xF34A,0x8d09}, // + {0xF34B,0x8dac}, // + {0xF34C,0x8daa}, // + {0xF34D,0x8dad}, // + {0xF34E,0x8dab}, // + {0xF34F,0x8e6d}, // + {0xF350,0x8e78}, // + {0xF351,0x8e73}, // + {0xF352,0x8e6a}, // + {0xF353,0x8e6f}, // + {0xF354,0x8e7b}, // + {0xF355,0x8ec2}, // + {0xF356,0x8f52}, // + {0xF357,0x8f51}, // + {0xF358,0x8f4f}, // + {0xF359,0x8f50}, // + {0xF35A,0x8f53}, // + {0xF35B,0x8fb4}, // + {0xF35C,0x9140}, // + {0xF35D,0x913f}, // + {0xF35E,0x91b0}, // + {0xF35F,0x91ad}, // + {0xF360,0x93de}, // + {0xF361,0x93c7}, // + {0xF362,0x93cf}, // + {0xF363,0x93c2}, // + {0xF364,0x93da}, // + {0xF365,0x93d0}, // + {0xF366,0x93f9}, // + {0xF367,0x93ec}, // + {0xF368,0x93cc}, // + {0xF369,0x93d9}, // + {0xF36A,0x93a9}, // + {0xF36B,0x93e6}, // + {0xF36C,0x93ca}, // + {0xF36D,0x93d4}, // + {0xF36E,0x93ee}, // + {0xF36F,0x93e3}, // + {0xF370,0x93d5}, // + {0xF371,0x93c4}, // + {0xF372,0x93ce}, // + {0xF373,0x93c0}, // + {0xF374,0x93d2}, // + {0xF375,0x93e7}, // + {0xF376,0x957d}, // + {0xF377,0x95da}, // + {0xF378,0x95db}, // + {0xF379,0x96e1}, // + {0xF37A,0x9729}, // + {0xF37B,0x972b}, // + {0xF37C,0x972c}, // + {0xF37D,0x9728}, // + {0xF37E,0x9726}, // + {0xF3A1,0x97b3}, // + {0xF3A2,0x97b7}, // + {0xF3A3,0x97b6}, // + {0xF3A4,0x97dd}, // + {0xF3A5,0x97de}, // + {0xF3A6,0x97df}, // + {0xF3A7,0x985c}, // + {0xF3A8,0x9859}, // + {0xF3A9,0x985d}, // + {0xF3AA,0x9857}, // + {0xF3AB,0x98bf}, // + {0xF3AC,0x98bd}, // + {0xF3AD,0x98bb}, // + {0xF3AE,0x98be}, // + {0xF3AF,0x9948}, // + {0xF3B0,0x9947}, // + {0xF3B1,0x9943}, // + {0xF3B2,0x99a6}, // + {0xF3B3,0x99a7}, // + {0xF3B4,0x9a1a}, // + {0xF3B5,0x9a15}, // + {0xF3B6,0x9a25}, // + {0xF3B7,0x9a1d}, // + {0xF3B8,0x9a24}, // + {0xF3B9,0x9a1b}, // + {0xF3BA,0x9a22}, // + {0xF3BB,0x9a20}, // + {0xF3BC,0x9a27}, // + {0xF3BD,0x9a23}, // + {0xF3BE,0x9a1e}, // + {0xF3BF,0x9a1c}, // + {0xF3C0,0x9a14}, // + {0xF3C1,0x9ac2}, // + {0xF3C2,0x9b0b}, // + {0xF3C3,0x9b0a}, // + {0xF3C4,0x9b0e}, // + {0xF3C5,0x9b0c}, // + {0xF3C6,0x9b37}, // + {0xF3C7,0x9bea}, // + {0xF3C8,0x9beb}, // + {0xF3C9,0x9be0}, // + {0xF3CA,0x9bde}, // + {0xF3CB,0x9be4}, // + {0xF3CC,0x9be6}, // + {0xF3CD,0x9be2}, // + {0xF3CE,0x9bf0}, // + {0xF3CF,0x9bd4}, // + {0xF3D0,0x9bd7}, // + {0xF3D1,0x9bec}, // + {0xF3D2,0x9bdc}, // + {0xF3D3,0x9bd9}, // + {0xF3D4,0x9be5}, // + {0xF3D5,0x9bd5}, // + {0xF3D6,0x9be1}, // + {0xF3D7,0x9bda}, // + {0xF3D8,0x9d77}, // + {0xF3D9,0x9d81}, // + {0xF3DA,0x9d8a}, // + {0xF3DB,0x9d84}, // + {0xF3DC,0x9d88}, // + {0xF3DD,0x9d71}, // + {0xF3DE,0x9d80}, // + {0xF3DF,0x9d78}, // + {0xF3E0,0x9d86}, // + {0xF3E1,0x9d8b}, // + {0xF3E2,0x9d8c}, // + {0xF3E3,0x9d7d}, // + {0xF3E4,0x9d6b}, // + {0xF3E5,0x9d74}, // + {0xF3E6,0x9d75}, // + {0xF3E7,0x9d70}, // + {0xF3E8,0x9d69}, // + {0xF3E9,0x9d85}, // + {0xF3EA,0x9d73}, // + {0xF3EB,0x9d7b}, // + {0xF3EC,0x9d82}, // + {0xF3ED,0x9d6f}, // + {0xF3EE,0x9d79}, // + {0xF3EF,0x9d7f}, // + {0xF3F0,0x9d87}, // + {0xF3F1,0x9d68}, // + {0xF3F2,0x9e94}, // + {0xF3F3,0x9e91}, // + {0xF3F4,0x9ec0}, // + {0xF3F5,0x9efc}, // + {0xF3F6,0x9f2d}, // + {0xF3F7,0x9f40}, // + {0xF3F8,0x9f41}, // + {0xF3F9,0x9f4d}, // + {0xF3FA,0x9f56}, // + {0xF3FB,0x9f57}, // + {0xF3FC,0x9f58}, // + {0xF3FD,0x5337}, // + {0xF3FE,0x56b2}, // + {0xF440,0x56b5}, // + {0xF441,0x56b3}, // + {0xF442,0x58e3}, // + {0xF443,0x5b45}, // + {0xF444,0x5dc6}, // + {0xF445,0x5dc7}, // + {0xF446,0x5eee}, // + {0xF447,0x5eef}, // + {0xF448,0x5fc0}, // + {0xF449,0x5fc1}, // + {0xF44A,0x61f9}, // + {0xF44B,0x6517}, // + {0xF44C,0x6516}, // + {0xF44D,0x6515}, // + {0xF44E,0x6513}, // + {0xF44F,0x65df}, // + {0xF450,0x66e8}, // + {0xF451,0x66e3}, // + {0xF452,0x66e4}, // + {0xF453,0x6af3}, // + {0xF454,0x6af0}, // + {0xF455,0x6aea}, // + {0xF456,0x6ae8}, // + {0xF457,0x6af9}, // + {0xF458,0x6af1}, // + {0xF459,0x6aee}, // + {0xF45A,0x6aef}, // + {0xF45B,0x703c}, // + {0xF45C,0x7035}, // + {0xF45D,0x702f}, // + {0xF45E,0x7037}, // + {0xF45F,0x7034}, // + {0xF460,0x7031}, // + {0xF461,0x7042}, // + {0xF462,0x7038}, // + {0xF463,0x703f}, // + {0xF464,0x703a}, // + {0xF465,0x7039}, // + {0xF466,0x7040}, // + {0xF467,0x703b}, // + {0xF468,0x7033}, // + {0xF469,0x7041}, // + {0xF46A,0x7213}, // + {0xF46B,0x7214}, // + {0xF46C,0x72a8}, // + {0xF46D,0x737d}, // + {0xF46E,0x737c}, // + {0xF46F,0x74ba}, // + {0xF470,0x76ab}, // + {0xF471,0x76aa}, // + {0xF472,0x76be}, // + {0xF473,0x76ed}, // + {0xF474,0x77cc}, // + {0xF475,0x77ce}, // + {0xF476,0x77cf}, // + {0xF477,0x77cd}, // + {0xF478,0x77f2}, // + {0xF479,0x7925}, // + {0xF47A,0x7923}, // + {0xF47B,0x7927}, // + {0xF47C,0x7928}, // + {0xF47D,0x7924}, // + {0xF47E,0x7929}, // + {0xF4A1,0x79b2}, // + {0xF4A2,0x7a6e}, // + {0xF4A3,0x7a6c}, // + {0xF4A4,0x7a6d}, // + {0xF4A5,0x7af7}, // + {0xF4A6,0x7c49}, // + {0xF4A7,0x7c48}, // + {0xF4A8,0x7c4a}, // + {0xF4A9,0x7c47}, // + {0xF4AA,0x7c45}, // + {0xF4AB,0x7cee}, // + {0xF4AC,0x7e7b}, // + {0xF4AD,0x7e7e}, // + {0xF4AE,0x7e81}, // + {0xF4AF,0x7e80}, // + {0xF4B0,0x7fba}, // + {0xF4B1,0x7fff}, // + {0xF4B2,0x8079}, // + {0xF4B3,0x81db}, // + {0xF4B4,0x81d9}, // + {0xF4B5,0x820b}, // + {0xF4B6,0x8268}, // + {0xF4B7,0x8269}, // + {0xF4B8,0x8622}, // + {0xF4B9,0x85ff}, // + {0xF4BA,0x8601}, // + {0xF4BB,0x85fe}, // + {0xF4BC,0x861b}, // + {0xF4BD,0x8600}, // + {0xF4BE,0x85f6}, // + {0xF4BF,0x8604}, // + {0xF4C0,0x8609}, // + {0xF4C1,0x8605}, // + {0xF4C2,0x860c}, // + {0xF4C3,0x85fd}, // + {0xF4C4,0x8819}, // + {0xF4C5,0x8810}, // + {0xF4C6,0x8811}, // + {0xF4C7,0x8817}, // + {0xF4C8,0x8813}, // + {0xF4C9,0x8816}, // + {0xF4CA,0x8963}, // + {0xF4CB,0x8966}, // + {0xF4CC,0x89b9}, // + {0xF4CD,0x89f7}, // + {0xF4CE,0x8b60}, // + {0xF4CF,0x8b6a}, // + {0xF4D0,0x8b5d}, // + {0xF4D1,0x8b68}, // + {0xF4D2,0x8b63}, // + {0xF4D3,0x8b65}, // + {0xF4D4,0x8b67}, // + {0xF4D5,0x8b6d}, // + {0xF4D6,0x8dae}, // + {0xF4D7,0x8e86}, // + {0xF4D8,0x8e88}, // + {0xF4D9,0x8e84}, // + {0xF4DA,0x8f59}, // + {0xF4DB,0x8f56}, // + {0xF4DC,0x8f57}, // + {0xF4DD,0x8f55}, // + {0xF4DE,0x8f58}, // + {0xF4DF,0x8f5a}, // + {0xF4E0,0x908d}, // + {0xF4E1,0x9143}, // + {0xF4E2,0x9141}, // + {0xF4E3,0x91b7}, // + {0xF4E4,0x91b5}, // + {0xF4E5,0x91b2}, // + {0xF4E6,0x91b3}, // + {0xF4E7,0x940b}, // + {0xF4E8,0x9413}, // + {0xF4E9,0x93fb}, // + {0xF4EA,0x9420}, // + {0xF4EB,0x940f}, // + {0xF4EC,0x9414}, // + {0xF4ED,0x93fe}, // + {0xF4EE,0x9415}, // + {0xF4EF,0x9410}, // + {0xF4F0,0x9428}, // + {0xF4F1,0x9419}, // + {0xF4F2,0x940d}, // + {0xF4F3,0x93f5}, // + {0xF4F4,0x9400}, // + {0xF4F5,0x93f7}, // + {0xF4F6,0x9407}, // + {0xF4F7,0x940e}, // + {0xF4F8,0x9416}, // + {0xF4F9,0x9412}, // + {0xF4FA,0x93fa}, // + {0xF4FB,0x9409}, // + {0xF4FC,0x93f8}, // + {0xF4FD,0x940a}, // + {0xF4FE,0x93ff}, // + {0xF540,0x93fc}, // + {0xF541,0x940c}, // + {0xF542,0x93f6}, // + {0xF543,0x9411}, // + {0xF544,0x9406}, // + {0xF545,0x95de}, // + {0xF546,0x95e0}, // + {0xF547,0x95df}, // + {0xF548,0x972e}, // + {0xF549,0x972f}, // + {0xF54A,0x97b9}, // + {0xF54B,0x97bb}, // + {0xF54C,0x97fd}, // + {0xF54D,0x97fe}, // + {0xF54E,0x9860}, // + {0xF54F,0x9862}, // + {0xF550,0x9863}, // + {0xF551,0x985f}, // + {0xF552,0x98c1}, // + {0xF553,0x98c2}, // + {0xF554,0x9950}, // + {0xF555,0x994e}, // + {0xF556,0x9959}, // + {0xF557,0x994c}, // + {0xF558,0x994b}, // + {0xF559,0x9953}, // + {0xF55A,0x9a32}, // + {0xF55B,0x9a34}, // + {0xF55C,0x9a31}, // + {0xF55D,0x9a2c}, // + {0xF55E,0x9a2a}, // + {0xF55F,0x9a36}, // + {0xF560,0x9a29}, // + {0xF561,0x9a2e}, // + {0xF562,0x9a38}, // + {0xF563,0x9a2d}, // + {0xF564,0x9ac7}, // + {0xF565,0x9aca}, // + {0xF566,0x9ac6}, // + {0xF567,0x9b10}, // + {0xF568,0x9b12}, // + {0xF569,0x9b11}, // + {0xF56A,0x9c0b}, // + {0xF56B,0x9c08}, // + {0xF56C,0x9bf7}, // + {0xF56D,0x9c05}, // + {0xF56E,0x9c12}, // + {0xF56F,0x9bf8}, // + {0xF570,0x9c40}, // + {0xF571,0x9c07}, // + {0xF572,0x9c0e}, // + {0xF573,0x9c06}, // + {0xF574,0x9c17}, // + {0xF575,0x9c14}, // + {0xF576,0x9c09}, // + {0xF577,0x9d9f}, // + {0xF578,0x9d99}, // + {0xF579,0x9da4}, // + {0xF57A,0x9d9d}, // + {0xF57B,0x9d92}, // + {0xF57C,0x9d98}, // + {0xF57D,0x9d90}, // + {0xF57E,0x9d9b}, // + {0xF5A1,0x9da0}, // + {0xF5A2,0x9d94}, // + {0xF5A3,0x9d9c}, // + {0xF5A4,0x9daa}, // + {0xF5A5,0x9d97}, // + {0xF5A6,0x9da1}, // + {0xF5A7,0x9d9a}, // + {0xF5A8,0x9da2}, // + {0xF5A9,0x9da8}, // + {0xF5AA,0x9d9e}, // + {0xF5AB,0x9da3}, // + {0xF5AC,0x9dbf}, // + {0xF5AD,0x9da9}, // + {0xF5AE,0x9d96}, // + {0xF5AF,0x9da6}, // + {0xF5B0,0x9da7}, // + {0xF5B1,0x9e99}, // + {0xF5B2,0x9e9b}, // + {0xF5B3,0x9e9a}, // + {0xF5B4,0x9ee5}, // + {0xF5B5,0x9ee4}, // + {0xF5B6,0x9ee7}, // + {0xF5B7,0x9ee6}, // + {0xF5B8,0x9f30}, // + {0xF5B9,0x9f2e}, // + {0xF5BA,0x9f5b}, // + {0xF5BB,0x9f60}, // + {0xF5BC,0x9f5e}, // + {0xF5BD,0x9f5d}, // + {0xF5BE,0x9f59}, // + {0xF5BF,0x9f91}, // + {0xF5C0,0x513a}, // + {0xF5C1,0x5139}, // + {0xF5C2,0x5298}, // + {0xF5C3,0x5297}, // + {0xF5C4,0x56c3}, // + {0xF5C5,0x56bd}, // + {0xF5C6,0x56be}, // + {0xF5C7,0x5b48}, // + {0xF5C8,0x5b47}, // + {0xF5C9,0x5dcb}, // + {0xF5CA,0x5dcf}, // + {0xF5CB,0x5ef1}, // + {0xF5CC,0x61fd}, // + {0xF5CD,0x651b}, // + {0xF5CE,0x6b02}, // + {0xF5CF,0x6afc}, // + {0xF5D0,0x6b03}, // + {0xF5D1,0x6af8}, // + {0xF5D2,0x6b00}, // + {0xF5D3,0x7043}, // + {0xF5D4,0x7044}, // + {0xF5D5,0x704a}, // + {0xF5D6,0x7048}, // + {0xF5D7,0x7049}, // + {0xF5D8,0x7045}, // + {0xF5D9,0x7046}, // + {0xF5DA,0x721d}, // + {0xF5DB,0x721a}, // + {0xF5DC,0x7219}, // + {0xF5DD,0x737e}, // + {0xF5DE,0x7517}, // + {0xF5DF,0x766a}, // + {0xF5E0,0x77d0}, // + {0xF5E1,0x792d}, // + {0xF5E2,0x7931}, // + {0xF5E3,0x792f}, // + {0xF5E4,0x7c54}, // + {0xF5E5,0x7c53}, // + {0xF5E6,0x7cf2}, // + {0xF5E7,0x7e8a}, // + {0xF5E8,0x7e87}, // + {0xF5E9,0x7e88}, // + {0xF5EA,0x7e8b}, // + {0xF5EB,0x7e86}, // + {0xF5EC,0x7e8d}, // + {0xF5ED,0x7f4d}, // + {0xF5EE,0x7fbb}, // + {0xF5EF,0x8030}, // + {0xF5F0,0x81dd}, // + {0xF5F1,0x8618}, // + {0xF5F2,0x862a}, // + {0xF5F3,0x8626}, // + {0xF5F4,0x861f}, // + {0xF5F5,0x8623}, // + {0xF5F6,0x861c}, // + {0xF5F7,0x8619}, // + {0xF5F8,0x8627}, // + {0xF5F9,0x862e}, // + {0xF5FA,0x8621}, // + {0xF5FB,0x8620}, // + {0xF5FC,0x8629}, // + {0xF5FD,0x861e}, // + {0xF5FE,0x8625}, // + {0xF640,0x8829}, // + {0xF641,0x881d}, // + {0xF642,0x881b}, // + {0xF643,0x8820}, // + {0xF644,0x8824}, // + {0xF645,0x881c}, // + {0xF646,0x882b}, // + {0xF647,0x884a}, // + {0xF648,0x896d}, // + {0xF649,0x8969}, // + {0xF64A,0x896e}, // + {0xF64B,0x896b}, // + {0xF64C,0x89fa}, // + {0xF64D,0x8b79}, // + {0xF64E,0x8b78}, // + {0xF64F,0x8b45}, // + {0xF650,0x8b7a}, // + {0xF651,0x8b7b}, // + {0xF652,0x8d10}, // + {0xF653,0x8d14}, // + {0xF654,0x8daf}, // + {0xF655,0x8e8e}, // + {0xF656,0x8e8c}, // + {0xF657,0x8f5e}, // + {0xF658,0x8f5b}, // + {0xF659,0x8f5d}, // + {0xF65A,0x9146}, // + {0xF65B,0x9144}, // + {0xF65C,0x9145}, // + {0xF65D,0x91b9}, // + {0xF65E,0x943f}, // + {0xF65F,0x943b}, // + {0xF660,0x9436}, // + {0xF661,0x9429}, // + {0xF662,0x943d}, // + {0xF663,0x943c}, // + {0xF664,0x9430}, // + {0xF665,0x9439}, // + {0xF666,0x942a}, // + {0xF667,0x9437}, // + {0xF668,0x942c}, // + {0xF669,0x9440}, // + {0xF66A,0x9431}, // + {0xF66B,0x95e5}, // + {0xF66C,0x95e4}, // + {0xF66D,0x95e3}, // + {0xF66E,0x9735}, // + {0xF66F,0x973a}, // + {0xF670,0x97bf}, // + {0xF671,0x97e1}, // + {0xF672,0x9864}, // + {0xF673,0x98c9}, // + {0xF674,0x98c6}, // + {0xF675,0x98c0}, // + {0xF676,0x9958}, // + {0xF677,0x9956}, // + {0xF678,0x9a39}, // + {0xF679,0x9a3d}, // + {0xF67A,0x9a46}, // + {0xF67B,0x9a44}, // + {0xF67C,0x9a42}, // + {0xF67D,0x9a41}, // + {0xF67E,0x9a3a}, // + {0xF6A1,0x9a3f}, // + {0xF6A2,0x9acd}, // + {0xF6A3,0x9b15}, // + {0xF6A4,0x9b17}, // + {0xF6A5,0x9b18}, // + {0xF6A6,0x9b16}, // + {0xF6A7,0x9b3a}, // + {0xF6A8,0x9b52}, // + {0xF6A9,0x9c2b}, // + {0xF6AA,0x9c1d}, // + {0xF6AB,0x9c1c}, // + {0xF6AC,0x9c2c}, // + {0xF6AD,0x9c23}, // + {0xF6AE,0x9c28}, // + {0xF6AF,0x9c29}, // + {0xF6B0,0x9c24}, // + {0xF6B1,0x9c21}, // + {0xF6B2,0x9db7}, // + {0xF6B3,0x9db6}, // + {0xF6B4,0x9dbc}, // + {0xF6B5,0x9dc1}, // + {0xF6B6,0x9dc7}, // + {0xF6B7,0x9dca}, // + {0xF6B8,0x9dcf}, // + {0xF6B9,0x9dbe}, // + {0xF6BA,0x9dc5}, // + {0xF6BB,0x9dc3}, // + {0xF6BC,0x9dbb}, // + {0xF6BD,0x9db5}, // + {0xF6BE,0x9dce}, // + {0xF6BF,0x9db9}, // + {0xF6C0,0x9dba}, // + {0xF6C1,0x9dac}, // + {0xF6C2,0x9dc8}, // + {0xF6C3,0x9db1}, // + {0xF6C4,0x9dad}, // + {0xF6C5,0x9dcc}, // + {0xF6C6,0x9db3}, // + {0xF6C7,0x9dcd}, // + {0xF6C8,0x9db2}, // + {0xF6C9,0x9e7a}, // + {0xF6CA,0x9e9c}, // + {0xF6CB,0x9eeb}, // + {0xF6CC,0x9eee}, // + {0xF6CD,0x9eed}, // + {0xF6CE,0x9f1b}, // + {0xF6CF,0x9f18}, // + {0xF6D0,0x9f1a}, // + {0xF6D1,0x9f31}, // + {0xF6D2,0x9f4e}, // + {0xF6D3,0x9f65}, // + {0xF6D4,0x9f64}, // + {0xF6D5,0x9f92}, // + {0xF6D6,0x4eb9}, // + {0xF6D7,0x56c6}, // + {0xF6D8,0x56c5}, // + {0xF6D9,0x56cb}, // + {0xF6DA,0x5971}, // + {0xF6DB,0x5b4b}, // + {0xF6DC,0x5b4c}, // + {0xF6DD,0x5dd5}, // + {0xF6DE,0x5dd1}, // + {0xF6DF,0x5ef2}, // + {0xF6E0,0x6521}, // + {0xF6E1,0x6520}, // + {0xF6E2,0x6526}, // + {0xF6E3,0x6522}, // + {0xF6E4,0x6b0b}, // + {0xF6E5,0x6b08}, // + {0xF6E6,0x6b09}, // + {0xF6E7,0x6c0d}, // + {0xF6E8,0x7055}, // + {0xF6E9,0x7056}, // + {0xF6EA,0x7057}, // + {0xF6EB,0x7052}, // + {0xF6EC,0x721e}, // + {0xF6ED,0x721f}, // + {0xF6EE,0x72a9}, // + {0xF6EF,0x737f}, // + {0xF6F0,0x74d8}, // + {0xF6F1,0x74d5}, // + {0xF6F2,0x74d9}, // + {0xF6F3,0x74d7}, // + {0xF6F4,0x766d}, // + {0xF6F5,0x76ad}, // + {0xF6F6,0x7935}, // + {0xF6F7,0x79b4}, // + {0xF6F8,0x7a70}, // + {0xF6F9,0x7a71}, // + {0xF6FA,0x7c57}, // + {0xF6FB,0x7c5c}, // + {0xF6FC,0x7c59}, // + {0xF6FD,0x7c5b}, // + {0xF6FE,0x7c5a}, // + {0xF740,0x7cf4}, // + {0xF741,0x7cf1}, // + {0xF742,0x7e91}, // + {0xF743,0x7f4f}, // + {0xF744,0x7f87}, // + {0xF745,0x81de}, // + {0xF746,0x826b}, // + {0xF747,0x8634}, // + {0xF748,0x8635}, // + {0xF749,0x8633}, // + {0xF74A,0x862c}, // + {0xF74B,0x8632}, // + {0xF74C,0x8636}, // + {0xF74D,0x882c}, // + {0xF74E,0x8828}, // + {0xF74F,0x8826}, // + {0xF750,0x882a}, // + {0xF751,0x8825}, // + {0xF752,0x8971}, // + {0xF753,0x89bf}, // + {0xF754,0x89be}, // + {0xF755,0x89fb}, // + {0xF756,0x8b7e}, // + {0xF757,0x8b84}, // + {0xF758,0x8b82}, // + {0xF759,0x8b86}, // + {0xF75A,0x8b85}, // + {0xF75B,0x8b7f}, // + {0xF75C,0x8d15}, // + {0xF75D,0x8e95}, // + {0xF75E,0x8e94}, // + {0xF75F,0x8e9a}, // + {0xF760,0x8e92}, // + {0xF761,0x8e90}, // + {0xF762,0x8e96}, // + {0xF763,0x8e97}, // + {0xF764,0x8f60}, // + {0xF765,0x8f62}, // + {0xF766,0x9147}, // + {0xF767,0x944c}, // + {0xF768,0x9450}, // + {0xF769,0x944a}, // + {0xF76A,0x944b}, // + {0xF76B,0x944f}, // + {0xF76C,0x9447}, // + {0xF76D,0x9445}, // + {0xF76E,0x9448}, // + {0xF76F,0x9449}, // + {0xF770,0x9446}, // + {0xF771,0x973f}, // + {0xF772,0x97e3}, // + {0xF773,0x986a}, // + {0xF774,0x9869}, // + {0xF775,0x98cb}, // + {0xF776,0x9954}, // + {0xF777,0x995b}, // + {0xF778,0x9a4e}, // + {0xF779,0x9a53}, // + {0xF77A,0x9a54}, // + {0xF77B,0x9a4c}, // + {0xF77C,0x9a4f}, // + {0xF77D,0x9a48}, // + {0xF77E,0x9a4a}, // + {0xF7A1,0x9a49}, // + {0xF7A2,0x9a52}, // + {0xF7A3,0x9a50}, // + {0xF7A4,0x9ad0}, // + {0xF7A5,0x9b19}, // + {0xF7A6,0x9b2b}, // + {0xF7A7,0x9b3b}, // + {0xF7A8,0x9b56}, // + {0xF7A9,0x9b55}, // + {0xF7AA,0x9c46}, // + {0xF7AB,0x9c48}, // + {0xF7AC,0x9c3f}, // + {0xF7AD,0x9c44}, // + {0xF7AE,0x9c39}, // + {0xF7AF,0x9c33}, // + {0xF7B0,0x9c41}, // + {0xF7B1,0x9c3c}, // + {0xF7B2,0x9c37}, // + {0xF7B3,0x9c34}, // + {0xF7B4,0x9c32}, // + {0xF7B5,0x9c3d}, // + {0xF7B6,0x9c36}, // + {0xF7B7,0x9ddb}, // + {0xF7B8,0x9dd2}, // + {0xF7B9,0x9dde}, // + {0xF7BA,0x9dda}, // + {0xF7BB,0x9dcb}, // + {0xF7BC,0x9dd0}, // + {0xF7BD,0x9ddc}, // + {0xF7BE,0x9dd1}, // + {0xF7BF,0x9ddf}, // + {0xF7C0,0x9de9}, // + {0xF7C1,0x9dd9}, // + {0xF7C2,0x9dd8}, // + {0xF7C3,0x9dd6}, // + {0xF7C4,0x9df5}, // + {0xF7C5,0x9dd5}, // + {0xF7C6,0x9ddd}, // + {0xF7C7,0x9eb6}, // + {0xF7C8,0x9ef0}, // + {0xF7C9,0x9f35}, // + {0xF7CA,0x9f33}, // + {0xF7CB,0x9f32}, // + {0xF7CC,0x9f42}, // + {0xF7CD,0x9f6b}, // + {0xF7CE,0x9f95}, // + {0xF7CF,0x9fa2}, // + {0xF7D0,0x513d}, // + {0xF7D1,0x5299}, // + {0xF7D2,0x58e8}, // + {0xF7D3,0x58e7}, // + {0xF7D4,0x5972}, // + {0xF7D5,0x5b4d}, // + {0xF7D6,0x5dd8}, // + {0xF7D7,0x882f}, // + {0xF7D8,0x5f4f}, // + {0xF7D9,0x6201}, // + {0xF7DA,0x6203}, // + {0xF7DB,0x6204}, // + {0xF7DC,0x6529}, // + {0xF7DD,0x6525}, // + {0xF7DE,0x6596}, // + {0xF7DF,0x66eb}, // + {0xF7E0,0x6b11}, // + {0xF7E1,0x6b12}, // + {0xF7E2,0x6b0f}, // + {0xF7E3,0x6bca}, // + {0xF7E4,0x705b}, // + {0xF7E5,0x705a}, // + {0xF7E6,0x7222}, // + {0xF7E7,0x7382}, // + {0xF7E8,0x7381}, // + {0xF7E9,0x7383}, // + {0xF7EA,0x7670}, // + {0xF7EB,0x77d4}, // + {0xF7EC,0x7c67}, // + {0xF7ED,0x7c66}, // + {0xF7EE,0x7e95}, // + {0xF7EF,0x826c}, // + {0xF7F0,0x863a}, // + {0xF7F1,0x8640}, // + {0xF7F2,0x8639}, // + {0xF7F3,0x863c}, // + {0xF7F4,0x8631}, // + {0xF7F5,0x863b}, // + {0xF7F6,0x863e}, // + {0xF7F7,0x8830}, // + {0xF7F8,0x8832}, // + {0xF7F9,0x882e}, // + {0xF7FA,0x8833}, // + {0xF7FB,0x8976}, // + {0xF7FC,0x8974}, // + {0xF7FD,0x8973}, // + {0xF7FE,0x89fe}, // + {0xF840,0x8b8c}, // + {0xF841,0x8b8e}, // + {0xF842,0x8b8b}, // + {0xF843,0x8b88}, // + {0xF844,0x8c45}, // + {0xF845,0x8d19}, // + {0xF846,0x8e98}, // + {0xF847,0x8f64}, // + {0xF848,0x8f63}, // + {0xF849,0x91bc}, // + {0xF84A,0x9462}, // + {0xF84B,0x9455}, // + {0xF84C,0x945d}, // + {0xF84D,0x9457}, // + {0xF84E,0x945e}, // + {0xF84F,0x97c4}, // + {0xF850,0x97c5}, // + {0xF851,0x9800}, // + {0xF852,0x9a56}, // + {0xF853,0x9a59}, // + {0xF854,0x9b1e}, // + {0xF855,0x9b1f}, // + {0xF856,0x9b20}, // + {0xF857,0x9c52}, // + {0xF858,0x9c58}, // + {0xF859,0x9c50}, // + {0xF85A,0x9c4a}, // + {0xF85B,0x9c4d}, // + {0xF85C,0x9c4b}, // + {0xF85D,0x9c55}, // + {0xF85E,0x9c59}, // + {0xF85F,0x9c4c}, // + {0xF860,0x9c4e}, // + {0xF861,0x9dfb}, // + {0xF862,0x9df7}, // + {0xF863,0x9def}, // + {0xF864,0x9de3}, // + {0xF865,0x9deb}, // + {0xF866,0x9df8}, // + {0xF867,0x9de4}, // + {0xF868,0x9df6}, // + {0xF869,0x9de1}, // + {0xF86A,0x9dee}, // + {0xF86B,0x9de6}, // + {0xF86C,0x9df2}, // + {0xF86D,0x9df0}, // + {0xF86E,0x9de2}, // + {0xF86F,0x9dec}, // + {0xF870,0x9df4}, // + {0xF871,0x9df3}, // + {0xF872,0x9de8}, // + {0xF873,0x9ded}, // + {0xF874,0x9ec2}, // + {0xF875,0x9ed0}, // + {0xF876,0x9ef2}, // + {0xF877,0x9ef3}, // + {0xF878,0x9f06}, // + {0xF879,0x9f1c}, // + {0xF87A,0x9f38}, // + {0xF87B,0x9f37}, // + {0xF87C,0x9f36}, // + {0xF87D,0x9f43}, // + {0xF87E,0x9f4f}, // + {0xF8A1,0x9f71}, // + {0xF8A2,0x9f70}, // + {0xF8A3,0x9f6e}, // + {0xF8A4,0x9f6f}, // + {0xF8A5,0x56d3}, // + {0xF8A6,0x56cd}, // + {0xF8A7,0x5b4e}, // + {0xF8A8,0x5c6d}, // + {0xF8A9,0x652d}, // + {0xF8AA,0x66ed}, // + {0xF8AB,0x66ee}, // + {0xF8AC,0x6b13}, // + {0xF8AD,0x705f}, // + {0xF8AE,0x7061}, // + {0xF8AF,0x705d}, // + {0xF8B0,0x7060}, // + {0xF8B1,0x7223}, // + {0xF8B2,0x74db}, // + {0xF8B3,0x74e5}, // + {0xF8B4,0x77d5}, // + {0xF8B5,0x7938}, // + {0xF8B6,0x79b7}, // + {0xF8B7,0x79b6}, // + {0xF8B8,0x7c6a}, // + {0xF8B9,0x7e97}, // + {0xF8BA,0x7f89}, // + {0xF8BB,0x826d}, // + {0xF8BC,0x8643}, // + {0xF8BD,0x8838}, // + {0xF8BE,0x8837}, // + {0xF8BF,0x8835}, // + {0xF8C0,0x884b}, // + {0xF8C1,0x8b94}, // + {0xF8C2,0x8b95}, // + {0xF8C3,0x8e9e}, // + {0xF8C4,0x8e9f}, // + {0xF8C5,0x8ea0}, // + {0xF8C6,0x8e9d}, // + {0xF8C7,0x91be}, // + {0xF8C8,0x91bd}, // + {0xF8C9,0x91c2}, // + {0xF8CA,0x946b}, // + {0xF8CB,0x9468}, // + {0xF8CC,0x9469}, // + {0xF8CD,0x96e5}, // + {0xF8CE,0x9746}, // + {0xF8CF,0x9743}, // + {0xF8D0,0x9747}, // + {0xF8D1,0x97c7}, // + {0xF8D2,0x97e5}, // + {0xF8D3,0x9a5e}, // + {0xF8D4,0x9ad5}, // + {0xF8D5,0x9b59}, // + {0xF8D6,0x9c63}, // + {0xF8D7,0x9c67}, // + {0xF8D8,0x9c66}, // + {0xF8D9,0x9c62}, // + {0xF8DA,0x9c5e}, // + {0xF8DB,0x9c60}, // + {0xF8DC,0x9e02}, // + {0xF8DD,0x9dfe}, // + {0xF8DE,0x9e07}, // + {0xF8DF,0x9e03}, // + {0xF8E0,0x9e06}, // + {0xF8E1,0x9e05}, // + {0xF8E2,0x9e00}, // + {0xF8E3,0x9e01}, // + {0xF8E4,0x9e09}, // + {0xF8E5,0x9dff}, // + {0xF8E6,0x9dfd}, // + {0xF8E7,0x9e04}, // + {0xF8E8,0x9ea0}, // + {0xF8E9,0x9f1e}, // + {0xF8EA,0x9f46}, // + {0xF8EB,0x9f74}, // + {0xF8EC,0x9f75}, // + {0xF8ED,0x9f76}, // + {0xF8EE,0x56d4}, // + {0xF8EF,0x652e}, // + {0xF8F0,0x65b8}, // + {0xF8F1,0x6b18}, // + {0xF8F2,0x6b19}, // + {0xF8F3,0x6b17}, // + {0xF8F4,0x6b1a}, // + {0xF8F5,0x7062}, // + {0xF8F6,0x7226}, // + {0xF8F7,0x72aa}, // + {0xF8F8,0x77d8}, // + {0xF8F9,0x77d9}, // + {0xF8FA,0x7939}, // + {0xF8FB,0x7c69}, // + {0xF8FC,0x7c6b}, // + {0xF8FD,0x7cf6}, // + {0xF8FE,0x7e9a}, // + {0xF940,0x7e98}, // + {0xF941,0x7e9b}, // + {0xF942,0x7e99}, // + {0xF943,0x81e0}, // + {0xF944,0x81e1}, // + {0xF945,0x8646}, // + {0xF946,0x8647}, // + {0xF947,0x8648}, // + {0xF948,0x8979}, // + {0xF949,0x897a}, // + {0xF94A,0x897c}, // + {0xF94B,0x897b}, // + {0xF94C,0x89ff}, // + {0xF94D,0x8b98}, // + {0xF94E,0x8b99}, // + {0xF94F,0x8ea5}, // + {0xF950,0x8ea4}, // + {0xF951,0x8ea3}, // + {0xF952,0x946e}, // + {0xF953,0x946d}, // + {0xF954,0x946f}, // + {0xF955,0x9471}, // + {0xF956,0x9473}, // + {0xF957,0x9749}, // + {0xF958,0x9872}, // + {0xF959,0x995f}, // + {0xF95A,0x9c68}, // + {0xF95B,0x9c6e}, // + {0xF95C,0x9c6d}, // + {0xF95D,0x9e0b}, // + {0xF95E,0x9e0d}, // + {0xF95F,0x9e10}, // + {0xF960,0x9e0f}, // + {0xF961,0x9e12}, // + {0xF962,0x9e11}, // + {0xF963,0x9ea1}, // + {0xF964,0x9ef5}, // + {0xF965,0x9f09}, // + {0xF966,0x9f47}, // + {0xF967,0x9f78}, // + {0xF968,0x9f7b}, // + {0xF969,0x9f7a}, // + {0xF96A,0x9f79}, // + {0xF96B,0x571e}, // + {0xF96C,0x7066}, // + {0xF96D,0x7c6f}, // + {0xF96E,0x883c}, // + {0xF96F,0x8db2}, // + {0xF970,0x8ea6}, // + {0xF971,0x91c3}, // + {0xF972,0x9474}, // + {0xF973,0x9478}, // + {0xF974,0x9476}, // + {0xF975,0x9475}, // + {0xF976,0x9a60}, // + {0xF977,0x9c74}, // + {0xF978,0x9c73}, // + {0xF979,0x9c71}, // + {0xF97A,0x9c75}, // + {0xF97B,0x9e14}, // + {0xF97C,0x9e13}, // + {0xF97D,0x9ef6}, // + {0xF97E,0x9f0a}, // + {0xF9A1,0x9fa4}, // + {0xF9A2,0x7068}, // + {0xF9A3,0x7065}, // + {0xF9A4,0x7cf7}, // + {0xF9A5,0x866a}, // + {0xF9A6,0x883e}, // + {0xF9A7,0x883d}, // + {0xF9A8,0x883f}, // + {0xF9A9,0x8b9e}, // + {0xF9AA,0x8c9c}, // + {0xF9AB,0x8ea9}, // + {0xF9AC,0x8ec9}, // + {0xF9AD,0x974b}, // + {0xF9AE,0x9873}, // + {0xF9AF,0x9874}, // + {0xF9B0,0x98cc}, // + {0xF9B1,0x9961}, // + {0xF9B2,0x99ab}, // + {0xF9B3,0x9a64}, // + {0xF9B4,0x9a66}, // + {0xF9B5,0x9a67}, // + {0xF9B6,0x9b24}, // + {0xF9B7,0x9e15}, // + {0xF9B8,0x9e17}, // + {0xF9B9,0x9f48}, // + {0xF9BA,0x6207}, // + {0xF9BB,0x6b1e}, // + {0xF9BC,0x7227}, // + {0xF9BD,0x864c}, // + {0xF9BE,0x8ea8}, // + {0xF9BF,0x9482}, // + {0xF9C0,0x9480}, // + {0xF9C1,0x9481}, // + {0xF9C2,0x9a69}, // + {0xF9C3,0x9a68}, // + {0xF9C4,0x9b2e}, // + {0xF9C5,0x9e19}, // + {0xF9C6,0x7229}, // + {0xF9C7,0x864b}, // + {0xF9C8,0x8b9f}, // + {0xF9C9,0x9483}, // + {0xF9CA,0x9c79}, // + {0xF9CB,0x9eb7}, // + {0xF9CC,0x7675}, // + {0xF9CD,0x9a6b}, // + {0xF9CE,0x9c7a}, // + {0xF9CF,0x9e1d}, // + {0xF9D0,0x7069}, // + {0xF9D1,0x706a}, // + {0xF9D2,0x9ea4}, // + {0xF9D3,0x9f7e}, // + {0xF9D4,0x9f49}, // + {0xF9D5,0x9f98}, // + {0xF9D6,0x7881}, // [MOD20210517] Windows code page 950 addition + {0xF9D7,0x92b9}, // [MOD20210517] Windows code page 950 addition + {0xF9D8,0x88cf}, // [MOD20210517] Windows code page 950 addition + {0xF9D9,0x58bb}, // [MOD20210517] Windows code page 950 addition + {0xF9DA,0x6052}, // [MOD20210517] Windows code page 950 addition + {0xF9DB,0x7ca7}, // [MOD20210517] Windows code page 950 addition + {0xF9DC,0x5afa} // [MOD20210517] Windows code page 950 addition + }; + + static ON_SleepLock lock; + static ON_SimpleArray< ON_Big5UnicodePair > big5_to_unicode; + + if (big5_to_unicode.Capacity() > 0) + { + // big5_to_unicode[] is initialized. + return big5_to_unicode; + } + + const ON_SleepLockGuard getlock(lock); + if (big5_to_unicode.Capacity() > 0) + { + // by the time we got the lock another thread had initialized big5_to_unicode[]. + return big5_to_unicode; + } + + // thread safe one time initialization of big5_to_unicode[] + const int pairs_count = (int)(sizeof(pairs) / (2 * sizeof(pairs[0][0]))); + big5_to_unicode.Reserve(pairs_count); + unsigned prev_big5_code_point = 0; + for (int i = 0; i < pairs_count; ++i) + { + const ON_Big5UnicodePair pair = ON_Big5UnicodePair::Create(ON_Big5CodePoint::Create(pairs[i][0]), ON_UnicodeShortCodePoint::Create(pairs[i][1])); + const unsigned big5_code_point = pair.Big5CodePoint(); + if (pair.IsValid(false, false) && big5_code_point > prev_big5_code_point) + { + prev_big5_code_point = big5_code_point; + big5_to_unicode.Append(pair); + } + else + { + // Bug introduced after May 2021. + ON_ERROR("pairs[][2] is no longer valid."); + } + } + + return big5_to_unicode; +} + +const ON_SimpleArray< ON_Big5UnicodePair >& ON_Big5UnicodePair::UnicodeToBig5() +{ + static ON_SleepLock lock; + static ON_SimpleArray< ON_Big5UnicodePair > unicode_to_big5; + + if (unicode_to_big5.Capacity() > 0) + return unicode_to_big5; + + + const ON_SleepLockGuard getlock(lock); + if (unicode_to_big5.Capacity() > 0) + return unicode_to_big5; + + const ON_SimpleArray< ON_Big5UnicodePair >& big5_to_unicode = ON_Big5UnicodePair::Big5ToUnicode(); + const int count0 = big5_to_unicode.Count(); + if (count0 <= 0) + return unicode_to_big5; + + ON_MemoryAllocationTracking debug_memory_tracking(false); + + + const ON_Big5UnicodePair u_big5_pair_fix[][2] = + { + // big5_to_unicode[] maps BIG5 code points 0xA2CC and 0xA451 to U+5341. + // U+5341 is a character that looks like U+3038 HANGZHOU NUMERAL TEN + // To make unicode_to_big5[] a well defined Unicode to BIG5 map, + // (0xA2CC,U+5341) is replaced with (0xA2CC,U+3038). + {ON_Big5UnicodePair::Create(0xA2CC,0x5341),ON_Big5UnicodePair::Create(0xA2CC,0x3038)}, + + // big5_to_unicode[] maps BIG5 code points 0xA2CE and 0xA4CA to U+5345. + // U+5345 is a character that looks like U+303A HANGZHOU NUMERAL THIRTY + // To make unicode_to_big5[] a well defined Unicode to BIG5 map, + // (0xA2CE,U+5345) is replaced with (0xA2CE,U+303A). + {ON_Big5UnicodePair::Create(0xA2CE,0x5345),ON_Big5UnicodePair::Create(0xA2CE,0x303A)}, + }; + + const ON_Big5UnicodePair u_big5_pair_add[] = + { + // big5_to_unicode[] maps BIG5 code point 0xA2CD to U+5344. + // U+5344 is a character that looks like U+3039 HANGZHOU NUMERAL TWENTY + // (0xA2CD,U+3039) is added to unicode_to_big5[]. + ON_Big5UnicodePair::Create(0xA2CD,0x3039), + }; + + unicode_to_big5.Reserve(count0 + ((int)(sizeof(u_big5_pair_add)/sizeof(u_big5_pair_add[0])))); + unicode_to_big5.Append(count0, big5_to_unicode.Array()); + + // Dictionary sort unicode_to_big5[] by Uniocode then BIG5 code point. + // (There are typically duplicate Unicode code points.) + unicode_to_big5.QuickSortAndRemoveDuplicates(ON_Big5UnicodePair::CompareUnicodeAndBig5CodePoints); + if (count0 != unicode_to_big5.Count()) + { + ON_ERROR("Input parameter ON_Big5UnicodePair::Big5ToUnicode() returned corrupt information."); + } + + // Locate the elements in unicode_to_big5[] where the fixes will be made. + int fixdex[sizeof(u_big5_pair_fix) / sizeof(u_big5_pair_fix[0])] = {}; + for (size_t i = 0; i < sizeof(u_big5_pair_fix) / sizeof(u_big5_pair_fix[0]); ++i) + { + const ON_Big5UnicodePair key = u_big5_pair_fix[i][0]; + const ON_Big5UnicodePair fix = u_big5_pair_fix[i][1]; + fixdex[i] + = (key.Unicode() != fix.Unicode() && key.Big5() == fix.Big5()) + ? unicode_to_big5.BinarySearch(&key, ON_Big5UnicodePair::CompareUnicodeAndBig5CodePoints) + : -1; + } + + // Fix those elements (after the first fix unicode_to_big5[] is no longer sorted). + for (size_t i = 0; i < sizeof(u_big5_pair_fix) / sizeof(u_big5_pair_fix[0]); ++i) + { + const ON_Big5UnicodePair key = u_big5_pair_fix[i][0]; + const ON_Big5UnicodePair fix = u_big5_pair_fix[i][1]; + const int j = fixdex[i]; + if (j >= 0 && key == unicode_to_big5[j]) + unicode_to_big5[j] = fix; + else + { + ON_ERROR("skipping a fix."); + } + } + + // Add additional UNICODE to BIG5 mappings. + unicode_to_big5.Append((int)(sizeof(u_big5_pair_add) / sizeof(u_big5_pair_add[0])), u_big5_pair_add); + + // Dictionary sort the fixed and expanded unicodeto_big5[] + const unsigned count1 = unicode_to_big5.UnsignedCount(); + unicode_to_big5.QuickSortAndRemoveDuplicates(ON_Big5UnicodePair::CompareUnicodeCodePoint); + if (count1 != unicode_to_big5.UnsignedCount()) + { + ON_ERROR("Invalid fixes or additions to unicodeto_big5[]."); + } + + return unicode_to_big5; +} diff --git a/opennurbs_unicode.h b/opennurbs_unicode.h index 30db5951..9d9da784 100644 --- a/opennurbs_unicode.h +++ b/opennurbs_unicode.h @@ -316,17 +316,6 @@ enum ON_UnicodeCodePoint /// ON_BlackRecyclingSymbol = 0x267B, - /// - /// BYTE ORDER MARK (BOM) U+FEFF - /// U+FEFF is used at the beginning of UTF encoded text to indicate the - /// byte order being used. It is valid for UTF-8 encoded text to begin - /// with the UTF-8 encoding of U+FEFF (0xEF,0xBB,0xBF). - /// This sometimes used to mark a char string as UTF-8 encoded. - /// and also occures when UTF-16 and UTF-32 encoded text with a byte - /// order mark is converted to UTF-8 encoded text. - /// - ON_ByteOrderMark = 0xFEFF, - /// /// REPLACEMENT CHARACTER U+FFFD (�) /// By convention, U+FFFD is used to mark string elements where @@ -334,6 +323,18 @@ enum ON_UnicodeCodePoint /// ON_ReplacementCharacter = 0xFFFD, + /// + /// BYTE ORDER MARK (BOM) U+FEFF + /// 0xFEFF is used at the beginning of UTF encoded text to indicate the + /// byte order being used. It is valid for UTF-8 encoded text to begin + /// with the UTF-8 encoding of U+FEFF (0xEF,0xBB,0xBF). + /// This sometimes used to mark a char string as UTF-8 encoded. + /// and also occures when UTF-16 and UTF-32 encoded text with a byte + /// order mark is converted to UTF-8 encoded text. + /// The Unicode specification states that the 0xFFFE is <not a character>. + /// + ON_ByteOrderMark = 0xFEFF, + /// /// WASTEBASKET U+1F5D1 (🗑) /// The wastebasket is a good code point to test glyph rendering and UTF-16 surrogate pair encodings. @@ -344,6 +345,7 @@ enum ON_UnicodeCodePoint /// /// The maximum valid unicode code point value is 0x10FFFF. + /// The Unicode specification states that 0x10FFFF is <not a character>. /// ON_MaximumCodePoint = 0x10FFFF, @@ -421,20 +423,18 @@ unsigned int ON_UTFSizeofByteOrderMark( /* Description: - Test a value to determine if it is a valid unicode code point value. + Test a value to determine if it is a valid Unicode code point value. Parameters: u - [in] value to test Returns: - true: u is a valid unicode code point - false: u is not a valid unicode code point + If u is valid Unicode code point, then true is returned. Otherwise false is returned. Remarks: - Valid unicode code point values u satisfy - (0 <= u && u <= 0xD7FF) || (0xE000 <= u && u <= 0x10FFFF) + This function returns true for the Unicode byte order mark U+FFFE. */ ON_DECL int ON_IsValidUnicodeCodePoint( - ON__UINT32 u - ); + ON__UINT32 unicode_code_point +); /* Returns: @@ -3588,9 +3588,12 @@ int ON_ConvertUTF32ToWideChar( /* Description: Convert a string from a Microsoft multibyte code page encoding - to a wide string using the native platform's wchar_t encoding. + to a wide string using UTF-8 / UTF-16 / UTF-32 encoding + (depending on the size of wchar_t). This function is designed to be used to parse portions of - rich text RTF in ON_TextContent and user interface code. + rich text RTF in ON_TextContent, strings from outside sources + with known MBCS encodings, and some user interface code. + Opennnurbs assumes all other char strings are UTF-8 encoded. If 1 = sizeof(wchar_t), then UTF-8 encoding is used for the @@ -3606,14 +3609,14 @@ Description: Parameters: windows_code_page - [in] - THe windows code page specifices the encoding of the sMBCS string. + The windows code page specifices the encoding of the sMBCS string. sMBCS - [in] Windows multibyte string with encoding identified by windows_code_page. sMBCS_count - [in] If sMBCS_count >= 0, then it specifies the number of - char elements in sMBCS[] to convert. + char elements (bytes) in sMBCS[] to convert. If sMBCS_count == -1, then sMBCS must be a null terminated string and all the elements up to the first null element are @@ -3671,6 +3674,91 @@ int ON_ConvertMSMBCPToWideChar( ); +/* +Description: + Convert a string from UTF-8/UTF=16/UTF-32 encoding (depending on size of wchar_t) + to a Microsoft multibyte code page encoding. + + This function is designed to be used to create strings that will + be used write files that require non-UTF encoded char strings. + + Opennnurbs assumes all other char strings are UTF-8 encoded. + + If 1 = sizeof(wchar_t), then sWideChar must be UTF-8 encoded. + + If 2 = sizeof(wchar_t), then sWideChar must be UTF-16 encoded. + + If 4 = sizeof(wchar_t), then sWideChar must be UTF-16 or UTF-32 encoded. + +Parameters: + windows_code_page - [in] + THe windows code page specifices the encoding of the sMBCS string. + + sWideChar - [out] + The input UTF encoded string. If sWideChar_count is -1, this string + must be null terminated. If sWideChar_count > 0, the string + must has sWideChar_count wchar_t elements that are a UTF encoding. + + sWideChar_count - [in] + If sWideChar_capacity > 0, then it specifies the number of wchar_t + elements in the sWideChar[] to convert. + + If sWideChar_count == -1, then sWideChar must be a null terminated + string and all the elements up to the first null element are + converted. + + sMBCS - [out] + If sMBCS is not null and sMBCS_count > 0, then the + output MBCS encoded string is returned in this buffer. + If there is room for the null terminator, the converted string + will be null terminated. The null terminator is never included + in the count of returned by this function. + + sMBCS_capacity - [in] + If sWideChar_capacity > 0, then it specifies the number of available + char elements (bytes) in the sMBCS[] buffer. + + If sMBCS_capacity == 0, then the sMBCS parameter is ignored. + + error_status - [out] + If error_status is not null, then bits of *error_status are + set to indicate the success or failure of the conversion. + When the error_mask parameter is used to used to mask some + conversion errors, multiple bits may be set. + 0: Successful conversion with no errors. + 1: The input parameters were invalid. + This error cannot be masked. + 2: The ouput buffer was not large enough to hold the converted + string. As much conversion as possible is performed in this + case and the error cannot be masked. + 16: An illegal encoding sequence occurred or a UNICODE codepoint + was encountered that cannot be encoded in the code page + specified by windows_code_page. In either case, a + a single question mark (?) in the output string + and parsing continues. + +Returns: + If sMBCS_capacity > 0, the return value is the number + MBCS encoded char elements written to sWideChar[]. + When the return value < sMBCSChar_capacity, + a null terminator is written to sWideChar[return value]. + + If sMBCS_count == 0, the return value is the minimum number of + char elements that are needed to hold the MBCS encode string. + The return value does not include room for a null terminator. + Increment the return value by one if you want to have an element + to use for a null terminator. +*/ +ON_DECL +int ON_ConvertWideCharToMSMBCP( + const wchar_t* sWideChar, + int sWideChar_count, + ON__UINT32 windows_code_page, + char* sMBCS, + int sMBCS_capacity, + unsigned int* error_status +); + ON_END_EXTERNC #if defined(ON_CPLUSPLUS) @@ -3703,6 +3791,36 @@ bool ON_Test_PrintPlatformMSSBCPToUnicodeTable( ON_TextLog& text_log ); +/* +Description: + Test a value to determine if it is a Unicode code point reserved for + private use (can be user defined). +Parameters: + unicode_code_point - [in] value to test +Returns: + If unicode_code_point is a private use Unicode code point, then true is returned. Otherwise false is returned. +*/ +ON_DECL +bool ON_IsPrivateUseUnicodeCodePoint( + ON__UINT32 unicode_code_point +); + +/* +Description: + Test a value to determine if it is a standard Unicode code point. +Parameters: + unicode_code_point - [in] value to test +Returns: + If unicode_code_point is a valid Unicode code point that is not reserved for private use + and not the Unicode byte order mark (U+FFFE), then true is returned. + Otherwise false is returned. +*/ +ON_DECL +bool ON_IsStandardUnicodeCodePoint( + ON__UINT32 unicode_code_point +); + + /* Parameters: code_point - [in] @@ -3793,6 +3911,335 @@ unsigned ON_UnicodeSubscriptFromDigit( unsigned decimal_digit ); +/// +/// ON_UnicodeShortCodePoint is a tool to use when working with Unicode code points +/// with values <=0xFFFF. +/// Note that valid Unicode code point values can be as large as 0x10FFFD. +/// (0x10FFFE and 0x10FFFF are specified as <not a character> by the Unicode Standard code chart +/// https://www.unicode.org/charts/PDF/U10FF80.pdf) +/// This class is used when converting between Unicode and BIG5 encodings and in other settings +/// where Unicode code points > 0xFFFF are not encountered +/// and the 2 byte size of ON_UnicodeShortCodePoint +/// appreciably more efficient that a 4 byte size of an unsigned int. +/// +class ON_CLASS ON_UnicodeShortCodePoint +{ +public: + ON_UnicodeShortCodePoint() = default; + ~ON_UnicodeShortCodePoint() = default; + ON_UnicodeShortCodePoint(const ON_UnicodeShortCodePoint&) = default; + ON_UnicodeShortCodePoint& operator=(const ON_UnicodeShortCodePoint&) = default; + +public: + /// + /// ON_UnicodeShortCodePoint::NUll has a code point value = 0. + /// + static const ON_UnicodeShortCodePoint Null; + + /// + /// ON_UnicodeShortCodePoint::ReplacementCharacter has a code point = U+FFFD. + /// + static const ON_UnicodeShortCodePoint ReplacementCharacter; + + /// + /// ON_UnicodeShortCodePoint::ByteOrderMark has a code point value = 0xFFFE. + /// (0xFFFE is not a Unicode character code point.) + /// + static const ON_UnicodeShortCodePoint ByteOrderMark; + + /// + /// ON_UnicodeShortCodePoint::Error has a code point value = 0xFFFF. + /// (0xFFFF is not a Unicode character code point.) + /// + static const ON_UnicodeShortCodePoint Error; + + /// + /// Creates a Unicode code point with the specified code point value. + /// + /// + /// A valid Unicode code point. + /// + /// + /// If unicode_code_point is <= 0xFFFE and a valid Unicode code point or + /// is the Unicode byte order mark (0xFFFE), then an instance with that + /// value as code point is returned. + /// Otherwise ON_UnicodeShortCodePoint::Error is returned. + /// Notes: + /// 1. Valid Unicode code points can be as large as 0x10FFFD and + /// ON_UnicodeShortCodePoint cannot accomodate code points >= U+10000. + /// 2. Values >= 0xD800 and < 0xE000 are not valid Unicode code points. + /// These values are used in UTF-16 surrogate pair encodings of code points >= U+10000. + /// + static const ON_UnicodeShortCodePoint Create(unsigned int unicode_code_point); + + /// + /// Find a Unicode code point with the same character as big5_code_point. + /// + /// + /// Value to return when big5_code_point is valid but does not map to a Unicode code point. + /// + /// If there is a corresponding BIG5 or ASCII code point, that code point is returned. + /// Otherwise, if big5_code_point is valid, not_available is returned. + /// Otherwise ON_UnicodeShortCodePoint::Error is returned. + /// + static const ON_UnicodeShortCodePoint CreateFromBig5( + unsigned int big5_code_point, + ON_UnicodeShortCodePoint not_available + ); + + /// + /// Find a Unicode code point with the same character as big5_code_point. + /// + /// + /// Value to return when big5_code_point is valid but does not map to a Unicode code point. + /// + /// If there is a corresponding BIG5 or ASCII code point, that code point is returned. + /// Otherwise, if big5_code_point is valid, not_available is returned. + /// Otherwise ON_UnicodeShortCodePoint::Error is returned. + /// + static const ON_UnicodeShortCodePoint CreateFromBig5( + const class ON_Big5CodePoint& big5_code_point, + ON_UnicodeShortCodePoint not_available + ); + + /// + /// Determine if this Unicode code point is 0. + /// + /// True if the code point value is 0. + bool IsNull() const; + + /// + /// The Unicode is a extension of ASCII encoding and code points <= 0x7F are valid Unicode code points. + /// + /// + /// Value to return if this Unicode code point equal to ON_UnicodeShortCodePoint::Null. + /// + /// True if the code point value &le= 0x7F. + /// + bool IsASCII(bool bNullIsASCII) const; + + /// + /// Determine if the Unicode code point is valid. + /// + /// + /// Value to return if the code point value is 0. + /// + /// + /// Value to return if the code point value is 0xFFFE. + /// + /// True if the code point value is a valud Unicode code point. + bool IsValid(bool bNullIsValid, bool bByteOrderMarkIsValid) const; + + /// + /// Unicode code points are separated into standard and private use (user defined) code points. + /// + /// + /// Value to return if the code point value is 0. + /// + /// Returns true this Unicode code point is a standard code point. + bool IsStandard(bool bNullIsValid) const; + + /// + /// Unicode code points are separated into standard and private use (user defined) code points. + /// + /// True if this Unicode code point is a private use (user defined) code point. + bool IsPrivateUse() const; + + /// + /// The Unicode code point U+FFFD is called the replacement character. + /// It is typically a light question mark with a dark diamond background. + /// It is often used to indicate a character is unknown, unavailable, does + /// not exist, or an error occured when creating that code point. + /// + /// True if this Unicode code point is U+FFFD. + bool IsReplacementCharacter() const; + + /// + /// The Unicode code point value 0xFFFE os not a character and is used as a byte order mark. + /// + /// True if this Unicode code point value is 0xFFFE. + bool IsByteOrderMark() const; + + unsigned int UnicodeCodePoint() const; + + static int Compare(const ON_UnicodeShortCodePoint* lhs, const ON_UnicodeShortCodePoint* rhs); +private: + ON__UINT16 m_unicode_code_point = 0; +}; + +ON_DECL bool operator==(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs); +ON_DECL bool operator!=(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs); +ON_DECL bool operator<=(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs); +ON_DECL bool operator>=(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs); +ON_DECL bool operator<(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs); +ON_DECL bool operator>(ON_UnicodeShortCodePoint lhs, ON_UnicodeShortCodePoint rhs); + + +/// +/// ON_Big5CodePoint is a tool to use when working with BIG5 encoded strings. +/// +class ON_CLASS ON_Big5CodePoint +{ +public: + /// + /// ON_Big5CodePoint::NUll has a code point value = 0. + /// + static const ON_Big5CodePoint Null; + + /// + /// ON_Big5CodePoint::Error has a code point value = 0xA3E1. + /// 0xA3E1 is in the BIG5 reserved section but old versions of Windows + /// mapped it to the Euro currency symbol. The main use of this code is to translate + /// from legacy BIG5 to Unicode, so this anomaly is supported. + /// + static const ON_Big5CodePoint WindowsEuro; + + /// + /// ON_Big5CodePoint::Error has a code point value = 0xFFFF. + /// (0xFFFF is not a valid BIG5 code point value.) + /// + static const ON_Big5CodePoint Error; + + static const char* Decode( + const char* buffer, + size_t buffer_count, + bool bParseNull, + bool bParseASCII, + ON_Big5CodePoint* big5_code_point + ); + + enum : unsigned int + { + MinimumCodePoint = 0x8140, + MinimumPrivateUseCodePoint = 0x8140, + MinimumStandardCodePoint = 0x8140, + MaximumStandardCodePoint = 0xF9D5, + MaximumPrivateUseCodePoint = 0xFEFE, + MaximumCodePoint = 0xFEFE + }; + + int Encode( + char* buffer, + size_t buffer_capacity + ) const; + + ON_Big5CodePoint() = default; + ~ON_Big5CodePoint() = default; + ON_Big5CodePoint(const ON_Big5CodePoint&) = default; + ON_Big5CodePoint& operator=(const ON_Big5CodePoint&) = default; + + /// + /// Creates a BIG5 code point with the specified code point value. + /// + /// + /// A valid BIG5 code point, ASCII code point (0x00-0x7E), or the + /// old Windows Euro currency symbol code point 0xA3E1 in the reserved area. + /// + /// + /// If big5_code_point is valid BIG5 code point or an ASCII code point, + /// then a ON_Big5CodePoint instance with that value as code point is returned. + /// Otherwise ON_Big5CodePoint::Error is returned. + /// + static const ON_Big5CodePoint Create(unsigned int big5_code_point); + + /// + /// Find a BIG5 code point with the same character as unicode_code_point. + /// + /// + /// Value to return when unicode_code_point is valid but does not mapt to a BIG5 code point. + /// + /// If there is a corresponding BIG5 or ASCII code point, that code point is returned. + /// Otherwise, if unicode_code_point is valid, not_available is returned. + /// Otherwise ON_Big5CodePoint::Error is returned. + /// + static const ON_Big5CodePoint CreateFromUnicode( + unsigned int unicode_code_point, + ON_Big5CodePoint not_available + ); + + /// + /// Find a BIG5 code point with the same character as unicode_code_point. + /// + /// + /// Value to return when unicode_code_point is valid but does not mapt to a BIG5 code point. + /// + /// If there is a corresponding BIG5 or ASCII code point, that code point is returned. + /// Otherwise, if unicode_code_point is valid, not_available is returned. + /// Otherwise ON_Big5CodePoint::Error is returned. + /// + static const ON_Big5CodePoint CreateFromUnicode( + const class ON_UnicodeShortCodePoint& unicode_code_point, + ON_Big5CodePoint not_available + ); + + /// + /// Determine if this BIG5 code point is 0. + /// + /// True if the code point value is 0. + bool IsNull() const; + + /// + /// Strictly speaking, BIG5 does not extend ASCII, but it is common to mix + /// single bytes ASCII and double byte BIG5 encodings in the same char string. + /// BIG5 is a double byte string encoding with the first byte in the range 0x81 to 0xFE, the + /// minimum BIG5 code point is 0x8140 and the maximum BIG5 code point is 0xFEFE. + /// Thus it is possible to mix ASCII and BIG5 encodings in the same char string. + /// + /// + /// Value to return if this BIG5 code point equal to ON_Big5CodePoint::Null. + /// + /// True if the code point value &le= 0x7F. + /// + bool IsASCII(bool bNullIsASCII) const; + + /// + /// Determine if the pair of code points is valid. + /// If the values for BIG5 and Unicode code point values are < 0xFF and equal, the pair is considered valid. + /// Use IsASCII() if you need to treat nonzero ASCII code points differently. + /// + /// + /// Value to return if the code point value is 0. + /// + /// + /// Value to return if the code point value is an ASCII code point (<= 0x7F). + /// + /// True if the code point value is a valud BIG5 code point. + bool IsValid(bool bNullIsValid, bool bASCIICodePointIsValid) const; + + /// + /// BIG5 code points in the ranges0xA140-0xA3Bf, 0xA440-0xC67E, and 0xC940-0xF9D5 + /// are standard code points. + /// + /// + /// Value to return if the code point value is 0. + /// + /// + /// Value to return if the code point value is an ASCII code point (<= 0x7F). + /// + /// Returns true this BIG5 code point is a standard code point. + bool IsStandard(bool bNullIsValid, bool bASCIICodePointIsValid) const; + + /// + /// BIG5 code points in the ranges 0xC6A1-0xC8FE, 0xC6A1-0xC8FE, and 0xF9D6-0xFEFE + /// are for private use (user defined characters). + /// + /// True if this BIG5 code point is a private use (user defined) code point. + bool IsPrivateUse() const; + + unsigned int Big5CodePoint() const; + + static int Compare(const ON_Big5CodePoint* lhs, const ON_Big5CodePoint* rhs); + +private: + ON__UINT16 m_big5_code_point = 0; +}; + +ON_DECL bool operator==(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs); +ON_DECL bool operator!=(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs); +ON_DECL bool operator<=(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs); +ON_DECL bool operator>=(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs); +ON_DECL bool operator<(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs); +ON_DECL bool operator>(ON_Big5CodePoint lhs, ON_Big5CodePoint rhs); #endif #endif diff --git a/opennurbs_xform.cpp b/opennurbs_xform.cpp index d74679d3..2101f694 100644 --- a/opennurbs_xform.cpp +++ b/opennurbs_xform.cpp @@ -944,6 +944,19 @@ ON_3dVector ON_Xform::operator*( const ON_3dVector& v ) const return ON_3dVector( xh[0],xh[1],xh[2] ); } +const ON_SHA1_Hash ON_Xform::Hash() const +{ + ON_SHA1 sha1; + sha1.AccumulateDoubleArray(16, &this->m_xform[0][0]); + return sha1.Hash(); +} + +ON__UINT32 ON_Xform::CRC32(ON__UINT32 current_remainder) const +{ + const ON_SHA1_Hash hash = this->Hash(); + return ON_CRC32(current_remainder, sizeof(hash), &hash); +} + bool ON_Xform::IsValid() const { const double* x = &m_xform[0][0]; @@ -1503,6 +1516,45 @@ bool ON_Xform::IsRotation() const return rc; } +bool ON_Xform::GetQuaternion(ON_Quaternion& Q) const +{ + bool rc = IsRotation(); + if (rc) + { + double theta = 0; + ON_3dVector Axis(m_xform[2][1] - m_xform[1][2], m_xform[0][2] - m_xform[2][0], m_xform[1][0] - m_xform[0][1]); + double Alen = Axis.Length(); + double trace = m_xform[0][0] + m_xform[1][1] + m_xform[2][2]; + + theta = atan2(Alen, trace - 1); // 0<= theta <= Pi/2 + + if(Alen>0.0 && trace> -.999) + Axis = 1.0 / Alen * Axis; + else + { + if (theta == 0.0) + Axis = ON_3dVector::ZAxis; // case where axis is unspecified + else + { + // Form off diagonal elements of the symmetric matrix (R+R^t)/2 + double S12 = (m_xform[1][2] + m_xform[2][1]) / 2; + double S13 = (m_xform[1][2] + m_xform[3][1]) / 2; + // double S23 = (m_xform[2][3] + m_xform[3][2]) / 2; + + double c = (1 - trace) / 2.0; // cos(theta) should be ~-1.0 + // magnitude of axis coefficients are compted as such: + for (int i = 0; i < 3; i++) + Axis[i] = sqrt((m_xform[i][i] - c) / (1 - c)); + // need to set the signs + if (S12 < 0) Axis[1] *= -1; + if (S13 < 0) Axis[2] *= -1; + } + } + Q.SetRotation(theta, Axis); + } + return rc; +} + bool ON_Xform::Orthogonalize(double tol) { bool rc = false; @@ -2065,6 +2117,227 @@ bool ON_Xform::GetEulerZYZ(double& alpha, double& beta, double& gamma)const return rc; } +bool ON_Xform::GetKMLOrientationAnglesRadians(double& heading_radians, double& tilt_radians, double& roll_radians ) const +{ + // NOTE: In KML, postive rotations are CLOCKWISE about the specified axis. + // This is opposite the conventional "right hand rule." + // https://developers.google.com/kml/documentation/kmlreference#orientation + heading_radians = ON_DBL_QNAN; + tilt_radians = ON_DBL_QNAN; + roll_radians = ON_DBL_QNAN; + + bool rc = false; + for (;;) + { + if (false == IsRotation()) + break; + + // sin(1 degree)^3 = 5e-6. + const double zero_tol = ON_ZERO_TOLERANCE; + ON_Xform clean(*this); + for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) + { + double x = (i < 3 && j < 3) ? m_xform[i][j] : ((3==i&&3==j) ? 1.0 : 0.0); + if (fabs(x) <= zero_tol) + x = 0.0; + else if (fabs(x-1.0) <= zero_tol) + x = 1.0; + else if (fabs(x+1.0) <= zero_tol) + x = -1.0; + else + continue; + clean.m_xform[i][j] = x; + } + if (false == clean.IsRotation()) + clean = *this; + + + // Set: h = -heading angle, t = -tilt angle, r = -roll angle. + // (negatives because KML angles are opposite the right hand rule direction, and trig works the other way.) // + // The KML specification says 0 <= heading <= 2pi, 0 <= tilt <= pi, 0 <= roll <= pi. + // So, if this transformation is really a KML rotation, then we are looking for h,t,r + // in the ranges -2pi <= h <= 0, -pi <= t <= 0, and -pi <= r <= 0. + // + // If you calculate the 3x3 KML orientation matrix M by hand, + // then you get + // M[1][0] = -sin(h)*cos(t) + // M[1][1] = +cos(h)*cos(t) + // M[2][0] = -cos(t)*sin(r) + // M[2][1] = +sin(t) + // M[2][2] = +cos(t)*cos(r) + // So, a bit of trigonometry and you have h, t, and r. + + // NOTE WELL: When cos(t) is very near zero, but not equal to zero, + // this calculation is unstable. In practice t is typically + // a integer number of degrees between 0 and 180, and this + // unstability rarely matters. + + // tol = one half an arc second. + // Should be way more precise than KML requires. + const double zero_angle_tol = (0.5 / (60.0 * 60.0)) * ON_DEGREES_TO_RADIANS; + double h = ON_DBL_QNAN; + double r = ON_DBL_QNAN; + double t = ON_DBL_QNAN; + if ( + (0.0 == clean.m_xform[0][1] && 0.0 == clean.m_xform[1][1]) + || + (0.0 == clean.m_xform[2][0] && 0.0 == clean.m_xform[2][2]) + || + (1.0 == fabs(clean.m_xform[2][1])) + ) + { + // In this case, cos(tilt angle) = 0, clean.m_xform[2][1] = sin(tilt angle) = +1 or -1. + // In this case it is impossible to distinguish between the initial rotation around + // the y axis and the final rototation around the z axis + // (tilt is the middle rotation afound the x axis). + // I'm choosing to set roll = 0 in this case. + h = atan2(clean.m_xform[1][0], clean.m_xform[0][0]); // = atan2(clean.m_xform[0][1], -clean.m_xform[1][2]) + if (fabs(h) <= zero_angle_tol) + h = 0.0; + r = 0.0; + t = clean.m_xform[2][1] < 0.0 ? -ON_HALFPI : ON_HALFPI; // t = asin(clean.m_xform[2][1]); + } + else + { + // KML wants -pi <= r <= 0, so sin(r) <= 0 + // clean.m_xform[2][0] = -cos(t)*sin(r) + const double sign_cos_t = (clean.m_xform[2][0] < 0.0) ? -1.0 : 1.0; + + h = atan2(-sign_cos_t * clean.m_xform[0][1], sign_cos_t * clean.m_xform[1][1]); + if (fabs(h) <= zero_angle_tol) + h = 0.0; + r = atan2(-sign_cos_t * clean.m_xform[2][0], sign_cos_t * clean.m_xform[2][2]); + + const double cos_h = cos(h); + const double sin_h = sin(h); + double cos_t + = (fabs(sin_h) >= fabs(cos_h)) + ? (-clean.m_xform[0][1] / sin_h) + : (clean.m_xform[1][1] / cos_h) + ; + t = asin(clean.m_xform[2][1]); + if (cos_t < 0.0) + { + // adjust the branch of t accordingly + // cos_t could have a fair bit of noise in it + // but the sign should generally be correct. + if (0.0 == t) + { + // KML specification has -pi <= t <= 0 + if (cos_t < -0.99) + t = -ON_PI; + } + else if (t > -ON_HALFPI && t < 0.0) + t = -ON_PI - t; + } + } + + if (h == h && r == r && t == t) + { + // NOTE: In KML, postive rotations are CLOCKWISE about the specified axis. + // This is opposite the conventional "right hand rule." + // https://developers.google.com/kml/documentation/kmlreference#orientation + heading_radians = -h; + if (heading_radians < 0.0) + heading_radians += ON_2PI; // KML wants headings >= 0. + tilt_radians = -t; + roll_radians = -r; + + // Specifying a 3D rotation as a sequence of rotations about fixed axes + // requires restricting rotations to intervals in order to get a one-to-one + // correspondence between the 3 angles and the rotation. KML specifies + // 0 <= heading < 360 + // 0 <= tilt <= 180 + // 0 <= roll <= 180 + // TODO - If the angles we have are not in the specified intervals, + // adjust them to produce the same rotation and be in the specified intervals. + rc = true; + } + + break; + } + return rc; +} + +static double Internal_RadiansToPrettyKMLDegrees(double r, double min_degrees) +{ + double d = r * ON_RADIANS_TO_DEGREES; + double f = floor(d); + if ( d-f > 0.5) + f += 1.0; + const double one_half_second_in_decimal_degrees = 0.5 / (60.0 * 60.0); + if ( fabs(d - f) < one_half_second_in_decimal_degrees) // fabs(d-f) + d = f; + if (d < min_degrees) + d += 360.0; + if (fabs(d) < one_half_second_in_decimal_degrees) + d = 0.0; // clean up -0.0 + return d; +} + +bool ON_Xform::GetKMLOrientationAnglesDegrees(double& heading_degrees, double& tilt_degrees, double& roll_degrees) const +{ + double heading_radians = ON_DBL_QNAN; + double tilt_radians = ON_DBL_QNAN; + double roll_radians = ON_DBL_QNAN; + const bool rc = ON_Xform::GetKMLOrientationAnglesRadians(heading_radians, tilt_radians, roll_radians); + heading_degrees = Internal_RadiansToPrettyKMLDegrees(heading_radians, 0.0); + tilt_degrees = Internal_RadiansToPrettyKMLDegrees(tilt_radians, -180.0); + roll_degrees = Internal_RadiansToPrettyKMLDegrees(roll_radians, -180.0); + return rc; +} + +const ON_Xform ON_Xform::RotationTransformationFromKMLAnglesRadians( + double heading_radians, + double tilt_radians, + double roll_radians +) +{ + // NOTE: In KML, postive rotations are CLOCKWISE looking down the specified axis towards the orgin. + // This is opposite the conventional "right hand rule." + // https://developers.google.com/kml/documentation/kmlreference#orientation + ON_Xform H, R, T; + // Standard trigonometry functons (cosine, sine, ...) follow the right hand rule + // convention, so the input angles must be negated. + H.Rotation(-heading_radians, ON_3dVector::ZAxis, ON_3dPoint::Origin); // KML Earth z-axis = up + T.Rotation(-tilt_radians, ON_3dVector::XAxis, ON_3dPoint::Origin); // KML Earth x-axis = east + R.Rotation(-roll_radians, ON_3dVector::YAxis, ON_3dPoint::Origin); // KML Earth y-axis = north + // KML specifes the rotation order as first R, second T, third H. + // Since openurbs ON_Xform acts on the left of points and vectors, + // H*T*R is the correct order. + // Example transformed_point = H*T*R*point (R is first, T is second, H is third). + ON_Xform kml_orientation = H * T * R; + + // clean up -0, .99999999999999999, and other similar results that + // commonly occur and commonly disturb novices. + for (int i = 0; i < 4; ++i) for (int j = 0; j < 4; ++j) + { + double x = kml_orientation.m_xform[i][j]; + if (fabs(x) <= ON_ZERO_TOLERANCE) + x = 0.0; + else if (fabs(x - 1.0) <= ON_ZERO_TOLERANCE) + x = 1.0; + else if (fabs(x + 1.0) <= ON_ZERO_TOLERANCE) + x = -1.0; + else + continue; + kml_orientation.m_xform[i][j] = x; + } + return kml_orientation; +} + +const ON_Xform ON_Xform::RotationTransformationFromKMLAnglesDegrees( + double heading_degrees, + double tilt_degrees, + double roll_degrees + ) +{ + return ON_Xform::RotationTransformationFromKMLAnglesRadians( + heading_degrees * ON_DEGREES_TO_RADIANS, + tilt_degrees * ON_DEGREES_TO_RADIANS, + roll_degrees * ON_DEGREES_TO_RADIANS + ); +} void ON_Xform::Mirror( ON_3dPoint point_on_mirror_plane, diff --git a/opennurbs_xform.h b/opennurbs_xform.h index 13d0d9e0..0c9a71fa 100644 --- a/opennurbs_xform.h +++ b/opennurbs_xform.h @@ -24,6 +24,7 @@ #define ON_XFORM_INC_ class ON_Matrix; +class ON_Quaternion; class ON_CLASS ON_Xform { @@ -140,6 +141,9 @@ public: ON_Xform operator+( const ON_Xform& ) const; ON_Xform operator-( const ON_Xform& /*rhs*/ ) const; + const ON_SHA1_Hash Hash() const; + ON__UINT32 CRC32(ON__UINT32 current_remainder) const; + /* Description: Test the entries of the transformation matrix @@ -325,6 +329,16 @@ public: // true if this is a proper rotation. bool IsRotation() const; + /* + Description: + If *this is a proper rotation then find the eqivalent quaternion. + Parameters: + Q - [out] Quaternion that represents this rotation tranformation + Returns: + True - if *this is a proper rotation + */ + bool GetQuaternion(ON_Quaternion& Q) const; + /* Description: An affine transformation can be decomposed into a Symmetric, Rotation and Translation. @@ -802,17 +816,169 @@ public: */ bool GetYawPitchRoll(double& yaw, double& pitch, double& roll)const; -/* -Description: - Create rotation transformation From Euler angles. -Parameters: - alpha - angle (in radians) to rotate about the Z axis - beta - angle (in radians) to rotate about the Y axis - gamma - angle (in radians) to rotate about the Z axis -Details: - RotationZYZ(alpha, beta, gamma) = R_z( alpha) * R_y(beta) * R_z(gamma) - where R_*(angle) is rotation of angle radians about the corresponding *-world coordinate axis. -*/ + /* + Description: + Find the Keyhole Markup Language (KML) orientation angles (in radians) of a rotation + transformation that maps model (east,north,up) to ((1,0,0),(0,1,0),(0,0,1)). + KML Earth Z axis = up, KML Earth X axis = east, KML Earth Y axis = north. + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Parameters: + heading_radians - [out] + angle (in radians) of rotation around KML Earth Z axis (Earth up). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + tilt_radians - [out] + angle (in radians) of rotation around KML Earth X axis (Earth east). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + roll_radians - [out] + angle (in radians) of rotation around KML Earth Y axis (Earth north). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Returns: + True if this transformation is a rotation and the KML angles are returned. + False if this transformation is not a rotation, in which case all returned + angle values are ON_DLB_QNAN. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + bool GetKMLOrientationAnglesRadians( + double& heading_radians, + double& tilt_radians, + double& roll_radians + ) const; + + /* + Description: + Find the Keyhole Markup Language (KML) orientation angles (in degrees) of a rotation + transformation that maps model (east,north,up) to ((1,0,0),(0,1,0),(0,0,1)). + KML Earth Z axis = up, KML Earth X axis = east, KML Earth Y axis = north. + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Parameters: + heading_degrees - [out] + angle (in degrees) of rotation around KML Earth Z axis (Earth up). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + tilt_degrees - [out] + angle (in degrees) of rotation around KML Earth X axis (Earth east). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + roll_degrees - [out] + angle (in degrees) of rotation around KML Earth Y axis (Earth north). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Returns: + True if this transformation is a rotation and the KML angles are returned. + False if this transformation is not a rotation, in which case all returned + angle values are ON_DLB_QNAN. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + bool GetKMLOrientationAnglesDegrees( + double& heading_degrees, + double& tilt_degrees, + double& roll_degrees + ) const; + + /* + Description: + Get a rotation transformation from the Keyhole Markup Language (KML) orientation angles in radians. + (KML Earth Z axis = up, KML Earth X axis = east, KML Earth Y axis = north). + KML rotations are applied in the following order: first roll, second tilt, third heading. + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Parameters: + heading_radians - [in] + angle (in radians) of rotation around KML Earth Z axis (Earth up). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. + If R = RotationTransformationFromKMLAnglesRadians(pi/2,0,0), + then R*(1,0,0) = (0,-1,0), R*(0,1,0) = (1,0,0), R*(0,0,1) = (0,0,1) + tilt_radians - [in] + angle (in radians) of rotation around KML Earth X axis (Earth east). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. + If R = RotationTransformationFromKMLAnglesRadians(0,pi/2,0), + then R*(1,0,0) = (1,0,0), R*(0,1,0) = (0,0,-1), R*(0,0,1) = (0,1,0) + roll_radians - [in] + angle (in radians) of rotation around KML Earth Y axis (Earth north). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. + If R = RotationTransformationFromKMLAnglesRadians(0,0,pi/2), + then R*(1,0,0) = (0,0,1), R*(0,1,0) = (0,1,0), R*(0,0,1) = (-1,0,0) + Returns: + If the input is valid, the rotation transformation is returned. + Otherwise the ON_Xform::Nan is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + static const ON_Xform RotationTransformationFromKMLAnglesRadians( + double heading_radians, + double tilt_radians, + double roll_radians + ); + + /* + Description: + Get a rotation transformation from the Keyhole Markup Language (KML) orientation angles in degrees. + (KML Earth Z axis = up, KML Earth X axis = east, KML Earth Y axis = north). + KML rotations are applied in the following order: first roll, second tilt, third heading. + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. This is rotation direction + is opposite the conventional "right hand rule." + Parameters: + heading_degrees - [in] + angle (in degrees) of rotation around KML Earth Z axis (Earth up). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. + If R = RotationTransformationFromKMLAnglesDegrees(90,0,0), + then R*(1,0,0) = (0,-1,0), R*(0,1,0) = (1,0,0), R*(0,0,1) = (0,0,1) + tilt_degrees - [in] + angle (in degrees) of rotation around KML Earth X axis (Earth east). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. + If R = RotationTransformationFromKMLAnglesDegrees(0,90,0), + then R*(1,0,0) = (1,0,0), R*(0,1,0) = (0,0,-1), R*(0,0,1) = (0,1,0) + roll_degrees - [in] + angle (in degrees) of rotation around KML Earth Y axis (Earth north). + NOTE WELL: In KML, postive rotations are CLOCKWISE looking down + specied axis vector towards the origin. + If R = RotationTransformationFromKMLAnglesDegrees(0,0,90), + then R*(1,0,0) = (0,0,1), R*(0,1,0) = (0,1,0), R*(0,0,1) = (-1,0,0) + Returns: + If the input is valid, the rotation transformation is returned. + Otherwise the ON_Xform::Nan is returned. + See Also: + https://developers.google.com/kml/documentation/kmlreference#orientation + */ + static const ON_Xform RotationTransformationFromKMLAnglesDegrees( + double heading_degrees, + double tilt_degrees, + double roll_degrees + ); + + /* + Description: + Create rotation transformation From Euler angles. + Parameters: + alpha - angle (in radians) to rotate about the Z axis + beta - angle (in radians) to rotate about the Y axis + gamma - angle (in radians) to rotate about the Z axis + Details: + RotationZYZ(alpha, beta, gamma) = R_z( alpha) * R_y(beta) * R_z(gamma) + where R_*(angle) is rotation of angle radians about the corresponding *-world coordinate axis. + */ void RotationZYZ(double alpha, double beta, double gamma); /*