From d070976d356bc022bc964f439ecf2c901a0bfd84 Mon Sep 17 00:00:00 2001 From: UnknownObject Date: Mon, 19 May 2025 16:50:42 +0800 Subject: [PATCH] add dll version and its usage --- DLLUsageDemo/DLLUsageDemo.cpp | 46 + DLLUsageDemo/DLLUsageDemo.vcxproj | 146 + DLLUsageDemo/DLLUsageDemo.vcxproj.filters | 27 + DLLUsageDemo/LibEasyOCR-CPP.h | 89 + DLLUsageDemo/LibEasyOCR-CPP.lib | Bin 0 -> 21786 bytes DLLUsageDemo/LibEasyOCR-CPPd.lib | Bin 0 -> 21828 bytes EasyOCR-CPP.sln | 20 + EasyOCR-CPP/EasyOCR-CPP.cpp | 16 +- EasyOCR-CPP/OCRToolBox.cpp | 3 +- LibEasyOCR-CPP/ATW.cpp | 214 + LibEasyOCR-CPP/ATW.h | 69 + LibEasyOCR-CPP/EasyOCR_Detector.cpp | 263 + LibEasyOCR-CPP/EasyOCR_Detector.h | 51 + LibEasyOCR-CPP/EasyOCR_Recognizer.cpp | 389 + LibEasyOCR-CPP/EasyOCR_Recognizer.h | 96 + LibEasyOCR-CPP/LibEasyOCR-CPP-Export.h | 12 + LibEasyOCR-CPP/LibEasyOCR-CPP.cpp | 135 + LibEasyOCR-CPP/LibEasyOCR-CPP.h | 46 + LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj | 181 + LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj.filters | 78 + LibEasyOCR-CPP/OCRCharset.cpp | 6874 +++++++++++++++++ LibEasyOCR-CPP/OCRCharset.h | 22 + LibEasyOCR-CPP/OCRConfig.cpp | 58 + LibEasyOCR-CPP/OCRConfig.h | 51 + LibEasyOCR-CPP/OCRToolBox.cpp | 86 + LibEasyOCR-CPP/OCRToolBox.h | 27 + LibEasyOCR-CPP/dllmain.cpp | 16 + LibEasyOCR-CPP/framework.h | 5 + LibEasyOCR-CPP/pch.cpp | 5 + LibEasyOCR-CPP/pch.h | 13 + 30 files changed, 9035 insertions(+), 3 deletions(-) create mode 100644 DLLUsageDemo/DLLUsageDemo.cpp create mode 100644 DLLUsageDemo/DLLUsageDemo.vcxproj create mode 100644 DLLUsageDemo/DLLUsageDemo.vcxproj.filters create mode 100644 DLLUsageDemo/LibEasyOCR-CPP.h create mode 100644 DLLUsageDemo/LibEasyOCR-CPP.lib create mode 100644 DLLUsageDemo/LibEasyOCR-CPPd.lib create mode 100644 LibEasyOCR-CPP/ATW.cpp create mode 100644 LibEasyOCR-CPP/ATW.h create mode 100644 LibEasyOCR-CPP/EasyOCR_Detector.cpp create mode 100644 LibEasyOCR-CPP/EasyOCR_Detector.h create mode 100644 LibEasyOCR-CPP/EasyOCR_Recognizer.cpp create mode 100644 LibEasyOCR-CPP/EasyOCR_Recognizer.h create mode 100644 LibEasyOCR-CPP/LibEasyOCR-CPP-Export.h create mode 100644 LibEasyOCR-CPP/LibEasyOCR-CPP.cpp create mode 100644 LibEasyOCR-CPP/LibEasyOCR-CPP.h create mode 100644 LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj create mode 100644 LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj.filters create mode 100644 LibEasyOCR-CPP/OCRCharset.cpp create mode 100644 LibEasyOCR-CPP/OCRCharset.h create mode 100644 LibEasyOCR-CPP/OCRConfig.cpp create mode 100644 LibEasyOCR-CPP/OCRConfig.h create mode 100644 LibEasyOCR-CPP/OCRToolBox.cpp create mode 100644 LibEasyOCR-CPP/OCRToolBox.h create mode 100644 LibEasyOCR-CPP/dllmain.cpp create mode 100644 LibEasyOCR-CPP/framework.h create mode 100644 LibEasyOCR-CPP/pch.cpp create mode 100644 LibEasyOCR-CPP/pch.h diff --git a/DLLUsageDemo/DLLUsageDemo.cpp b/DLLUsageDemo/DLLUsageDemo.cpp new file mode 100644 index 0000000..ed2a79a --- /dev/null +++ b/DLLUsageDemo/DLLUsageDemo.cpp @@ -0,0 +1,46 @@ +// DLLUsageDemo.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 +// + +#include +#include "LibEasyOCR-CPP.h" +#include +#include + +int main() +{ + std::wstring detect_model = L"..\\EasyOCR-CPP\\DetectionModel.onnx"; + std::wstring recognize_model = L"..\\EasyOCR-CPP\\RecognitionModel-EN.onnx"; + std::string image = "..\\..\\vin.jpg"; + + uns::EasyOCR_CPP::GlobalOCRConfig().SetDetectModelPath(detect_model); + uns::EasyOCR_CPP::GlobalOCRConfig().SetGPUUsage(uns::easyocr::GPUUsage::CPUOnly); + uns::EasyOCR_CPP::SetRecognitionModel(recognize_model, uns::easyocr::CharsetType::EN); + + if (!uns::EasyOCR_CPP::InitDetectionModel()) + { + std::cout << "Detector Init Failure!" << std::endl; + return -1; + } + if (!uns::EasyOCR_CPP::InitRecognitionModel()) + { + std::cout << "Recognizer Init Failure!" << std::endl; + return -2; + } + + cv::Mat img = uns::EOCR_SupportTools::ReadImage(image, true); + if (img.empty()) + { + std::cerr << "Failed to load image: " << image << std::endl; + return -1; + } + + auto results = uns::EasyOCR_CPP::FullAuto(img); + for (const auto& [index, info] : results) + { + const auto& [text, conf] = info; + std::cout << "Box " << index << ": \"" << uns::EOCR_SupportTools::WtoA(text) << "\" Confidence=" << conf << "\n"; + } + + uns::EasyOCR_CPP::CleanupOCR(); + return 0; +} diff --git a/DLLUsageDemo/DLLUsageDemo.vcxproj b/DLLUsageDemo/DLLUsageDemo.vcxproj new file mode 100644 index 0000000..748a540 --- /dev/null +++ b/DLLUsageDemo/DLLUsageDemo.vcxproj @@ -0,0 +1,146 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {4855fd5b-4d48-4ce9-8ac1-8be3d89a206d} + DLLUsageDemo + 10.0 + + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + Application + true + v143 + Unicode + + + Application + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + F:\vcpkg\installed\x64-windows\include\opencv4;$(IncludePath) + + + F:\vcpkg\installed\x64-windows\include\opencv4;$(IncludePath) + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp17 + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp17 + + + Console + true + true + true + + + + + + + + + + + + \ No newline at end of file diff --git a/DLLUsageDemo/DLLUsageDemo.vcxproj.filters b/DLLUsageDemo/DLLUsageDemo.vcxproj.filters new file mode 100644 index 0000000..06f531c --- /dev/null +++ b/DLLUsageDemo/DLLUsageDemo.vcxproj.filters @@ -0,0 +1,27 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/DLLUsageDemo/LibEasyOCR-CPP.h b/DLLUsageDemo/LibEasyOCR-CPP.h new file mode 100644 index 0000000..61b5714 --- /dev/null +++ b/DLLUsageDemo/LibEasyOCR-CPP.h @@ -0,0 +1,89 @@ +#pragma once +#include +#include +#include +#include + +#ifdef LIBEASYOCRCPP_EXPORTS +#define LIBEASYOCRCPP_API _declspec(dllexport) +#else +#define LIBEASYOCRCPP_API _declspec(dllimport) +#ifdef _DEBUG +#pragma comment(lib, "LibEasyOCR-CPPd.lib") +#else +#pragma comment(lib, "LibEasyOCR-CPP.lib") +#endif +#endif + +namespace uns +{ + namespace easyocr + { + enum class LIBEASYOCRCPP_API GPUUsage + { + ForceGPU, + PreferGPU, + CPUOnly + }; + + enum class LIBEASYOCRCPP_API CharsetType + { + EN, + EN_CH + }; + + using EOCR_Result = std::pair; + using EOCR_ResultSet = std::map; + using EOCRD_Rects = std::vector>; + } + + class LIBEASYOCRCPP_API OCRConfig + { + public: + OCRConfig(); + OCRConfig(const OCRConfig& obj) = delete; + OCRConfig(const std::wstring& detect_model, const std::wstring& reco_model, easyocr::CharsetType language, easyocr::GPUUsage gpu = easyocr::GPUUsage::PreferGPU); + + public: + easyocr::GPUUsage GetGPUUsage() const; + easyocr::CharsetType GetLanguage() const; + + std::wstring GetDetectModelPath() const; + std::wstring GetRecognizeModelPath() const; + + public: + void SetGPUUsage(easyocr::GPUUsage usage); + void SetLanguage(easyocr::CharsetType type); + void SetDetectModelPath(const std::wstring& path); + void SetRecognizeModelPath(const std::wstring& path); + }; + + class LIBEASYOCRCPP_API EasyOCR_CPP + { + public: + static OCRConfig& GlobalOCRConfig(); + static void SetRecognitionModel(const std::wstring& reco_model, easyocr::CharsetType language); + + static bool CleanupOCR(); + static bool InitDetectionModel(); + static bool InitRecognitionModel(); + + static easyocr::EOCRD_Rects Detect(const cv::Mat& img); + static easyocr::EOCR_Result Recognize(const cv::Mat& img); + static easyocr::EOCR_ResultSet Recognize(const cv::Mat& img, const easyocr::EOCRD_Rects& rects); + + static easyocr::EOCR_ResultSet FullAuto(const cv::Mat& img); + }; + + class LIBEASYOCRCPP_API EOCR_SupportTools + { + public: + static std::string WtoA(const std::wstring& wstr); + static std::wstring AtoW(const std::string& str); + static std::string AtoUTF8(const std::string& str); + static std::string UTF8toA(const std::string& utf8); + + static cv::Mat ReadImage(const std::string& file, bool blur = false, int blur_size = 3); + static cv::Mat ReadImage(const std::wstring& file, bool blur = false, int blur_size = 3); + }; +} \ No newline at end of file diff --git a/DLLUsageDemo/LibEasyOCR-CPP.lib b/DLLUsageDemo/LibEasyOCR-CPP.lib new file mode 100644 index 0000000000000000000000000000000000000000..a49b7996930db5b7fa07ff8896ed9a748459af75 GIT binary patch literal 21786 zcmeGkZERat^(5)mHtj~%X6x5F++tSv(bP`td~9vsd$E%=&1dsDRg)aoaT80f9qgB( zR#AgGQGoCN<*v+5dF~!CPc+Hn1oa$s0v~l=e+yA9N%ZZ zXTQ8SU7mFOzV5x}~f|N03?8p zs{mcM0G`Kt@ihh~?f?)BTxW3lCIG>Bl!4^Kss#5KOf&-!L|}X_k6k@UA z$-%+maWU=y+N#f61zPM*kS(|JbSxFkqZLvdM5 zyd*003I22Od@2#k%eho$PK-@Y3jV}=JQtI5@sym$2V!2H6~!sRA5W*ViMX82(Zg1e zJ&z5aGWc6B^wsknUBz~k!*z6xn63o3FgelNDQBgU{k*Dgo#7$nZ3~%{*F%hgBxebo zhunFHk+_?7!kXhjNqtvo=bO8{_6ZfH*L)DH5~P#PFw3&`2^D%5(`ji@&Wh^P7{jU2 zG;Ij}3-JXpHh`vbA)d<7lu+H=F~p24wwF%kajF?W16wf9Xqf!|NVofV8Ft;M)1c92 zMq^6bl!-|uIL{`sbD7j7Twk!&(^gmPZpB9Jq0JZTL&ulUpGnE8vdF1yW+*$GO!N9JHf-!=9o11VFu6Ht-)0RVl1|1miwn4O zE=RSElEQe>mM~sm)~LGiI~|JPo;{zGCoV1|#U#$n*+hFl|9+VF31 z))C}AF$%Pr93PccMz@QFH^k(t@%!;+wYSDuHCuS7w^#Xu%40Dq5suX>ud-a&tWc(H zg9zQ5Rf-g&xM?I@N-9QSG%nAJMi=XTGgrm}Pvw@Y+pKi@d>QXoPSF2r(8MC9uSc%KBs^mV4 zo}ncEtTm4qvr^uIE~&T)!msOBk@_+G`g=qF3XtpX9n}|vKv8)~awP%~;L9v1PKR__ z!v#^08X(0&9)_g(^1}B{BXS*qfF6-M3;`1iLkF22ulLCiS1>^0OS#X zyQ3HjLkOJ$cot)3ul8X*Jm-!BoJE|70uI4pcm$q=r(h54g)Oih8etcF3U02pb56ZqwqL92K(V@H~_n0A8dmiPzUu@w$Om_vzk^0>rkAn#h!UlX{&;1(PV$2 zXM5d-1vy5bC|K!b^koCYLhNh{A3i6=W-vf^7vhG((}hvxtAwi7H&j`7^_AGaxV8SP z&=ugs2jt8nwLVz{)nj!MkyQMVEN5e#oy+CW<1XqG6KwB{a)GB*nDhwMr_~ z>aU#>-PrXQxNQ2YZB^j3Z)YE*w(VhNn1OL)?=Zm%AqoYc=6iioLUe=_HzNXKiGT@K>D_?ksP) zCKA%s-q96;Z}`?YbH*MKoBJ%v-m9I-#+Z0U?tGYgpDWk{0RN12epnA zD8KBd9%k^On!SEmt#qhGt>F%n7S+SvuOIo#3ew1E=WEd{zBeBxEo#%AlXm<-yHU@i zMbz$EX@{M@K8W}&KfrW62HOIfxY-zdck+X~e?<(Xq*r1LhE+i+W0=OE`4Ba87)QL8qU}AE=VO9GUilG zlfSZk>8)j?WE)Z9p_iA#j$^yf8qk!^7@61p-SX~_k)Q1)CL8vu4F@%c4ClQO(l!!CZ?t}Y`ObSt#}1<7p>uz`A+@$ZvDAL};NF{ua0j!K zq_*i?H#yhcka#ep8Dv9GFYk`L@g>yL$4KH{y6!m)IUWC9no&2+buBmKKVr%(Zekff z*1oJ#aRCl-j;%t_v=hKxq0!|S5WimYZ^-6EBk4id)a#~aMYzK zx@kT2KjFJ?4I)STRF16IQzc@9ZqTM}7EH9=zV`CJ@KY!JE{RFodNox#@W>(0@q8N8 zH=~9fT-yG#zkdhmJD}2MXF7EynX^P%sVlsOwZ)9V>+$aUx4w+LK3&MGM?q6pxZ?PT m@-tiiK|Z2`#Fd93SvUCM`G}-{_P$9zqGyPo+7I}0#PENO2i%wd literal 0 HcmV?d00001 diff --git a/DLLUsageDemo/LibEasyOCR-CPPd.lib b/DLLUsageDemo/LibEasyOCR-CPPd.lib new file mode 100644 index 0000000000000000000000000000000000000000..4a198d3570ffdbd02fc474e89cb221213194af8b GIT binary patch literal 21828 zcmeGkZEPG@aU8o&b4`Qmq)BM(;)bgzh&p%noj=qhyXUjxIR3hv&$U5FoAuqT2C-MjVrl6s}_?(M$!=Ht!In>RD-2lmVPPeI2F8!@<(u>{md$=nVw4%VRzO zhye7S0qDO1@JK7bf$J2+=K%VO1Y$TYfulYOlg|PWh$GGMbCNVN9-E9Oq`{%7XnZ7=n2bwfnYkgk@c3jj z{%|xFOMxU!OplF~H-wX`TGDoj!_yO^(qJSJ0YM1jDAC-~d}cvhSt^L)(V<90oc%nG znOR(x%%2NFh|@DN6nQid6eB|e8!}XJ4<*H{Bv?4lavZdKC`qSN;A`fKY3ivOG;kOC*S z6NWUQYlw}O!Uzg?Fs-DMmLfKe>Y#@@x}7OpJ-+Qe0;QcN2_b@W{TMQa6J2r@%Vm}n zNgNlGkFC-NY*zA+ss=}KTo|vYc|?21Wksb%*S6b^FF~8rC(``M!uNGq&ZtvW+nYR2 z=Zi1a^(CT`3{b5W#a3hgftI$T0c+(E<1IYA+Bovc@@~M!UY> z&yd0VSJ0e|sUvz-Vm(XrZ1uynHm&N^35Qm)*~p5L-Qs))qc3u$i@!BjFO9pL+AiXQ!C5MxxA9d<+26lhO2&0$r3tzyaP@fZVI##i}C_`=N5*AS$#fthL=4pH(J?*NRCRxXc}!kfSRryT!ORcMl_0Nr2!fvmThst! zOjeHb$-v!0$tvzxF-qw53?<>OxOerGMK7_ESh2bOMk2FZ_0^Z4YP%D>=BlUSS{+I*efa$65)m|DIwTHq=qcO6KM<+OXYO0W)F=faU>!9?b4#rvR>D z+m}ZHKE$lp9Kt+~`6OoFT805GARIh|;~mDfm?`rij%O!v?6{g7g!|y*&;+|-7qq~~ z;11Xht#BvY1>2w<_COol56!Rzd~h%9gspHlJOH174%iHPVF%m;4X~-k5gIXnRu9W6 zp9owDEYo+D9kfy}$cEcQOaRUMIS5TuXj(F6+0xAkqIkJOyajglc2aq_UxI5RC~Hjj zdFp-=WaeIym6uO?ntLgxbMB4V{_ zW1UjH$hRf>k5bx)dj7XSmeu2}3_)jZ3DtdD@v$E6z&#M@Xl@AAj(j_)_0@FKvf9R# z{Te?Cr4}@Kzoqgrcz#Qy$7-k?WU46TiB`W8j+MC&v4 z%0)xmn~%k!1800Y8zGIDbxD}r8tG0OwTqe%X)MaL!lS;|J~bIel!#^4^f22-okqD# za3fJM^hh=%?#Akio^e@Pr>$<&G_usY75Ln zf**FBY#q-e^SMH9Ug>x!{^^dfkqJyRmLFU379ofLU_y~xwcy`7)GH1)5R5!d8;ENT zFW2@%L7!7i>I(N6G-(qw-FW)HuOOL}d;p#%r5H!r*`P_?>=DtB@3SApb^%qyYo;M~ z=DQtW&EuWUgbTD)LycTv&+=C(CbH z+?P@De+KAUoA}D9t5_z4)jbvIaalUO96g#lKYRs?p|Gwp_gN)znJ*@ zKl@M)J|YJjQEMI{j^`uHmQsB_wp_S=`7Na5E<(p`7ZZ0wYTc|{(qKP-`~~U8Ufk7e zB~sgnxEmtwZb&>BVn$il)6dMFfAg!Tr*{*Hdl}E?G33|+^fSY5(4q4`-1+VVa~dw?WEkTXNJrb9z(t5 zJihhiPk!(V^jLP;;Bg}XSBD8WS2QCSE`PWG@xqngeGRpLH_;4l^LwuF)X$XNu#WyE z_RIJ1GbQzFqN-~)U7;?>{sE$ay2bhLyoMh?VceBU+}yXaE)3-n=yYWb7B{E5J^atm z&#rzG>D!~xXJ=tu>)fX+yoQ-uqx1Sk({JBBjl8y%^6F7$)fKKdQKS6-nqPSexoRg| ed6>6#gCAbhDEjE1Z<46d{e++T&kFOz;QK$BGxJjb literal 0 HcmV?d00001 diff --git a/EasyOCR-CPP.sln b/EasyOCR-CPP.sln index 2c5b3f4..379e863 100644 --- a/EasyOCR-CPP.sln +++ b/EasyOCR-CPP.sln @@ -5,6 +5,10 @@ VisualStudioVersion = 17.6.33815.320 MinimumVisualStudioVersion = 10.0.40219.1 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EasyOCR-CPP", "EasyOCR-CPP\EasyOCR-CPP.vcxproj", "{166232A4-C250-4AAE-9D41-F22ED3FB9585}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibEasyOCR-CPP", "LibEasyOCR-CPP\LibEasyOCR-CPP.vcxproj", "{1900CF83-6BCE-41C9-B022-0645107ABD57}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DLLUsageDemo", "DLLUsageDemo\DLLUsageDemo.vcxproj", "{4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|x64 = Debug|x64 @@ -21,6 +25,22 @@ Global {166232A4-C250-4AAE-9D41-F22ED3FB9585}.Release|x64.Build.0 = Release|x64 {166232A4-C250-4AAE-9D41-F22ED3FB9585}.Release|x86.ActiveCfg = Release|Win32 {166232A4-C250-4AAE-9D41-F22ED3FB9585}.Release|x86.Build.0 = Release|Win32 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Debug|x64.ActiveCfg = Debug|x64 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Debug|x64.Build.0 = Debug|x64 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Debug|x86.ActiveCfg = Debug|Win32 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Debug|x86.Build.0 = Debug|Win32 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Release|x64.ActiveCfg = Release|x64 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Release|x64.Build.0 = Release|x64 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Release|x86.ActiveCfg = Release|Win32 + {1900CF83-6BCE-41C9-B022-0645107ABD57}.Release|x86.Build.0 = Release|Win32 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Debug|x64.ActiveCfg = Debug|x64 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Debug|x64.Build.0 = Debug|x64 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Debug|x86.ActiveCfg = Debug|Win32 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Debug|x86.Build.0 = Debug|Win32 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Release|x64.ActiveCfg = Release|x64 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Release|x64.Build.0 = Release|x64 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Release|x86.ActiveCfg = Release|Win32 + {4855FD5B-4D48-4CE9-8AC1-8BE3D89A206D}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/EasyOCR-CPP/EasyOCR-CPP.cpp b/EasyOCR-CPP/EasyOCR-CPP.cpp index 406b655..9bdbd1f 100644 --- a/EasyOCR-CPP/EasyOCR-CPP.cpp +++ b/EasyOCR-CPP/EasyOCR-CPP.cpp @@ -11,10 +11,10 @@ int main() const std::wstring detModelPath = L".\\DetectionModel.onnx"; const std::wstring recModelPath = L".\\RecognitionModel-EN.onnx"; const std::wstring recModelWithChnPath = L".\\RecognitionModel_EN+CH_SIM.onnx"; - const std::string imagePath = ""; + const std::string imagePath = "..\\..\\vin.jpg"; //Init Config - uns::G_OCRConfig.SetGPUUsage(uns::OCRConfig::GPUUsage::PreferGPU); + uns::G_OCRConfig.SetGPUUsage(uns::OCRConfig::GPUUsage::CPUOnly); uns::G_OCRConfig.SetDetectModelPath(detModelPath); uns::G_OCRConfig.SetRecognizeModelPath(recModelPath); uns::G_OCRConfig.SetLanguage(uns::OCRConfig::CharsetType::EN); @@ -44,6 +44,18 @@ int main() } cv::blur(image, image, { 3,3 }); + //WarmUP GPU + for (int i = 0; i < 10; i++) + { + std::cout << "Warming UP GPU (" << i << ") ......" << std::endl; + clock_t start = clock(); + auto rects = detector(image); + auto results = recognizer(image, rects); + clock_t end = clock(); + std::cout << "Warm UP [" << i << "] Cost " << static_cast(end - start) / static_cast(CLOCKS_PER_SEC) << " Second(s)" << std::endl; + } + std::cout << "GPU Warm UP Finished" << std::endl; + //Begin OCR clock_t start = clock(); auto rects = detector(image); diff --git a/EasyOCR-CPP/OCRToolBox.cpp b/EasyOCR-CPP/OCRToolBox.cpp index 000e3f1..da30649 100644 --- a/EasyOCR-CPP/OCRToolBox.cpp +++ b/EasyOCR-CPP/OCRToolBox.cpp @@ -1,5 +1,6 @@ #include "OCRToolBox.h" #include "OCRConfig.h" +#include //debug bool uns::OCRToolBox::CheckFile(const std::wstring& file) { @@ -36,7 +37,7 @@ bool uns::OCRToolBox::AutoSelectEP(const OrtApi* ort, Ort::SessionOptions& se_op try { OrtStatusPtr status = OrtSessionOptionsAppendExecutionProvider_CUDA(se_opt, 0); - if (status) + if (status != nullptr) { ort->ReleaseStatus(status); if (G_OCRConfig.GetGPUUsage() == OCRConfig::GPUUsage::ForceGPU) diff --git a/LibEasyOCR-CPP/ATW.cpp b/LibEasyOCR-CPP/ATW.cpp new file mode 100644 index 0000000..a08d024 --- /dev/null +++ b/LibEasyOCR-CPP/ATW.cpp @@ -0,0 +1,214 @@ +/* Copyright (C) 2011 + * + * һԴ,ɵ޸ĺͷ. + * ֹҵ;. + * + * ϵԭ: querw@sina.com +*/ + +// ATW.h: interface for the CBase64 class. +// by Ted.Que - Que's C++ Studio +// 2010-11-12 +// תַ +#include "pch.h" +#include "ATW.h" + + +std::string __do_w_to_a_utf8(const wchar_t* pwszText, UINT uCodePage) +{ + // ָ + if (pwszText == NULL) return ""; + + // ޷Ҫij. + int nNeedSize = WideCharToMultiByte(uCodePage, 0, pwszText, -1, NULL, 0, NULL, NULL); + if (0 == nNeedSize) return ""; + + // ռ,ת. + char* pRet = new char[nNeedSize + 1]; // ȻWideCharToMultiByteijǰ null ַij, Ƕ+һַ. + memset(pRet, 0, nNeedSize + 1); + + std::string strRet(""); + if (0 == WideCharToMultiByte(uCodePage, 0, pwszText, -1, pRet, nNeedSize, NULL, NULL)) + { + } + else + { + strRet = pRet; + } + + delete[]pRet; + return strRet; +} + +std::wstring __do_a_utf8_to_w(const char* pszText, UINT uCodePage) +{ + // ָ + if (pszText == NULL) return L""; + + // 㳤 + int nNeedSize = MultiByteToWideChar(uCodePage, 0, pszText, -1, NULL, 0); + if (0 == nNeedSize) return L""; + + // ռ,ת + std::wstring strRet(L""); + wchar_t* pRet = new wchar_t[nNeedSize + 1]; + memset(pRet, 0, (nNeedSize + 1) * sizeof(wchar_t)); + if (0 == MultiByteToWideChar(uCodePage, 0, pszText, -1, pRet, nNeedSize)) + { + } + else + { + strRet = pRet; + } + delete[]pRet; + return strRet; +} + +std::string WtoA(const std::wstring& strText) +{ + return __do_w_to_a_utf8(strText.c_str(), CP_ACP); +} + +std::string WtoA(const wchar_t* pwszText) +{ + return __do_w_to_a_utf8(pwszText, CP_ACP); +} + +std::wstring AtoW(const std::string& strText) +{ + return __do_a_utf8_to_w(strText.c_str(), CP_ACP); +} + +std::wstring AtoW(const char* pszText) +{ + return __do_a_utf8_to_w(pszText, CP_ACP); +} + +std::string WtoUTF8(const std::wstring& strText) +{ + return __do_w_to_a_utf8(strText.c_str(), CP_UTF8); +} + +std::string WtoUTF8(const wchar_t* pwszText) +{ + return __do_w_to_a_utf8(pwszText, CP_UTF8); +} + +std::wstring UTF8toW(const std::string& strText) +{ + return __do_a_utf8_to_w(strText.c_str(), CP_UTF8); +} + +std::wstring UTF8toW(const char* pszText) +{ + return __do_a_utf8_to_w(pszText, CP_UTF8); +} + +std::string UTF8toA(const std::string& src) +{ + return WtoA(UTF8toW(src)); +} + +std::string UTF8toA(const char* src) +{ + return WtoA(UTF8toW(src)); +} + +std::string AtoUTF8(const std::string& src) +{ + return WtoUTF8(AtoW(src)); +} + +std::string AtoUTF8(const char* src) +{ + return WtoUTF8(AtoW(src)); +} +/* +UTF-8 6ֽ + +1ֽ 0xxxxxxx +2ֽ 110xxxxx 10xxxxxx +3ֽ 1110xxxx 10xxxxxx 10xxxxxx +4ֽ 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx +5ֽ 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx +6ֽ 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx + +*/ + +// ֵ˵: +// 0 -> ַUTF-8 +// -1 -> ⵽ǷUTF-8ֽ +// -2 -> ⵽ǷUTF-8ֽڱĺֽ. + +int IsTextUTF8(const char* pszSrc) +{ + const unsigned char* puszSrc = (const unsigned char*)pszSrc; // һҪ޷ŵ,зŵıȽϾͲȷ. + // ûBOMʾ EF BB BF + if (puszSrc[0] != 0 && puszSrc[0] == 0xEF && + puszSrc[1] != 0 && puszSrc[1] == 0xBB && + puszSrc[2] != 0 && puszSrc[2] == 0xBF) + { + return 0; + } + + // û BOMʶ + bool bIsNextByte = false; + int nBytes = 0; // ¼һַUTF8Ѿռ˼ֽ. + const unsigned char* pCur = (const unsigned char*)pszSrc; // ָα޷ַ. ΪλΪ1, char , Ϊ,ڱʱıȽϲ. + + while (pCur[0] != 0) + { + if (!bIsNextByte) + { + bIsNextByte = true; + if ((pCur[0] >> 7) == 0) + { + bIsNextByte = false; nBytes = 1; bIsNextByte = false; + } // λΪ0, ANSI ݵ. + else if ((pCur[0] >> 5) == 0x06) + { + nBytes = 2; + } // 5λ 110 -> 2ֽڱUTF8ַֽ + else if ((pCur[0] >> 4) == 0x0E) + { + nBytes = 3; + } // 4λ 1110 -> 3ֽڱUTF8ַֽ + else if ((pCur[0] >> 3) == 0x1E) + { + nBytes = 4; + } // 3λ 11110 -> 4ֽڱUTF8ַֽ + else if ((pCur[0] >> 2) == 0x3E) + { + nBytes = 5; + } // 2λ 111110 -> 5ֽڱUTF8ַֽ + else if ((pCur[0] >> 1) == 0x7E) + { + nBytes = 6; + } // 1λ 1111110 -> 6ֽڱUTF8ַֽ + else + { + nBytes = -1; // ǷUTF8ַֽ + break; + } + } + else + { + if ((pCur[0] >> 6) == 0x02) // ,ֽڱ 10xxx ͷ + { + nBytes--; + if (nBytes == 1) bIsNextByte = false; // nBytes = 1ʱ, ˵һֽӦֽ. + } + else + { + nBytes = -2; + break; + } + } + + // һַ + pCur++; + } + + if (nBytes == 1) return 0; + else return nBytes; +} diff --git a/LibEasyOCR-CPP/ATW.h b/LibEasyOCR-CPP/ATW.h new file mode 100644 index 0000000..e44ef16 --- /dev/null +++ b/LibEasyOCR-CPP/ATW.h @@ -0,0 +1,69 @@ +/* Copyright (C) 2011 + * + * һԴ,ɵ޸ĺͷ. + * ֹҵ;. + * + * ϵԭ: querw@sina.com +*/ + +/* + +1. ʵUSCѹ,Unicode <-> UTF-8. +2. ʵֶֽ <-> Unicode + +Unicodeַ, wstring 洢. +ڷUnicodeַ string 洢. ANSI, GB2312 һ +UTF-8,Ҳ string 洢, UTF-8ı봮вnull. +*/ + +/* + ҪʹATL е USES_CONVERSION; A2W, A2T, W2A ȵĺ, Щ궼 alloca() ںջзڴ. + Ȼdz,غԶ, Σ, ջֻ 1M ĴС. + + µĺʹõĿռ䶼ڶз,Ƚϰȫ. +*/ + +#pragma once +#include +#if defined(_WIN32) || defined(WIN32) +#include "Windows.h" +#endif + +#if defined(_UNICODE) || defined(UNICODE) +#define TtoA WtoA +#define AtoT AtoW +#define WtoT(a) (a) +#define TtoW(a) (a) +typedef std::wstring _tstring; +#else +#define TtoA(a) (a) +#define AtoT(a) (a) +#define WtoT WtoA +#define TtoW AtoW +typedef std::string _tstring; +#endif + +std::string WtoA(const wchar_t* pwszSrc); +std::string WtoA(const std::wstring &strSrc); + +std::wstring AtoW(const char* pszSrc); +std::wstring AtoW(const std::string &strSrc); + +std::string WtoUTF8(const wchar_t* pwszSrc); +std::string WtoUTF8(const std::wstring &strSrc); + +std::wstring UTF8toW(const char* pszSrc); +std::wstring UTF8toW(const std::string &strSr); + +std::string AtoUTF8(const char* src); +std::string AtoUTF8(const std::string &src); + +std::string UTF8toA(const char* src); +std::string UTF8toA(const std::string &src); + +// һ null βַǷUTF-8, 0, Ҳֻʾպ÷UTF8ı. +// ֵ˵: +// 1 -> ַUTF-8 +// -1 -> ⵽ǷUTF-8ֽ +// -2 -> ⵽ǷUTF-8ֽڱĺֽ. +int IsTextUTF8(const char* pszSrc); \ No newline at end of file diff --git a/LibEasyOCR-CPP/EasyOCR_Detector.cpp b/LibEasyOCR-CPP/EasyOCR_Detector.cpp new file mode 100644 index 0000000..c8f3ac2 --- /dev/null +++ b/LibEasyOCR-CPP/EasyOCR_Detector.cpp @@ -0,0 +1,263 @@ +#include "pch.h" +#include "OCRConfig.h" +#include "EasyOCR_Detector.h" + +cv::Mat uns::EasyOCR_Detector::NormalizeMeanVariance(const cv::Mat& in) +{ + cv::Mat img; + in.convertTo(img, CV_32FC3); + cv::Scalar mean(0.485f * 255, 0.456f * 255, 0.406f * 255); + cv::Scalar var(0.229f * 255, 0.224f * 255, 0.225f * 255); + img -= mean; + img /= var; + return img; +} + +void uns::EasyOCR_Detector::AdjustResultCoordinates(EOCRD_Rects& polys, float ratioW, float ratioH, float ratioNet) +{ + for (auto& poly : polys) + { + for (auto& pt : poly) + { + pt.x *= ratioW * ratioNet; + pt.y *= ratioH * ratioNet; + } + } +} + +void uns::EasyOCR_Detector::ResizeAspectRatio(const cv::Mat& src, cv::Mat& dst, float squareSize, float magRatio, float& ratio, cv::Size& heatmapSize) +{ + int h = src.rows, w = src.cols, c = src.channels(); + float target = magRatio * std::max(h, w); + if (target > squareSize) + target = squareSize; + ratio = target / std::max(h, w); + + int targetH = int(h * ratio), targetW = int(w * ratio); + cv::resize(src, dst, cv::Size(targetW, targetH)); + + int h32 = (targetH + 31) / 32 * 32; + int w32 = (targetW + 31) / 32 * 32; + cv::Mat canvas = cv::Mat::zeros(h32, w32, src.type()); + dst.copyTo(canvas(cv::Rect(0, 0, targetW, targetH))); + dst = canvas; + heatmapSize = cv::Size(w32 / 2, h32 / 2); +} + +bool uns::EasyOCR_Detector::GetDetBoxesCore(const cv::Mat& textmap, const cv::Mat& linkmap, float textThresh, float linkThresh, float lowText, EOCRD_Rects& boxes, cv::Mat& labels, std::vector& mapper, bool estimateNumChars) +{ + cv::Mat tmap = textmap.clone(), lmap = linkmap.clone(); + int H = tmap.rows, W = tmap.cols; + // 1. ֵ & ϲ + cv::Mat textScore, linkScore; + cv::threshold(tmap, textScore, lowText, 1, cv::THRESH_BINARY); + cv::threshold(lmap, linkScore, linkThresh, 1, cv::THRESH_BINARY); + cv::Mat combined; + cv::add(textScore, linkScore, combined); + combined = cv::min(combined, 1); + // 2. ͨ + int nLabels = 0; + cv::Mat stats, centroids; + cv::Mat combined8u; + combined.convertTo(combined8u, CV_8U); + try + { + nLabels = cv::connectedComponentsWithStats(combined8u, labels, stats, centroids, 4); + } + catch (cv::Exception e) + { + return false; + } + // 3. ÿ label + for (int k = 1; k < nLabels; ++k) + { + int area = stats.at(k, cv::CC_STAT_AREA); + if (area < 10) + continue; + // ıֵ + cv::Mat mask = (labels == k); + double maxVal; + cv::minMaxLoc(tmap, nullptr, &maxVal, nullptr, nullptr, mask); + if (maxVal < textThresh) + continue; + // segmap + cv::Mat segmap = cv::Mat::zeros(H, W, CV_8UC1); + segmap.setTo(255, labels == k); + mapper.push_back(k); + // ɾ link + segmap.setTo(0, (linkScore == 1) & (textScore == 0)); + // + int x = stats.at(k, cv::CC_STAT_LEFT); + int y = stats.at(k, cv::CC_STAT_TOP); + int wbox = stats.at(k, cv::CC_STAT_WIDTH); + int hbox = stats.at(k, cv::CC_STAT_HEIGHT); + int niter = int(std::sqrt(area * std::min(wbox, hbox) / float(wbox * hbox)) * 2); + int sx = std::max(0, x - niter), sy = std::max(0, y - niter); + int ex = std::min(W, x + wbox + niter + 1), ey = std::min(H, y + hbox + niter + 1); + cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(1 + niter, 1 + niter)); + cv::dilate(segmap(cv::Rect(sx, sy, ex - sx, ey - sy)), segmap(cv::Rect(sx, sy, ex - sx, ey - sy)), kernel); + // СӾ + std::vector pts; + cv::findNonZero(segmap, pts); + cv::RotatedRect rect = cv::minAreaRect(pts); + cv::Point2f boxPts[4]; + rect.points(boxPts); + std::vector box(boxPts, boxPts + 4); + // diamond->rect + float wlen = (float)cv::norm(box[0] - box[1]); + float hlen = (float)cv::norm(box[1] - box[2]); + float ratio = std::max(wlen, hlen) / (std::min(wlen, hlen) + 1e-5f); + if (std::abs(1 - ratio) <= 0.1f) + { + int minx = W, maxx = 0, miny = H, maxy = 0; + for (auto& p : pts) + { + minx = std::min(minx, p.x); maxx = std::max(maxx, p.x); + miny = std::min(miny, p.y); maxy = std::max(maxy, p.y); + } + box = + { + { float(minx),float(miny) }, + { float(maxx),float(miny) }, + { float(maxx),float(maxy) }, + { float(minx),float(maxy) } + }; + } + // ˳ʱ + int start = 0; + float minSum = box[0].x + box[0].y; + for (int i = 1; i < 4; i++) + { + float s = box[i].x + box[i].y; + if (s < minSum) + { + minSum = s; + start = i; + } + } + std::rotate(box.begin(), box.begin() + start, box.end()); + boxes.push_back(box); + } + return (!boxes.empty()); +} + +uns::EasyOCR_Detector::EasyOCR_Detector() +{ + ort_inited = false; + ort_cpu_session = nullptr; + model_path = G_OCRConfig.GetDetectModelPath(); + ort = OrtGetApiBase()->GetApi(ORT_API_VERSION); +} + +bool uns::EasyOCR_Detector::Init() +{ + if (ort_inited) + return true; + if (!RecheckModelInfo()) + return false; + try + { + ort_env = Ort::Env(ORT_LOGGING_LEVEL_WARNING, "EasyOCR_Detector"); + bool fallback_to_cpu = false; + if (!OCRToolBox::AutoSelectEP(ort, ort_session_options, fallback_to_cpu)) + return false; + OCRToolBox::InitOrtSessionOptions(ort_session_options); + if ((G_OCRConfig.GetGPUUsage() == easyocr::GPUUsage::CPUOnly) || fallback_to_cpu) //ʹCPUʼcpu session + { + ort_cpu_session = new Ort::Session(ort_env, model_path.c_str(), ort_session_options); + //ͨCPU sessionȡ + OCRToolBox::GetInputOutputNames(ort_cpu_session, input_names, input_ns, output_names, output_ns); + } + else + { + //ͨʱsessionȡCUDA̲߳ȫ + Ort::Session ort_session(ort_env, model_path.c_str(), ort_session_options); + OCRToolBox::GetInputOutputNames(&ort_session, input_names, input_ns, output_names, output_ns); + } + ort_inited = true; + return true; + } + catch (...) + { + return false; + } +} + +bool uns::EasyOCR_Detector::UnInit() +{ + try + { + if (ort_cpu_session != nullptr) + delete ort_cpu_session; + ort_cpu_session = nullptr; + return true; + } + catch (...) + { + return false; + } +} + +bool uns::EasyOCR_Detector::RecheckModelInfo() +{ + if (model_path.empty()) + model_path = G_OCRConfig.GetDetectModelPath(); + return OCRToolBox::CheckFile(model_path); +} + +uns::EOCRD_Rects uns::EasyOCR_Detector::operator()(const cv::Mat& image) +{ + // 0. check model + if (!RecheckModelInfo()) + return {}; + try + { + // 1. resize + normalize + cv::Mat resized; + float ratio; + cv::Size heatmapSize; + ResizeAspectRatio(image, resized, 1280.0f, 1.5f, ratio, heatmapSize); + cv::Mat input = NormalizeMeanVariance(resized); + // 2. NCHW tensor + cv::dnn::blobFromImage(input, input); + std::array shape = { 1, 3, input.size[2], input.size[3] }; + Ort::MemoryInfo memInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault); + Ort::Value tensor = Ort::Value::CreateTensor(memInfo, input.ptr(), input.total(), shape.data(), shape.size()); + // 3. ONNX + auto outputs = ((ort_cpu_session != nullptr) ? ort_cpu_session->Run(Ort::RunOptions{nullptr}, input_names.data(), & tensor, 1, output_names.data(), 1) : Ort::Session(ort_env, model_path.c_str(), ort_session_options).Run(Ort::RunOptions{nullptr}, input_names.data(), & tensor, 1, output_names.data(), 1)); + std::vector outputShape = outputs[0].GetTensorTypeAndShapeInfo().GetShape(); + // 4. score_text & score_link + float* outData = outputs[0].GetTensorMutableData(); + int H = int(outputShape[1]), W = int(outputShape[2]); + cv::Mat score_text(H, W, CV_32F); + cv::Mat score_link(H, W, CV_32F); + for (int y = 0; y < H; ++y) + { + for (int x = 0; x < W; ++x) + { + int offset = (y * W + x) * 2; + score_text.at(y, x) = outData[offset + 0]; + score_link.at(y, x) = outData[offset + 1]; + } + } + // --- 3. õ boxes/polys (heatmap ϵ) --- + EOCRD_Rects boxes, polys; + cv::Mat labels; + std::vector mapper; + if (!GetDetBoxesCore(score_text, score_link, textThreshold, linkThreshold, lowText, boxes, labels, mapper, false)) + return {}; + polys = boxes; + // --- 4. ӳ --- + float invRatio = 1.0f / ratio; + float ratioNetW = float(resized.cols) / float(heatmapSize.width); + float ratioNetH = float(resized.rows) / float(heatmapSize.height); + // ͨ heatmapSize = (resized.cols/2, resized.rows/2) ratioNetW/H 2 + // --- 5. ӳԭͼ --- + AdjustResultCoordinates(polys, invRatio, invRatio, ratioNetW); + return polys; + } + catch (...) + { + return {}; + } +} diff --git a/LibEasyOCR-CPP/EasyOCR_Detector.h b/LibEasyOCR-CPP/EasyOCR_Detector.h new file mode 100644 index 0000000..93a7767 --- /dev/null +++ b/LibEasyOCR-CPP/EasyOCR_Detector.h @@ -0,0 +1,51 @@ +#pragma once +#include +#include "OCRToolBox.h" +#include +#include + +namespace uns +{ + class EasyOCR_Detector + { + private: + const float lowText = 0.4f; + const float textThreshold = 0.7f; + const float linkThreshold = 0.4f; + + private: + const OrtApi* ort; + + Ort::Env ort_env; + Ort::Session* ort_cpu_session; + Ort::SessionOptions ort_session_options; + + bool ort_inited; + std::wstring model_path; + + IONames input_names, output_names; + IONamesStorage input_ns, output_ns; + + private: + cv::Mat NormalizeMeanVariance(const cv::Mat& in); + void AdjustResultCoordinates(EOCRD_Rects& polys, float ratioW, float ratioH, float ratioNet = 2.0f); + void ResizeAspectRatio(const cv::Mat& src, cv::Mat& dst, float squareSize, float magRatio, float& ratio, cv::Size& heatmapSize); + bool GetDetBoxesCore(const cv::Mat& textmap, const cv::Mat& linkmap, float textThresh, float linkThresh, float lowText, EOCRD_Rects& boxes, cv::Mat& labels, std::vector& mapper, bool estimateNumChars); + + public: + EasyOCR_Detector(); + EasyOCR_Detector(const EasyOCR_Detector&) = delete; + + public: + bool Init(); + bool UnInit(); + bool RecheckModelInfo(); + /// + /// EasyOCR ı⺯ + /// + /// ͼͨBGRͼ + /// ⵽ľο + EOCRD_Rects operator()(const cv::Mat& image); + }; +} + diff --git a/LibEasyOCR-CPP/EasyOCR_Recognizer.cpp b/LibEasyOCR-CPP/EasyOCR_Recognizer.cpp new file mode 100644 index 0000000..2477d13 --- /dev/null +++ b/LibEasyOCR-CPP/EasyOCR_Recognizer.cpp @@ -0,0 +1,389 @@ +#include "pch.h" +#include "OCRCharset.h" +#include "EasyOCR_Recognizer.h" + +uns::EasyOCR_Recognizer::NormalizePAD::Size3i uns::EasyOCR_Recognizer::NormalizePAD::Size3i::operator=(const Size3i& obj) +{ + d0 = obj.d0; + d1 = obj.d1; + d2 = obj.d2; + return (*this); +} + +uns::EasyOCR_Recognizer::NormalizePAD::NormalizePAD(Size3i max_size, const std::string& PAD_type) +{ + this->max_size = max_size; + this->PAD_type = PAD_type; + max_width_half = max_size.d2 / 2; // ȵһ룬ڿѡ +} + +cv::Mat uns::EasyOCR_Recognizer::NormalizePAD::operator()(const cv::Mat& input_img) const +{ + // ԭͼתΪ32λͲһ[0,1] + cv::Mat img; + input_img.convertTo(img, CV_32F, 1.0 / 255); // line 10: img = toTensor + img = (img - 0.5f) / 0.5f; // line 11: img.sub_(0.5).div_(0.5) + int h = img.rows; // ȡͼ߶ + int w = img.cols; // ȡͼ + int c = img.channels(); // ȡͨҶͼĬΪ1 + // ĿСȫMatΪ32FߴΪmax_size.d1 x max_size.d2 + cv::Mat pad_img = cv::Mat::zeros(max_size.d1, max_size.d2, CV_32FC(c)); // line 13 + // ԭͼ񿽱pad_imgϽʵҲ + img.copyTo(pad_img(cv::Rect(0, 0, w, h))); // line 14 + // Ŀȴԭͼȣʹһؽչ + if (max_size.d2 != w) + { // line 15 + cv::Mat last_col = img.col(w - 1); + cv::Mat border; + cv::repeat(last_col, 1, max_size.d2 - w, border); // ظһ + border.copyTo(pad_img(cv::Rect(w, 0, max_size.d2 - w, h))); + } + return pad_img; // شĸ +} + +cv::Mat uns::EasyOCR_Recognizer::AlignCollate::AdjustContrastGrey(const cv::Mat& img_in, double target) const +{ + double contrast; + int high, low; + ContrastGrey(img_in, contrast, high, low); + cv::Mat img = img_in.clone(); + if (contrast < target) + { + cv::Mat img_i; + img.convertTo(img_i, CV_32S); + double ratio = 200.0 / std::max(10, high - low); + img_i = (img_i - low + 25) * ratio; + // ֵ[0,255]Χת8λ + img_i.forEach([] (int& pixel, const int*) + { + pixel = std::clamp(pixel, 0, 255); + }); + img_i.convertTo(img, CV_8U); + } + return img; +} + +void uns::EasyOCR_Recognizer::AlignCollate::ContrastGrey(const cv::Mat& img, double& contrast, int& high, int& low) const +{ + // MatͼݸƵһvectorУԱ + std::vector pixels; + pixels.reserve(img.rows * img.cols); // ԤռЧ + for (int i = 0; i < img.rows; ++i) + { + const uchar* row_ptr = img.ptr(i); + for (int j = 0; j < img.cols; ++j) + pixels.push_back(static_cast(row_ptr[j])); + } + // ֵ򣬱ڻȡٷλ + std::sort(pixels.begin(), pixels.end()); + // 90%λãPython np.percentileһ + int idx90 = static_cast(0.9 * (pixels.size() - 1)); + int idx10 = static_cast(0.1 * (pixels.size() - 1)); + high = pixels[idx90]; + low = pixels[idx10]; + // contrast: (high - low) / max(10, high + low) + contrast = double(high - low) / double(std::max(10, high + low)); +} + +uns::EasyOCR_Recognizer::AlignCollate::AlignCollate(int imgH, int imgW, bool keep_ratio_with_pad, double adjust_contrast) +{ + this->imgH = imgH; + this->imgW = imgW; + this->adjust_contrast = adjust_contrast; + this->keep_ratio_with_pad = keep_ratio_with_pad; +} + +cv::Mat uns::EasyOCR_Recognizer::AlignCollate::operator()(const std::vector& batch) const +{ + std::vector resized_images; + + // NormalizePADʵڹһ + NormalizePAD transform({ 1, imgH, imgW }); + + for (const cv::Mat& image : batch) + { + cv::Mat working; + if (adjust_contrast > 0) + { + cv::Mat grey; + if (image.channels() > 1) + cv::cvtColor(image, grey, cv::COLOR_BGR2GRAY); + else + grey = image; + working = AdjustContrastGrey(grey, adjust_contrast); + } + else + working = image; + int w = working.cols; + int h = working.rows; + double ratio = double(w) / h; + int resized_w = static_cast(std::ceil(imgH * ratio)); + if (resized_w > imgW) + resized_w = imgW; + cv::Mat resized; + cv::resize(working, resized, cv::Size(resized_w, imgH), 0, 0, cv::INTER_CUBIC); + cv::Mat tensor = transform(resized); + resized_images.push_back(tensor); + } + cv::Mat blob; + cv::dnn::blobFromImages(resized_images, blob); + return blob; +} + +float uns::EasyOCR_Recognizer::CustomMean(const VecFloat& x) +{ + size_t N = x.size(); + if (N == 0) + return 0.0f; + // 1. Ԫصij˻ + double prod = 1.0; + for (float v : x) + if (v != 0) + prod *= static_cast(v); + // 2. ָ 2.0 / sqrt(N) + double exponent = 2.0 / std::sqrt(static_cast(N)); + // 3. prod exponent + return static_cast(std::pow(prod, exponent)); +} + +cv::Mat uns::EasyOCR_Recognizer::Preprocess(const cv::Mat& img) const +{ + if (img.empty()) + return {}; //˴ʺ׳쳣ʹÿͼֹ󼶵Ĵ + cv::Mat gray; + int ch = img.channels(); + // case 2: BGR ɫͼ3 ͨ + if (ch == 3) + cv::cvtColor(img, gray, cv::COLOR_BGR2GRAY); + // case 3: RGBA ɫͼ4 ͨ + else if (ch == 4) + { + // ȥ alpha ͨ BGRA GRAY + cv::Mat bgr; + cv::cvtColor(img, gray, cv::COLOR_BGRA2GRAY); + } + else // image (hw) (hw1)˵Ҷȴ + gray = img; + int width = gray.cols; + int height = gray.rows; + int model_height = 64, model_width = 0; + float ratio = static_cast(width) / static_cast(height); + cv::Mat resized; + if (ratio < 1.0f) + { + // ֱıʹ calculate_ratio ֤߶Ϊ model_height + float adj_ratio = CalculateRatio(width, height); + model_width = static_cast(model_height * adj_ratio); + cv::resize(gray, resized, cv::Size(model_height, model_width), 0, 0, cv::INTER_LINEAR); + ratio = adj_ratio; + } + else + { + // ı߶Ϊ model_height + model_width = static_cast(model_height * ratio); + cv::resize(gray, resized, cv::Size(model_width, model_height), 0, 0, cv::INTER_LINEAR); + } + AlignCollate alignCollate(model_height, model_width, true, 0.5); + return alignCollate({ resized }); +} + +float uns::EasyOCR_Recognizer::CalculateRatio(int width, int height) const +{ + float ratio = static_cast(width) / static_cast(height); + if (ratio < 1.0f) + ratio = 1.0f / ratio; + return ratio; +} + +uns::VecFloat uns::EasyOCR_Recognizer::SoftMAX(const float* logits, int C) const +{ + // ҵֵȶֵ + float m = logits[0]; + for (int i = 1; i < C; ++i) + m = std::max(m, logits[i]); + // exp(logit - m) + std::vector exps(C); + float sum = 0.f; + for (int i = 0; i < C; ++i) + { + exps[i] = std::exp(logits[i] - m); + sum += exps[i]; + } + // һ + for (int i = 0; i < C; ++i) + exps[i] /= (sum > 1e-6f ? sum : 1e-6f); + return exps; +} + +void uns::EasyOCR_Recognizer::PostprocessONNXOutput(const Ort::Value& outputs, int N, int T, int C, VecInt& out_indices, VecFloat& out_probs, const VecInt ignore_idx) +{ + // ָʵײ + const float* data = outputs.GetTensorData(); + out_indices.clear(); + out_probs.clear(); + // ʱ洢ÿ + std::vector probs; + probs.reserve(C); + // ÿÿʱ䲽 + for (int n = 0; n < N; ++n) + { + for (int t = 0; t < T; ++t) + { + // logits ʼλ: ((n * T) + t) * C + const float* logits = data + ((size_t)n * T + t) * C; + // 1) Softmax + probs = SoftMAX(logits, C); + // 2) ignore_idx + if (!ignore_idx.empty()) + for (const auto& idx : ignore_idx) + probs[idx] = 0.f; + // 3) ٴιһ + float sum = 0.f; + for (int c = 0; c < C; ++c) + sum += probs[c]; + if (sum > 1e-6f) + { + for (int c = 0; c < C; ++c) + probs[c] /= sum; + } + // 4) ȡ + int best = 0; + float best_prob = 0.0f; + for (int c = 1; c < C; ++c) + { + if (probs[c] > probs[best]) + { + best = c; + best_prob = probs[c]; + } + } + out_indices.push_back(best); + out_probs.push_back(best_prob); + } + } +} + +uns::EasyOCR_Recognizer::EasyOCR_Recognizer() +{ + ort_inited = false; + ort_cpu_session = nullptr; + model_path = G_OCRConfig.GetRecognizeModelPath(); + ort = OrtGetApiBase()->GetApi(ORT_API_VERSION); +} + +bool uns::EasyOCR_Recognizer::Init() +{ + if (ort_inited) + return true; + if (!RecheckModelInfo()) + return false; + try + { + ort_env = Ort::Env(ORT_LOGGING_LEVEL_WARNING, "EasyOCR_Recognizer"); + bool fallback_to_cpu = false; + if (!OCRToolBox::AutoSelectEP(ort, ort_session_options, fallback_to_cpu)) + return false; + OCRToolBox::InitOrtSessionOptions(ort_session_options); + if ((G_OCRConfig.GetGPUUsage() == easyocr::GPUUsage::CPUOnly) || fallback_to_cpu) //ʹCPUʼcpu session + { + ort_cpu_session = new Ort::Session(ort_env, model_path.c_str(), ort_session_options); + //ͨCPU sessionȡ + OCRToolBox::GetInputOutputNames(ort_cpu_session, input_names, input_ns, output_names, output_ns); + } + else + { + //ͨʱsessionȡCUDA̲߳ȫ + Ort::Session ort_session(ort_env, model_path.c_str(), ort_session_options); + OCRToolBox::GetInputOutputNames(&ort_session, input_names, input_ns, output_names, output_ns); + } + ort_inited = true; + return true; + } + catch (...) + { + return false; + } +} + +bool uns::EasyOCR_Recognizer::UnInit() +{ + try + { + if (ort_cpu_session != nullptr) + delete ort_cpu_session; + ort_cpu_session = nullptr; + return true; + } + catch (...) + { + return false; + } +} + +bool uns::EasyOCR_Recognizer::RecheckModelInfo() +{ + if (model_path.empty()) + model_path = G_OCRConfig.GetRecognizeModelPath(); + return OCRToolBox::CheckFile(model_path); +} + +uns::EOCR_Result uns::EasyOCR_Recognizer::operator()(const cv::Mat& image) +{ + try + { + if (!RecheckModelInfo()) + return { L"", -1.0f }; + cv::Mat input = Preprocess(image); + if (input.empty()) + return { L"", 0.0f }; + std::array inputShape = { 1, 1, input.size[2], input.size[3] }; + Ort::MemoryInfo memInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault); + Ort::Value inputTensor = Ort::Value::CreateTensor(memInfo, input.ptr(), input.total(), inputShape.data(), inputShape.size()); + auto outputs = ((ort_cpu_session != nullptr) ? ort_cpu_session->Run(Ort::RunOptions{nullptr}, input_names.data(), & inputTensor, 1, output_names.data(), 1) : Ort::Session(ort_env, model_path.c_str(), ort_session_options).Run(Ort::RunOptions{nullptr}, input_names.data(), & inputTensor, 1, output_names.data(), 1)); + // shape: [1, T, C] + auto& outVal = outputs.front(); + auto info = outVal.GetTensorTypeAndShapeInfo(); + auto shape = info.GetShape(); // {1, T, C} + int N = (int)shape[0], T = (int)shape[1], C = (int)shape[2]; + float* data = outVal.GetTensorMutableData(); + // greedy pick & softmax + std::vector indices(T); + std::vector maxProbs(T); + PostprocessONNXOutput(outputs[0], N, T, C, indices, maxProbs); + // + std::wstring text = OCRCharset::GetString(indices); + // Ŷ + float conf = CustomMean(maxProbs); + return { text, conf }; + } + catch (...) + { + return { L"", -2.0f }; + } +} + +uns::EOCR_ResultSet uns::EasyOCR_Recognizer::operator()(const cv::Mat& full_image, const EOCRD_Rects& rects) +{ + if (!RecheckModelInfo()) + return {}; + try + { + EOCR_ResultSet result_set; + for (size_t i = 0; i < rects.size(); ++i) + { + // תΪСӾβü + cv::Rect rect = cv::boundingRect(rects[i]); + rect &= cv::Rect(0, 0, full_image.cols, full_image.rows); // üͼΧ + cv::Mat crop = full_image(rect); + if (crop.empty()) + continue; + auto [text, conf] = (*this)(crop); + result_set.insert({ i, { text, conf } }); + } + return result_set; + } + catch (...) + { + return {}; + } +} diff --git a/LibEasyOCR-CPP/EasyOCR_Recognizer.h b/LibEasyOCR-CPP/EasyOCR_Recognizer.h new file mode 100644 index 0000000..8424d56 --- /dev/null +++ b/LibEasyOCR-CPP/EasyOCR_Recognizer.h @@ -0,0 +1,96 @@ +#pragma once +#include +#include +#include "OCRConfig.h" +#include "OCRToolBox.h" +#include +#include + +namespace uns +{ + class EasyOCR_Recognizer + { + public: + class NormalizePAD + { + public: + struct Size3i // Զ3άߴṹʾͨ߶ȡ + { + int d0, d1, d2; + + Size3i operator=(const Size3i& obj); + }; + + private: + Size3i max_size; // ߴ + int max_width_half; // һ룬ڿѡIJüȹ + std::string PAD_type; // ֧ͣ"right""left" + + public: + NormalizePAD(Size3i max_size, const std::string& PAD_type = "right"); + + public: + cv::Mat operator()(const cv::Mat& input_img) const; + }; + + class AlignCollate + { + private: + int imgH; // Ŀͼ߶ + int imgW; // Ŀͼ + bool keep_ratio_with_pad; // ֳȲ־δʹã + double adjust_contrast; // ԱȶȵĿֵ + + private: + cv::Mat AdjustContrastGrey(const cv::Mat& img_in, double target = 0.4) const; + void ContrastGrey(const cv::Mat& img, double& contrast, int& high, int& low) const; + + public: + AlignCollate(int imgH = 32, int imgW = 100, bool keep_ratio_with_pad = false, double adjust_contrast = 0.0); + + public: + cv::Mat operator()(const std::vector& batch) const; + }; + + private: + const OrtApi* ort; + + Ort::Env ort_env; + Ort::Session* ort_cpu_session; + Ort::SessionOptions ort_session_options; + + bool ort_inited; + std::wstring model_path; + + IONames input_names, output_names; + IONamesStorage input_ns, output_ns; + + private: + float CustomMean(const VecFloat& x); + cv::Mat Preprocess(const cv::Mat& img) const; + float CalculateRatio(int width, int height) const; + VecFloat SoftMAX(const float* logits, int C) const; + void PostprocessONNXOutput(const Ort::Value& outputs, int N, int T, int C, VecInt& out_indices, VecFloat& out_probs, const VecInt ignore_idx = {}); + + public: + EasyOCR_Recognizer(); + + public: + bool Init(); + bool UnInit(); + bool RecheckModelInfo(); + /// + /// EasyOCR ıʶ + /// + /// ıͼͨBGRͼ + /// ıŶ + EOCR_Result operator()(const cv::Mat& image); + /// + /// EasyOCR ıʶ + /// + /// ĴͼͨBGRͼ + /// EasyOCR_Detector⵽ıλþ + /// ɸ [ıŶ] + EOCR_ResultSet operator()(const cv::Mat& full_image, const EOCRD_Rects& rects); + }; +} diff --git a/LibEasyOCR-CPP/LibEasyOCR-CPP-Export.h b/LibEasyOCR-CPP/LibEasyOCR-CPP-Export.h new file mode 100644 index 0000000..a52ee16 --- /dev/null +++ b/LibEasyOCR-CPP/LibEasyOCR-CPP-Export.h @@ -0,0 +1,12 @@ +#pragma once + +#ifdef LIBEASYOCRCPP_EXPORTS +#define LIBEASYOCRCPP_API _declspec(dllexport) +#else +#define LIBEASYOCRCPP_API _declspec(dllimport) +#ifdef _DEBUG +#pragma comment(lib, "LibEasyOCR-CPPd.lib") +#else +#pragma comment(lib, "LibEasyOCR-CPP.lib") +#endif +#endif \ No newline at end of file diff --git a/LibEasyOCR-CPP/LibEasyOCR-CPP.cpp b/LibEasyOCR-CPP/LibEasyOCR-CPP.cpp new file mode 100644 index 0000000..ef64443 --- /dev/null +++ b/LibEasyOCR-CPP/LibEasyOCR-CPP.cpp @@ -0,0 +1,135 @@ +#include "pch.h" +#include "ATW.h" +#include "OCRConfig.h" +#include "LibEasyOCR-CPP.h" +#include "EasyOCR_Detector.h" +#include "EasyOCR_Recognizer.h" + +uns::EasyOCR_Detector G_Detector; +uns::EasyOCR_Recognizer G_Recognizer; + +uns::OCRConfig& uns::EasyOCR_CPP::GlobalOCRConfig() +{ + return G_OCRConfig; +} + +void uns::EasyOCR_CPP::SetRecognitionModel(const std::wstring& reco_model, easyocr::CharsetType language) +{ + G_OCRConfig.SetLanguage(language); + G_OCRConfig.SetRecognizeModelPath(reco_model); +} + +bool uns::EasyOCR_CPP::CleanupOCR() +{ + bool detect = G_Detector.UnInit(); + bool recognize = G_Recognizer.UnInit(); + return (detect && recognize); +} + +bool uns::EasyOCR_CPP::InitDetectionModel() +{ + return G_Detector.Init(); +} + +bool uns::EasyOCR_CPP::InitRecognitionModel() +{ + return G_Recognizer.Init(); +} + +uns::easyocr::EOCRD_Rects uns::EasyOCR_CPP::Detect(const cv::Mat& img) +{ + if (img.empty() || (!G_Detector.RecheckModelInfo())) + return {}; + return G_Detector(img); +} + +uns::easyocr::EOCR_Result uns::EasyOCR_CPP::Recognize(const cv::Mat& img) +{ + if (img.empty() || (!G_Recognizer.RecheckModelInfo())) + return {}; + return G_Recognizer(img); +} + +uns::easyocr::EOCR_ResultSet uns::EasyOCR_CPP::Recognize(const cv::Mat& img, const easyocr::EOCRD_Rects& rects) +{ + if (img.empty() || (!G_Recognizer.RecheckModelInfo())) + return {}; + return G_Recognizer(img, rects); +} + +uns::easyocr::EOCR_ResultSet uns::EasyOCR_CPP::FullAuto(const cv::Mat& img) +{ + if (img.empty() || (!G_Detector.RecheckModelInfo()) || (!G_Recognizer.RecheckModelInfo())) + return {}; + auto rects = G_Detector(img); + if (rects.empty()) + return {}; + else + return G_Recognizer(img, rects); +} + +std::string uns::EOCR_SupportTools::WtoA(const std::wstring& wstr) +{ + return ::WtoA(wstr); +} + +std::wstring uns::EOCR_SupportTools::AtoW(const std::string& str) +{ + return ::AtoW(str); +} + +std::string uns::EOCR_SupportTools::AtoUTF8(const std::string& str) +{ + return ::AtoUTF8(str); +} + +std::string uns::EOCR_SupportTools::UTF8toA(const std::string& utf8) +{ + return ::UTF8toA(utf8); +} + +cv::Mat uns::EOCR_SupportTools::ReadImage(const std::string& file, bool blur, int blur_size) +{ + if (!uns::OCRToolBox::CheckFile(::AtoW(file))) + return {}; + try + { + if (!blur) + return cv::imread(file); + else + { + cv::Mat img = cv::imread(file); + if (img.empty()) + return {}; + cv::blur(img, img, cv::Size(blur_size, blur_size)); + return img; + } + } + catch (...) + { + return {}; + } +} + +cv::Mat uns::EOCR_SupportTools::ReadImage(const std::wstring& file, bool blur, int blur_size) +{ + if (!uns::OCRToolBox::CheckFile(file)) + return {}; + try + { + if (!blur) + return cv::imread(::WtoA(file)); + else + { + cv::Mat img = cv::imread(::WtoA(file)); + if (img.empty()) + return {}; + cv::blur(img, img, cv::Size(blur_size, blur_size)); + return img; + } + } + catch (...) + { + return {}; + } +} diff --git a/LibEasyOCR-CPP/LibEasyOCR-CPP.h b/LibEasyOCR-CPP/LibEasyOCR-CPP.h new file mode 100644 index 0000000..3d283ad --- /dev/null +++ b/LibEasyOCR-CPP/LibEasyOCR-CPP.h @@ -0,0 +1,46 @@ +#pragma once +#include +#include +#include +#include "OCRConfig.h" +#include +#include "LibEasyOCR-CPP-Export.h" + +namespace uns +{ + namespace easyocr + { + using EOCR_Result = std::pair; + using EOCR_ResultSet = std::map; + using EOCRD_Rects = std::vector>; + } + + class LIBEASYOCRCPP_API EasyOCR_CPP + { + public: + static OCRConfig& GlobalOCRConfig(); + static void SetRecognitionModel(const std::wstring& reco_model, easyocr::CharsetType language); + + static bool CleanupOCR(); + static bool InitDetectionModel(); + static bool InitRecognitionModel(); + + static easyocr::EOCRD_Rects Detect(const cv::Mat& img); + static easyocr::EOCR_Result Recognize(const cv::Mat& img); + static easyocr::EOCR_ResultSet Recognize(const cv::Mat& img, const easyocr::EOCRD_Rects& rects); + + static easyocr::EOCR_ResultSet FullAuto(const cv::Mat& img); + }; + + class LIBEASYOCRCPP_API EOCR_SupportTools + { + public: + static std::string WtoA(const std::wstring& wstr); + static std::wstring AtoW(const std::string& str); + static std::string AtoUTF8(const std::string& str); + static std::string UTF8toA(const std::string& utf8); + + static cv::Mat ReadImage(const std::string& file, bool blur = false, int blur_size = 3); + static cv::Mat ReadImage(const std::wstring& file, bool blur = false, int blur_size = 3); + }; +} \ No newline at end of file diff --git a/LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj b/LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj new file mode 100644 index 0000000..076d467 --- /dev/null +++ b/LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj @@ -0,0 +1,181 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {1900cf83-6bce-41c9-b022-0645107abd57} + LibEasyOCRCPP + 10.0 + + + + DynamicLibrary + true + v143 + Unicode + + + DynamicLibrary + false + v143 + true + Unicode + + + DynamicLibrary + true + v143 + Unicode + + + DynamicLibrary + false + v143 + true + Unicode + + + + + + + + + + + + + + + + + + + + + F:\vcpkg\installed\x64-windows\include\opencv4;$(IncludePath) + + + F:\vcpkg\installed\x64-windows\include\opencv4;$(IncludePath) + $(ProjectName)d + + + + Level3 + true + WIN32;_DEBUG;LIBEASYOCRCPP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + false + + + + + Level3 + true + true + true + WIN32;NDEBUG;LIBEASYOCRCPP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + true + true + false + + + + + Level3 + true + _DEBUG;LIBEASYOCRCPP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + stdcpp17 + + + Windows + true + false + + + + + Level3 + true + true + true + NDEBUG;LIBEASYOCRCPP_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + stdcpp17 + + + Windows + true + true + true + false + + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + \ No newline at end of file diff --git a/LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj.filters b/LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj.filters new file mode 100644 index 0000000..f1181d2 --- /dev/null +++ b/LibEasyOCR-CPP/LibEasyOCR-CPP.vcxproj.filters @@ -0,0 +1,78 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + 头文件 + + + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + 源文件 + + + \ No newline at end of file diff --git a/LibEasyOCR-CPP/OCRCharset.cpp b/LibEasyOCR-CPP/OCRCharset.cpp new file mode 100644 index 0000000..d938234 --- /dev/null +++ b/LibEasyOCR-CPP/OCRCharset.cpp @@ -0,0 +1,6874 @@ +#include "pch.h" +#include "OCRCharset.h" +#include "OCRConfig.h" +#pragma warning(disable:6262) + +std::map uns::OCRCharset::en_charmap = +{ + {0, L"[blank]"}, + {1, L"0"}, + {2, L"1"}, + {3, L"2"}, + {4, L"3"}, + {5, L"4"}, + {6, L"5"}, + {7, L"6"}, + {8, L"7"}, + {9, L"8"}, + {10, L"9"}, + {11, L"!"}, + {12, L"\""}, + {13, L"#"}, + {14, L"$"}, + {15, L"%"}, + {16, L"&"}, + {17, L"'"}, + {18, L"("}, + {19, L")"}, + {20, L"*"}, + {21, L"+"}, + {22, L","}, + {23, L"-"}, + {24, L"."}, + {25, L"/"}, + {26, L":"}, + {27, L";"}, + {28, L"<"}, + {29, L"="}, + {30, L">"}, + {31, L"?"}, + {32, L"@"}, + {33, L"["}, + {34, L"\\"}, + {35, L"]"}, + {36, L"^"}, + {37, L"_"}, + {38, L"`"}, + {39, L"{"}, + {40, L"|"}, + {41, L"}"}, + {42, L"~"}, + {43, L" "}, + {44, L""}, + {45, L"A"}, + {46, L"B"}, + {47, L"C"}, + {48, L"D"}, + {49, L"E"}, + {50, L"F"}, + {51, L"G"}, + {52, L"H"}, + {53, L"I"}, + {54, L"J"}, + {55, L"K"}, + {56, L"L"}, + {57, L"M"}, + {58, L"N"}, + {59, L"O"}, + {60, L"P"}, + {61, L"Q"}, + {62, L"R"}, + {64, L"T"}, + {65, L"U"}, + {66, L"V"}, + {67, L"W"}, + {68, L"X"}, + {69, L"Y"}, + {70, L"Z"}, + {71, L"a"}, + {72, L"b"}, + {73, L"c"}, + {74, L"d"}, + {75, L"e"}, + {76, L"f"}, + {77, L"g"}, + {78, L"h"}, + {79, L"i"}, + {80, L"j"}, + {81, L"k"}, + {82, L"l"}, + {83, L"m"}, + {84, L"n"}, + {85, L"o"}, + {86, L"p"}, + {87, L"q"}, + {88, L"r"}, + {89, L"s"}, + {90, L"t"}, + {91, L"u"}, + {92, L"v"}, + {93, L"w"}, + {94, L"x"}, + {95, L"y"}, + {96, L"z"}, +}; + +std::map uns::OCRCharset::ch_en_charmap = +{ + {0, L"[blank]"}, + {1, L" "}, + {2, L"!"}, + {3, L"\""}, + {4, L"#"}, + {5, L"$"}, + {6, L"%"}, + {7, L"&"}, + {8, L"'"}, + {9, L"("}, + {10, L")"}, + {11, L"*"}, + {12, L"+"}, + {13, L","}, + {14, L"-"}, + {15, L"."}, + {16, L"/"}, + {17, L"0"}, + {18, L"1"}, + {19, L"2"}, + {20, L"3"}, + {21, L"4"}, + {22, L"5"}, + {23, L"6"}, + {24, L"7"}, + {25, L"8"}, + {26, L"9"}, + {27, L":"}, + {28, L";"}, + {29, L"<"}, + {30, L"="}, + {31, L">"}, + {32, L"?"}, + {33, L"@"}, + {34, L"A"}, + {35, L"B"}, + {36, L"C"}, + {37, L"D"}, + {38, L"E"}, + {39, L"F"}, + {40, L"G"}, + {41, L"H"}, + {42, L"I"}, + {43, L"J"}, + {44, L"K"}, + {45, L"L"}, + {46, L"M"}, + {47, L"N"}, + {48, L"O"}, + {49, L"P"}, + {50, L"Q"}, + {51, L"R"}, + {52, L"S"}, + {53, L"T"}, + {54, L"U"}, + {55, L"V"}, + {56, L"W"}, + {57, L"X"}, + {58, L"Y"}, + {59, L"Z"}, + {60, L"["}, + {61, L"\\"}, + {62, L"]"}, + {63, L"^"}, + {64, L"_"}, + {65, L"`"}, + {66, L"a"}, + {67, L"b"}, + {68, L"c"}, + {69, L"d"}, + {70, L"e"}, + {71, L"f"}, + {72, L"g"}, + {73, L"h"}, + {74, L"i"}, + {75, L"j"}, + {76, L"k"}, + {77, L"l"}, + {78, L"m"}, + {79, L"n"}, + {80, L"o"}, + {81, L"p"}, + {82, L"q"}, + {83, L"r"}, + {84, L"s"}, + {85, L"t"}, + {86, L"u"}, + {87, L"v"}, + {88, L"w"}, + {89, L"x"}, + {90, L"y"}, + {91, L"z"}, + {92, L"{"}, + {93, L"|"}, + {94, L"}"}, + {95, L"~"}, + {96, L""}, + {97, L""}, + {98, L""}, + {99, L""}, + {100, L""}, + {101, L""}, + {102, L""}, + {103, L""}, + {104, L""}, + {105, L"һ"}, + {106, L""}, + {107, L""}, + {108, L""}, + {109, L""}, + {110, L""}, + {111, L""}, + {112, L""}, + {113, L""}, + {114, L""}, + {115, L"ؤ"}, + {116, L""}, + {117, L"ר"}, + {118, L""}, + {119, L"ا"}, + {120, L""}, + {121, L""}, + {122, L""}, + {123, L"ҵ"}, + {124, L""}, + {125, L""}, + {126, L"˿"}, + {127, L"ة"}, + {128, L""}, + {129, L""}, + {130, L""}, + {131, L"ɥ"}, + {132, L""}, + {133, L"Ѿ"}, + {134, L""}, + {135, L""}, + {136, L""}, + {137, L""}, + {138, L""}, + {139, L""}, + {140, L"Ϊ"}, + {141, L""}, + {142, L""}, + {143, L""}, + {144, L""}, + {145, L""}, + {146, L"ô"}, + {147, L""}, + {148, L"֮"}, + {149, L""}, + {150, L"է"}, + {151, L""}, + {152, L""}, + {153, L""}, + {154, L"ƹ"}, + {155, L""}, + {156, L""}, + {157, L""}, + {158, L""}, + {159, L""}, + {160, L"ؿ"}, + {161, L""}, + {162, L""}, + {163, L"Ҳ"}, + {164, L"ϰ"}, + {165, L""}, + {166, L""}, + {167, L""}, + {168, L""}, + {169, L""}, + {170, L""}, + {171, L"Ǭ"}, + {172, L""}, + {173, L""}, + {174, L""}, + {175, L""}, + {176, L""}, + {177, L"ء"}, + {178, L""}, + {179, L""}, + {180, L""}, + {181, L""}, + {182, L""}, + {183, L""}, + {184, L""}, + {185, L"ب"}, + {186, L""}, + {187, L"Щ"}, + {188, L"ؽ"}, + {189, L""}, + {190, L""}, + {191, L""}, + {192, L""}, + {193, L""}, + {194, L""}, + {195, L""}, + {196, L"Ķ"}, + {197, L""}, + {198, L""}, + {199, L"ͤ"}, + {200, L""}, + {201, L""}, + {202, L""}, + {203, L""}, + {204, L""}, + {205, L""}, + {206, L"ʲ"}, + {207, L""}, + {208, L""}, + {209, L""}, + {210, L""}, + {211, L""}, + {212, L""}, + {213, L""}, + {214, L""}, + {215, L""}, + {216, L""}, + {217, L""}, + {218, L""}, + {219, L""}, + {220, L""}, + {221, L""}, + {222, L""}, + {223, L""}, + {224, L""}, + {225, L""}, + {226, L""}, + {227, L""}, + {228, L"Ǫ"}, + {229, L""}, + {230, L""}, + {231, L""}, + {232, L""}, + {233, L""}, + {234, L""}, + {235, L""}, + {236, L""}, + {237, L""}, + {238, L""}, + {239, L""}, + {240, L""}, + {241, L""}, + {242, L""}, + {243, L""}, + {244, L""}, + {245, L""}, + {246, L""}, + {247, L""}, + {248, L""}, + {249, L""}, + {250, L""}, + {251, L""}, + {252, L""}, + {253, L""}, + {254, L""}, + {255, L""}, + {256, L""}, + {257, L""}, + {258, L""}, + {259, L"ɡ"}, + {260, L"ΰ"}, + {261, L""}, + {262, L""}, + {263, L""}, + {264, L""}, + {265, L""}, + {266, L"α"}, + {267, L""}, + {268, L""}, + {269, L""}, + {270, L""}, + {271, L""}, + {272, L""}, + {273, L""}, + {274, L""}, + {275, L"٤"}, + {276, L""}, + {277, L""}, + {278, L"λ"}, + {279, L""}, + {280, L"ס"}, + {281, L""}, + {282, L""}, + {283, L""}, + {284, L""}, + {285, L"٢"}, + {286, L""}, + {287, L""}, + {288, L""}, + {289, L""}, + {290, L""}, + {291, L""}, + {292, L""}, + {293, L"١"}, + {294, L""}, + {295, L"Ӷ"}, + {296, L""}, + {297, L""}, + {298, L""}, + {299, L""}, + {300, L""}, + {301, L""}, + {302, L""}, + {303, L"٦"}, + {304, L"٥"}, + {305, L"٬"}, + {306, L"ٮ"}, + {307, L"٫"}, + {308, L"ʹ"}, + {309, L"٩"}, + {310, L"ֶ"}, + {311, L""}, + {312, L"٨"}, + {313, L""}, + {314, L""}, + {315, L"٪"}, + {316, L"٧"}, + {317, L"ٰ"}, + {318, L""}, + {319, L""}, + {320, L""}, + {321, L""}, + {322, L""}, + {323, L""}, + {324, L""}, + {325, L""}, + {326, L""}, + {327, L""}, + {328, L"٭"}, + {329, L"ٯ"}, + {330, L""}, + {331, L""}, + {332, L""}, + {333, L""}, + {334, L""}, + {335, L""}, + {336, L"ٴ"}, + {337, L""}, + {338, L""}, + {339, L""}, + {340, L""}, + {341, L"ٸ"}, + {342, L""}, + {343, L""}, + {344, L"ٵ"}, + {345, L"ٷ"}, + {346, L""}, + {347, L""}, + {348, L"ٹ"}, + {349, L""}, + {350, L"ٶ"}, + {351, L"ٱ"}, + {352, L"ٲ"}, + {353, L""}, + {354, L"ٳ"}, + {355, L""}, + {356, L""}, + {357, L""}, + {358, L""}, + {359, L"ٽ"}, + {360, L"ٺ"}, + {361, L""}, + {362, L""}, + {363, L""}, + {364, L""}, + {365, L"ٿ"}, + {366, L""}, + {367, L""}, + {368, L""}, + {369, L""}, + {370, L""}, + {371, L""}, + {372, L""}, + {373, L""}, + {374, L""}, + {375, L""}, + {376, L""}, + {377, L"ٻ"}, + {378, L""}, + {379, L"پ"}, + {380, L""}, + {381, L"ծ"}, + {382, L"ֵ"}, + {383, L""}, + {384, L""}, + {385, L""}, + {386, L""}, + {387, L"ټ"}, + {388, L""}, + {389, L"ƫ"}, + {390, L""}, + {391, L""}, + {392, L"ͣ"}, + {393, L""}, + {394, L""}, + {395, L"ż"}, + {396, L"͵"}, + {397, L""}, + {398, L""}, + {399, L""}, + {400, L""}, + {401, L""}, + {402, L""}, + {403, L""}, + {404, L""}, + {405, L""}, + {406, L""}, + {407, L""}, + {408, L""}, + {409, L""}, + {410, L""}, + {411, L"ɵ"}, + {412, L""}, + {413, L""}, + {414, L""}, + {415, L""}, + {416, L"ɮ"}, + {417, L""}, + {418, L""}, + {419, L""}, + {420, L""}, + {421, L""}, + {422, L"Ƨ"}, + {423, L""}, + {424, L""}, + {425, L""}, + {426, L""}, + {427, L""}, + {428, L""}, + {429, L"أ"}, + {430, L""}, + {431, L"Ԫ"}, + {432, L""}, + {433, L""}, + {434, L""}, + {435, L""}, + {436, L""}, + {437, L""}, + {438, L""}, + {439, L""}, + {440, L""}, + {441, L""}, + {442, L""}, + {443, L""}, + {444, L""}, + {445, L""}, + {446, L""}, + {447, L"ȫ"}, + {448, L""}, + {449, L""}, + {450, L""}, + {451, L""}, + {452, L""}, + {453, L""}, + {454, L""}, + {455, L""}, + {456, L""}, + {457, L""}, + {458, L""}, + {459, L""}, + {460, L""}, + {461, L""}, + {462, L""}, + {463, L""}, + {464, L""}, + {465, L""}, + {466, L""}, + {467, L""}, + {468, L"Ƚ"}, + {469, L""}, + {470, L""}, + {471, L"ð"}, + {472, L""}, + {473, L""}, + {474, L"д"}, + {475, L""}, + {476, L"ũ"}, + {477, L""}, + {478, L"ڣ"}, + {479, L"ԩ"}, + {480, L"ڤ"}, + {481, L""}, + {482, L""}, + {483, L""}, + {484, L""}, + {485, L""}, + {486, L""}, + {487, L""}, + {488, L"ұ"}, + {489, L""}, + {490, L""}, + {491, L""}, + {492, L""}, + {493, L""}, + {494, L""}, + {495, L"׼"}, + {496, L"ڡ"}, + {497, L""}, + {498, L""}, + {499, L""}, + {500, L""}, + {501, L""}, + {502, L""}, + {503, L""}, + {504, L""}, + {505, L""}, + {506, L""}, + {507, L""}, + {508, L"ƾ"}, + {509, L""}, + {510, L""}, + {511, L""}, + {512, L""}, + {513, L"͹"}, + {514, L""}, + {515, L""}, + {516, L""}, + {517, L""}, + {518, L""}, + {519, L""}, + {520, L""}, + {521, L""}, + {522, L""}, + {523, L""}, + {524, L""}, + {525, L""}, + {526, L""}, + {527, L"ۻ"}, + {528, L""}, + {529, L""}, + {530, L""}, + {531, L""}, + {532, L""}, + {533, L""}, + {534, L""}, + {535, L""}, + {536, L""}, + {537, L""}, + {538, L"ɾ"}, + {539, L""}, + {540, L""}, + {541, L""}, + {542, L""}, + {543, L""}, + {544, L""}, + {545, L""}, + {546, L""}, + {547, L""}, + {548, L"ˢ"}, + {549, L"ȯ"}, + {550, L"ɲ"}, + {551, L""}, + {552, L""}, + {553, L""}, + {554, L""}, + {555, L""}, + {556, L""}, + {557, L""}, + {558, L""}, + {559, L""}, + {560, L""}, + {561, L"ǰ"}, + {562, L""}, + {563, L""}, + {564, L""}, + {565, L""}, + {566, L""}, + {567, L""}, + {568, L""}, + {569, L""}, + {570, L""}, + {571, L"ʣ"}, + {572, L""}, + {573, L""}, + {574, L""}, + {575, L""}, + {576, L""}, + {577, L""}, + {578, L""}, + {579, L""}, + {580, L""}, + {581, L""}, + {582, L""}, + {583, L"Ȱ"}, + {584, L""}, + {585, L""}, + {586, L""}, + {587, L""}, + {588, L"۽"}, + {589, L""}, + {590, L""}, + {591, L""}, + {592, L"Ŭ"}, + {593, L""}, + {594, L"۾"}, + {595, L"ۿ"}, + {596, L""}, + {597, L""}, + {598, L""}, + {599, L""}, + {600, L""}, + {601, L""}, + {602, L""}, + {603, L""}, + {604, L"ѫ"}, + {605, L""}, + {606, L""}, + {607, L""}, + {608, L""}, + {609, L"ļ"}, + {610, L""}, + {611, L""}, + {612, L""}, + {613, L""}, + {614, L""}, + {615, L""}, + {616, L""}, + {617, L""}, + {618, L""}, + {619, L""}, + {620, L""}, + {621, L""}, + {622, L"ذ"}, + {623, L""}, + {624, L""}, + {625, L""}, + {626, L""}, + {627, L""}, + {628, L""}, + {629, L"ϻ"}, + {630, L""}, + {631, L""}, + {632, L""}, + {633, L"ƥ"}, + {634, L""}, + {635, L"ҽ"}, + {636, L""}, + {637, L""}, + {638, L"ʮ"}, + {639, L"ǧ"}, + {640, L"ئ"}, + {641, L""}, + {642, L""}, + {643, L""}, + {644, L""}, + {645, L""}, + {646, L"Э"}, + {647, L""}, + {648, L""}, + {649, L"׿"}, + {650, L""}, + {651, L""}, + {652, L""}, + {653, L""}, + {654, L""}, + {655, L""}, + {656, L"߲"}, + {657, L"ռ"}, + {658, L""}, + {659, L"¬"}, + {660, L""}, + {661, L"±"}, + {662, L""}, + {663, L""}, + {664, L""}, + {665, L"ش"}, + {666, L"î"}, + {667, L"ӡ"}, + {668, L"Σ"}, + {669, L""}, + {670, L"ȴ"}, + {671, L""}, + {672, L""}, + {673, L"ж"}, + {674, L""}, + {675, L""}, + {676, L""}, + {677, L""}, + {678, L""}, + {679, L""}, + {680, L""}, + {681, L"ѹ"}, + {682, L""}, + {683, L""}, + {684, L""}, + {685, L""}, + {686, L""}, + {687, L""}, + {688, L"ԭ"}, + {689, L""}, + {690, L""}, + {691, L""}, + {692, L""}, + {693, L""}, + {694, L""}, + {695, L""}, + {696, L"ȥ"}, + {697, L""}, + {698, L""}, + {699, L""}, + {700, L""}, + {701, L""}, + {702, L""}, + {703, L""}, + {704, L"˫"}, + {705, L""}, + {706, L""}, + {707, L""}, + {708, L"ȡ"}, + {709, L""}, + {710, L""}, + {711, L""}, + {712, L""}, + {713, L""}, + {714, L""}, + {715, L""}, + {716, L""}, + {717, L""}, + {718, L""}, + {719, L"߶"}, + {720, L"ߵ"}, + {721, L"ֻ"}, + {722, L""}, + {723, L""}, + {724, L""}, + {725, L""}, + {726, L""}, + {727, L"̨"}, + {728, L"߳"}, + {729, L"ʷ"}, + {730, L""}, + {731, L""}, + {732, L"Ҷ"}, + {733, L""}, + {734, L"˾"}, + {735, L"̾"}, + {736, L"߷"}, + {737, L""}, + {738, L"ߴ"}, + {739, L""}, + {740, L""}, + {741, L""}, + {742, L"ߺ"}, + {743, L""}, + {744, L""}, + {745, L""}, + {746, L"ͬ"}, + {747, L""}, + {748, L""}, + {749, L""}, + {750, L""}, + {751, L""}, + {752, L"߸"}, + {753, L""}, + {754, L""}, + {755, L""}, + {756, L""}, + {757, L""}, + {758, L""}, + {759, L""}, + {760, L""}, + {761, L""}, + {762, L""}, + {763, L""}, + {764, L""}, + {765, L""}, + {766, L""}, + {767, L""}, + {768, L""}, + {769, L""}, + {770, L"˱"}, + {771, L""}, + {772, L"֨"}, + {773, L""}, + {774, L""}, + {775, L""}, + {776, L""}, + {777, L""}, + {778, L""}, + {779, L""}, + {780, L""}, + {781, L"ѽ"}, + {782, L""}, + {783, L""}, + {784, L""}, + {785, L""}, + {786, L"߻"}, + {787, L""}, + {788, L"߽"}, + {789, L"߾"}, + {790, L"Ż"}, + {791, L"߿"}, + {792, L""}, + {793, L"Ա"}, + {794, L""}, + {795, L"Ǻ"}, + {796, L""}, + {797, L""}, + {798, L""}, + {799, L""}, + {800, L""}, + {801, L""}, + {802, L""}, + {803, L"ζ"}, + {804, L""}, + {805, L""}, + {806, L""}, + {807, L""}, + {808, L""}, + {809, L""}, + {810, L""}, + {811, L""}, + {812, L""}, + {813, L""}, + {814, L""}, + {815, L"զ"}, + {816, L""}, + {817, L""}, + {818, L"ӽ"}, + {819, L""}, + {820, L""}, + {821, L""}, + {822, L""}, + {823, L""}, + {824, L""}, + {825, L""}, + {826, L""}, + {827, L""}, + {828, L""}, + {829, L""}, + {830, L""}, + {831, L""}, + {832, L""}, + {833, L""}, + {834, L""}, + {835, L""}, + {836, L"ҧ"}, + {837, L""}, + {838, L""}, + {839, L""}, + {840, L""}, + {841, L""}, + {842, L""}, + {843, L""}, + {844, L""}, + {845, L""}, + {846, L""}, + {847, L"Ʒ"}, + {848, L""}, + {849, L""}, + {850, L""}, + {851, L""}, + {852, L""}, + {853, L""}, + {854, L""}, + {855, L""}, + {856, L""}, + {857, L""}, + {858, L""}, + {859, L""}, + {860, L""}, + {861, L""}, + {862, L""}, + {863, L""}, + {864, L""}, + {865, L""}, + {866, L""}, + {867, L""}, + {868, L"Ӵ"}, + {869, L""}, + {870, L"Ŷ"}, + {871, L""}, + {872, L""}, + {873, L""}, + {874, L""}, + {875, L""}, + {876, L""}, + {877, L""}, + {878, L""}, + {879, L""}, + {880, L""}, + {881, L""}, + {882, L""}, + {883, L""}, + {884, L""}, + {885, L""}, + {886, L""}, + {887, L""}, + {888, L""}, + {889, L""}, + {890, L""}, + {891, L""}, + {892, L""}, + {893, L""}, + {894, L""}, + {895, L""}, + {896, L""}, + {897, L""}, + {898, L""}, + {899, L""}, + {900, L"Ψ"}, + {901, L""}, + {902, L""}, + {903, L""}, + {904, L""}, + {905, L""}, + {906, L""}, + {907, L""}, + {908, L""}, + {909, L""}, + {910, L""}, + {911, L""}, + {912, L""}, + {913, L""}, + {914, L""}, + {915, L""}, + {916, L""}, + {917, L""}, + {918, L"ơ"}, + {919, L"ɶ"}, + {920, L""}, + {921, L""}, + {922, L"ž"}, + {923, L""}, + {924, L""}, + {925, L""}, + {926, L""}, + {927, L""}, + {928, L""}, + {929, L"Х"}, + {930, L""}, + {931, L""}, + {932, L""}, + {933, L""}, + {934, L""}, + {935, L"ι"}, + {936, L""}, + {937, L""}, + {938, L""}, + {939, L""}, + {940, L""}, + {941, L""}, + {942, L""}, + {943, L""}, + {944, L""}, + {945, L""}, + {946, L""}, + {947, L""}, + {948, L"ϲ"}, + {949, L""}, + {950, L""}, + {951, L""}, + {952, L""}, + {953, L""}, + {954, L""}, + {955, L""}, + {956, L""}, + {957, L""}, + {958, L""}, + {959, L""}, + {960, L""}, + {961, L""}, + {962, L""}, + {963, L""}, + {964, L""}, + {965, L""}, + {966, L""}, + {967, L"ɤ"}, + {968, L""}, + {969, L""}, + {970, L""}, + {971, L""}, + {972, L""}, + {973, L""}, + {974, L""}, + {975, L""}, + {976, L""}, + {977, L""}, + {978, L""}, + {979, L""}, + {980, L""}, + {981, L""}, + {982, L""}, + {983, L""}, + {984, L""}, + {985, L""}, + {986, L""}, + {987, L""}, + {988, L""}, + {989, L""}, + {990, L""}, + {991, L""}, + {992, L""}, + {993, L""}, + {994, L""}, + {995, L""}, + {996, L""}, + {997, L""}, + {998, L""}, + {999, L""}, + {1000, L""}, + {1001, L""}, + {1002, L""}, + {1003, L""}, + {1004, L""}, + {1005, L""}, + {1006, L""}, + {1007, L""}, + {1008, L"˻"}, + {1009, L""}, + {1010, L""}, + {1011, L""}, + {1012, L""}, + {1013, L""}, + {1014, L"ҭ"}, + {1015, L""}, + {1016, L""}, + {1017, L""}, + {1018, L""}, + {1019, L""}, + {1020, L""}, + {1021, L""}, + {1022, L"ج"}, + {1023, L""}, + {1024, L""}, + {1025, L""}, + {1026, L""}, + {1027, L""}, + {1028, L""}, + {1029, L""}, + {1030, L""}, + {1031, L""}, + {1032, L""}, + {1033, L""}, + {1034, L""}, + {1035, L""}, + {1036, L""}, + {1037, L""}, + {1038, L""}, + {1039, L""}, + {1040, L""}, + {1041, L""}, + {1042, L""}, + {1043, L""}, + {1044, L""}, + {1045, L"ض"}, + {1046, L""}, + {1047, L""}, + {1048, L""}, + {1049, L""}, + {1050, L""}, + {1051, L"԰"}, + {1052, L""}, + {1053, L""}, + {1054, L"Χ"}, + {1055, L""}, + {1056, L""}, + {1057, L""}, + {1058, L""}, + {1059, L"ͼ"}, + {1060, L""}, + {1061, L""}, + {1062, L""}, + {1063, L"Բ"}, + {1064, L"Ȧ"}, + {1065, L""}, + {1066, L""}, + {1067, L""}, + {1068, L""}, + {1069, L"ʥ"}, + {1070, L""}, + {1071, L""}, + {1072, L""}, + {1073, L""}, + {1074, L""}, + {1075, L""}, + {1076, L""}, + {1077, L""}, + {1078, L""}, + {1079, L""}, + {1080, L""}, + {1081, L""}, + {1082, L""}, + {1083, L"ַ"}, + {1084, L""}, + {1085, L""}, + {1086, L""}, + {1087, L""}, + {1088, L"̮"}, + {1089, L""}, + {1090, L""}, + {1091, L""}, + {1092, L""}, + {1093, L""}, + {1094, L""}, + {1095, L"̳"}, + {1096, L""}, + {1097, L""}, + {1098, L""}, + {1099, L""}, + {1100, L"׹"}, + {1101, L""}, + {1102, L""}, + {1103, L"̹"}, + {1104, L""}, + {1105, L""}, + {1106, L"ƺ"}, + {1107, L""}, + {1108, L""}, + {1109, L""}, + {1110, L""}, + {1111, L""}, + {1112, L""}, + {1113, L""}, + {1114, L""}, + {1115, L""}, + {1116, L"¢"}, + {1117, L""}, + {1118, L""}, + {1119, L""}, + {1120, L""}, + {1121, L""}, + {1122, L""}, + {1123, L""}, + {1124, L""}, + {1125, L""}, + {1126, L""}, + {1127, L"ԫ"}, + {1128, L""}, + {1129, L""}, + {1130, L""}, + {1131, L""}, + {1132, L""}, + {1133, L""}, + {1134, L""}, + {1135, L""}, + {1136, L""}, + {1137, L""}, + {1138, L""}, + {1139, L""}, + {1140, L""}, + {1141, L""}, + {1142, L""}, + {1143, L""}, + {1144, L""}, + {1145, L""}, + {1146, L""}, + {1147, L""}, + {1148, L""}, + {1149, L""}, + {1150, L""}, + {1151, L""}, + {1152, L"ܤ"}, + {1153, L""}, + {1154, L""}, + {1155, L""}, + {1156, L""}, + {1157, L""}, + {1158, L"ܣ"}, + {1159, L""}, + {1160, L""}, + {1161, L""}, + {1162, L"ܡ"}, + {1163, L"ܢ"}, + {1164, L"ǵ"}, + {1165, L""}, + {1166, L"ܧ"}, + {1167, L"ܦ"}, + {1168, L"ܩ"}, + {1169, L""}, + {1170, L""}, + {1171, L""}, + {1172, L""}, + {1173, L""}, + {1174, L"ܨ"}, + {1175, L""}, + {1176, L""}, + {1177, L""}, + {1178, L""}, + {1179, L""}, + {1180, L""}, + {1181, L"ܪ"}, + {1182, L""}, + {1183, L"ܫ"}, + {1184, L""}, + {1185, L"ܯ"}, + {1186, L"ܬ"}, + {1187, L""}, + {1188, L""}, + {1189, L"ܭ"}, + {1190, L""}, + {1191, L"Ĺ"}, + {1192, L"ǽ"}, + {1193, L""}, + {1194, L""}, + {1195, L"ī"}, + {1196, L""}, + {1197, L""}, + {1198, L""}, + {1199, L""}, + {1200, L""}, + {1201, L""}, + {1202, L""}, + {1203, L"ʿ"}, + {1204, L""}, + {1205, L"׳"}, + {1206, L""}, + {1207, L""}, + {1208, L""}, + {1209, L"Ҽ"}, + {1210, L""}, + {1211, L""}, + {1212, L""}, + {1213, L""}, + {1214, L""}, + {1215, L"Ϧ"}, + {1216, L""}, + {1217, L""}, + {1218, L""}, + {1219, L"ҹ"}, + {1220, L""}, + {1221, L""}, + {1222, L""}, + {1223, L""}, + {1224, L""}, + {1225, L"̫"}, + {1226, L""}, + {1227, L"ز"}, + {1228, L""}, + {1229, L""}, + {1230, L"ʧ"}, + {1231, L"ͷ"}, + {1232, L""}, + {1233, L""}, + {1234, L""}, + {1235, L""}, + {1236, L""}, + {1237, L""}, + {1238, L"ۼ"}, + {1239, L""}, + {1240, L""}, + {1241, L""}, + {1242, L""}, + {1243, L""}, + {1244, L""}, + {1245, L""}, + {1246, L""}, + {1247, L""}, + {1248, L""}, + {1249, L""}, + {1250, L""}, + {1251, L""}, + {1252, L""}, + {1253, L""}, + {1254, L""}, + {1255, L""}, + {1256, L"Ů"}, + {1257, L"ū"}, + {1258, L""}, + {1259, L""}, + {1260, L""}, + {1261, L""}, + {1262, L""}, + {1263, L""}, + {1264, L""}, + {1265, L""}, + {1266, L"ױ"}, + {1267, L""}, + {1268, L""}, + {1269, L""}, + {1270, L""}, + {1271, L""}, + {1272, L""}, + {1273, L""}, + {1274, L""}, + {1275, L""}, + {1276, L""}, + {1277, L""}, + {1278, L""}, + {1279, L""}, + {1280, L""}, + {1281, L""}, + {1282, L""}, + {1283, L""}, + {1284, L""}, + {1285, L""}, + {1286, L""}, + {1287, L""}, + {1288, L""}, + {1289, L""}, + {1290, L"ķ"}, + {1291, L""}, + {1292, L"ʼ"}, + {1293, L""}, + {1294, L""}, + {1295, L""}, + {1296, L""}, + {1297, L"ί"}, + {1298, L""}, + {1299, L""}, + {1300, L"Ҧ"}, + {1301, L""}, + {1302, L""}, + {1303, L""}, + {1304, L""}, + {1305, L""}, + {1306, L""}, + {1307, L""}, + {1308, L""}, + {1309, L""}, + {1310, L""}, + {1311, L""}, + {1312, L"¦"}, + {1313, L""}, + {1314, L""}, + {1315, L""}, + {1316, L""}, + {1317, L""}, + {1318, L""}, + {1319, L""}, + {1320, L""}, + {1321, L""}, + {1322, L""}, + {1323, L""}, + {1324, L""}, + {1325, L""}, + {1326, L""}, + {1327, L""}, + {1328, L""}, + {1329, L""}, + {1330, L""}, + {1331, L"Ȣ"}, + {1332, L""}, + {1333, L""}, + {1334, L""}, + {1335, L""}, + {1336, L""}, + {1337, L""}, + {1338, L""}, + {1339, L""}, + {1340, L""}, + {1341, L""}, + {1342, L"Ӥ"}, + {1343, L""}, + {1344, L""}, + {1345, L""}, + {1346, L""}, + {1347, L""}, + {1348, L"ý"}, + {1349, L""}, + {1350, L""}, + {1351, L""}, + {1352, L""}, + {1353, L"ϱ"}, + {1354, L""}, + {1355, L""}, + {1356, L""}, + {1357, L""}, + {1358, L"ɩ"}, + {1359, L""}, + {1360, L""}, + {1361, L""}, + {1362, L""}, + {1363, L""}, + {1364, L""}, + {1365, L""}, + {1366, L""}, + {1367, L""}, + {1368, L""}, + {1369, L""}, + {1370, L""}, + {1371, L""}, + {1372, L""}, + {1373, L""}, + {1374, L""}, + {1375, L""}, + {1376, L""}, + {1377, L""}, + {1378, L""}, + {1379, L""}, + {1380, L""}, + {1381, L""}, + {1382, L""}, + {1383, L""}, + {1384, L""}, + {1385, L""}, + {1386, L""}, + {1387, L""}, + {1388, L""}, + {1389, L""}, + {1390, L"Т"}, + {1391, L""}, + {1392, L""}, + {1393, L""}, + {1394, L""}, + {1395, L""}, + {1396, L"ѧ"}, + {1397, L""}, + {1398, L""}, + {1399, L"ث"}, + {1400, L""}, + {1401, L""}, + {1402, L""}, + {1403, L""}, + {1404, L""}, + {1405, L""}, + {1406, L""}, + {1407, L""}, + {1408, L""}, + {1409, L"լ"}, + {1410, L""}, + {1411, L""}, + {1412, L""}, + {1413, L""}, + {1414, L""}, + {1415, L""}, + {1416, L""}, + {1417, L""}, + {1418, L""}, + {1419, L""}, + {1420, L""}, + {1421, L""}, + {1422, L""}, + {1423, L""}, + {1424, L""}, + {1425, L"ʵ"}, + {1426, L""}, + {1427, L""}, + {1428, L""}, + {1429, L""}, + {1430, L""}, + {1431, L""}, + {1432, L""}, + {1433, L""}, + {1434, L""}, + {1435, L""}, + {1436, L""}, + {1437, L""}, + {1438, L""}, + {1439, L""}, + {1440, L""}, + {1441, L""}, + {1442, L""}, + {1443, L""}, + {1444, L""}, + {1445, L""}, + {1446, L""}, + {1447, L""}, + {1448, L""}, + {1449, L""}, + {1450, L""}, + {1451, L""}, + {1452, L""}, + {1453, L"Ԣ"}, + {1454, L""}, + {1455, L"į"}, + {1456, L""}, + {1457, L""}, + {1458, L""}, + {1459, L""}, + {1460, L"կ"}, + {1461, L""}, + {1462, L""}, + {1463, L""}, + {1464, L""}, + {1465, L""}, + {1466, L"Ѱ"}, + {1467, L""}, + {1468, L""}, + {1469, L""}, + {1470, L""}, + {1471, L""}, + {1472, L"ξ"}, + {1473, L""}, + {1474, L"С"}, + {1475, L""}, + {1476, L""}, + {1477, L""}, + {1478, L""}, + {1479, L""}, + {1480, L""}, + {1481, L""}, + {1482, L""}, + {1483, L""}, + {1484, L""}, + {1485, L"Ң"}, + {1486, L""}, + {1487, L""}, + {1488, L""}, + {1489, L"ʬ"}, + {1490, L""}, + {1491, L""}, + {1492, L""}, + {1493, L""}, + {1494, L""}, + {1495, L"β"}, + {1496, L""}, + {1497, L""}, + {1498, L"ƨ"}, + {1499, L""}, + {1500, L""}, + {1501, L""}, + {1502, L""}, + {1503, L""}, + {1504, L""}, + {1505, L"ʺ"}, + {1506, L""}, + {1507, L""}, + {1508, L"м"}, + {1509, L"չ"}, + {1510, L""}, + {1511, L""}, + {1512, L""}, + {1513, L""}, + {1514, L""}, + {1515, L""}, + {1516, L""}, + {1517, L""}, + {1518, L"ɽ"}, + {1519, L""}, + {1520, L""}, + {1521, L""}, + {1522, L""}, + {1523, L""}, + {1524, L""}, + {1525, L""}, + {1526, L""}, + {1527, L""}, + {1528, L""}, + {1529, L""}, + {1530, L""}, + {1531, L""}, + {1532, L""}, + {1533, L""}, + {1534, L""}, + {1535, L""}, + {1536, L""}, + {1537, L""}, + {1538, L""}, + {1539, L""}, + {1540, L""}, + {1541, L""}, + {1542, L""}, + {1543, L""}, + {1544, L""}, + {1545, L""}, + {1546, L""}, + {1547, L""}, + {1548, L""}, + {1549, L""}, + {1550, L""}, + {1551, L""}, + {1552, L""}, + {1553, L"Ͽ"}, + {1554, L""}, + {1555, L""}, + {1556, L""}, + {1557, L""}, + {1558, L""}, + {1559, L""}, + {1560, L""}, + {1561, L""}, + {1562, L""}, + {1563, L""}, + {1564, L""}, + {1565, L""}, + {1566, L""}, + {1567, L""}, + {1568, L""}, + {1569, L""}, + {1570, L""}, + {1571, L""}, + {1572, L""}, + {1573, L""}, + {1574, L""}, + {1575, L"ո"}, + {1576, L""}, + {1577, L""}, + {1578, L""}, + {1579, L""}, + {1580, L""}, + {1581, L""}, + {1582, L"Ƕ"}, + {1583, L""}, + {1584, L""}, + {1585, L""}, + {1586, L""}, + {1587, L""}, + {1588, L""}, + {1589, L""}, + {1590, L""}, + {1591, L""}, + {1592, L""}, + {1593, L""}, + {1594, L""}, + {1595, L""}, + {1596, L"Ρ"}, + {1597, L""}, + {1598, L""}, + {1599, L"Ѳ"}, + {1600, L""}, + {1601, L""}, + {1602, L""}, + {1603, L""}, + {1604, L""}, + {1605, L""}, + {1606, L""}, + {1607, L""}, + {1608, L""}, + {1609, L""}, + {1610, L""}, + {1611, L""}, + {1612, L""}, + {1613, L""}, + {1614, L""}, + {1615, L""}, + {1616, L""}, + {1617, L""}, + {1618, L""}, + {1619, L"˧"}, + {1620, L""}, + {1621, L"ʦ"}, + {1622, L"ϣ"}, + {1623, L""}, + {1624, L""}, + {1625, L""}, + {1626, L""}, + {1627, L""}, + {1628, L""}, + {1629, L""}, + {1630, L""}, + {1631, L""}, + {1632, L""}, + {1633, L""}, + {1634, L""}, + {1635, L""}, + {1636, L"֡"}, + {1637, L"ϯ"}, + {1638, L""}, + {1639, L""}, + {1640, L""}, + {1641, L""}, + {1642, L""}, + {1643, L""}, + {1644, L"ñ"}, + {1645, L""}, + {1646, L""}, + {1647, L""}, + {1648, L""}, + {1649, L""}, + {1650, L"Ļ"}, + {1651, L""}, + {1652, L""}, + {1653, L""}, + {1654, L""}, + {1655, L""}, + {1656, L"ƽ"}, + {1657, L""}, + {1658, L""}, + {1659, L""}, + {1660, L""}, + {1661, L""}, + {1662, L""}, + {1663, L""}, + {1664, L""}, + {1665, L""}, + {1666, L"ׯ"}, + {1667, L""}, + {1668, L""}, + {1669, L""}, + {1670, L""}, + {1671, L""}, + {1672, L"®"}, + {1673, L""}, + {1674, L""}, + {1675, L"Ӧ"}, + {1676, L""}, + {1677, L""}, + {1678, L""}, + {1679, L""}, + {1680, L""}, + {1681, L""}, + {1682, L""}, + {1683, L""}, + {1684, L""}, + {1685, L""}, + {1686, L""}, + {1687, L""}, + {1688, L"ͥ"}, + {1689, L""}, + {1690, L""}, + {1691, L""}, + {1692, L""}, + {1693, L"ӹ"}, + {1694, L""}, + {1695, L""}, + {1696, L""}, + {1697, L""}, + {1698, L""}, + {1699, L""}, + {1700, L""}, + {1701, L""}, + {1702, L""}, + {1703, L""}, + {1704, L""}, + {1705, L"͢"}, + {1706, L""}, + {1707, L"إ"}, + {1708, L""}, + {1709, L""}, + {1710, L""}, + {1711, L""}, + {1712, L"Ū"}, + {1713, L""}, + {1714, L""}, + {1715, L"߮"}, + {1716, L"ʽ"}, + {1717, L"߱"}, + {1718, L""}, + {1719, L""}, + {1720, L""}, + {1721, L""}, + {1722, L""}, + {1723, L""}, + {1724, L""}, + {1725, L""}, + {1726, L""}, + {1727, L""}, + {1728, L""}, + {1729, L""}, + {1730, L""}, + {1731, L""}, + {1732, L""}, + {1733, L"ǿ"}, + {1734, L""}, + {1735, L""}, + {1736, L""}, + {1737, L""}, + {1738, L"¼"}, + {1739, L""}, + {1740, L""}, + {1741, L""}, + {1742, L""}, + {1743, L""}, + {1744, L"ͮ"}, + {1745, L""}, + {1746, L""}, + {1747, L""}, + {1748, L""}, + {1749, L""}, + {1750, L""}, + {1751, L"Ӱ"}, + {1752, L""}, + {1753, L""}, + {1754, L""}, + {1755, L""}, + {1756, L""}, + {1757, L""}, + {1758, L""}, + {1759, L""}, + {1760, L""}, + {1761, L""}, + {1762, L""}, + {1763, L""}, + {1764, L""}, + {1765, L""}, + {1766, L""}, + {1767, L""}, + {1768, L""}, + {1769, L"ͽ"}, + {1770, L""}, + {1771, L""}, + {1772, L""}, + {1773, L""}, + {1774, L""}, + {1775, L""}, + {1776, L""}, + {1777, L"ѭ"}, + {1778, L""}, + {1779, L"΢"}, + {1780, L""}, + {1781, L""}, + {1782, L""}, + {1783, L""}, + {1784, L""}, + {1785, L""}, + {1786, L""}, + {1787, L""}, + {1788, L""}, + {1789, L""}, + {1790, L""}, + {1791, L""}, + {1792, L""}, + {1793, L"߯"}, + {1794, L""}, + {1795, L"־"}, + {1796, L""}, + {1797, L"æ"}, + {1798, L""}, + {1799, L""}, + {1800, L""}, + {1801, L""}, + {1802, L""}, + {1803, L""}, + {1804, L""}, + {1805, L""}, + {1806, L""}, + {1807, L""}, + {1808, L""}, + {1809, L""}, + {1810, L""}, + {1811, L""}, + {1812, L""}, + {1813, L""}, + {1814, L""}, + {1815, L"̬"}, + {1816, L""}, + {1817, L""}, + {1818, L""}, + {1819, L""}, + {1820, L""}, + {1821, L""}, + {1822, L""}, + {1823, L""}, + {1824, L""}, + {1825, L"ŭ"}, + {1826, L""}, + {1827, L""}, + {1828, L""}, + {1829, L""}, + {1830, L""}, + {1831, L""}, + {1832, L"˼"}, + {1833, L""}, + {1834, L""}, + {1835, L""}, + {1836, L""}, + {1837, L""}, + {1838, L"Թ"}, + {1839, L""}, + {1840, L""}, + {1841, L""}, + {1842, L""}, + {1843, L""}, + {1844, L""}, + {1845, L""}, + {1846, L""}, + {1847, L""}, + {1848, L""}, + {1849, L""}, + {1850, L""}, + {1851, L""}, + {1852, L""}, + {1853, L""}, + {1854, L"ˡ"}, + {1855, L""}, + {1856, L""}, + {1857, L""}, + {1858, L""}, + {1859, L""}, + {1860, L""}, + {1861, L""}, + {1862, L""}, + {1863, L""}, + {1864, L""}, + {1865, L""}, + {1866, L""}, + {1867, L""}, + {1868, L"Ϣ"}, + {1869, L"ǡ"}, + {1870, L""}, + {1871, L""}, + {1872, L""}, + {1873, L""}, + {1874, L""}, + {1875, L""}, + {1876, L""}, + {1877, L""}, + {1878, L""}, + {1879, L""}, + {1880, L""}, + {1881, L"Ϥ"}, + {1882, L""}, + {1883, L""}, + {1884, L""}, + {1885, L""}, + {1886, L""}, + {1887, L""}, + {1888, L""}, + {1889, L""}, + {1890, L""}, + {1891, L""}, + {1892, L""}, + {1893, L""}, + {1894, L""}, + {1895, L""}, + {1896, L""}, + {1897, L""}, + {1898, L""}, + {1899, L""}, + {1900, L""}, + {1901, L""}, + {1902, L""}, + {1903, L""}, + {1904, L""}, + {1905, L""}, + {1906, L""}, + {1907, L""}, + {1908, L""}, + {1909, L""}, + {1910, L""}, + {1911, L""}, + {1912, L""}, + {1913, L"ϧ"}, + {1914, L""}, + {1915, L"Ω"}, + {1916, L""}, + {1917, L""}, + {1918, L""}, + {1919, L""}, + {1920, L""}, + {1921, L""}, + {1922, L""}, + {1923, L""}, + {1924, L""}, + {1925, L""}, + {1926, L""}, + {1927, L""}, + {1928, L""}, + {1929, L""}, + {1930, L""}, + {1931, L""}, + {1932, L""}, + {1933, L""}, + {1934, L""}, + {1935, L""}, + {1936, L""}, + {1937, L""}, + {1938, L""}, + {1939, L""}, + {1940, L""}, + {1941, L""}, + {1942, L""}, + {1943, L""}, + {1944, L""}, + {1945, L""}, + {1946, L""}, + {1947, L""}, + {1948, L""}, + {1949, L"Ը"}, + {1950, L""}, + {1951, L""}, + {1952, L""}, + {1953, L""}, + {1954, L""}, + {1955, L"Ľ"}, + {1956, L""}, + {1957, L""}, + {1958, L""}, + {1959, L""}, + {1960, L"ο"}, + {1961, L""}, + {1962, L""}, + {1963, L""}, + {1964, L""}, + {1965, L""}, + {1966, L""}, + {1967, L""}, + {1968, L""}, + {1969, L""}, + {1970, L""}, + {1971, L""}, + {1972, L""}, + {1973, L""}, + {1974, L"и"}, + {1975, L""}, + {1976, L""}, + {1977, L""}, + {1978, L""}, + {1979, L"ų"}, + {1980, L""}, + {1981, L"ܲ"}, + {1982, L""}, + {1983, L""}, + {1984, L""}, + {1985, L""}, + {1986, L""}, + {1987, L""}, + {1988, L""}, + {1989, L"Ϸ"}, + {1990, L""}, + {1991, L""}, + {1992, L""}, + {1993, L""}, + {1994, L""}, + {1995, L""}, + {1996, L"ս"}, + {1997, L""}, + {1998, L""}, + {1999, L""}, + {2000, L""}, + {2001, L""}, + {2002, L""}, + {2003, L""}, + {2004, L""}, + {2005, L"¾"}, + {2006, L""}, + {2007, L""}, + {2008, L""}, + {2009, L""}, + {2010, L""}, + {2011, L""}, + {2012, L""}, + {2013, L""}, + {2014, L""}, + {2015, L""}, + {2016, L""}, + {2017, L""}, + {2018, L""}, + {2019, L""}, + {2020, L""}, + {2021, L""}, + {2022, L""}, + {2023, L""}, + {2024, L""}, + {2025, L""}, + {2026, L""}, + {2027, L""}, + {2028, L""}, + {2029, L"Ǥ"}, + {2030, L"ִ"}, + {2031, L""}, + {2032, L""}, + {2033, L"ɨ"}, + {2034, L""}, + {2035, L"Ť"}, + {2036, L""}, + {2037, L""}, + {2038, L""}, + {2039, L""}, + {2040, L""}, + {2041, L""}, + {2042, L""}, + {2043, L""}, + {2044, L""}, + {2045, L""}, + {2046, L""}, + {2047, L""}, + {2048, L""}, + {2049, L""}, + {2050, L""}, + {2051, L"ץ"}, + {2052, L"Ͷ"}, + {2053, L""}, + {2054, L""}, + {2055, L""}, + {2056, L""}, + {2057, L""}, + {2058, L""}, + {2059, L""}, + {2060, L""}, + {2061, L""}, + {2062, L""}, + {2063, L""}, + {2064, L""}, + {2065, L""}, + {2066, L"̧"}, + {2067, L""}, + {2068, L""}, + {2069, L"Ĩ"}, + {2070, L""}, + {2071, L"Ѻ"}, + {2072, L""}, + {2073, L""}, + {2074, L""}, + {2075, L""}, + {2076, L""}, + {2077, L""}, + {2078, L"Ĵ"}, + {2079, L""}, + {2080, L""}, + {2081, L""}, + {2082, L""}, + {2083, L""}, + {2084, L""}, + {2085, L""}, + {2086, L""}, + {2087, L""}, + {2088, L""}, + {2089, L""}, + {2090, L""}, + {2091, L""}, + {2092, L"׾"}, + {2093, L""}, + {2094, L""}, + {2095, L""}, + {2096, L""}, + {2097, L"£"}, + {2098, L""}, + {2099, L"ӵ"}, + {2100, L""}, + {2101, L"š"}, + {2102, L""}, + {2103, L""}, + {2104, L""}, + {2105, L""}, + {2106, L""}, + {2107, L""}, + {2108, L""}, + {2109, L"ȭ"}, + {2110, L"˩"}, + {2111, L""}, + {2112, L""}, + {2113, L"ƴ"}, + {2114, L"ק"}, + {2115, L"ʰ"}, + {2116, L""}, + {2117, L""}, + {2118, L""}, + {2119, L"ָ"}, + {2120, L""}, + {2121, L""}, + {2122, L""}, + {2123, L""}, + {2124, L""}, + {2125, L"ֿ"}, + {2126, L""}, + {2127, L""}, + {2128, L"̢"}, + {2129, L"Ю"}, + {2130, L""}, + {2131, L""}, + {2132, L""}, + {2133, L""}, + {2134, L""}, + {2135, L""}, + {2136, L""}, + {2137, L"Ų"}, + {2138, L""}, + {2139, L""}, + {2140, L""}, + {2141, L""}, + {2142, L"ͦ"}, + {2143, L""}, + {2144, L""}, + {2145, L""}, + {2146, L"ͱ"}, + {2147, L""}, + {2148, L"׽"}, + {2149, L""}, + {2150, L""}, + {2151, L""}, + {2152, L""}, + {2153, L""}, + {2154, L""}, + {2155, L""}, + {2156, L""}, + {2157, L""}, + {2158, L""}, + {2159, L""}, + {2160, L""}, + {2161, L""}, + {2162, L""}, + {2163, L""}, + {2164, L""}, + {2165, L""}, + {2166, L""}, + {2167, L""}, + {2168, L""}, + {2169, L""}, + {2170, L""}, + {2171, L""}, + {2172, L""}, + {2173, L""}, + {2174, L""}, + {2175, L""}, + {2176, L""}, + {2177, L""}, + {2178, L""}, + {2179, L""}, + {2180, L""}, + {2181, L"Ҵ"}, + {2182, L""}, + {2183, L""}, + {2184, L"̽"}, + {2185, L""}, + {2186, L""}, + {2187, L""}, + {2188, L""}, + {2189, L""}, + {2190, L""}, + {2191, L""}, + {2192, L""}, + {2193, L""}, + {2194, L""}, + {2195, L"°"}, + {2196, L""}, + {2197, L""}, + {2198, L""}, + {2199, L""}, + {2200, L""}, + {2201, L""}, + {2202, L""}, + {2203, L""}, + {2204, L""}, + {2205, L""}, + {2206, L""}, + {2207, L""}, + {2208, L""}, + {2209, L""}, + {2210, L"Ҿ"}, + {2211, L""}, + {2212, L""}, + {2213, L""}, + {2214, L""}, + {2215, L""}, + {2216, L""}, + {2217, L""}, + {2218, L"Ԯ"}, + {2219, L""}, + {2220, L""}, + {2221, L""}, + {2222, L""}, + {2223, L""}, + {2224, L""}, + {2225, L"§"}, + {2226, L""}, + {2227, L""}, + {2228, L""}, + {2229, L""}, + {2230, L""}, + {2231, L""}, + {2232, L"ɦ"}, + {2233, L""}, + {2234, L""}, + {2235, L""}, + {2236, L""}, + {2237, L""}, + {2238, L""}, + {2239, L""}, + {2240, L""}, + {2241, L""}, + {2242, L""}, + {2243, L"Я"}, + {2244, L""}, + {2245, L""}, + {2246, L""}, + {2247, L""}, + {2248, L""}, + {2249, L"ҡ"}, + {2250, L""}, + {2251, L"̯"}, + {2252, L""}, + {2253, L"ˤ"}, + {2254, L"ժ"}, + {2255, L""}, + {2256, L""}, + {2257, L"Ħ"}, + {2258, L""}, + {2259, L""}, + {2260, L"ġ"}, + {2261, L"ߡ"}, + {2262, L""}, + {2263, L""}, + {2264, L""}, + {2265, L"Ʋ"}, + {2266, L""}, + {2267, L""}, + {2268, L"˺"}, + {2269, L""}, + {2270, L"ߤ"}, + {2271, L"ײ"}, + {2272, L""}, + {2273, L""}, + {2274, L""}, + {2275, L""}, + {2276, L""}, + {2277, L"׫"}, + {2278, L""}, + {2279, L"ߢ"}, + {2280, L"ߣ"}, + {2281, L"ߥ"}, + {2282, L""}, + {2283, L"ߦ"}, + {2284, L""}, + {2285, L""}, + {2286, L""}, + {2287, L""}, + {2288, L"ߧ"}, + {2289, L""}, + {2290, L""}, + {2291, L""}, + {2292, L"ߪ"}, + {2293, L"ߩ"}, + {2294, L""}, + {2295, L""}, + {2296, L"߫"}, + {2297, L""}, + {2298, L""}, + {2299, L"߬"}, + {2300, L""}, + {2301, L"߭"}, + {2302, L"֧"}, + {2303, L""}, + {2304, L""}, + {2305, L""}, + {2306, L""}, + {2307, L""}, + {2308, L""}, + {2309, L""}, + {2310, L"Ч"}, + {2311, L""}, + {2312, L""}, + {2313, L""}, + {2314, L""}, + {2315, L""}, + {2316, L""}, + {2317, L""}, + {2318, L""}, + {2319, L""}, + {2320, L""}, + {2321, L""}, + {2322, L"ɢ"}, + {2323, L""}, + {2324, L""}, + {2325, L""}, + {2326, L""}, + {2327, L""}, + {2328, L""}, + {2329, L""}, + {2330, L""}, + {2331, L"ի"}, + {2332, L""}, + {2333, L""}, + {2334, L""}, + {2335, L""}, + {2336, L""}, + {2337, L""}, + {2338, L""}, + {2339, L"б"}, + {2340, L""}, + {2341, L""}, + {2342, L""}, + {2343, L""}, + {2344, L""}, + {2345, L"ն"}, + {2346, L""}, + {2347, L""}, + {2348, L"˹"}, + {2349, L""}, + {2350, L""}, + {2351, L""}, + {2352, L"ʩ"}, + {2353, L""}, + {2354, L""}, + {2355, L""}, + {2356, L""}, + {2357, L""}, + {2358, L""}, + {2359, L""}, + {2360, L""}, + {2361, L""}, + {2362, L""}, + {2363, L""}, + {2364, L""}, + {2365, L""}, + {2366, L""}, + {2367, L""}, + {2368, L""}, + {2369, L""}, + {2370, L"ּ"}, + {2371, L""}, + {2372, L"Ѯ"}, + {2373, L""}, + {2374, L""}, + {2375, L""}, + {2376, L""}, + {2377, L""}, + {2378, L"ʱ"}, + {2379, L""}, + {2380, L""}, + {2381, L""}, + {2382, L""}, + {2383, L""}, + {2384, L""}, + {2385, L""}, + {2386, L""}, + {2387, L""}, + {2388, L""}, + {2389, L""}, + {2390, L""}, + {2391, L""}, + {2392, L""}, + {2393, L""}, + {2394, L""}, + {2395, L"ӳ"}, + {2396, L""}, + {2397, L""}, + {2398, L""}, + {2399, L""}, + {2400, L""}, + {2401, L""}, + {2402, L""}, + {2403, L""}, + {2404, L""}, + {2405, L""}, + {2406, L""}, + {2407, L""}, + {2408, L""}, + {2409, L""}, + {2410, L""}, + {2411, L""}, + {2412, L"ɹ"}, + {2413, L""}, + {2414, L""}, + {2415, L""}, + {2416, L""}, + {2417, L""}, + {2418, L""}, + {2419, L""}, + {2420, L""}, + {2421, L""}, + {2422, L""}, + {2423, L""}, + {2424, L""}, + {2425, L""}, + {2426, L""}, + {2427, L""}, + {2428, L""}, + {2429, L""}, + {2430, L""}, + {2431, L""}, + {2432, L""}, + {2433, L""}, + {2434, L"Ͼ"}, + {2435, L""}, + {2436, L""}, + {2437, L"ů"}, + {2438, L""}, + {2439, L""}, + {2440, L""}, + {2441, L""}, + {2442, L"ĺ"}, + {2443, L""}, + {2444, L""}, + {2445, L""}, + {2446, L""}, + {2447, L""}, + {2448, L""}, + {2449, L""}, + {2450, L""}, + {2451, L""}, + {2452, L"Ի"}, + {2453, L""}, + {2454, L"ҷ"}, + {2455, L""}, + {2456, L""}, + {2457, L""}, + {2458, L""}, + {2459, L""}, + {2460, L""}, + {2461, L""}, + {2462, L""}, + {2463, L""}, + {2464, L""}, + {2465, L""}, + {2466, L""}, + {2467, L""}, + {2468, L"˷"}, + {2469, L""}, + {2470, L""}, + {2471, L""}, + {2472, L""}, + {2473, L""}, + {2474, L""}, + {2475, L"ľ"}, + {2476, L"δ"}, + {2477, L"ĩ"}, + {2478, L""}, + {2479, L""}, + {2480, L""}, + {2481, L""}, + {2482, L""}, + {2483, L""}, + {2484, L""}, + {2485, L""}, + {2486, L"ɱ"}, + {2487, L""}, + {2488, L"Ȩ"}, + {2489, L""}, + {2490, L""}, + {2491, L"ɼ"}, + {2492, L""}, + {2493, L""}, + {2494, L""}, + {2495, L""}, + {2496, L""}, + {2497, L""}, + {2498, L""}, + {2499, L""}, + {2500, L""}, + {2501, L""}, + {2502, L""}, + {2503, L""}, + {2504, L""}, + {2505, L""}, + {2506, L""}, + {2507, L""}, + {2508, L""}, + {2509, L""}, + {2510, L""}, + {2511, L""}, + {2512, L""}, + {2513, L""}, + {2514, L""}, + {2515, L""}, + {2516, L""}, + {2517, L""}, + {2518, L""}, + {2519, L""}, + {2520, L""}, + {2521, L""}, + {2522, L""}, + {2523, L""}, + {2524, L""}, + {2525, L""}, + {2526, L"ö"}, + {2527, L""}, + {2528, L"֦"}, + {2529, L""}, + {2530, L""}, + {2531, L""}, + {2532, L""}, + {2533, L""}, + {2534, L""}, + {2535, L"ǹ"}, + {2536, L""}, + {2537, L""}, + {2538, L""}, + {2539, L""}, + {2540, L""}, + {2541, L""}, + {2542, L""}, + {2543, L""}, + {2544, L""}, + {2545, L""}, + {2546, L""}, + {2547, L""}, + {2548, L""}, + {2549, L"ij"}, + {2550, L""}, + {2551, L""}, + {2552, L"Ⱦ"}, + {2553, L""}, + {2554, L""}, + {2555, L""}, + {2556, L""}, + {2557, L""}, + {2558, L""}, + {2559, L""}, + {2560, L""}, + {2561, L""}, + {2562, L""}, + {2563, L""}, + {2564, L""}, + {2565, L""}, + {2566, L""}, + {2567, L""}, + {2568, L""}, + {2569, L""}, + {2570, L""}, + {2571, L""}, + {2572, L""}, + {2573, L"դ"}, + {2574, L""}, + {2575, L"ջ"}, + {2576, L""}, + {2577, L""}, + {2578, L""}, + {2579, L""}, + {2580, L""}, + {2581, L""}, + {2582, L""}, + {2583, L"˨"}, + {2584, L""}, + {2585, L""}, + {2586, L""}, + {2587, L"У"}, + {2588, L""}, + {2589, L""}, + {2590, L""}, + {2591, L""}, + {2592, L""}, + {2593, L""}, + {2594, L""}, + {2595, L""}, + {2596, L""}, + {2597, L""}, + {2598, L""}, + {2599, L""}, + {2600, L""}, + {2601, L""}, + {2602, L""}, + {2603, L"Φ"}, + {2604, L""}, + {2605, L""}, + {2606, L""}, + {2607, L""}, + {2608, L""}, + {2609, L""}, + {2610, L"ͩ"}, + {2611, L"ɣ"}, + {2612, L""}, + {2613, L""}, + {2614, L""}, + {2615, L""}, + {2616, L""}, + {2617, L""}, + {2618, L""}, + {2619, L""}, + {2620, L""}, + {2621, L""}, + {2622, L""}, + {2623, L""}, + {2624, L"׮"}, + {2625, L""}, + {2626, L""}, + {2627, L"Ͱ"}, + {2628, L""}, + {2629, L""}, + {2630, L""}, + {2631, L"÷"}, + {2632, L""}, + {2633, L""}, + {2634, L""}, + {2635, L""}, + {2636, L""}, + {2637, L""}, + {2638, L""}, + {2639, L""}, + {2640, L""}, + {2641, L""}, + {2642, L"е"}, + {2643, L""}, + {2644, L""}, + {2645, L""}, + {2646, L""}, + {2647, L""}, + {2648, L""}, + {2649, L""}, + {2650, L""}, + {2651, L""}, + {2652, L""}, + {2653, L""}, + {2654, L""}, + {2655, L""}, + {2656, L"ɭ"}, + {2657, L""}, + {2658, L""}, + {2659, L""}, + {2660, L""}, + {2661, L""}, + {2662, L""}, + {2663, L""}, + {2664, L""}, + {2665, L""}, + {2666, L"ֲ"}, + {2667, L"׵"}, + {2668, L""}, + {2669, L""}, + {2670, L""}, + {2671, L""}, + {2672, L""}, + {2673, L""}, + {2674, L"Ҭ"}, + {2675, L""}, + {2676, L""}, + {2677, L""}, + {2678, L""}, + {2679, L""}, + {2680, L"Ш"}, + {2681, L""}, + {2682, L""}, + {2683, L""}, + {2684, L""}, + {2685, L""}, + {2686, L""}, + {2687, L""}, + {2688, L""}, + {2689, L""}, + {2690, L""}, + {2691, L""}, + {2692, L""}, + {2693, L"¥"}, + {2694, L""}, + {2695, L""}, + {2696, L""}, + {2697, L""}, + {2698, L""}, + {2699, L""}, + {2700, L""}, + {2701, L""}, + {2702, L""}, + {2703, L""}, + {2704, L""}, + {2705, L""}, + {2706, L""}, + {2707, L"ե"}, + {2708, L""}, + {2709, L""}, + {2710, L""}, + {2711, L""}, + {2712, L"ȶ"}, + {2713, L""}, + {2714, L""}, + {2715, L""}, + {2716, L""}, + {2717, L""}, + {2718, L""}, + {2719, L""}, + {2720, L""}, + {2721, L""}, + {2722, L""}, + {2723, L""}, + {2724, L""}, + {2725, L""}, + {2726, L""}, + {2727, L""}, + {2728, L""}, + {2729, L""}, + {2730, L""}, + {2731, L"ģ"}, + {2732, L""}, + {2733, L""}, + {2734, L""}, + {2735, L"ӣ"}, + {2736, L""}, + {2737, L""}, + {2738, L""}, + {2739, L""}, + {2740, L""}, + {2741, L""}, + {2742, L""}, + {2743, L""}, + {2744, L""}, + {2745, L""}, + {2746, L""}, + {2747, L""}, + {2748, L""}, + {2749, L""}, + {2750, L"̴"}, + {2751, L"ϭ"}, + {2752, L""}, + {2753, L""}, + {2754, L""}, + {2755, L""}, + {2756, L""}, + {2757, L""}, + {2758, L""}, + {2759, L""}, + {2760, L"Ƿ"}, + {2761, L""}, + {2762, L""}, + {2763, L""}, + {2764, L""}, + {2765, L"ŷ"}, + {2766, L""}, + {2767, L""}, + {2768, L""}, + {2769, L""}, + {2770, L""}, + {2771, L""}, + {2772, L"Ъ"}, + {2773, L"Ǹ"}, + {2774, L""}, + {2775, L""}, + {2776, L"ֹ"}, + {2777, L""}, + {2778, L""}, + {2779, L""}, + {2780, L""}, + {2781, L""}, + {2782, L""}, + {2783, L""}, + {2784, L""}, + {2785, L""}, + {2786, L""}, + {2787, L""}, + {2788, L""}, + {2789, L""}, + {2790, L""}, + {2791, L""}, + {2792, L"ѳ"}, + {2793, L""}, + {2794, L""}, + {2795, L""}, + {2796, L""}, + {2797, L""}, + {2798, L"ֳ"}, + {2799, L""}, + {2800, L""}, + {2801, L""}, + {2802, L""}, + {2803, L""}, + {2804, L"Ź"}, + {2805, L""}, + {2806, L""}, + {2807, L""}, + {2808, L""}, + {2809, L""}, + {2810, L""}, + {2811, L""}, + {2812, L"ĸ"}, + {2813, L"ÿ"}, + {2814, L""}, + {2815, L"ع"}, + {2816, L""}, + {2817, L""}, + {2818, L""}, + {2819, L""}, + {2820, L""}, + {2821, L"ë"}, + {2822, L"ձ"}, + {2823, L""}, + {2824, L""}, + {2825, L"̺"}, + {2826, L""}, + {2827, L""}, + {2828, L""}, + {2829, L""}, + {2830, L""}, + {2831, L""}, + {2832, L""}, + {2833, L""}, + {2834, L""}, + {2835, L"ص"}, + {2836, L""}, + {2837, L"å"}, + {2838, L""}, + {2839, L""}, + {2840, L""}, + {2841, L""}, + {2842, L""}, + {2843, L""}, + {2844, L""}, + {2845, L""}, + {2846, L""}, + {2847, L""}, + {2848, L""}, + {2849, L""}, + {2850, L""}, + {2851, L""}, + {2852, L""}, + {2853, L""}, + {2854, L""}, + {2855, L""}, + {2856, L""}, + {2857, L""}, + {2858, L"ˮ"}, + {2859, L""}, + {2860, L""}, + {2861, L"͡"}, + {2862, L"֭"}, + {2863, L""}, + {2864, L""}, + {2865, L""}, + {2866, L""}, + {2867, L""}, + {2868, L"ϫ"}, + {2869, L""}, + {2870, L""}, + {2871, L""}, + {2872, L"Ѵ"}, + {2873, L""}, + {2874, L""}, + {2875, L""}, + {2876, L""}, + {2877, L""}, + {2878, L""}, + {2879, L""}, + {2880, L""}, + {2881, L""}, + {2882, L""}, + {2883, L"̭"}, + {2884, L""}, + {2885, L""}, + {2886, L""}, + {2887, L""}, + {2888, L""}, + {2889, L""}, + {2890, L""}, + {2891, L""}, + {2892, L""}, + {2893, L""}, + {2894, L""}, + {2895, L""}, + {2896, L""}, + {2897, L""}, + {2898, L""}, + {2899, L""}, + {2900, L""}, + {2901, L""}, + {2902, L"ɳ"}, + {2903, L""}, + {2904, L""}, + {2905, L"û"}, + {2906, L""}, + {2907, L"Ž"}, + {2908, L""}, + {2909, L""}, + {2910, L""}, + {2911, L""}, + {2912, L""}, + {2913, L"ĭ"}, + {2914, L""}, + {2915, L""}, + {2916, L""}, + {2917, L""}, + {2918, L""}, + {2919, L""}, + {2920, L""}, + {2921, L""}, + {2922, L""}, + {2923, L"մ"}, + {2924, L""}, + {2925, L"й"}, + {2926, L""}, + {2927, L"Ȫ"}, + {2928, L""}, + {2929, L""}, + {2930, L""}, + {2931, L""}, + {2932, L""}, + {2933, L""}, + {2934, L""}, + {2935, L""}, + {2936, L""}, + {2937, L"Ţ"}, + {2938, L""}, + {2939, L""}, + {2940, L""}, + {2941, L""}, + {2942, L""}, + {2943, L"ע"}, + {2944, L""}, + {2945, L""}, + {2946, L""}, + {2947, L""}, + {2948, L"̩"}, + {2949, L""}, + {2950, L"Ӿ"}, + {2951, L""}, + {2952, L""}, + {2953, L""}, + {2954, L""}, + {2955, L"к"}, + {2956, L""}, + {2957, L""}, + {2958, L""}, + {2959, L""}, + {2960, L""}, + {2961, L""}, + {2962, L""}, + {2963, L""}, + {2964, L""}, + {2965, L""}, + {2966, L"ϴ"}, + {2967, L""}, + {2968, L""}, + {2969, L""}, + {2970, L""}, + {2971, L""}, + {2972, L""}, + {2973, L""}, + {2974, L""}, + {2975, L""}, + {2976, L""}, + {2977, L""}, + {2978, L""}, + {2979, L""}, + {2980, L""}, + {2981, L""}, + {2982, L""}, + {2983, L"Ǣ"}, + {2984, L""}, + {2985, L""}, + {2986, L""}, + {2987, L"dz"}, + {2988, L""}, + {2989, L""}, + {2990, L""}, + {2991, L""}, + {2992, L""}, + {2993, L""}, + {2994, L""}, + {2995, L""}, + {2996, L""}, + {2997, L""}, + {2998, L"Ũ"}, + {2999, L""}, + {3000, L""}, + {3001, L""}, + {3002, L""}, + {3003, L""}, + {3004, L""}, + {3005, L""}, + {3006, L""}, + {3007, L""}, + {3008, L""}, + {3009, L""}, + {3010, L""}, + {3011, L"ԡ"}, + {3012, L""}, + {3013, L""}, + {3014, L""}, + {3015, L"Ϳ"}, + {3016, L""}, + {3017, L""}, + {3018, L""}, + {3019, L"ӿ"}, + {3020, L""}, + {3021, L""}, + {3022, L""}, + {3023, L""}, + {3024, L""}, + {3025, L""}, + {3026, L""}, + {3027, L""}, + {3028, L""}, + {3029, L""}, + {3030, L""}, + {3031, L""}, + {3032, L""}, + {3033, L""}, + {3034, L""}, + {3035, L""}, + {3036, L"ɬ"}, + {3037, L""}, + {3038, L""}, + {3039, L""}, + {3040, L""}, + {3041, L"Һ"}, + {3042, L""}, + {3043, L""}, + {3044, L""}, + {3045, L""}, + {3046, L""}, + {3047, L""}, + {3048, L""}, + {3049, L""}, + {3050, L""}, + {3051, L""}, + {3052, L""}, + {3053, L""}, + {3054, L""}, + {3055, L""}, + {3056, L""}, + {3057, L""}, + {3058, L""}, + {3059, L""}, + {3060, L""}, + {3061, L""}, + {3062, L""}, + {3063, L""}, + {3064, L""}, + {3065, L""}, + {3066, L""}, + {3067, L""}, + {3068, L""}, + {3069, L""}, + {3070, L""}, + {3071, L""}, + {3072, L"Ԩ"}, + {3073, L""}, + {3074, L""}, + {3075, L""}, + {3076, L""}, + {3077, L""}, + {3078, L""}, + {3079, L""}, + {3080, L""}, + {3081, L""}, + {3082, L""}, + {3083, L""}, + {3084, L""}, + {3085, L""}, + {3086, L""}, + {3087, L""}, + {3088, L""}, + {3089, L""}, + {3090, L"μ"}, + {3091, L""}, + {3092, L""}, + {3093, L""}, + {3094, L""}, + {3095, L""}, + {3096, L""}, + {3097, L""}, + {3098, L""}, + {3099, L""}, + {3100, L""}, + {3101, L""}, + {3102, L""}, + {3103, L"տ"}, + {3104, L""}, + {3105, L""}, + {3106, L""}, + {3107, L""}, + {3108, L"ʪ"}, + {3109, L""}, + {3110, L""}, + {3111, L""}, + {3112, L""}, + {3113, L""}, + {3114, L"Դ"}, + {3115, L""}, + {3116, L""}, + {3117, L""}, + {3118, L""}, + {3119, L""}, + {3120, L""}, + {3121, L"Ϫ"}, + {3122, L""}, + {3123, L""}, + {3124, L""}, + {3125, L""}, + {3126, L""}, + {3127, L""}, + {3128, L""}, + {3129, L""}, + {3130, L""}, + {3131, L""}, + {3132, L""}, + {3133, L""}, + {3134, L""}, + {3135, L""}, + {3136, L""}, + {3137, L""}, + {3138, L""}, + {3139, L""}, + {3140, L""}, + {3141, L""}, + {3142, L""}, + {3143, L""}, + {3144, L""}, + {3145, L""}, + {3146, L""}, + {3147, L""}, + {3148, L""}, + {3149, L""}, + {3150, L""}, + {3151, L"̲"}, + {3152, L""}, + {3153, L""}, + {3154, L"Ư"}, + {3155, L""}, + {3156, L""}, + {3157, L"©"}, + {3158, L""}, + {3159, L""}, + {3160, L""}, + {3161, L"Į"}, + {3162, L""}, + {3163, L""}, + {3164, L""}, + {3165, L""}, + {3166, L""}, + {3167, L""}, + {3168, L""}, + {3169, L""}, + {3170, L""}, + {3171, L""}, + {3172, L""}, + {3173, L""}, + {3174, L""}, + {3175, L"Ϋ"}, + {3176, L""}, + {3177, L"DZ"}, + {3178, L"º"}, + {3179, L""}, + {3180, L""}, + {3181, L"̶"}, + {3182, L""}, + {3183, L""}, + {3184, L""}, + {3185, L""}, + {3186, L""}, + {3187, L""}, + {3188, L""}, + {3189, L""}, + {3190, L""}, + {3191, L""}, + {3192, L""}, + {3193, L""}, + {3194, L""}, + {3195, L""}, + {3196, L""}, + {3197, L""}, + {3198, L""}, + {3199, L""}, + {3200, L""}, + {3201, L""}, + {3202, L""}, + {3203, L""}, + {3204, L""}, + {3205, L""}, + {3206, L""}, + {3207, L""}, + {3208, L""}, + {3209, L""}, + {3210, L""}, + {3211, L""}, + {3212, L""}, + {3213, L""}, + {3214, L""}, + {3215, L""}, + {3216, L""}, + {3217, L""}, + {3218, L""}, + {3219, L""}, + {3220, L""}, + {3221, L""}, + {3222, L""}, + {3223, L""}, + {3224, L""}, + {3225, L""}, + {3226, L""}, + {3227, L""}, + {3228, L""}, + {3229, L""}, + {3230, L""}, + {3231, L"¯"}, + {3232, L""}, + {3233, L""}, + {3234, L""}, + {3235, L"Ȳ"}, + {3236, L""}, + {3237, L""}, + {3238, L""}, + {3239, L""}, + {3240, L""}, + {3241, L""}, + {3242, L""}, + {3243, L"̿"}, + {3244, L""}, + {3245, L""}, + {3246, L""}, + {3247, L""}, + {3248, L""}, + {3249, L"ը"}, + {3250, L""}, + {3251, L""}, + {3252, L""}, + {3253, L""}, + {3254, L""}, + {3255, L"˸"}, + {3256, L""}, + {3257, L""}, + {3258, L""}, + {3259, L""}, + {3260, L""}, + {3261, L""}, + {3262, L""}, + {3263, L""}, + {3264, L""}, + {3265, L""}, + {3266, L""}, + {3267, L""}, + {3268, L""}, + {3269, L""}, + {3270, L""}, + {3271, L""}, + {3272, L"ϩ"}, + {3273, L""}, + {3274, L""}, + {3275, L""}, + {3276, L""}, + {3277, L""}, + {3278, L""}, + {3279, L""}, + {3280, L""}, + {3281, L""}, + {3282, L""}, + {3283, L""}, + {3284, L""}, + {3285, L""}, + {3286, L""}, + {3287, L""}, + {3288, L""}, + {3289, L"Ȼ"}, + {3290, L""}, + {3291, L""}, + {3292, L""}, + {3293, L""}, + {3294, L""}, + {3295, L"ɷ"}, + {3296, L"ú"}, + {3297, L""}, + {3298, L""}, + {3299, L""}, + {3300, L""}, + {3301, L""}, + {3302, L""}, + {3303, L""}, + {3304, L""}, + {3305, L"ɿ"}, + {3306, L"Ϩ"}, + {3307, L""}, + {3308, L"Ѭ"}, + {3309, L""}, + {3310, L""}, + {3311, L""}, + {3312, L""}, + {3313, L""}, + {3314, L""}, + {3315, L""}, + {3316, L""}, + {3317, L""}, + {3318, L"ȼ"}, + {3319, L""}, + {3320, L""}, + {3321, L""}, + {3322, L""}, + {3323, L""}, + {3324, L""}, + {3325, L""}, + {3326, L""}, + {3327, L""}, + {3328, L""}, + {3329, L""}, + {3330, L"צ"}, + {3331, L""}, + {3332, L""}, + {3333, L""}, + {3334, L""}, + {3335, L""}, + {3336, L"ү"}, + {3337, L""}, + {3338, L""}, + {3339, L"س"}, + {3340, L"ˬ"}, + {3341, L""}, + {3342, L"Ƭ"}, + {3343, L""}, + {3344, L""}, + {3345, L""}, + {3346, L""}, + {3347, L""}, + {3348, L""}, + {3349, L"ţ"}, + {3350, L""}, + {3351, L"IJ"}, + {3352, L"ĵ"}, + {3353, L""}, + {3354, L""}, + {3355, L""}, + {3356, L""}, + {3357, L""}, + {3358, L""}, + {3359, L""}, + {3360, L"ǣ"}, + {3361, L""}, + {3362, L""}, + {3363, L""}, + {3364, L"Ϭ"}, + {3365, L""}, + {3366, L""}, + {3367, L""}, + {3368, L""}, + {3369, L""}, + {3370, L""}, + {3371, L""}, + {3372, L""}, + {3373, L"Ȯ"}, + {3374, L""}, + {3375, L""}, + {3376, L""}, + {3377, L"״"}, + {3378, L""}, + {3379, L""}, + {3380, L""}, + {3381, L""}, + {3382, L""}, + {3383, L""}, + {3384, L""}, + {3385, L""}, + {3386, L""}, + {3387, L""}, + {3388, L""}, + {3389, L""}, + {3390, L""}, + {3391, L""}, + {3392, L""}, + {3393, L""}, + {3394, L""}, + {3395, L""}, + {3396, L""}, + {3397, L""}, + {3398, L""}, + {3399, L"ʨ"}, + {3400, L""}, + {3401, L""}, + {3402, L""}, + {3403, L""}, + {3404, L""}, + {3405, L""}, + {3406, L""}, + {3407, L""}, + {3408, L""}, + {3409, L""}, + {3410, L""}, + {3411, L""}, + {3412, L""}, + {3413, L""}, + {3414, L""}, + {3415, L""}, + {3416, L""}, + {3417, L""}, + {3418, L""}, + {3419, L""}, + {3420, L""}, + {3421, L""}, + {3422, L""}, + {3423, L""}, + {3424, L""}, + {3425, L""}, + {3426, L""}, + {3427, L"è"}, + {3428, L""}, + {3429, L""}, + {3430, L""}, + {3431, L""}, + {3432, L""}, + {3433, L""}, + {3434, L""}, + {3435, L""}, + {3436, L"Գ"}, + {3437, L""}, + {3438, L""}, + {3439, L""}, + {3440, L""}, + {3441, L""}, + {3442, L""}, + {3443, L"̡"}, + {3444, L""}, + {3445, L""}, + {3446, L""}, + {3447, L""}, + {3448, L""}, + {3449, L""}, + {3450, L""}, + {3451, L""}, + {3452, L""}, + {3453, L""}, + {3454, L""}, + {3455, L""}, + {3456, L"õ"}, + {3457, L""}, + {3458, L""}, + {3459, L""}, + {3460, L""}, + {3461, L""}, + {3462, L""}, + {3463, L""}, + {3464, L""}, + {3465, L""}, + {3466, L""}, + {3467, L""}, + {3468, L""}, + {3469, L"ɺ"}, + {3470, L""}, + {3471, L""}, + {3472, L""}, + {3473, L""}, + {3474, L""}, + {3475, L""}, + {3476, L""}, + {3477, L""}, + {3478, L""}, + {3479, L""}, + {3480, L""}, + {3481, L""}, + {3482, L""}, + {3483, L""}, + {3484, L""}, + {3485, L""}, + {3486, L""}, + {3487, L""}, + {3488, L""}, + {3489, L""}, + {3490, L""}, + {3491, L""}, + {3492, L""}, + {3493, L""}, + {3494, L""}, + {3495, L""}, + {3496, L""}, + {3497, L""}, + {3498, L""}, + {3499, L""}, + {3500, L""}, + {3501, L""}, + {3502, L""}, + {3503, L""}, + {3504, L""}, + {3505, L""}, + {3506, L""}, + {3507, L""}, + {3508, L""}, + {3509, L""}, + {3510, L""}, + {3511, L"ɪ"}, + {3512, L""}, + {3513, L""}, + {3514, L""}, + {3515, L""}, + {3516, L""}, + {3517, L""}, + {3518, L""}, + {3519, L""}, + {3520, L""}, + {3521, L""}, + {3522, L""}, + {3523, L""}, + {3524, L""}, + {3525, L""}, + {3526, L""}, + {3527, L""}, + {3528, L""}, + {3529, L""}, + {3530, L""}, + {3531, L""}, + {3532, L"ư"}, + {3533, L""}, + {3534, L"ȿ"}, + {3535, L""}, + {3536, L""}, + {3537, L""}, + {3538, L""}, + {3539, L"ƿ"}, + {3540, L""}, + {3541, L""}, + {3542, L""}, + {3543, L""}, + {3544, L""}, + {3545, L""}, + {3546, L""}, + {3547, L"߰"}, + {3548, L""}, + {3549, L""}, + {3550, L""}, + {3551, L""}, + {3552, L""}, + {3553, L"˦"}, + {3554, L""}, + {3555, L""}, + {3556, L""}, + {3557, L""}, + {3558, L""}, + {3559, L""}, + {3560, L""}, + {3561, L""}, + {3562, L""}, + {3563, L""}, + {3564, L""}, + {3565, L""}, + {3566, L""}, + {3567, L""}, + {3568, L""}, + {3569, L""}, + {3570, L""}, + {3571, L""}, + {3572, L""}, + {3573, L"η"}, + {3574, L""}, + {3575, L""}, + {3576, L""}, + {3577, L""}, + {3578, L""}, + {3579, L""}, + {3580, L""}, + {3581, L""}, + {3582, L""}, + {3583, L""}, + {3584, L""}, + {3585, L""}, + {3586, L""}, + {3587, L""}, + {3588, L""}, + {3589, L""}, + {3590, L""}, + {3591, L""}, + {3592, L""}, + {3593, L""}, + {3594, L""}, + {3595, L""}, + {3596, L""}, + {3597, L""}, + {3598, L"ű"}, + {3599, L""}, + {3600, L""}, + {3601, L""}, + {3602, L""}, + {3603, L""}, + {3604, L""}, + {3605, L""}, + {3606, L""}, + {3607, L""}, + {3608, L""}, + {3609, L""}, + {3610, L"ƣ"}, + {3611, L""}, + {3612, L""}, + {3613, L""}, + {3614, L""}, + {3615, L""}, + {3616, L""}, + {3617, L""}, + {3618, L""}, + {3619, L""}, + {3620, L""}, + {3621, L""}, + {3622, L""}, + {3623, L"֢"}, + {3624, L"Ӹ"}, + {3625, L""}, + {3626, L"Ȭ"}, + {3627, L""}, + {3628, L""}, + {3629, L""}, + {3630, L""}, + {3631, L""}, + {3632, L"ʹ"}, + {3633, L"Ʀ"}, + {3634, L""}, + {3635, L""}, + {3636, L""}, + {3637, L""}, + {3638, L""}, + {3639, L""}, + {3640, L""}, + {3641, L""}, + {3642, L"̵"}, + {3643, L""}, + {3644, L""}, + {3645, L""}, + {3646, L""}, + {3647, L""}, + {3648, L""}, + {3649, L""}, + {3650, L""}, + {3651, L""}, + {3652, L""}, + {3653, L""}, + {3654, L""}, + {3655, L""}, + {3656, L""}, + {3657, L""}, + {3658, L""}, + {3659, L""}, + {3660, L""}, + {3661, L""}, + {3662, L""}, + {3663, L""}, + {3664, L""}, + {3665, L""}, + {3666, L""}, + {3667, L"̱"}, + {3668, L""}, + {3669, L""}, + {3670, L""}, + {3671, L""}, + {3672, L""}, + {3673, L"ȳ"}, + {3674, L""}, + {3675, L""}, + {3676, L""}, + {3677, L""}, + {3678, L""}, + {3679, L""}, + {3680, L""}, + {3681, L""}, + {3682, L""}, + {3683, L""}, + {3684, L""}, + {3685, L"Ѣ"}, + {3686, L""}, + {3687, L""}, + {3688, L""}, + {3689, L""}, + {3690, L""}, + {3691, L""}, + {3692, L""}, + {3693, L""}, + {3694, L""}, + {3695, L""}, + {3696, L""}, + {3697, L""}, + {3698, L""}, + {3699, L""}, + {3700, L""}, + {3701, L""}, + {3702, L""}, + {3703, L""}, + {3704, L"Ƥ"}, + {3705, L""}, + {3706, L""}, + {3707, L""}, + {3708, L""}, + {3709, L""}, + {3710, L""}, + {3711, L""}, + {3712, L"ӯ"}, + {3713, L""}, + {3714, L""}, + {3715, L""}, + {3716, L"յ"}, + {3717, L""}, + {3718, L""}, + {3719, L""}, + {3720, L""}, + {3721, L""}, + {3722, L""}, + {3723, L""}, + {3724, L"ʢ"}, + {3725, L""}, + {3726, L""}, + {3727, L"Ŀ"}, + {3728, L""}, + {3729, L""}, + {3730, L"ä"}, + {3731, L"ֱ"}, + {3732, L""}, + {3733, L""}, + {3734, L""}, + {3735, L""}, + {3736, L"ʡ"}, + {3737, L""}, + {3738, L""}, + {3739, L""}, + {3740, L"ü"}, + {3741, L""}, + {3742, L""}, + {3743, L""}, + {3744, L""}, + {3745, L""}, + {3746, L""}, + {3747, L""}, + {3748, L""}, + {3749, L"գ"}, + {3750, L"ѣ"}, + {3751, L""}, + {3752, L""}, + {3753, L""}, + {3754, L""}, + {3755, L""}, + {3756, L""}, + {3757, L""}, + {3758, L""}, + {3759, L""}, + {3760, L""}, + {3761, L""}, + {3762, L""}, + {3763, L""}, + {3764, L""}, + {3765, L""}, + {3766, L""}, + {3767, L"˯"}, + {3768, L""}, + {3769, L""}, + {3770, L""}, + {3771, L""}, + {3772, L""}, + {3773, L""}, + {3774, L""}, + {3775, L""}, + {3776, L""}, + {3777, L"غ"}, + {3778, L""}, + {3779, L""}, + {3780, L""}, + {3781, L""}, + {3782, L""}, + {3783, L""}, + {3784, L"Ϲ"}, + {3785, L""}, + {3786, L""}, + {3787, L""}, + {3788, L""}, + {3789, L"ޫ"}, + {3790, L"Ƴ"}, + {3791, L""}, + {3792, L""}, + {3793, L""}, + {3794, L"˲"}, + {3795, L""}, + {3796, L"ͫ"}, + {3797, L""}, + {3798, L"հ"}, + {3799, L""}, + {3800, L""}, + {3801, L""}, + {3802, L""}, + {3803, L"ì"}, + {3804, L""}, + {3805, L"ʸ"}, + {3806, L""}, + {3807, L"֪"}, + {3808, L""}, + {3809, L""}, + {3810, L""}, + {3811, L""}, + {3812, L""}, + {3813, L""}, + {3814, L"ʯ"}, + {3815, L""}, + {3816, L""}, + {3817, L""}, + {3818, L""}, + {3819, L""}, + {3820, L""}, + {3821, L""}, + {3822, L"ɰ"}, + {3823, L""}, + {3824, L""}, + {3825, L""}, + {3826, L""}, + {3827, L""}, + {3828, L""}, + {3829, L"ש"}, + {3830, L""}, + {3831, L""}, + {3832, L""}, + {3833, L""}, + {3834, L""}, + {3835, L""}, + {3836, L""}, + {3837, L""}, + {3838, L""}, + {3839, L""}, + {3840, L""}, + {3841, L""}, + {3842, L""}, + {3843, L""}, + {3844, L""}, + {3845, L""}, + {3846, L""}, + {3847, L""}, + {3848, L""}, + {3849, L""}, + {3850, L""}, + {3851, L""}, + {3852, L""}, + {3853, L""}, + {3854, L""}, + {3855, L""}, + {3856, L"˶"}, + {3857, L""}, + {3858, L""}, + {3859, L""}, + {3860, L""}, + {3861, L""}, + {3862, L"Ӳ"}, + {3863, L""}, + {3864, L"ȷ"}, + {3865, L""}, + {3866, L""}, + {3867, L""}, + {3868, L""}, + {3869, L"µ"}, + {3870, L""}, + {3871, L""}, + {3872, L""}, + {3873, L""}, + {3874, L""}, + {3875, L""}, + {3876, L""}, + {3877, L""}, + {3878, L""}, + {3879, L""}, + {3880, L""}, + {3881, L""}, + {3882, L""}, + {3883, L""}, + {3884, L""}, + {3885, L""}, + {3886, L""}, + {3887, L"̼"}, + {3888, L""}, + {3889, L""}, + {3890, L""}, + {3891, L""}, + {3892, L""}, + {3893, L""}, + {3894, L""}, + {3895, L""}, + {3896, L""}, + {3897, L""}, + {3898, L""}, + {3899, L""}, + {3900, L"ĥ"}, + {3901, L""}, + {3902, L""}, + {3903, L""}, + {3904, L""}, + {3905, L""}, + {3906, L""}, + {3907, L""}, + {3908, L""}, + {3909, L""}, + {3910, L""}, + {3911, L""}, + {3912, L"ʾ"}, + {3913, L""}, + {3914, L""}, + {3915, L""}, + {3916, L""}, + {3917, L""}, + {3918, L""}, + {3919, L""}, + {3920, L""}, + {3921, L""}, + {3922, L""}, + {3923, L""}, + {3924, L""}, + {3925, L""}, + {3926, L""}, + {3927, L"ף"}, + {3928, L""}, + {3929, L""}, + {3930, L""}, + {3931, L""}, + {3932, L""}, + {3933, L""}, + {3934, L"Ʊ"}, + {3935, L""}, + {3936, L""}, + {3937, L""}, + {3938, L""}, + {3939, L""}, + {3940, L""}, + {3941, L""}, + {3942, L"»"}, + {3943, L""}, + {3944, L""}, + {3945, L""}, + {3946, L""}, + {3947, L""}, + {3948, L""}, + {3949, L""}, + {3950, L"خ"}, + {3951, L""}, + {3952, L""}, + {3953, L""}, + {3954, L""}, + {3955, L"˽"}, + {3956, L"ͺ"}, + {3957, L""}, + {3958, L""}, + {3959, L""}, + {3960, L""}, + {3961, L""}, + {3962, L""}, + {3963, L""}, + {3964, L""}, + {3965, L""}, + {3966, L""}, + {3967, L""}, + {3968, L""}, + {3969, L""}, + {3970, L""}, + {3971, L""}, + {3972, L""}, + {3973, L""}, + {3974, L""}, + {3975, L""}, + {3976, L""}, + {3977, L""}, + {3978, L"ϡ"}, + {3979, L""}, + {3980, L""}, + {3981, L""}, + {3982, L""}, + {3983, L"˰"}, + {3984, L""}, + {3985, L""}, + {3986, L""}, + {3987, L""}, + {3988, L""}, + {3989, L""}, + {3990, L""}, + {3991, L""}, + {3992, L""}, + {3993, L""}, + {3994, L""}, + {3995, L""}, + {3996, L""}, + {3997, L""}, + {3998, L""}, + {3999, L""}, + {4000, L"Ѩ"}, + {4001, L""}, + {4002, L""}, + {4003, L""}, + {4004, L""}, + {4005, L""}, + {4006, L""}, + {4007, L""}, + {4008, L"ͻ"}, + {4009, L""}, + {4010, L"խ"}, + {4011, L""}, + {4012, L""}, + {4013, L"Ҥ"}, + {4014, L""}, + {4015, L""}, + {4016, L""}, + {4017, L""}, + {4018, L""}, + {4019, L""}, + {4020, L""}, + {4021, L""}, + {4022, L""}, + {4023, L""}, + {4024, L""}, + {4025, L""}, + {4026, L""}, + {4027, L""}, + {4028, L""}, + {4029, L""}, + {4030, L""}, + {4031, L""}, + {4032, L"վ"}, + {4033, L""}, + {4034, L""}, + {4035, L""}, + {4036, L""}, + {4037, L"ͯ"}, + {4038, L""}, + {4039, L""}, + {4040, L""}, + {4041, L""}, + {4042, L""}, + {4043, L""}, + {4044, L""}, + {4045, L""}, + {4046, L""}, + {4047, L""}, + {4048, L""}, + {4049, L""}, + {4050, L""}, + {4051, L""}, + {4052, L"Ц"}, + {4053, L""}, + {4054, L""}, + {4055, L""}, + {4056, L""}, + {4057, L""}, + {4058, L""}, + {4059, L""}, + {4060, L""}, + {4061, L""}, + {4062, L""}, + {4063, L""}, + {4064, L""}, + {4065, L""}, + {4066, L""}, + {4067, L""}, + {4068, L""}, + {4069, L""}, + {4070, L""}, + {4071, L""}, + {4072, L""}, + {4073, L""}, + {4074, L""}, + {4075, L""}, + {4076, L""}, + {4077, L""}, + {4078, L""}, + {4079, L""}, + {4080, L""}, + {4081, L"Ͳ"}, + {4082, L""}, + {4083, L""}, + {4084, L""}, + {4085, L""}, + {4086, L"ɸ"}, + {4087, L""}, + {4088, L""}, + {4089, L""}, + {4090, L""}, + {4091, L""}, + {4092, L""}, + {4093, L""}, + {4094, L""}, + {4095, L""}, + {4096, L""}, + {4097, L"ǩ"}, + {4098, L""}, + {4099, L""}, + {4100, L""}, + {4101, L""}, + {4102, L""}, + {4103, L""}, + {4104, L""}, + {4105, L""}, + {4106, L""}, + {4107, L""}, + {4108, L""}, + {4109, L""}, + {4110, L""}, + {4111, L""}, + {4112, L""}, + {4113, L""}, + {4114, L""}, + {4115, L""}, + {4116, L""}, + {4117, L""}, + {4118, L""}, + {4119, L""}, + {4120, L"׭"}, + {4121, L"ƪ"}, + {4122, L""}, + {4123, L""}, + {4124, L"¨"}, + {4125, L""}, + {4126, L""}, + {4127, L""}, + {4128, L""}, + {4129, L""}, + {4130, L""}, + {4131, L""}, + {4132, L""}, + {4133, L""}, + {4134, L""}, + {4135, L""}, + {4136, L""}, + {4137, L""}, + {4138, L""}, + {4139, L""}, + {4140, L""}, + {4141, L""}, + {4142, L""}, + {4143, L""}, + {4144, L""}, + {4145, L""}, + {4146, L""}, + {4147, L""}, + {4148, L""}, + {4149, L""}, + {4150, L""}, + {4151, L""}, + {4152, L""}, + {4153, L""}, + {4154, L""}, + {4155, L""}, + {4156, L""}, + {4157, L""}, + {4158, L""}, + {4159, L""}, + {4160, L""}, + {4161, L"ճ"}, + {4162, L""}, + {4163, L""}, + {4164, L""}, + {4165, L""}, + {4166, L""}, + {4167, L""}, + {4168, L""}, + {4169, L""}, + {4170, L""}, + {4171, L""}, + {4172, L""}, + {4173, L""}, + {4174, L""}, + {4175, L""}, + {4176, L""}, + {4177, L""}, + {4178, L""}, + {4179, L""}, + {4180, L""}, + {4181, L""}, + {4182, L""}, + {4183, L""}, + {4184, L""}, + {4185, L""}, + {4186, L""}, + {4187, L""}, + {4188, L""}, + {4189, L""}, + {4190, L""}, + {4191, L""}, + {4192, L"Ŵ"}, + {4193, L"ϵ"}, + {4194, L""}, + {4195, L""}, + {4196, L""}, + {4197, L""}, + {4198, L""}, + {4199, L""}, + {4200, L""}, + {4201, L""}, + {4202, L""}, + {4203, L""}, + {4204, L""}, + {4205, L""}, + {4206, L""}, + {4207, L""}, + {4208, L""}, + {4209, L""}, + {4210, L""}, + {4211, L""}, + {4212, L""}, + {4213, L""}, + {4214, L""}, + {4215, L"Լ"}, + {4216, L""}, + {4217, L""}, + {4218, L""}, + {4219, L""}, + {4220, L""}, + {4221, L"γ"}, + {4222, L""}, + {4223, L""}, + {4224, L""}, + {4225, L"ɴ"}, + {4226, L""}, + {4227, L""}, + {4228, L""}, + {4229, L""}, + {4230, L""}, + {4231, L"ֽ"}, + {4232, L""}, + {4233, L""}, + {4234, L"Ŧ"}, + {4235, L""}, + {4236, L""}, + {4237, L""}, + {4238, L""}, + {4239, L""}, + {4240, L""}, + {4241, L""}, + {4242, L""}, + {4243, L"ϸ"}, + {4244, L"֯"}, + {4245, L""}, + {4246, L""}, + {4247, L""}, + {4248, L""}, + {4249, L""}, + {4250, L""}, + {4251, L""}, + {4252, L""}, + {4253, L""}, + {4254, L""}, + {4255, L""}, + {4256, L""}, + {4257, L""}, + {4258, L""}, + {4259, L""}, + {4260, L""}, + {4261, L""}, + {4262, L"Ѥ"}, + {4263, L""}, + {4264, L""}, + {4265, L""}, + {4266, L""}, + {4267, L"ͳ"}, + {4268, L""}, + {4269, L""}, + {4270, L""}, + {4271, L""}, + {4272, L""}, + {4273, L""}, + {4274, L""}, + {4275, L""}, + {4276, L""}, + {4277, L""}, + {4278, L""}, + {4279, L""}, + {4280, L""}, + {4281, L""}, + {4282, L""}, + {4283, L""}, + {4284, L""}, + {4285, L"ά"}, + {4286, L""}, + {4287, L""}, + {4288, L""}, + {4289, L""}, + {4290, L""}, + {4291, L""}, + {4292, L""}, + {4293, L""}, + {4294, L""}, + {4295, L""}, + {4296, L"׺"}, + {4297, L""}, + {4298, L""}, + {4299, L""}, + {4300, L""}, + {4301, L""}, + {4302, L""}, + {4303, L""}, + {4304, L""}, + {4305, L""}, + {4306, L""}, + {4307, L""}, + {4308, L""}, + {4309, L""}, + {4310, L""}, + {4311, L""}, + {4312, L""}, + {4313, L""}, + {4314, L""}, + {4315, L""}, + {4316, L"Ե"}, + {4317, L""}, + {4318, L""}, + {4319, L""}, + {4320, L""}, + {4321, L""}, + {4322, L""}, + {4323, L""}, + {4324, L""}, + {4325, L""}, + {4326, L""}, + {4327, L""}, + {4328, L""}, + {4329, L""}, + {4330, L""}, + {4331, L"ӧ"}, + {4332, L""}, + {4333, L""}, + {4334, L""}, + {4335, L""}, + {4336, L""}, + {4337, L""}, + {4338, L""}, + {4339, L""}, + {4340, L""}, + {4341, L""}, + {4342, L""}, + {4343, L""}, + {4344, L""}, + {4345, L""}, + {4346, L""}, + {4347, L"ȱ"}, + {4348, L""}, + {4349, L""}, + {4350, L""}, + {4351, L""}, + {4352, L""}, + {4353, L""}, + {4354, L""}, + {4355, L""}, + {4356, L""}, + {4357, L""}, + {4358, L""}, + {4359, L""}, + {4360, L""}, + {4361, L""}, + {4362, L""}, + {4363, L""}, + {4364, L""}, + {4365, L""}, + {4366, L""}, + {4367, L""}, + {4368, L""}, + {4369, L""}, + {4370, L""}, + {4371, L""}, + {4372, L"Ǽ"}, + {4373, L""}, + {4374, L""}, + {4375, L""}, + {4376, L""}, + {4377, L""}, + {4378, L""}, + {4379, L""}, + {4380, L"Ⱥ"}, + {4381, L""}, + {4382, L""}, + {4383, L""}, + {4384, L""}, + {4385, L""}, + {4386, L""}, + {4387, L""}, + {4388, L""}, + {4389, L""}, + {4390, L""}, + {4391, L""}, + {4392, L""}, + {4393, L""}, + {4394, L""}, + {4395, L""}, + {4396, L""}, + {4397, L""}, + {4398, L""}, + {4399, L""}, + {4400, L""}, + {4401, L""}, + {4402, L""}, + {4403, L""}, + {4404, L""}, + {4405, L""}, + {4406, L""}, + {4407, L""}, + {4408, L""}, + {4409, L""}, + {4410, L"ҫ"}, + {4411, L""}, + {4412, L""}, + {4413, L""}, + {4414, L""}, + {4415, L""}, + {4416, L""}, + {4417, L""}, + {4418, L"ˣ"}, + {4419, L""}, + {4420, L""}, + {4421, L""}, + {4422, L""}, + {4423, L""}, + {4424, L""}, + {4425, L""}, + {4426, L""}, + {4427, L""}, + {4428, L""}, + {4429, L""}, + {4430, L""}, + {4431, L""}, + {4432, L""}, + {4433, L""}, + {4434, L""}, + {4435, L""}, + {4436, L""}, + {4437, L""}, + {4438, L""}, + {4439, L"Ү"}, + {4440, L""}, + {4441, L""}, + {4442, L""}, + {4443, L""}, + {4444, L""}, + {4445, L""}, + {4446, L""}, + {4447, L""}, + {4448, L""}, + {4449, L""}, + {4450, L"ְ"}, + {4451, L""}, + {4452, L""}, + {4453, L""}, + {4454, L"Ƹ"}, + {4455, L""}, + {4456, L""}, + {4457, L""}, + {4458, L""}, + {4459, L""}, + {4460, L""}, + {4461, L""}, + {4462, L""}, + {4463, L""}, + {4464, L""}, + {4465, L""}, + {4466, L""}, + {4467, L""}, + {4468, L"Ф"}, + {4469, L""}, + {4470, L""}, + {4471, L""}, + {4472, L""}, + {4473, L""}, + {4474, L""}, + {4475, L""}, + {4476, L"֫"}, + {4477, L""}, + {4478, L""}, + {4479, L""}, + {4480, L""}, + {4481, L""}, + {4482, L""}, + {4483, L""}, + {4484, L""}, + {4485, L""}, + {4486, L""}, + {4487, L""}, + {4488, L""}, + {4489, L""}, + {4490, L""}, + {4491, L""}, + {4492, L""}, + {4493, L""}, + {4494, L""}, + {4495, L"в"}, + {4496, L""}, + {4497, L"θ"}, + {4498, L""}, + {4499, L""}, + {4500, L""}, + {4501, L""}, + {4502, L"̥"}, + {4503, L""}, + {4504, L""}, + {4505, L""}, + {4506, L""}, + {4507, L""}, + {4508, L"ʤ"}, + {4509, L""}, + {4510, L""}, + {4511, L""}, + {4512, L"ط"}, + {4513, L""}, + {4514, L""}, + {4515, L""}, + {4516, L""}, + {4517, L""}, + {4518, L""}, + {4519, L""}, + {4520, L""}, + {4521, L""}, + {4522, L""}, + {4523, L""}, + {4524, L""}, + {4525, L""}, + {4526, L""}, + {4527, L""}, + {4528, L""}, + {4529, L""}, + {4530, L""}, + {4531, L""}, + {4532, L"֬"}, + {4533, L""}, + {4534, L""}, + {4535, L""}, + {4536, L""}, + {4537, L""}, + {4538, L""}, + {4539, L""}, + {4540, L""}, + {4541, L""}, + {4542, L"ŧ"}, + {4543, L""}, + {4544, L""}, + {4545, L""}, + {4546, L""}, + {4547, L""}, + {4548, L""}, + {4549, L""}, + {4550, L""}, + {4551, L""}, + {4552, L""}, + {4553, L""}, + {4554, L"Ƣ"}, + {4555, L""}, + {4556, L""}, + {4557, L""}, + {4558, L"Ҹ"}, + {4559, L""}, + {4560, L""}, + {4561, L""}, + {4562, L""}, + {4563, L"ǻ"}, + {4564, L""}, + {4565, L""}, + {4566, L""}, + {4567, L""}, + {4568, L""}, + {4569, L""}, + {4570, L""}, + {4571, L""}, + {4572, L""}, + {4573, L""}, + {4574, L""}, + {4575, L""}, + {4576, L""}, + {4577, L""}, + {4578, L""}, + {4579, L""}, + {4580, L""}, + {4581, L""}, + {4582, L""}, + {4583, L""}, + {4584, L""}, + {4585, L""}, + {4586, L""}, + {4587, L""}, + {4588, L""}, + {4589, L""}, + {4590, L""}, + {4591, L"Ĥ"}, + {4592, L"ϥ"}, + {4593, L""}, + {4594, L""}, + {4595, L""}, + {4596, L""}, + {4597, L""}, + {4598, L""}, + {4599, L""}, + {4600, L""}, + {4601, L""}, + {4602, L"ӷ"}, + {4603, L""}, + {4604, L""}, + {4605, L""}, + {4606, L""}, + {4607, L""}, + {4608, L""}, + {4609, L""}, + {4610, L""}, + {4611, L""}, + {4612, L""}, + {4613, L""}, + {4614, L""}, + {4615, L""}, + {4616, L"Ҩ"}, + {4617, L""}, + {4618, L""}, + {4619, L""}, + {4620, L""}, + {4621, L""}, + {4622, L""}, + {4623, L""}, + {4624, L""}, + {4625, L""}, + {4626, L""}, + {4627, L""}, + {4628, L"˴"}, + {4629, L""}, + {4630, L""}, + {4631, L""}, + {4632, L""}, + {4633, L""}, + {4634, L""}, + {4635, L""}, + {4636, L""}, + {4637, L""}, + {4638, L""}, + {4639, L""}, + {4640, L""}, + {4641, L""}, + {4642, L""}, + {4643, L""}, + {4644, L""}, + {4645, L""}, + {4646, L""}, + {4647, L""}, + {4648, L""}, + {4649, L""}, + {4650, L"ͧ"}, + {4651, L""}, + {4652, L""}, + {4653, L""}, + {4654, L""}, + {4655, L""}, + {4656, L""}, + {4657, L""}, + {4658, L""}, + {4659, L"ɫ"}, + {4660, L""}, + {4661, L""}, + {4662, L""}, + {4663, L"ܴ"}, + {4664, L""}, + {4665, L"ܵ"}, + {4666, L""}, + {4667, L"ܹ"}, + {4668, L""}, + {4669, L"ܷ"}, + {4670, L""}, + {4671, L""}, + {4672, L"ܺ"}, + {4673, L"ܶ"}, + {4674, L"ܻ"}, + {4675, L"â"}, + {4676, L"ܼ"}, + {4677, L""}, + {4678, L"ܽ"}, + {4679, L""}, + {4680, L"֥"}, + {4681, L""}, + {4682, L""}, + {4683, L""}, + {4684, L"«"}, + {4685, L"ܸ"}, + {4686, L""}, + {4687, L""}, + {4688, L"ܾ"}, + {4689, L""}, + {4690, L""}, + {4691, L""}, + {4692, L"о"}, + {4693, L""}, + {4694, L""}, + {4695, L""}, + {4696, L""}, + {4697, L""}, + {4698, L"ܿ"}, + {4699, L""}, + {4700, L"ѿ"}, + {4701, L""}, + {4702, L""}, + {4703, L""}, + {4704, L"έ"}, + {4705, L""}, + {4706, L""}, + {4707, L""}, + {4708, L""}, + {4709, L""}, + {4710, L""}, + {4711, L""}, + {4712, L"Է"}, + {4713, L""}, + {4714, L""}, + {4715, L"̦"}, + {4716, L""}, + {4717, L""}, + {4718, L""}, + {4719, L""}, + {4720, L""}, + {4721, L""}, + {4722, L""}, + {4723, L""}, + {4724, L""}, + {4725, L""}, + {4726, L""}, + {4727, L""}, + {4728, L""}, + {4729, L"ɻ"}, + {4730, L""}, + {4731, L"Ӣ"}, + {4732, L""}, + {4733, L""}, + {4734, L"ƻ"}, + {4735, L""}, + {4736, L""}, + {4737, L"ï"}, + {4738, L""}, + {4739, L""}, + {4740, L"é"}, + {4741, L""}, + {4742, L""}, + {4743, L""}, + {4744, L""}, + {4745, L""}, + {4746, L""}, + {4747, L""}, + {4748, L""}, + {4749, L""}, + {4750, L""}, + {4751, L""}, + {4752, L"ݢ"}, + {4753, L""}, + {4754, L""}, + {4755, L""}, + {4756, L"ã"}, + {4757, L""}, + {4758, L""}, + {4759, L""}, + {4760, L""}, + {4761, L""}, + {4762, L""}, + {4763, L""}, + {4764, L""}, + {4765, L""}, + {4766, L""}, + {4767, L""}, + {4768, L""}, + {4769, L""}, + {4770, L""}, + {4771, L""}, + {4772, L""}, + {4773, L""}, + {4774, L""}, + {4775, L""}, + {4776, L""}, + {4777, L""}, + {4778, L""}, + {4779, L""}, + {4780, L""}, + {4781, L""}, + {4782, L""}, + {4783, L""}, + {4784, L""}, + {4785, L""}, + {4786, L""}, + {4787, L""}, + {4788, L""}, + {4789, L"ӫ"}, + {4790, L"ݡ"}, + {4791, L"ݣ"}, + {4792, L"ݥ"}, + {4793, L""}, + {4794, L"ݤ"}, + {4795, L"ݦ"}, + {4796, L"ҩ"}, + {4797, L""}, + {4798, L"ݩ"}, + {4799, L"ݶ"}, + {4800, L"ݱ"}, + {4801, L"ݴ"}, + {4802, L"ݰ"}, + {4803, L""}, + {4804, L""}, + {4805, L"ɯ"}, + {4806, L""}, + {4807, L"ݮ"}, + {4808, L"ݷ"}, + {4809, L""}, + {4810, L"ݯ"}, + {4811, L"ݸ"}, + {4812, L"ݬ"}, + {4813, L"ݹ"}, + {4814, L"ݳ"}, + {4815, L"ݭ"}, + {4816, L"Ī"}, + {4817, L"ݨ"}, + {4818, L""}, + {4819, L""}, + {4820, L"ݪ"}, + {4821, L"ݫ"}, + {4822, L"ݲ"}, + {4823, L""}, + {4824, L"ݵ"}, + {4825, L"Ө"}, + {4826, L"ݺ"}, + {4827, L"ݻ"}, + {4828, L"ç"}, + {4829, L""}, + {4830, L"ݼ"}, + {4831, L""}, + {4832, L""}, + {4833, L""}, + {4834, L""}, + {4835, L""}, + {4836, L""}, + {4837, L""}, + {4838, L"ݿ"}, + {4839, L""}, + {4840, L""}, + {4841, L""}, + {4842, L""}, + {4843, L""}, + {4844, L"ݾ"}, + {4845, L""}, + {4846, L""}, + {4847, L""}, + {4848, L""}, + {4849, L""}, + {4850, L""}, + {4851, L""}, + {4852, L"ݽ"}, + {4853, L""}, + {4854, L""}, + {4855, L""}, + {4856, L""}, + {4857, L"Ƽ"}, + {4858, L"ή"}, + {4859, L""}, + {4860, L""}, + {4861, L""}, + {4862, L""}, + {4863, L""}, + {4864, L"ө"}, + {4865, L"Ӫ"}, + {4866, L""}, + {4867, L""}, + {4868, L""}, + {4869, L""}, + {4870, L""}, + {4871, L""}, + {4872, L""}, + {4873, L""}, + {4874, L""}, + {4875, L""}, + {4876, L""}, + {4877, L""}, + {4878, L""}, + {4879, L""}, + {4880, L""}, + {4881, L""}, + {4882, L""}, + {4883, L""}, + {4884, L""}, + {4885, L""}, + {4886, L""}, + {4887, L""}, + {4888, L""}, + {4889, L""}, + {4890, L""}, + {4891, L""}, + {4892, L""}, + {4893, L""}, + {4894, L""}, + {4895, L""}, + {4896, L""}, + {4897, L""}, + {4898, L""}, + {4899, L""}, + {4900, L""}, + {4901, L""}, + {4902, L""}, + {4903, L""}, + {4904, L""}, + {4905, L""}, + {4906, L""}, + {4907, L""}, + {4908, L""}, + {4909, L""}, + {4910, L""}, + {4911, L""}, + {4912, L""}, + {4913, L""}, + {4914, L""}, + {4915, L""}, + {4916, L""}, + {4917, L""}, + {4918, L""}, + {4919, L""}, + {4920, L""}, + {4921, L""}, + {4922, L""}, + {4923, L""}, + {4924, L""}, + {4925, L""}, + {4926, L""}, + {4927, L"ޤ"}, + {4928, L"ޣ"}, + {4929, L""}, + {4930, L""}, + {4931, L""}, + {4932, L""}, + {4933, L"ε"}, + {4934, L""}, + {4935, L""}, + {4936, L""}, + {4937, L""}, + {4938, L"Ǿ"}, + {4939, L""}, + {4940, L""}, + {4941, L""}, + {4942, L"ޢ"}, + {4943, L""}, + {4944, L""}, + {4945, L"ެ"}, + {4946, L"ަ"}, + {4947, L""}, + {4948, L""}, + {4949, L"ޡ"}, + {4950, L"ޥ"}, + {4951, L"ީ"}, + {4952, L"ި"}, + {4953, L"ާ"}, + {4954, L"ޭ"}, + {4955, L""}, + {4956, L"޳"}, + {4957, L"ު"}, + {4958, L"ޮ"}, + {4959, L""}, + {4960, L""}, + {4961, L"޶"}, + {4962, L"ޱ"}, + {4963, L"޲"}, + {4964, L"Ѧ"}, + {4965, L"޵"}, + {4966, L"ޯ"}, + {4967, L"ް"}, + {4968, L"н"}, + {4969, L"޴"}, + {4970, L""}, + {4971, L"޹"}, + {4972, L"޸"}, + {4973, L"޷"}, + {4974, L"޻"}, + {4975, L""}, + {4976, L""}, + {4977, L""}, + {4978, L"޺"}, + {4979, L"ź"}, + {4980, L"޼"}, + {4981, L""}, + {4982, L""}, + {4983, L""}, + {4984, L"޽"}, + {4985, L"޿"}, + {4986, L"Ģ"}, + {4987, L""}, + {4988, L"޾"}, + {4989, L""}, + {4990, L"պ"}, + {4991, L""}, + {4992, L""}, + {4993, L"²"}, + {4994, L"Ű"}, + {4995, L""}, + {4996, L""}, + {4997, L""}, + {4998, L""}, + {4999, L""}, + {5000, L""}, + {5001, L""}, + {5002, L""}, + {5003, L"ʭ"}, + {5004, L""}, + {5005, L""}, + {5006, L""}, + {5007, L""}, + {5008, L""}, + {5009, L"Ϻ"}, + {5010, L""}, + {5011, L"ʴ"}, + {5012, L""}, + {5013, L""}, + {5014, L""}, + {5015, L""}, + {5016, L""}, + {5017, L""}, + {5018, L""}, + {5019, L""}, + {5020, L""}, + {5021, L""}, + {5022, L""}, + {5023, L""}, + {5024, L""}, + {5025, L""}, + {5026, L""}, + {5027, L""}, + {5028, L""}, + {5029, L""}, + {5030, L""}, + {5031, L""}, + {5032, L""}, + {5033, L""}, + {5034, L""}, + {5035, L""}, + {5036, L""}, + {5037, L""}, + {5038, L""}, + {5039, L""}, + {5040, L""}, + {5041, L""}, + {5042, L""}, + {5043, L""}, + {5044, L""}, + {5045, L""}, + {5046, L""}, + {5047, L""}, + {5048, L""}, + {5049, L""}, + {5050, L""}, + {5051, L""}, + {5052, L""}, + {5053, L""}, + {5054, L""}, + {5055, L""}, + {5056, L""}, + {5057, L""}, + {5058, L""}, + {5059, L""}, + {5060, L""}, + {5061, L"Ӽ"}, + {5062, L""}, + {5063, L""}, + {5064, L""}, + {5065, L""}, + {5066, L""}, + {5067, L""}, + {5068, L""}, + {5069, L""}, + {5070, L""}, + {5071, L""}, + {5072, L""}, + {5073, L""}, + {5074, L""}, + {5075, L"֩"}, + {5076, L""}, + {5077, L""}, + {5078, L""}, + {5079, L""}, + {5080, L""}, + {5081, L""}, + {5082, L""}, + {5083, L""}, + {5084, L""}, + {5085, L""}, + {5086, L""}, + {5087, L""}, + {5088, L""}, + {5089, L""}, + {5090, L""}, + {5091, L"Ӭ"}, + {5092, L""}, + {5093, L""}, + {5094, L""}, + {5095, L"Ы"}, + {5096, L""}, + {5097, L""}, + {5098, L""}, + {5099, L""}, + {5100, L""}, + {5101, L""}, + {5102, L""}, + {5103, L""}, + {5104, L""}, + {5105, L""}, + {5106, L""}, + {5107, L""}, + {5108, L""}, + {5109, L""}, + {5110, L""}, + {5111, L""}, + {5112, L""}, + {5113, L""}, + {5114, L""}, + {5115, L""}, + {5116, L""}, + {5117, L""}, + {5118, L""}, + {5119, L""}, + {5120, L""}, + {5121, L""}, + {5122, L""}, + {5123, L""}, + {5124, L""}, + {5125, L""}, + {5126, L""}, + {5127, L""}, + {5128, L""}, + {5129, L""}, + {5130, L""}, + {5131, L""}, + {5132, L""}, + {5133, L""}, + {5134, L""}, + {5135, L""}, + {5136, L""}, + {5137, L""}, + {5138, L""}, + {5139, L"з"}, + {5140, L""}, + {5141, L""}, + {5142, L""}, + {5143, L""}, + {5144, L""}, + {5145, L""}, + {5146, L""}, + {5147, L""}, + {5148, L""}, + {5149, L""}, + {5150, L""}, + {5151, L"Ѫ"}, + {5152, L""}, + {5153, L""}, + {5154, L""}, + {5155, L""}, + {5156, L""}, + {5157, L""}, + {5158, L""}, + {5159, L""}, + {5160, L""}, + {5161, L""}, + {5162, L""}, + {5163, L""}, + {5164, L""}, + {5165, L""}, + {5166, L""}, + {5167, L""}, + {5168, L"˥"}, + {5169, L""}, + {5170, L""}, + {5171, L""}, + {5172, L""}, + {5173, L""}, + {5174, L"Ԭ"}, + {5175, L""}, + {5176, L""}, + {5177, L""}, + {5178, L""}, + {5179, L""}, + {5180, L""}, + {5181, L"̻"}, + {5182, L""}, + {5183, L""}, + {5184, L""}, + {5185, L""}, + {5186, L""}, + {5187, L"Ϯ"}, + {5188, L""}, + {5189, L""}, + {5190, L""}, + {5191, L""}, + {5192, L"װ"}, + {5193, L""}, + {5194, L""}, + {5195, L""}, + {5196, L""}, + {5197, L""}, + {5198, L"ԣ"}, + {5199, L""}, + {5200, L"ȹ"}, + {5201, L""}, + {5202, L""}, + {5203, L""}, + {5204, L""}, + {5205, L""}, + {5206, L""}, + {5207, L""}, + {5208, L""}, + {5209, L""}, + {5210, L""}, + {5211, L""}, + {5212, L""}, + {5213, L""}, + {5214, L""}, + {5215, L""}, + {5216, L""}, + {5217, L""}, + {5218, L""}, + {5219, L""}, + {5220, L""}, + {5221, L""}, + {5222, L""}, + {5223, L""}, + {5224, L""}, + {5225, L""}, + {5226, L""}, + {5227, L""}, + {5228, L""}, + {5229, L""}, + {5230, L""}, + {5231, L""}, + {5232, L""}, + {5233, L""}, + {5234, L""}, + {5235, L""}, + {5236, L""}, + {5237, L"Ҫ"}, + {5238, L""}, + {5239, L""}, + {5240, L""}, + {5241, L""}, + {5242, L""}, + {5243, L""}, + {5244, L""}, + {5245, L""}, + {5246, L""}, + {5247, L""}, + {5248, L""}, + {5249, L""}, + {5250, L""}, + {5251, L""}, + {5252, L""}, + {5253, L""}, + {5254, L""}, + {5255, L""}, + {5256, L""}, + {5257, L""}, + {5258, L""}, + {5259, L""}, + {5260, L""}, + {5261, L""}, + {5262, L""}, + {5263, L""}, + {5264, L""}, + {5265, L""}, + {5266, L""}, + {5267, L""}, + {5268, L""}, + {5269, L""}, + {5270, L"ղ"}, + {5271, L""}, + {5272, L""}, + {5273, L""}, + {5274, L""}, + {5275, L""}, + {5276, L"Ʃ"}, + {5277, L""}, + {5278, L""}, + {5279, L""}, + {5280, L""}, + {5281, L""}, + {5282, L"ڦ"}, + {5283, L"ڧ"}, + {5284, L""}, + {5285, L""}, + {5286, L"ڨ"}, + {5287, L""}, + {5288, L"ѵ"}, + {5289, L""}, + {5290, L"Ѷ"}, + {5291, L""}, + {5292, L""}, + {5293, L""}, + {5294, L"ک"}, + {5295, L"ڪ"}, + {5296, L""}, + {5297, L"ګ"}, + {5298, L""}, + {5299, L""}, + {5300, L""}, + {5301, L""}, + {5302, L""}, + {5303, L""}, + {5304, L""}, + {5305, L""}, + {5306, L"֤"}, + {5307, L"ڬ"}, + {5308, L"ڭ"}, + {5309, L""}, + {5310, L""}, + {5311, L"ʶ"}, + {5312, L"թ"}, + {5313, L""}, + {5314, L""}, + {5315, L"ڮ"}, + {5316, L""}, + {5317, L""}, + {5318, L"ڰ"}, + {5319, L"گ"}, + {5320, L""}, + {5321, L"ڱ"}, + {5322, L"ڲ"}, + {5323, L"ڳ"}, + {5324, L""}, + {5325, L"ڴ"}, + {5326, L"ʫ"}, + {5327, L"ڵ"}, + {5328, L"ڶ"}, + {5329, L""}, + {5330, L""}, + {5331, L"ڷ"}, + {5332, L""}, + {5333, L""}, + {5334, L"ڸ"}, + {5335, L"ڹ"}, + {5336, L""}, + {5337, L"ѯ"}, + {5338, L""}, + {5339, L"ں"}, + {5340, L""}, + {5341, L""}, + {5342, L""}, + {5343, L"ڻ"}, + {5344, L"ڼ"}, + {5345, L""}, + {5346, L""}, + {5347, L""}, + {5348, L"ڽ"}, + {5349, L""}, + {5350, L"ھ"}, + {5351, L""}, + {5352, L""}, + {5353, L"ڿ"}, + {5354, L"˵"}, + {5355, L""}, + {5356, L""}, + {5357, L""}, + {5358, L""}, + {5359, L"ŵ"}, + {5360, L""}, + {5361, L""}, + {5362, L""}, + {5363, L""}, + {5364, L""}, + {5365, L""}, + {5366, L"˭"}, + {5367, L""}, + {5368, L""}, + {5369, L""}, + {5370, L""}, + {5371, L"׻"}, + {5372, L""}, + {5373, L"̸"}, + {5374, L""}, + {5375, L"ı"}, + {5376, L""}, + {5377, L""}, + {5378, L""}, + {5379, L""}, + {5380, L"г"}, + {5381, L""}, + {5382, L""}, + {5383, L"ν"}, + {5384, L""}, + {5385, L""}, + {5386, L""}, + {5387, L""}, + {5388, L""}, + {5389, L""}, + {5390, L""}, + {5391, L""}, + {5392, L""}, + {5393, L""}, + {5394, L""}, + {5395, L""}, + {5396, L"л"}, + {5397, L"ҥ"}, + {5398, L""}, + {5399, L""}, + {5400, L"ǫ"}, + {5401, L""}, + {5402, L""}, + {5403, L"á"}, + {5404, L""}, + {5405, L""}, + {5406, L""}, + {5407, L"̷"}, + {5408, L""}, + {5409, L""}, + {5410, L""}, + {5411, L""}, + {5412, L""}, + {5413, L""}, + {5414, L"Ǵ"}, + {5415, L""}, + {5416, L""}, + {5417, L""}, + {5418, L""}, + {5419, L""}, + {5420, L""}, + {5421, L""}, + {5422, L""}, + {5423, L""}, + {5424, L""}, + {5425, L""}, + {5426, L""}, + {5427, L""}, + {5428, L"ԥ"}, + {5429, L""}, + {5430, L""}, + {5431, L""}, + {5432, L""}, + {5433, L""}, + {5434, L""}, + {5435, L""}, + {5436, L""}, + {5437, L"ò"}, + {5438, L""}, + {5439, L""}, + {5440, L""}, + {5441, L""}, + {5442, L""}, + {5443, L""}, + {5444, L""}, + {5445, L""}, + {5446, L""}, + {5447, L""}, + {5448, L""}, + {5449, L""}, + {5450, L""}, + {5451, L""}, + {5452, L"̰"}, + {5453, L"ƶ"}, + {5454, L""}, + {5455, L""}, + {5456, L""}, + {5457, L""}, + {5458, L""}, + {5459, L""}, + {5460, L""}, + {5461, L""}, + {5462, L""}, + {5463, L""}, + {5464, L""}, + {5465, L""}, + {5466, L"ó"}, + {5467, L""}, + {5468, L""}, + {5469, L""}, + {5470, L""}, + {5471, L""}, + {5472, L""}, + {5473, L""}, + {5474, L""}, + {5475, L""}, + {5476, L"¸"}, + {5477, L""}, + {5478, L""}, + {5479, L""}, + {5480, L""}, + {5481, L""}, + {5482, L""}, + {5483, L""}, + {5484, L""}, + {5485, L""}, + {5486, L""}, + {5487, L""}, + {5488, L""}, + {5489, L""}, + {5490, L""}, + {5491, L""}, + {5492, L""}, + {5493, L""}, + {5494, L"׸"}, + {5495, L""}, + {5496, L"׬"}, + {5497, L""}, + {5498, L""}, + {5499, L""}, + {5500, L""}, + {5501, L""}, + {5502, L""}, + {5503, L"Ӯ"}, + {5504, L""}, + {5505, L""}, + {5506, L""}, + {5507, L""}, + {5508, L""}, + {5509, L""}, + {5510, L""}, + {5511, L""}, + {5512, L""}, + {5513, L""}, + {5514, L""}, + {5515, L""}, + {5516, L""}, + {5517, L""}, + {5518, L""}, + {5519, L"Խ"}, + {5520, L""}, + {5521, L""}, + {5522, L""}, + {5523, L""}, + {5524, L"Ȥ"}, + {5525, L""}, + {5526, L""}, + {5527, L"ſ"}, + {5528, L""}, + {5529, L""}, + {5530, L""}, + {5531, L""}, + {5532, L"ֺ"}, + {5533, L""}, + {5534, L"Ծ"}, + {5535, L""}, + {5536, L""}, + {5537, L""}, + {5538, L""}, + {5539, L""}, + {5540, L""}, + {5541, L""}, + {5542, L""}, + {5543, L""}, + {5544, L""}, + {5545, L""}, + {5546, L""}, + {5547, L""}, + {5548, L""}, + {5549, L""}, + {5550, L""}, + {5551, L""}, + {5552, L""}, + {5553, L""}, + {5554, L"·"}, + {5555, L""}, + {5556, L""}, + {5557, L""}, + {5558, L""}, + {5559, L""}, + {5560, L""}, + {5561, L""}, + {5562, L""}, + {5563, L""}, + {5564, L""}, + {5565, L"ӻ"}, + {5566, L""}, + {5567, L"̤"}, + {5568, L""}, + {5569, L""}, + {5570, L""}, + {5571, L""}, + {5572, L""}, + {5573, L""}, + {5574, L""}, + {5575, L""}, + {5576, L""}, + {5577, L""}, + {5578, L""}, + {5579, L""}, + {5580, L""}, + {5581, L""}, + {5582, L""}, + {5583, L""}, + {5584, L""}, + {5585, L""}, + {5586, L""}, + {5587, L""}, + {5588, L""}, + {5589, L""}, + {5590, L""}, + {5591, L""}, + {5592, L"̣"}, + {5593, L""}, + {5594, L""}, + {5595, L""}, + {5596, L""}, + {5597, L""}, + {5598, L""}, + {5599, L""}, + {5600, L""}, + {5601, L""}, + {5602, L""}, + {5603, L""}, + {5604, L""}, + {5605, L""}, + {5606, L""}, + {5607, L""}, + {5608, L""}, + {5609, L""}, + {5610, L""}, + {5611, L""}, + {5612, L""}, + {5613, L""}, + {5614, L""}, + {5615, L""}, + {5616, L""}, + {5617, L""}, + {5618, L""}, + {5619, L""}, + {5620, L""}, + {5621, L""}, + {5622, L""}, + {5623, L""}, + {5624, L""}, + {5625, L"ת"}, + {5626, L""}, + {5627, L""}, + {5628, L""}, + {5629, L""}, + {5630, L""}, + {5631, L""}, + {5632, L""}, + {5633, L""}, + {5634, L""}, + {5635, L""}, + {5636, L""}, + {5637, L""}, + {5638, L""}, + {5639, L""}, + {5640, L""}, + {5641, L""}, + {5642, L""}, + {5643, L""}, + {5644, L""}, + {5645, L""}, + {5646, L""}, + {5647, L""}, + {5648, L""}, + {5649, L""}, + {5650, L""}, + {5651, L""}, + {5652, L""}, + {5653, L""}, + {5654, L""}, + {5655, L""}, + {5656, L""}, + {5657, L""}, + {5658, L""}, + {5659, L""}, + {5660, L""}, + {5661, L""}, + {5662, L"ԯ"}, + {5663, L"Ͻ"}, + {5664, L"շ"}, + {5665, L""}, + {5666, L""}, + {5667, L""}, + {5668, L""}, + {5669, L""}, + {5670, L""}, + {5671, L""}, + {5672, L""}, + {5673, L""}, + {5674, L""}, + {5675, L""}, + {5676, L""}, + {5677, L""}, + {5678, L""}, + {5679, L""}, + {5680, L""}, + {5681, L"Ǩ"}, + {5682, L""}, + {5683, L""}, + {5684, L"Ѹ"}, + {5685, L""}, + {5686, L""}, + {5687, L"ӭ"}, + {5688, L""}, + {5689, L""}, + {5690, L""}, + {5691, L""}, + {5692, L""}, + {5693, L""}, + {5694, L""}, + {5695, L""}, + {5696, L"Զ"}, + {5697, L"Υ"}, + {5698, L""}, + {5699, L""}, + {5700, L""}, + {5701, L""}, + {5702, L""}, + {5703, L""}, + {5704, L""}, + {5705, L""}, + {5706, L""}, + {5707, L""}, + {5708, L""}, + {5709, L""}, + {5710, L""}, + {5711, L""}, + {5712, L""}, + {5713, L""}, + {5714, L"׷"}, + {5715, L""}, + {5716, L""}, + {5717, L""}, + {5718, L""}, + {5719, L""}, + {5720, L""}, + {5721, L""}, + {5722, L"ѡ"}, + {5723, L"ѷ"}, + {5724, L""}, + {5725, L""}, + {5726, L"͸"}, + {5727, L""}, + {5728, L""}, + {5729, L""}, + {5730, L";"}, + {5731, L""}, + {5732, L""}, + {5733, L"ͨ"}, + {5734, L""}, + {5735, L""}, + {5736, L""}, + {5737, L""}, + {5738, L""}, + {5739, L""}, + {5740, L""}, + {5741, L""}, + {5742, L""}, + {5743, L""}, + {5744, L""}, + {5745, L""}, + {5746, L""}, + {5747, L""}, + {5748, L""}, + {5749, L""}, + {5750, L""}, + {5751, L""}, + {5752, L""}, + {5753, L""}, + {5754, L""}, + {5755, L""}, + {5756, L""}, + {5757, L""}, + {5758, L""}, + {5759, L""}, + {5760, L""}, + {5761, L""}, + {5762, L""}, + {5763, L""}, + {5764, L""}, + {5765, L"Dz"}, + {5766, L"ң"}, + {5767, L""}, + {5768, L""}, + {5769, L""}, + {5770, L""}, + {5771, L""}, + {5772, L""}, + {5773, L""}, + {5774, L""}, + {5775, L""}, + {5776, L""}, + {5777, L""}, + {5778, L""}, + {5779, L""}, + {5780, L""}, + {5781, L""}, + {5782, L""}, + {5783, L""}, + {5784, L""}, + {5785, L""}, + {5786, L""}, + {5787, L""}, + {5788, L""}, + {5789, L""}, + {5790, L"а"}, + {5791, L""}, + {5792, L""}, + {5793, L""}, + {5794, L"ۢ"}, + {5795, L""}, + {5796, L""}, + {5797, L""}, + {5798, L""}, + {5799, L""}, + {5800, L"ۡ"}, + {5801, L""}, + {5802, L""}, + {5803, L""}, + {5804, L"ۥ"}, + {5805, L""}, + {5806, L"ۧ"}, + {5807, L"ۤ"}, + {5808, L"ۨ"}, + {5809, L""}, + {5810, L""}, + {5811, L"ۣ"}, + {5812, L"ۦ"}, + {5813, L"֣"}, + {5814, L"۩"}, + {5815, L"ۭ"}, + {5816, L"ۮ"}, + {5817, L"۬"}, + {5818, L""}, + {5819, L""}, + {5820, L"۫"}, + {5821, L"۪"}, + {5822, L""}, + {5823, L""}, + {5824, L"ۯ"}, + {5825, L""}, + {5826, L"۰"}, + {5827, L""}, + {5828, L""}, + {5829, L""}, + {5830, L"۱"}, + {5831, L""}, + {5832, L"۲"}, + {5833, L""}, + {5834, L"۴"}, + {5835, L"۳"}, + {5836, L"۵"}, + {5837, L"۷"}, + {5838, L"۶"}, + {5839, L"۸"}, + {5840, L"۹"}, + {5841, L"ۺ"}, + {5842, L""}, + {5843, L""}, + {5844, L""}, + {5845, L""}, + {5846, L""}, + {5847, L""}, + {5848, L""}, + {5849, L""}, + {5850, L""}, + {5851, L""}, + {5852, L""}, + {5853, L""}, + {5854, L"̪"}, + {5855, L""}, + {5856, L""}, + {5857, L""}, + {5858, L""}, + {5859, L""}, + {5860, L""}, + {5861, L""}, + {5862, L""}, + {5863, L"ͪ"}, + {5864, L""}, + {5865, L""}, + {5866, L""}, + {5867, L""}, + {5868, L""}, + {5869, L""}, + {5870, L"ø"}, + {5871, L""}, + {5872, L""}, + {5873, L""}, + {5874, L""}, + {5875, L""}, + {5876, L""}, + {5877, L""}, + {5878, L""}, + {5879, L""}, + {5880, L""}, + {5881, L""}, + {5882, L""}, + {5883, L""}, + {5884, L""}, + {5885, L""}, + {5886, L""}, + {5887, L"ȩ"}, + {5888, L""}, + {5889, L""}, + {5890, L""}, + {5891, L""}, + {5892, L""}, + {5893, L""}, + {5894, L""}, + {5895, L""}, + {5896, L""}, + {5897, L""}, + {5898, L""}, + {5899, L""}, + {5900, L""}, + {5901, L"Ұ"}, + {5902, L""}, + {5903, L""}, + {5904, L""}, + {5905, L""}, + {5906, L""}, + {5907, L""}, + {5908, L""}, + {5909, L""}, + {5910, L""}, + {5911, L""}, + {5912, L""}, + {5913, L""}, + {5914, L""}, + {5915, L""}, + {5916, L""}, + {5917, L""}, + {5918, L""}, + {5919, L""}, + {5920, L""}, + {5921, L""}, + {5922, L""}, + {5923, L""}, + {5924, L"ǥ"}, + {5925, L""}, + {5926, L""}, + {5927, L""}, + {5928, L""}, + {5929, L""}, + {5930, L""}, + {5931, L""}, + {5932, L""}, + {5933, L""}, + {5934, L""}, + {5935, L""}, + {5936, L""}, + {5937, L""}, + {5938, L""}, + {5939, L""}, + {5940, L""}, + {5941, L""}, + {5942, L""}, + {5943, L""}, + {5944, L"Կ"}, + {5945, L""}, + {5946, L""}, + {5947, L""}, + {5948, L""}, + {5949, L""}, + {5950, L""}, + {5951, L""}, + {5952, L""}, + {5953, L"ť"}, + {5954, L""}, + {5955, L""}, + {5956, L"Ǯ"}, + {5957, L""}, + {5958, L"ǯ"}, + {5959, L""}, + {5960, L""}, + {5961, L""}, + {5962, L""}, + {5963, L""}, + {5964, L""}, + {5965, L""}, + {5966, L""}, + {5967, L""}, + {5968, L""}, + {5969, L""}, + {5970, L""}, + {5971, L""}, + {5972, L""}, + {5973, L""}, + {5974, L"Ǧ"}, + {5975, L"í"}, + {5976, L""}, + {5977, L""}, + {5978, L""}, + {5979, L""}, + {5980, L""}, + {5981, L""}, + {5982, L""}, + {5983, L""}, + {5984, L""}, + {5985, L""}, + {5986, L""}, + {5987, L""}, + {5988, L""}, + {5989, L""}, + {5990, L""}, + {5991, L"ͭ"}, + {5992, L""}, + {5993, L""}, + {5994, L""}, + {5995, L""}, + {5996, L"ա"}, + {5997, L""}, + {5998, L"ϳ"}, + {5999, L""}, + {6000, L""}, + {6001, L""}, + {6002, L""}, + {6003, L""}, + {6004, L""}, + {6005, L""}, + {6006, L""}, + {6007, L""}, + {6008, L""}, + {6009, L""}, + {6010, L""}, + {6011, L"ҿ"}, + {6012, L""}, + {6013, L""}, + {6014, L""}, + {6015, L""}, + {6016, L""}, + {6017, L""}, + {6018, L""}, + {6019, L""}, + {6020, L""}, + {6021, L""}, + {6022, L""}, + {6023, L""}, + {6024, L""}, + {6025, L""}, + {6026, L""}, + {6027, L""}, + {6028, L""}, + {6029, L""}, + {6030, L""}, + {6031, L""}, + {6032, L""}, + {6033, L""}, + {6034, L""}, + {6035, L""}, + {6036, L""}, + {6037, L"п"}, + {6038, L""}, + {6039, L""}, + {6040, L""}, + {6041, L""}, + {6042, L""}, + {6043, L""}, + {6044, L""}, + {6045, L""}, + {6046, L""}, + {6047, L""}, + {6048, L""}, + {6049, L""}, + {6050, L"ê"}, + {6051, L""}, + {6052, L""}, + {6053, L""}, + {6054, L""}, + {6055, L""}, + {6056, L""}, + {6057, L""}, + {6058, L""}, + {6059, L"׶"}, + {6060, L""}, + {6061, L""}, + {6062, L""}, + {6063, L""}, + {6064, L""}, + {6065, L""}, + {6066, L""}, + {6067, L""}, + {6068, L""}, + {6069, L""}, + {6070, L""}, + {6071, L""}, + {6072, L""}, + {6073, L""}, + {6074, L""}, + {6075, L""}, + {6076, L""}, + {6077, L""}, + {6078, L""}, + {6079, L""}, + {6080, L""}, + {6081, L""}, + {6082, L""}, + {6083, L"þ"}, + {6084, L""}, + {6085, L""}, + {6086, L""}, + {6087, L""}, + {6088, L""}, + {6089, L""}, + {6090, L""}, + {6091, L""}, + {6092, L""}, + {6093, L""}, + {6094, L""}, + {6095, L""}, + {6096, L""}, + {6097, L""}, + {6098, L""}, + {6099, L""}, + {6100, L""}, + {6101, L""}, + {6102, L""}, + {6103, L""}, + {6104, L""}, + {6105, L""}, + {6106, L""}, + {6107, L""}, + {6108, L""}, + {6109, L""}, + {6110, L""}, + {6111, L""}, + {6112, L""}, + {6113, L""}, + {6114, L""}, + {6115, L""}, + {6116, L""}, + {6117, L""}, + {6118, L""}, + {6119, L""}, + {6120, L""}, + {6121, L""}, + {6122, L""}, + {6123, L""}, + {6124, L""}, + {6125, L""}, + {6126, L""}, + {6127, L""}, + {6128, L""}, + {6129, L""}, + {6130, L""}, + {6131, L""}, + {6132, L""}, + {6133, L""}, + {6134, L""}, + {6135, L""}, + {6136, L""}, + {6137, L""}, + {6138, L""}, + {6139, L""}, + {6140, L""}, + {6141, L""}, + {6142, L"բ"}, + {6143, L""}, + {6144, L""}, + {6145, L""}, + {6146, L""}, + {6147, L""}, + {6148, L""}, + {6149, L""}, + {6150, L""}, + {6151, L""}, + {6152, L""}, + {6153, L""}, + {6154, L""}, + {6155, L""}, + {6156, L""}, + {6157, L""}, + {6158, L""}, + {6159, L""}, + {6160, L""}, + {6161, L""}, + {6162, L""}, + {6163, L""}, + {6164, L""}, + {6165, L""}, + {6166, L""}, + {6167, L""}, + {6168, L""}, + {6169, L""}, + {6170, L""}, + {6171, L""}, + {6172, L""}, + {6173, L""}, + {6174, L""}, + {6175, L""}, + {6176, L""}, + {6177, L""}, + {6178, L""}, + {6179, L""}, + {6180, L""}, + {6181, L""}, + {6182, L""}, + {6183, L""}, + {6184, L""}, + {6185, L""}, + {6186, L""}, + {6187, L""}, + {6188, L""}, + {6189, L""}, + {6190, L""}, + {6191, L""}, + {6192, L""}, + {6193, L"½"}, + {6194, L"¤"}, + {6195, L""}, + {6196, L""}, + {6197, L"ª"}, + {6198, L"İ"}, + {6199, L""}, + {6200, L""}, + {6201, L""}, + {6202, L""}, + {6203, L""}, + {6204, L""}, + {6205, L""}, + {6206, L"Ժ"}, + {6207, L""}, + {6208, L""}, + {6209, L""}, + {6210, L""}, + {6211, L""}, + {6212, L""}, + {6213, L""}, + {6214, L""}, + {6215, L""}, + {6216, L""}, + {6217, L""}, + {6218, L""}, + {6219, L"¡"}, + {6220, L""}, + {6221, L""}, + {6222, L""}, + {6223, L""}, + {6224, L""}, + {6225, L""}, + {6226, L""}, + {6227, L""}, + {6228, L"϶"}, + {6229, L""}, + {6230, L""}, + {6231, L""}, + {6232, L""}, + {6233, L""}, + {6234, L""}, + {6235, L""}, + {6236, L""}, + {6237, L"ȸ"}, + {6238, L""}, + {6239, L""}, + {6240, L""}, + {6241, L""}, + {6242, L""}, + {6243, L""}, + {6244, L""}, + {6245, L"Ӻ"}, + {6246, L""}, + {6247, L""}, + {6248, L""}, + {6249, L""}, + {6250, L""}, + {6251, L""}, + {6252, L""}, + {6253, L"ѩ"}, + {6254, L""}, + {6255, L""}, + {6256, L""}, + {6257, L""}, + {6258, L""}, + {6259, L""}, + {6260, L""}, + {6261, L""}, + {6262, L""}, + {6263, L""}, + {6264, L""}, + {6265, L""}, + {6266, L"ù"}, + {6267, L""}, + {6268, L""}, + {6269, L""}, + {6270, L""}, + {6271, L""}, + {6272, L"˪"}, + {6273, L"ϼ"}, + {6274, L""}, + {6275, L""}, + {6276, L""}, + {6277, L"¶"}, + {6278, L""}, + {6279, L""}, + {6280, L""}, + {6281, L""}, + {6282, L""}, + {6283, L""}, + {6284, L""}, + {6285, L""}, + {6286, L""}, + {6287, L""}, + {6288, L""}, + {6289, L""}, + {6290, L""}, + {6291, L""}, + {6292, L""}, + {6293, L"ѥ"}, + {6294, L""}, + {6295, L""}, + {6296, L""}, + {6297, L"Ь"}, + {6298, L""}, + {6299, L""}, + {6300, L""}, + {6301, L""}, + {6302, L""}, + {6303, L""}, + {6304, L""}, + {6305, L""}, + {6306, L""}, + {6307, L""}, + {6308, L""}, + {6309, L"Τ"}, + {6310, L""}, + {6311, L""}, + {6312, L""}, + {6313, L""}, + {6314, L""}, + {6315, L""}, + {6316, L""}, + {6317, L""}, + {6318, L""}, + {6319, L"ҳ"}, + {6320, L""}, + {6321, L""}, + {6322, L""}, + {6323, L""}, + {6324, L"˳"}, + {6325, L""}, + {6326, L""}, + {6327, L""}, + {6328, L""}, + {6329, L""}, + {6330, L""}, + {6331, L""}, + {6332, L""}, + {6333, L""}, + {6334, L"Ԥ"}, + {6335, L"­"}, + {6336, L""}, + {6337, L""}, + {6338, L""}, + {6339, L""}, + {6340, L""}, + {6341, L""}, + {6342, L""}, + {6343, L""}, + {6344, L""}, + {6345, L"Ƶ"}, + {6346, L""}, + {6347, L""}, + {6348, L"ӱ"}, + {6349, L""}, + {6350, L""}, + {6351, L""}, + {6352, L""}, + {6353, L""}, + {6354, L""}, + {6355, L""}, + {6356, L""}, + {6357, L""}, + {6358, L""}, + {6359, L""}, + {6360, L""}, + {6361, L""}, + {6362, L""}, + {6363, L"ȧ"}, + {6364, L""}, + {6365, L""}, + {6366, L""}, + {6367, L""}, + {6368, L""}, + {6369, L"Ʈ"}, + {6370, L""}, + {6371, L""}, + {6372, L""}, + {6373, L"ʳ"}, + {6374, L""}, + {6375, L""}, + {6376, L""}, + {6377, L""}, + {6378, L""}, + {6379, L""}, + {6380, L""}, + {6381, L""}, + {6382, L""}, + {6383, L""}, + {6384, L""}, + {6385, L""}, + {6386, L""}, + {6387, L""}, + {6388, L""}, + {6389, L""}, + {6390, L""}, + {6391, L""}, + {6392, L""}, + {6393, L""}, + {6394, L""}, + {6395, L""}, + {6396, L""}, + {6397, L""}, + {6398, L""}, + {6399, L""}, + {6400, L""}, + {6401, L""}, + {6402, L""}, + {6403, L""}, + {6404, L""}, + {6405, L""}, + {6406, L""}, + {6407, L""}, + {6408, L""}, + {6409, L""}, + {6410, L""}, + {6411, L""}, + {6412, L""}, + {6413, L""}, + {6414, L""}, + {6415, L""}, + {6416, L""}, + {6417, L""}, + {6418, L""}, + {6419, L""}, + {6420, L"ظ"}, + {6421, L""}, + {6422, L""}, + {6423, L""}, + {6424, L"ܰ"}, + {6425, L""}, + {6426, L"Ԧ"}, + {6427, L""}, + {6428, L"ѱ"}, + {6429, L""}, + {6430, L""}, + {6431, L""}, + {6432, L"¿"}, + {6433, L""}, + {6434, L"ʻ"}, + {6435, L""}, + {6436, L""}, + {6437, L""}, + {6438, L""}, + {6439, L"פ"}, + {6440, L""}, + {6441, L""}, + {6442, L""}, + {6443, L""}, + {6444, L""}, + {6445, L""}, + {6446, L""}, + {6447, L""}, + {6448, L""}, + {6449, L""}, + {6450, L""}, + {6451, L""}, + {6452, L""}, + {6453, L""}, + {6454, L""}, + {6455, L""}, + {6456, L""}, + {6457, L""}, + {6458, L""}, + {6459, L""}, + {6460, L""}, + {6461, L"ƭ"}, + {6462, L""}, + {6463, L"ɧ"}, + {6464, L""}, + {6465, L""}, + {6466, L""}, + {6467, L""}, + {6468, L""}, + {6469, L""}, + {6470, L""}, + {6471, L""}, + {6472, L""}, + {6473, L""}, + {6474, L""}, + {6475, L""}, + {6476, L""}, + {6477, L""}, + {6478, L""}, + {6479, L""}, + {6480, L""}, + {6481, L""}, + {6482, L""}, + {6483, L""}, + {6484, L""}, + {6485, L""}, + {6486, L""}, + {6487, L""}, + {6488, L""}, + {6489, L""}, + {6490, L""}, + {6491, L""}, + {6492, L""}, + {6493, L""}, + {6494, L""}, + {6495, L""}, + {6496, L""}, + {6497, L""}, + {6498, L""}, + {6499, L""}, + {6500, L""}, + {6501, L""}, + {6502, L""}, + {6503, L""}, + {6504, L""}, + {6505, L""}, + {6506, L"ت"}, + {6507, L""}, + {6508, L""}, + {6509, L""}, + {6510, L""}, + {6511, L""}, + {6512, L""}, + {6513, L""}, + {6514, L""}, + {6515, L""}, + {6516, L""}, + {6517, L""}, + {6518, L"κ"}, + {6519, L""}, + {6520, L"ħ"}, + {6521, L""}, + {6522, L""}, + {6523, L"³"}, + {6524, L""}, + {6525, L""}, + {6526, L""}, + {6527, L""}, + {6528, L""}, + {6529, L""}, + {6530, L""}, + {6531, L""}, + {6532, L""}, + {6533, L""}, + {6534, L""}, + {6535, L""}, + {6536, L""}, + {6537, L""}, + {6538, L""}, + {6539, L""}, + {6540, L""}, + {6541, L""}, + {6542, L""}, + {6543, L""}, + {6544, L""}, + {6545, L""}, + {6546, L""}, + {6547, L""}, + {6548, L""}, + {6549, L""}, + {6550, L""}, + {6551, L""}, + {6552, L""}, + {6553, L""}, + {6554, L""}, + {6555, L""}, + {6556, L""}, + {6557, L""}, + {6558, L""}, + {6559, L""}, + {6560, L""}, + {6561, L""}, + {6562, L""}, + {6563, L""}, + {6564, L""}, + {6565, L""}, + {6566, L""}, + {6567, L""}, + {6568, L""}, + {6569, L""}, + {6570, L""}, + {6571, L""}, + {6572, L""}, + {6573, L""}, + {6574, L""}, + {6575, L""}, + {6576, L""}, + {6577, L""}, + {6578, L""}, + {6579, L""}, + {6580, L""}, + {6581, L""}, + {6582, L""}, + {6583, L""}, + {6584, L""}, + {6585, L""}, + {6586, L""}, + {6587, L""}, + {6588, L""}, + {6589, L""}, + {6590, L""}, + {6591, L""}, + {6592, L""}, + {6593, L"Ÿ"}, + {6594, L"ѻ"}, + {6595, L""}, + {6596, L""}, + {6597, L""}, + {6598, L""}, + {6599, L""}, + {6600, L"Ѽ"}, + {6601, L""}, + {6602, L""}, + {6603, L""}, + {6604, L"ԧ"}, + {6605, L""}, + {6606, L""}, + {6607, L""}, + {6608, L""}, + {6609, L""}, + {6610, L""}, + {6611, L""}, + {6612, L""}, + {6613, L""}, + {6614, L""}, + {6615, L""}, + {6616, L""}, + {6617, L""}, + {6618, L""}, + {6619, L""}, + {6620, L""}, + {6621, L""}, + {6622, L""}, + {6623, L"ȵ"}, + {6624, L""}, + {6625, L""}, + {6626, L""}, + {6627, L""}, + {6628, L""}, + {6629, L""}, + {6630, L""}, + {6631, L""}, + {6632, L""}, + {6633, L""}, + {6634, L""}, + {6635, L""}, + {6636, L""}, + {6637, L""}, + {6638, L""}, + {6639, L""}, + {6640, L""}, + {6641, L""}, + {6642, L""}, + {6643, L""}, + {6644, L""}, + {6645, L""}, + {6646, L"ӥ"}, + {6647, L""}, + {6648, L""}, + {6649, L"¹"}, + {6650, L""}, + {6651, L""}, + {6652, L""}, + {6653, L""}, + {6654, L""}, + {6655, L"´"}, + {6656, L""}, + {6657, L""}, + {6658, L""}, + {6659, L""}, + {6660, L""}, + {6661, L""}, + {6662, L""}, + {6663, L""}, + {6664, L""}, + {6665, L""}, + {6666, L""}, + {6667, L""}, + {6668, L""}, + {6669, L"ǭ"}, + {6670, L"Ĭ"}, + {6671, L""}, + {6672, L""}, + {6673, L""}, + {6674, L""}, + {6675, L""}, + {6676, L""}, + {6677, L""}, + {6678, L""}, + {6679, L""}, + {6680, L""}, + {6681, L""}, + {6682, L""}, + {6683, L""}, + {6684, L""}, + {6685, L""}, + {6686, L""}, + {6687, L""}, + {6688, L"ؾ"}, + {6689, L""}, + {6690, L"ػ"}, + {6691, L"ܱ"}, + {6692, L""}, + {6693, L""}, + {6694, L""}, + {6695, L""}, + {6696, L""}, + {6697, L""}, + {6698, L""}, + {6699, L""}, + {6700, L""}, + {6701, L""}, + {6702, L""}, + {6703, L""}, + {6704, L""}, + {6705, L""}, + {6706, L""}, + {6707, L""}, + {6708, L""}, + {6709, L""}, + {6710, L""}, + {6711, L""}, + {6712, L"ȣ"}, + {6713, L""}, + {6714, L""}, + {6715, L""}, + {6716, L""}, + {6717, L""}, + {6718, L""} +}; + +std::wstring uns::OCRCharset::GetChar(int index) +{ + if (index == 0) + return L""; + std::map* charset_ptr = nullptr; + switch (G_OCRConfig.GetLanguage()) + { + case easyocr::CharsetType::EN: + charset_ptr = &en_charmap; + break; + case easyocr::CharsetType::EN_CH: + charset_ptr = &ch_en_charmap; + break; + } + if ((charset_ptr == nullptr)) + return L""; + if (charset_ptr->find(index) == charset_ptr->end()) + return L""; + return (*charset_ptr)[index]; +} + +std::wstring uns::OCRCharset::GetString(const std::vector& indexs) +{ + std::map* charset_ptr = nullptr; + switch (G_OCRConfig.GetLanguage()) + { + case easyocr::CharsetType::EN: + charset_ptr = &en_charmap; + break; + case easyocr::CharsetType::EN_CH: + charset_ptr = &ch_en_charmap; + break; + } + if ((charset_ptr == nullptr)) + return L""; + std::wstring result; + for (const auto& index : indexs) + { + if (charset_ptr->find(index) == charset_ptr->end()) + continue; + if (index == 0) //Ignore 0 (Invalidate Value) + continue; + result += (*charset_ptr)[index]; + } + return result; +} diff --git a/LibEasyOCR-CPP/OCRCharset.h b/LibEasyOCR-CPP/OCRCharset.h new file mode 100644 index 0000000..7e35370 --- /dev/null +++ b/LibEasyOCR-CPP/OCRCharset.h @@ -0,0 +1,22 @@ +#pragma once +#include +#include +#include + +namespace uns +{ + class OCRCharset + { + private: + static std::map en_charmap; + static std::map ch_en_charmap; + + public: + OCRCharset() = delete; + OCRCharset(const OCRCharset&) = delete; + + public: + static std::wstring GetChar(int index); + static std::wstring GetString(const std::vector& indexs); + }; +} \ No newline at end of file diff --git a/LibEasyOCR-CPP/OCRConfig.cpp b/LibEasyOCR-CPP/OCRConfig.cpp new file mode 100644 index 0000000..b2c4f05 --- /dev/null +++ b/LibEasyOCR-CPP/OCRConfig.cpp @@ -0,0 +1,58 @@ +#include "pch.h" +#include "OCRConfig.h" + +uns::OCRConfig uns::G_OCRConfig; + +uns::OCRConfig::OCRConfig() +{ + language = easyocr::CharsetType::EN; + gpu_usage = easyocr::GPUUsage::PreferGPU; +} + +uns::OCRConfig::OCRConfig(const std::wstring& detect_model, const std::wstring& reco_model, easyocr::CharsetType language, easyocr::GPUUsage gpu) +{ + gpu_usage = gpu; + this->language = language; + detect_model_path = detect_model; + recognize_model_path = reco_model; +} + +uns::easyocr::GPUUsage uns::OCRConfig::GetGPUUsage() const +{ + return gpu_usage; +} + +uns::easyocr::CharsetType uns::OCRConfig::GetLanguage() const +{ + return language; +} + +std::wstring uns::OCRConfig::GetDetectModelPath() const +{ + return detect_model_path; +} + +std::wstring uns::OCRConfig::GetRecognizeModelPath() const +{ + return recognize_model_path; +} + +void uns::OCRConfig::SetGPUUsage(easyocr::GPUUsage usage) +{ + gpu_usage = usage; +} + +void uns::OCRConfig::SetLanguage(easyocr::CharsetType type) +{ + language = type; +} + +void uns::OCRConfig::SetDetectModelPath(const std::wstring& path) +{ + detect_model_path = path; +} + +void uns::OCRConfig::SetRecognizeModelPath(const std::wstring& path) +{ + recognize_model_path = path; +} diff --git a/LibEasyOCR-CPP/OCRConfig.h b/LibEasyOCR-CPP/OCRConfig.h new file mode 100644 index 0000000..fb9b46a --- /dev/null +++ b/LibEasyOCR-CPP/OCRConfig.h @@ -0,0 +1,51 @@ +#pragma once +#include +#include "LibEasyOCR-CPP-Export.h" + +namespace uns +{ + namespace easyocr + { + enum class LIBEASYOCRCPP_API GPUUsage + { + ForceGPU, // ǿʹGPUʧܱ + PreferGPU, // GPUʧܻ + CPUOnly // ʹCPU + }; + + enum class LIBEASYOCRCPP_API CharsetType + { + EN, //Ӣ + EN_CH //Ӣ + }; + } + + class LIBEASYOCRCPP_API OCRConfig + { + private: + easyocr::GPUUsage gpu_usage; + easyocr::CharsetType language; + std::wstring detect_model_path; + std::wstring recognize_model_path; + + public: + OCRConfig(); + OCRConfig(const OCRConfig& obj) = delete; + OCRConfig(const std::wstring& detect_model, const std::wstring& reco_model, easyocr::CharsetType language, easyocr::GPUUsage gpu = easyocr::GPUUsage::PreferGPU); + + public: + easyocr::GPUUsage GetGPUUsage() const; + easyocr::CharsetType GetLanguage() const; + + std::wstring GetDetectModelPath() const; + std::wstring GetRecognizeModelPath() const; + + public: + void SetGPUUsage(easyocr::GPUUsage usage); + void SetLanguage(easyocr::CharsetType type); + void SetDetectModelPath(const std::wstring& path); + void SetRecognizeModelPath(const std::wstring& path); + }; + + extern OCRConfig G_OCRConfig; +} diff --git a/LibEasyOCR-CPP/OCRToolBox.cpp b/LibEasyOCR-CPP/OCRToolBox.cpp new file mode 100644 index 0000000..98a6100 --- /dev/null +++ b/LibEasyOCR-CPP/OCRToolBox.cpp @@ -0,0 +1,86 @@ +#include "pch.h" +#include "OCRToolBox.h" +#include "OCRConfig.h" + +bool uns::OCRToolBox::CheckFile(const std::wstring& file) +{ + namespace fs = std::filesystem; + try + { + if (file.empty()) + return false; + if (!fs::exists(file)) + return false; + if (!fs::is_regular_file(file)) + return false; + auto perms = fs::status(file).permissions(); + return ((perms & fs::perms::owner_read) != fs::perms::none && (perms & fs::perms::owner_write) != fs::perms::none); + } + catch (...) + { + return false; + } +} + +void uns::OCRToolBox::InitOrtSessionOptions(Ort::SessionOptions& se_opt) +{ + se_opt.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL); + se_opt.EnableCpuMemArena(); // ڴ + se_opt.EnableMemPattern(); // ڴģʽŻ +} + +bool uns::OCRToolBox::AutoSelectEP(const OrtApi* ort, Ort::SessionOptions& se_opt, bool& fallback_to_cpu) +{ + fallback_to_cpu = false; + if (G_OCRConfig.GetGPUUsage() == easyocr::GPUUsage::CPUOnly) + return true; + try + { + OrtStatusPtr status = OrtSessionOptionsAppendExecutionProvider_CUDA(se_opt, 0); + if (status) + { + ort->ReleaseStatus(status); + if (G_OCRConfig.GetGPUUsage() == easyocr::GPUUsage::ForceGPU) + return false; + se_opt = Ort::SessionOptions(); //Reset Session Options (Fallback to CPU) + fallback_to_cpu = true; + return true; + } + else + return true; //GPU Enable Successful + } + catch (const Ort::Exception&) + { + se_opt = Ort::SessionOptions(); //Reset Session Options (Fallback to CPU) + fallback_to_cpu = true; + return true; + } + catch (...) + { + return false; + } + return false; +} + +void uns::OCRToolBox::GetInputOutputNames(Ort::Session* ort_session, IONames& input_names, IONamesStorage& input_ns, IONames& output_names, IONamesStorage& output_ns) +{ + input_ns.clear(); + output_ns.clear(); + input_names.clear(); + output_names.clear(); + + if (ort_session == nullptr) + return; + + auto input_name_alloc = ort_session->GetInputNameAllocated(0, Ort::AllocatorWithDefaultOptions()); + std::string input_name = input_name_alloc.get(); + input_ns = { input_name }; + for (auto& name : input_ns) + input_names.push_back(name.c_str()); + + auto output_name_alloc = ort_session->GetOutputNameAllocated(0, Ort::AllocatorWithDefaultOptions()); + std::string output_name = output_name_alloc.get(); + output_ns = { output_name }; + for (auto& name : output_ns) + output_names.push_back(name.c_str()); +} diff --git a/LibEasyOCR-CPP/OCRToolBox.h b/LibEasyOCR-CPP/OCRToolBox.h new file mode 100644 index 0000000..d846422 --- /dev/null +++ b/LibEasyOCR-CPP/OCRToolBox.h @@ -0,0 +1,27 @@ +#pragma once +#include +#include +#include +#include +#include + +namespace uns +{ + using VecInt = std::vector; + using VecFloat = std::vector; + using IONames = std::vector; + using IONamesStorage = std::vector; + using EOCR_Result = std::pair; + using EOCR_ResultSet = std::map; + using EOCRD_Rects = std::vector>; + + class OCRToolBox + { + public: + static bool CheckFile(const std::wstring& file); + static void InitOrtSessionOptions(Ort::SessionOptions& se_opt); + static bool AutoSelectEP(const OrtApi* ort, Ort::SessionOptions& se_opt, bool& fallback_to_cpu); + static void GetInputOutputNames(Ort::Session* ort_session, IONames& input_names, IONamesStorage& input_ns, IONames& output_names, IONamesStorage& output_ns); + }; +} + diff --git a/LibEasyOCR-CPP/dllmain.cpp b/LibEasyOCR-CPP/dllmain.cpp new file mode 100644 index 0000000..c669be8 --- /dev/null +++ b/LibEasyOCR-CPP/dllmain.cpp @@ -0,0 +1,16 @@ +// dllmain.cpp : 定义 DLL 应用程序的入口点。 +#include "pch.h" + +BOOL APIENTRY DllMain(HMODULE hModule,DWORD ul_reason_for_call,LPVOID lpReserved) +{ + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + diff --git a/LibEasyOCR-CPP/framework.h b/LibEasyOCR-CPP/framework.h new file mode 100644 index 0000000..80cbbc9 --- /dev/null +++ b/LibEasyOCR-CPP/framework.h @@ -0,0 +1,5 @@ +#pragma once + +#define WIN32_LEAN_AND_MEAN // 从 Windows 头文件中排除极少使用的内容 +// Windows 头文件 +#include diff --git a/LibEasyOCR-CPP/pch.cpp b/LibEasyOCR-CPP/pch.cpp new file mode 100644 index 0000000..b6fb8f4 --- /dev/null +++ b/LibEasyOCR-CPP/pch.cpp @@ -0,0 +1,5 @@ +// pch.cpp: 与预编译标头对应的源文件 + +#include "pch.h" + +// 当使用预编译的头时，需要使用此源文件，编译才能成功。 diff --git a/LibEasyOCR-CPP/pch.h b/LibEasyOCR-CPP/pch.h new file mode 100644 index 0000000..9660927 --- /dev/null +++ b/LibEasyOCR-CPP/pch.h @@ -0,0 +1,13 @@ +// pch.h: 这是预编译标头文件。 +// 下方列出的文件仅编译一次，提高了将来生成的生成性能。 +// 这还将影响 IntelliSense 性能，包括代码完成和许多代码浏览功能。 +// 但是，如果此处列出的文件中的任何一个在生成之间有更新，它们全部都将被重新编译。 +// 请勿在此处添加要频繁更新的文件，这将使得性能优势无效。 + +#ifndef PCH_H +#define PCH_H + +// 添加要在此处预编译的标头 +#include "framework.h" + +#endif //PCH_H