comment

_718/Fl1.ino

@@ -0,0 +1,901 @@
+void flower1()
+
+{
+    byte bait;
+byte bait1;
+
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl1.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl ,80, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl ,59, 385); 
+ 
+//   myGLCD.setFont(Ubuntubold);
+// myGLCD.setColor(VGA_BLUE);
+//myGLCD.printNumI(osv ,440, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl ,65, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+// myGLCD.setColor(0,38,92);
+//  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+ //     myGLCD.setColor(255, 255, 255);//цвет обводки
+ // myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+//  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+
+graflawer();
+grafflm();
+
+//******************************************************************************************************************************
+
+
+
+}
+
+
+//********************************************************************************************************************
+ void graflawer()
+//*******рисуем график ********************************* 
+{       myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(215, 0, 635, 475);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(215, 0, 635, 475);//прямоугольник с  обводкой
+    int z=80;
+  int s=220;
+  myGLCD.setColor(30,55,90);
+  myGLCD.fillRoundRect(s+55, 5, s+55+15, 440-z);//рисуем синий пр-к1
+    myGLCD.setColor(45,55,105);
+  myGLCD.fillRoundRect(s+55+15, 5, s+55+30, 440-z);//рисуем синий пр-к2
+    myGLCD.setColor(60,55,110);
+  myGLCD.fillRoundRect(s+55+30, 5, s+55+45, 440-z);//рисуем синий пр-к3
+    myGLCD.setColor(75,55,115);
+  myGLCD.fillRoundRect(s+55+45, 5, s+55+60, 440-z);//рисуем синий пр-к4
+  
+   myGLCD.setColor(82,40,137);
+  myGLCD.fillRoundRect(s+55+60,5 , s+55+60+15, 440-z);//рисуем синий пр-к5
+  myGLCD.setColor(97,35,139);
+  myGLCD.fillRoundRect(s+55+60+15,5 , s+55+60+30, 440-z);//рисуем синий пр-к6
+  myGLCD.setColor(125,32,141);
+  myGLCD.fillRoundRect(s+55+60+30,5 , s+55+60+45, 440-z);//рисуем синий пр-к7
+  myGLCD.setColor(145,27,143);
+  myGLCD.fillRoundRect(s+55+60+45,5 , s+55+60+60, 440-z);//рисуем синий пр-к8
+  
+     myGLCD.setColor(163,25,146);
+  myGLCD.fillRoundRect(s+55+60+60,5 , s+55+60+60+15, 440-z);//рисуем синий пр-к9
+     myGLCD.setColor(173,35,136);
+  myGLCD.fillRoundRect(s+55+60+60+15,5 , s+55+60+60+30, 440-z);//рисуем синий пр-к10
+     myGLCD.setColor(187,45,120);
+  myGLCD.fillRoundRect(s+55+60+60+30,5 , s+55+60+60+45, 440-z);//рисуем синий пр-к11
+     myGLCD.setColor(195,55,106);
+  myGLCD.fillRoundRect(s+55+60+60+45,5 , s+55+60+60+60, 440-z);//рисуем синий пр-к 12
+  
+      myGLCD.setColor(200,64,97);
+  myGLCD.fillRoundRect(s+55+60+60+60,5 , s+55+60+60+60+15, 440-z);//рисуем синий пр-к13
+      myGLCD.setColor(195,75,92);
+  myGLCD.fillRoundRect(s+55+60+60+60+15,5 , s+55+60+60+60+30, 440-z);//рисуем синий пр-к14
+      myGLCD.setColor(190,85,87);
+  myGLCD.fillRoundRect(s+55+60+60+60+30,5 , s+55+60+60+60+45, 440-z);//рисуем синий пр-к15
+      myGLCD.setColor(180,95,82);
+  myGLCD.fillRoundRect(s+55+60+60+60+45,5 , s+55+60+60+60+60, 440-z);//рисуем синий пр-к 16
+  
+         myGLCD.setColor(171,103,76);
+  myGLCD.fillRoundRect(s+55+240,5 , s+55+240+15, 440-z);//рисуем синий пр-к 17
+         myGLCD.setColor(151,93,86);
+  myGLCD.fillRoundRect(s+55+240+15,5 , s+55+240+30, 440-z);//рисуем синий пр-к 18
+         myGLCD.setColor(131,83,96);
+  myGLCD.fillRoundRect(s+55+240+30,5 , s+55+240+45, 440-z);//рисуем синий пр-к 19
+         myGLCD.setColor(101,73,116);
+  myGLCD.fillRoundRect(s+55+240+45,5 , s+55+300, 440-z);//рисуем синий пр-к 20
+  
+        
+        myGLCD.setColor(82,40,137);
+  myGLCD.fillRoundRect(s+55+300,5 , s+55+315, 440-z);//рисуем синий пр-к 21 
+         myGLCD.setColor(60,55,110);
+  myGLCD.fillRoundRect(s+55+315,5 , s+55+330, 440-z);//рисуем синий пр-к 22 
+        myGLCD.setColor(30,55,90);
+  myGLCD.fillRoundRect(s+55+330,5 , s+55+345, 440-z);//рисуем синий пр-к 23
+
+
+
+
+
+  myGLCD.setBackColor(0,38,92);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setFont(BigFont);
+   myGLCD.drawLine(s+55, 10, s+55, 450-z);// ось у
+    myGLCD.drawLine(s+400, 10, s+400, 440-z);//ось у давление
+   myGLCD.drawLine(s+55, 90+180-z, s+400, 90+180-z);// ось х темп
+   myGLCD.drawLine(s+55, 440-z, s+400, 440-z);//ось х влажность
+ 
+  
+   myGLCD.setColor(35,173,255);
+    //myGLCD.drawLine(s+55, 270-80, s+400, 270-80);// ось 0
+     myGLCD.setColor(200,64,97);
+    myGLCD.drawLine(s+55, 270-200, s+400, 70);// ось 30
+      myGLCD.drawLine(s+55, 270-220, s+400, 50);// ось 35
+      myGLCD.drawLine(s+55, 440-30-z, s+400, 440-30-z);// ось 30
+      myGLCD.drawLine(s+55, 440-15-z, s+400, 440-15-z);// ось 30
+     myGLCD.setColor(45,112,56);
+     myGLCD.drawLine(s+55, 270-180, s+400, 270-180);// ось 25
+    myGLCD.drawLine(s+55, 270-160, s+400, 270-160);// ось 20
+    myGLCD.drawLine(s+55, 270-120, s+400, 270-120);// ось 10
+    myGLCD.drawLine(s+55, 270-100, s+400, 270-100);// ось 5
+    myGLCD.drawLine(s+55, 270-140, s+400, 270-140);// ось 15
+    myGLCD.drawLine(s+55, 440-105-z, s+400, 440-105-z);// ось 70
+    myGLCD.drawLine(s+55, 440-90-z, s+400, 440-90-z);// ось 60
+    myGLCD.drawLine(s+55, 440-75-z, s+400, 440-75-z);// ось 50
+    myGLCD.drawLine(s+55, 440-60-z, s+400, 440-60-z);// ось 40
+    myGLCD.drawLine(s+55, 440-45-z, s+400, 440-45-z);// ось 30
+    myGLCD.setColor(0,38,92);
+  //  myGLCD.drawLine(s+55, 270-60, s+400, 270-60);// ось -5
+ //  myGLCD.drawLine(s+55, 270-40, s+400, 270-40);// ось -10 
+//  myGLCD.drawLine(s+55, 270-20, s+400, 270-20);// ось -15 
+  myGLCD.drawLine(s+55, 440-135-z, s+400, 440-135-z);// ось 90
+  myGLCD.drawLine(s+55, 440-120-z, s+400, 440-120-z);// ось 80
+    myGLCD.setColor(255,75,29);
+     myGLCD.drawLine(s+55, 270-240, s+400, 270-240);// ось 40
+     myGLCD.drawLine(s+55, 270-260, s+400, 270-260);// ось 45
+    
+    
+   byte k=0;
+   myGLCD.setColor(VGA_WHITE);
+   for (int i =80 ; i < 270; i = i+4) //температура  шкала цифры
+    { 
+      myGLCD.drawLine(s+55, 90+180-i, s+52, 90+180-i);
+      myGLCD.drawLine(s+400, 90+180-i, s+403, 90+180-i);
+       k=k+1;
+        if((k==6)||(k==1))//верт метки tu td
+           {
+             if ((i/4-20)>29)
+             {myGLCD.setColor(255,62,62);
+              myGLCD.printNumI(i/4-20, s+5, 90+180-8-i);
+             }
+              if ((i/4-20)>0 && (i/4-20)<30)
+             {myGLCD.setColor(10,255,60);
+              myGLCD.printNumI(i/4-20, s+5, 90+180-8-i);
+             }
+             
+              if ((i/4-20)<1)
+             {myGLCD.setColor(35,173,255);
+              myGLCD.printNumI(i/4-20, s+5, 90+180-8-i);
+             }
+             
+           myGLCD.setColor(VGA_WHITE); 
+           myGLCD.drawLine(s+55, 90+180-i, s+55-9, 90+180-i);
+           myGLCD.drawLine(s+400, 90+180-i, s+400+9, 90+180-i);
+           k=1;}
+      
+      
+      
+    }
+
+    
+      k=0;
+   myGLCD.setColor(VGA_WHITE);
+   for (int i =0 ; i < 150; i = i+3) //влажность
+    { //myGLCD.drawLine(55, 440, 400, 440);//ось х давление
+    //myGLCD.drawLine(55, 10, 55, 450);// ось у
+       myGLCD.drawLine(s+55, 440-i-z, s+52, 440-i-z);
+       k=k+1;
+       
+       if((k==6)||(k==1))//верт метки tu td
+           {
+             if (i>119)
+             {myGLCD.setColor(35,173,255);
+               myGLCD.printNumI(i*2/3, s+5, 440-8-i-z);
+             }
+              if (i>31 && i<119)
+             {myGLCD.setColor(10,255,60);
+               myGLCD.printNumI(i*2/3, s+5, 440-8-i-z);
+             }
+             
+              if (i<31)
+             {myGLCD.setColor(255,255,0);
+              myGLCD.printNumI(i*2/3, s+5, 440-8-i-z);
+             }
+             
+           myGLCD.setColor(VGA_WHITE); 
+           myGLCD.drawLine(s+55, 440-i-z, s+55-9, 440-i-z);
+           k=1;}
+      
+    }
+ //*************************************   
+// int z=80;
+    k=0;
+    for (int i =0 ; i < 360; i = i+11) //гориз метки и шкала days
+    {
+      //for (byte n =0 ; n < 5; n = n++)
+        myGLCD.drawLine(s+55+i, 90+180-z, s+55+i, 90+180-z+5);
+         myGLCD.drawLine(s+55+i, 440-z, s+55+i, 440+5-z);
+        
+      
+      k=k+1;
+        if((k==6)||(k==1))
+           {myGLCD.printNumI(i/11, s+55+i-12, 90+180+10-z);
+           myGLCD.printNumI(i/11, s+55+i-12, 440+10-z);
+           myGLCD.drawLine(s+55+i, 90+180-z, s+55+i, 90+180+9-z);
+           myGLCD.drawLine(s+55+i, 440-z, s+55+i, 440+9-z);
+           k=1;}
+    }
+   myGLCD.setBackColor( VGA_TRANSPARENT);
+   myGLCD.setColor(255,62,62);
+   myGLCD.print("T C" ,s+59, 10);
+   myGLCD.print("T C" ,s+61, 10);
+   myGLCD.print("T C" ,s+60, 11);
+   myGLCD.print("T C" ,s+60, 9);
+     myGLCD.setColor(VGA_WHITE); 
+    myGLCD.print("T C" ,s+60, 10);
+    
+    
+     
+ //   myGLCD.setColor(10,255,60); 
+  // myGLCD.print("750" ,352, 250-8); 
+  // myGLCD.print("755" ,352, 230-8); 
+ //  myGLCD.print("760" ,352, 210-8);
+ //  myGLCD.print("765" ,352, 190-8);
+ //  myGLCD.print("770" ,352, 170-8);
+ //  myGLCD.setColor(0,38,92);
+//    myGLCD.print("Pmm" ,353, 170-35);
+  //   myGLCD.print("Pmm" ,351, 170-35);
+  //    myGLCD.print("Pmm" ,352, 171-35);
+   //    myGLCD.print("Pmm" ,352, 169-35);
+ //  myGLCD.setColor(VGA_WHITE);
+ //  myGLCD.print("Pmm" ,352, 170-35);
+   
+  myGLCD.setColor(35,173,255); 
+   myGLCD.print("H%" ,s+61, 290-z);
+   myGLCD.print("H%" ,s+59, 290-z);
+   myGLCD.print("H%" ,s+60, 291-z);
+   myGLCD.print("H%" ,s+60, 289-z);
+    myGLCD.setColor(VGA_WHITE);
+     myGLCD.print("H%" ,s+60, 290-z);
+  
+
+   
+ 
+}
+
+//***************************************************************
+void grafflm()
+{
+  boolean datm=1;
+  boolean daty=1;
+int m=t.mon;//месяц 
+int ye=t.year; //год
+// knopki******************************
+byte dat16=0;//16:00 date yes or no
+
+  myGLCD.setFont( Ubuntubold); 
+        myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 
+        myGLCD.print("M" ,235, 395);//выделение месяца цветом 440 203
+      
+      // myGLCD.setBackColor(8,101,192);
+       myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 440 243
+       myGLCD.print("Y" ,235, 435);
+       
+        myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 391, 400, 434-5);//рисуем синий пр-к  M
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 391, 400, 434-5);//прямоугольник с  обводкой 
+ 
+  myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 431, 400, 474-5);//рисуем синий пр-к  Y
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 431, 400, 474-5);//прямоугольник с  обводкой   
+  myGLCD.setBackColor(0,38,92);
+  
+  if (mon1<10)
+    {myGLCD.print("0" ,312, 395);
+    myGLCD.printNumI(m, 312+24, 395);
+    }
+  else
+    myGLCD.printNumI(m, 312, 395); 
+
+  myGLCD.printNumI(ye, 292, 435); 
+  
+   myGLCD.setColor(31,70,126);
+  myGLCD.print("<" ,312-32, 395); 
+ myGLCD.print(">" ,312+63, 395);
+  
+   myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(430, 391, 500, 434-5);//рисуем синий пр-к  RS
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+      myGLCD.drawRoundRect(430, 391, 500, 434-5);//прямоугольник с  обводкой
+      
+  myGLCD.setColor(0,38,92);     
+  myGLCD.fillRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  
+    myGLCD.setColor(0,38,92);     
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+
+        myGLCD.setColor(255, 255, 255);//цвет
+  
+  
+     myGLCD.setBackColor(0,38,92);
+    myGLCD.print("RS" ,440, 395);
+     myGLCD.print("OK" ,530, 395);
+     myGLCD.setColor(255, 97, 237);//цвет
+       myGLCD.print("QUIT" ,460, 435);
+    myGLCD.setColor(255, 255, 255);//цвет  
+    
+    
+//******************************************************************    
+graff:
+
+ byte dm=31;// макс день месяца  
+  if (m==2)
+     dm=28;
+    
+  if ((m==4)||(m==6)||(m==9)||(m==11))
+     dm=30;
+  
+ if(ye==t.year)//проверка на наличае данных
+   {if(m==t.mon)
+    { dm=t.date-1;
+    }
+   }
+//*************************GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG*******************************************************  
+word work[31]={100,250,250,244,245,246,240,248,249,245,250,249,250,250,250,244,245,246,250,248,250,250,250,249,250,250,250,250,250,250,249}; 
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  char* stry[] = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};  
+
+  char* name;
+  
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+  name= stry[ye-2014];
+                                                          
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+  //*************************************************************************
+   myFile.open("poliv.txt", O_READ);
+  char s;
+char token[] = "date:";  
+char token1[] = "16:00";  
+int n1=0;
+ int p=0; 
+int j=0; 
+int w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     w=10*(myFile.read()-48);//десятки даты
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+       for (j=0; j<8 ;j++)
+    { s=myFile.read();//пропуск 9 символов
+    //delay(10);
+    }
+  work[w-1]=10*(myFile.read()-48);//десятки t
+//  myGLCD.printNumI( work[w-1], 312-24, 10);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+  // myGLCD.printNumI(  work[w-1], 312+48, 10);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+ }//while 
+if (dat16==0)
+{
+ if (w>1){ work[w-1]=work[w-2];}
+}
+
+
+
+ }     
+    myFile.close();  
+  
+   delay (100);
+   
+   myGLCD.setColor(255, 0, 0);
+int y1;
+int y2;
+  //****************Рисуем графики   T*************************** 
+
+ // цвет графиа  
+    if(colorgraf>3)
+   colorgraf=0;
+    if(colorgraf==0)//выбор цвета графика
+     myGLCD.setColor(VGA_WHITE);
+     if(colorgraf==1)
+    myGLCD.setColor(35,173,255);
+      if(colorgraf==2)
+    myGLCD.setColor(255, 255, 0);
+     if(colorgraf==3)
+    myGLCD.setColor(10,255,60);
+   for ( byte x =1 ; x < dm; x = x+1) //****************темп дома постр  графика
+    { 
+        y1=190-(work[x-1]*4/10);
+        y2=190-(work[x]*4/10);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+       myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+      
+    }
+//********************************************************************************
+ //****************************влажность
+   strm = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+ stry = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};
+ 
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+ // name= stry[years1-2014];
+  name= stry[ye-2014];                                                         
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+
+  myFile.open("poliv.txt", O_READ);
+  w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     
+     w=10*(myFile.read()-48);//десятки даты
+ 
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+dat16=0;
+while (j<165) {
+   
+        if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+      s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск
+    
+  work[w-1]=10*(myFile.read()-48);//десятки t
+ // myGLCD.printNumI( work[w-1], 312-24, 250);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+// myGLCD.printNumI( work[w-1], 312+48, 250);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+      } 
+      
+       if (dat16==0)
+           {
+              if (w>1){ work[w-1]=work[w-2];}
+            } 
+
+ }     
+   
+     myFile.close();  
+  
+   
+  for ( byte x =1 ; x < dm; x = x+1) //******************************************влажность ул  постр  графика
+    { 
+      y1=360-(work[x-1]*15/100);
+      y2=360-(work[x]*15/100);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+      myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+    }
+  delay (100);  
+sd.chdir("/");  
+ //****************************************************************************  
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==45) )
+{
+
+ info(); 
+ }
+ 
+
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+           myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+      myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("x=    " , 650, 32);
+   //   myGLCD.printNumI(x , 700, 32);  
+   //   myGLCD.setFont( Ubuntubold);
+    //  myGLCD.print("y=    " ,650 , 72);
+    //  myGLCD.printNumI(y , 700, 72); 
+      
+    
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower1();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+           menu();
+        }
+       
+      } 
+      
+         if ((y>=400) && (y<=430))  //
+       {
+         if ((x>=280) && (x<=300))//<M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               myGLCD.print("<" ,312-32, 395); 
+                 //myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m-1;
+                   if (m==0)
+                       m=12;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                   myGLCD.setBackColor(0,38,92);
+                                if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print("<" ,312-32, 395);    
+                                
+       }
+       
+          if ((x>=370) && (x<=390))//>M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               //myGLCD.print("<" ,312-32, 395); 
+                 myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m+1;
+                   if (m==13)
+                       m=1;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                           myGLCD.setBackColor(0,38,92);
+                          if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print(">" ,312+63, 395); 
+          }
+          
+          
+          
+          
+          
+          if ((x>=435) && (x<=500))//RS
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("RS" ,440, 395);
+             //GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+                delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+                     graflawer();
+                grafflm();                                
+             }
+                else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("RS" ,440, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+             
+           }
+           
+           
+            if ((x>=525) && (x<=590))//OK
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("OK" ,530, 395);
+               delay(300);
+               colorgraf++;
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             goto graff;
+             }
+                  //*******GGGGGGGGGGGGGGGGGGGGGGGGG                              
+
+             
+                  else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("OK" ,530, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             
+          }
+          
+       }
+       
+         if ((y>=440) && (y<=470))  //
+       {
+          if ((x>=280) && (x<=300))//<Y
+            {daty=1;
+              ye=ye-1;
+             if(ye<2015)
+               ye=2015;
+                myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+           }
+          
+          
+   
+           if ((x>=370) && (x<=390))//>Y
+            {daty=1;
+              ye=ye+1;
+              myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+          }
+          
+           if ((x>=435) && (x<=590))//QUIT
+          {myGLCD.setBackColor(0,38,92);
+           myGLCD.setColor(59, 251, 104);//цвет
+            myGLCD.print("QUIT" ,460, 435);
+            delay(500);
+            flower();
+          }
+         
+       }
+      
+    }//touch
+
+
+}  
+  
+}

_718/Fl2.ino

@@ -0,0 +1,681 @@
+void flower2()
+
+{
+    byte bait;
+byte bait1;
+
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl2.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl2 ,80, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl2 ,59, 385); 
+ 
+//   myGLCD.setFont(Ubuntubold);
+// myGLCD.setColor(VGA_BLUE);
+//myGLCD.printNumI(osv ,440, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl2 ,65, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+// myGLCD.setColor(0,38,92);
+//  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+ //     myGLCD.setColor(255, 255, 255);//цвет обводки
+ // myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+//  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+
+graflawer();
+grafflm2();
+
+//******************************************************************************************************************************
+
+
+
+}
+
+
+
+
+//***************************************************************
+void grafflm2()
+{
+  boolean datm=1;
+  boolean daty=1;
+int m=t.mon;//месяц 
+int ye=t.year;  //год
+// knopki******************************
+byte dat16=0;//16:00 date yes or no
+
+  myGLCD.setFont( Ubuntubold); 
+        myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 
+        myGLCD.print("M" ,235, 395);//выделение месяца цветом 440 203
+      
+      // myGLCD.setBackColor(8,101,192);
+       myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 440 243
+       myGLCD.print("Y" ,235, 435);
+       
+        myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 391, 400, 434-5);//рисуем синий пр-к  M
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 391, 400, 434-5);//прямоугольник с  обводкой 
+ 
+  myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 431, 400, 474-5);//рисуем синий пр-к  Y
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 431, 400, 474-5);//прямоугольник с  обводкой   
+  myGLCD.setBackColor(0,38,92);
+  
+  if (mon1<10)
+    {myGLCD.print("0" ,312, 395);
+    myGLCD.printNumI(m, 312+24, 395);
+    }
+  else
+    myGLCD.printNumI(m, 312, 395); 
+
+  myGLCD.printNumI(ye, 292, 435); 
+  
+   myGLCD.setColor(31,70,126);
+  myGLCD.print("<" ,312-32, 395); 
+ myGLCD.print(">" ,312+63, 395);
+  
+   myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(430, 391, 500, 434-5);//рисуем синий пр-к  RS
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+      myGLCD.drawRoundRect(430, 391, 500, 434-5);//прямоугольник с  обводкой
+      
+  myGLCD.setColor(0,38,92);     
+  myGLCD.fillRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  
+    myGLCD.setColor(0,38,92);     
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+
+        myGLCD.setColor(255, 255, 255);//цвет
+  
+  
+     myGLCD.setBackColor(0,38,92);
+    myGLCD.print("RS" ,440, 395);
+     myGLCD.print("OK" ,530, 395);
+     myGLCD.setColor(255, 97, 237);//цвет
+       myGLCD.print("QUIT" ,460, 435);
+    myGLCD.setColor(255, 255, 255);//цвет  
+    
+    
+//******************************************************************    
+graff2:
+
+ byte dm=31;// макс день месяца  
+  if (m==2)
+     dm=28;
+    
+  if ((m==4)||(m==6)||(m==9)||(m==11))
+     dm=30;
+  
+ if(ye==t.year)//проверка на наличае данных
+   {if(m==t.mon)
+    { dm=t.date-1;
+    }
+   }
+//*************************GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG*******************************************************  
+word work[31]={100,250,250,244,245,246,240,248,249,245,250,249,250,250,250,244,245,246,250,248,250,250,250,249,250,250,250,250,250,250,249}; 
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  char* stry[] = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};  
+
+  char* name;
+  
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+  name= stry[ye-2014];
+                                                          
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+  //*************************************************************************
+   myFile.open("poliv2.txt", O_READ);
+  char s;
+char token[] = "date:";  
+char token1[] = "16:00";  
+int n1=0;
+ int p=0; 
+int j=0; 
+int w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     w=10*(myFile.read()-48);//десятки даты
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+       for (j=0; j<8 ;j++)
+    { s=myFile.read();//пропуск 9 символов
+    //delay(10);
+    }
+  work[w-1]=10*(myFile.read()-48);//десятки t
+//  myGLCD.printNumI( work[w-1], 312-24, 10);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+  // myGLCD.printNumI(  work[w-1], 312+48, 10);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+ }//while 
+if (dat16==0)
+{
+ if (w>1){ work[w-1]=work[w-2];}
+}
+
+
+
+ }     
+    myFile.close();  
+  
+   delay (100);
+   
+   myGLCD.setColor(255, 0, 0);
+int y1;
+int y2;
+  //****************Рисуем графики   T*************************** 
+
+ // цвет графиа  
+    if(colorgraf>3)
+   colorgraf=0;
+    if(colorgraf==0)//выбор цвета графика
+     myGLCD.setColor(VGA_WHITE);
+     if(colorgraf==1)
+    myGLCD.setColor(35,173,255);
+      if(colorgraf==2)
+    myGLCD.setColor(255, 255, 0);
+     if(colorgraf==3)
+    myGLCD.setColor(10,255,60);
+   for ( byte x =1 ; x < dm; x = x+1) //****************темп дома постр  графика
+    { 
+        y1=190-(work[x-1]*4/10);
+        y2=190-(work[x]*4/10);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+       myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+      
+    }
+//********************************************************************************
+ //****************************влажность
+   strm = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+ stry = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};
+ 
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+ // name= stry[years1-2014];
+  name= stry[ye-2014];                                                         
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+
+  myFile.open("poliv2.txt", O_READ);
+  w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     
+     w=10*(myFile.read()-48);//десятки даты
+ 
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+dat16=0;
+while (j<165) {
+   
+        if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+      s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск
+    
+  work[w-1]=10*(myFile.read()-48);//десятки t
+ // myGLCD.printNumI( work[w-1], 312-24, 250);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+// myGLCD.printNumI( work[w-1], 312+48, 250);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+      } 
+      
+       if (dat16==0)
+           {
+              if (w>1){ work[w-1]=work[w-2];}
+            } 
+
+ }     
+   
+     myFile.close();  
+  
+   
+  for ( byte x =1 ; x < dm; x = x+1) //******************************************влажность ул  постр  графика
+    { 
+      y1=360-(work[x-1]*15/100);
+      y2=360-(work[x]*15/100);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+      myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+    }
+  delay (100);  
+sd.chdir("/");  
+ //****************************************************************************  
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==45) )
+{
+
+ info(); 
+ }
+ 
+
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+           myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+      myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("x=    " , 650, 32);
+   //   myGLCD.printNumI(x , 700, 32);  
+   //   myGLCD.setFont( Ubuntubold);
+    //  myGLCD.print("y=    " ,650 , 72);
+    //  myGLCD.printNumI(y , 700, 72); 
+      
+    
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower2();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+           menu();
+        }
+       
+      } 
+      
+         if ((y>=400) && (y<=430))  //
+       {
+         if ((x>=280) && (x<=300))//<M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               myGLCD.print("<" ,312-32, 395); 
+                 //myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m-1;
+                   if (m==0)
+                       m=12;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                   myGLCD.setBackColor(0,38,92);
+                                if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print("<" ,312-32, 395);    
+                                
+       }
+       
+          if ((x>=370) && (x<=390))//>M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               //myGLCD.print("<" ,312-32, 395); 
+                 myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m+1;
+                   if (m==13)
+                       m=1;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                           myGLCD.setBackColor(0,38,92);
+                          if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print(">" ,312+63, 395); 
+          }
+          
+          
+          
+          
+          
+          if ((x>=435) && (x<=500))//RS
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("RS" ,440, 395);
+             //GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+                delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+                     graflawer();
+                grafflm2();                                
+             }
+                else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("RS" ,440, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+             
+           }
+           
+           
+            if ((x>=525) && (x<=590))//OK
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("OK" ,530, 395);
+               delay(300);
+               colorgraf++;
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             goto graff2;
+             }
+                  //*******GGGGGGGGGGGGGGGGGGGGGGGGG                              
+
+             
+                  else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("OK" ,530, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             
+          }
+          
+       }
+       
+         if ((y>=440) && (y<=470))  //
+       {
+          if ((x>=280) && (x<=300))//<Y
+            {daty=1;
+              ye=ye-1;
+             if(ye<2015)
+               ye=2015;
+                myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+           }
+          
+          
+   
+           if ((x>=370) && (x<=390))//>Y
+            {daty=1;
+              ye=ye+1;
+              myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+          }
+          
+           if ((x>=435) && (x<=590))//QUIT
+          {myGLCD.setBackColor(0,38,92);
+           myGLCD.setColor(59, 251, 104);//цвет
+            myGLCD.print("QUIT" ,460, 435);
+            delay(500);
+            flower();
+          }
+         
+       }
+      
+    }//touch
+
+
+}  
+  
+}

_718/Fl3.ino

@@ -0,0 +1,151 @@
+void flower3()
+
+{
+    byte bait;
+byte bait1;
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl3.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl3 ,80, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl3 ,59, 385); 
+ 
+//   myGLCD.setFont(Ubuntubold);
+// myGLCD.setColor(VGA_BLUE);
+//myGLCD.printNumI(osv ,440, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl3 ,65, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+  kalend();
+  clc();
+
+
+ 
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==42) )
+{
+
+ info(); 
+ }
+ 
+ if ((sec==55) || (sec==25) )
+{
+
+ info();  
+
+ } 
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+           myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+      myGLCD.setFont( Ubuntubold);
+      myGLCD.print("x=    " , 650, 32);
+      myGLCD.printNumI(x , 700, 32);  
+      myGLCD.setFont( Ubuntubold);
+      myGLCD.print("y=    " ,650 , 72);
+      myGLCD.printNumI(y , 700, 72); 
+      
+    
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower3();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+           flower();
+        }
+       
+      } 
+    }//touch
+
+
+}
+
+
+}

_718/Flower_.ino

@@ -0,0 +1,186 @@
+void flower()
+{
+    byte bait;
+byte bait1;
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+     myGLCD.print("+" ,260, 56);
+      myGLCD.print("+" ,522, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl ,80, 46);
+  myGLCD.printNumI(tfl2 ,280, 46);
+   myGLCD.printNumI(tfl3 ,542, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+      myGLCD.print("%" ,318, 410);
+        myGLCD.print("%" ,565, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl ,59, 385);
+ myGLCD.printNumI(vfl2 ,255, 385); 
+ myGLCD.printNumI(vfl3 ,500, 385);  
+ 
+   myGLCD.setFont(Ubuntubold);
+ myGLCD.setColor(VGA_BLUE);
+myGLCD.printNumI(osv ,443, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl ,65, 455); 
+   myGLCD.printNumI(dfl2 ,261, 455); 
+    myGLCD.printNumI(dfl3 ,506, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ myGLCD.print(":00",273+16, 455); 
+ myGLCD.print(":00",518+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+if (rawp==1)
+{delay (1000);
+rawp=0;
+return;
+}
+
+
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+ // kalend();
+ clc();
+
+
+ 
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==45) )
+{
+
+ info(); 
+ }
+ 
+
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+  //         myGLCD.setColor(VGA_BLUE);
+  //    myGLCD.setBackColor(255,255,255);
+ //     myGLCD.setFont( Ubuntubold);
+ //     myGLCD.print("x=    " , 650, 32);
+ //     myGLCD.printNumI(x , 700, 32);  
+ //     myGLCD.setFont( Ubuntubold);
+ //     myGLCD.print("y=    " ,650 , 72);
+ //     myGLCD.printNumI(y , 700, 72); 
+      
+        if ((y>=130) && (y<=450))  // Upper row
+      { if ((x>=40) && (x<=200))
+         {  flower1();
+         }
+         
+         if ((x>=230) && (x<=400))
+         {  flower2();
+         }
+         
+         if ((x>=480) && (x<=620))
+         {  flower3();
+         }
+    }
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+          menu();
+        }
+       
+      } 
+    }//touch
+
+
+}
+
+
+}
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  

_718/X.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: X.jpg
+// Time generated: 12.04.2014 22:14:47
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short X[0x384] ={
+0xD0C4, 0xD8E5, 0xF0C4, 0xE984, 0xF166, 0xF1C8, 0xF1A7, 0xF1C9, 0xF1C8, 0xF1C7, 0xE9C7, 0xF1E8, 0xE9A8, 0xF1A8, 0xF1C8, 0xE9E8,   // 0x0010 (16)
+0xF1C8, 0xF1C8, 0xE9C6, 0xF1C8, 0xF1C8, 0xF1C8, 0xE9A8, 0xEA07, 0xF1E8, 0xEA27, 0xF229, 0xEA8A, 0xEAAB, 0xF28B, 0xC8A2, 0xD0A4,   // 0x0020 (32)
+0xE0E5, 0xE8E4, 0xF106, 0xF187, 0xE1C7, 0xE1C7, 0xE988, 0xE9A8, 0xF1C6, 0xE9A7, 0xE9C8, 0xF1A7, 0xF167, 0xE9C7, 0xE9A7, 0xE9C6,   // 0x0030 (48)
+0xF1A8, 0xE1A6, 0xE9C7, 0xE187, 0xF1E8, 0xF187, 0xE9A9, 0xF208, 0xF229, 0xF26B, 0xF2AC, 0xF2AC, 0xB8C3, 0xB8C3, 0xD0A4, 0xE0E5,   // 0x0040 (64)
+0xF125, 0xE146, 0xF947, 0xF186, 0xF167, 0xE966, 0xF167, 0xE986, 0xF166, 0xE967, 0xF186, 0xF186, 0xE9A6, 0xE966, 0xF167, 0xE1A6,   // 0x0050 (80)
+0xE966, 0xF167, 0xE184, 0xF946, 0xF187, 0xE1E6, 0xF209, 0xE269, 0xEAAB, 0xF2CC, 0xA0C2, 0xB883, 0xC8C5, 0xD8A3, 0xE903, 0xE104,   // 0x0060 (96)
+0xF146, 0xE924, 0xF905, 0xF147, 0xE126, 0xE946, 0xE945, 0xF126, 0xE946, 0xE925, 0xE925, 0xE927, 0xF146, 0xF106, 0xF166, 0xE945,   // 0x0070 (112)
+0xF126, 0xE946, 0xE947, 0xE9A6, 0xEA08, 0xF229, 0xFA8B, 0xEAEB, 0x98A3, 0xB0A3, 0xB8A4, 0xD0E5, 0xD8C5, 0xFFFC, 0xFFBF, 0xFFBF,   // 0x0080 (128)
+0xD945, 0xE8E5, 0xE925, 0xE925, 0xE925, 0xE925, 0xE8E5, 0xF105, 0xE126, 0xF104, 0xF105, 0xE904, 0xE8E5, 0xD925, 0xFFBE, 0xFFFC,   // 0x0090 (144)
+0xFFBE, 0xE187, 0xF1A7, 0xF22A, 0xFA8B, 0xF2AA, 0x9883, 0xB883, 0xC0A3, 0xC8C3, 0xE0C4, 0xE0C6, 0xFFBC, 0xFFDF, 0xFFBC, 0xE8E5,   // 0x00A0 (160)
+0xF8C4, 0xE8E4, 0xE0C5, 0xE8E5, 0xE904, 0xE0E4, 0xE905, 0xE8E4, 0xE903, 0xE905, 0xE125, 0xFF9E, 0xFFBE, 0xF79F, 0xF5F7, 0xE946,   // 0x00B0 (176)
+0xF1C7, 0xEA29, 0xEA8A, 0xF2EB, 0x9883, 0xA882, 0xB8A2, 0xC8A3, 0xE8A4, 0xE8E4, 0xE8C7, 0xF7BE, 0xFFDF, 0xF7FC, 0xE8E5, 0xE8A5,   // 0x00C0 (192)
+0xF0E6, 0xE0E4, 0xE104, 0xF0E4, 0xF0E4, 0xE8C4, 0xE8C5, 0xF0C4, 0xFF9E, 0xF7FE, 0xFFBD, 0xFFDF, 0xF105, 0xE925, 0xE9A7, 0xEA28,   // 0x00D0 (208)
+0xEA8A, 0xEACC, 0x98A3, 0xA882, 0xB8E3, 0xC8C4, 0xD8A4, 0xE8A3, 0xE8E5, 0xFE79, 0xF7BF, 0xFFFF, 0xFFBD, 0xD905, 0xF883, 0xE8E4,   // 0x00E0 (224)
+0xE8C4, 0xF0C4, 0xE8E3, 0xE0E4, 0xE0E6, 0xFFBE, 0xFFDF, 0xFFBF, 0xFFFE, 0xF0C5, 0xE8C5, 0xE966, 0xF988, 0xF209, 0xF26A, 0xF2AC,   // 0x00F0 (240)
+0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xFEDB, 0xFF9E, 0xFFDE, 0xF7DE, 0xF0A6, 0xE8E3, 0xF0C3, 0xE8E6,   // 0x0100 (256)
+0xF0E3, 0xE8C6, 0xF73D, 0xF7FE, 0xFFDF, 0xFF9F, 0xE0E4, 0xE8E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3,   // 0x0110 (272)
+0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E5, 0xF77B, 0xFF9F, 0xFFBF, 0xFF9E, 0xF0C4, 0xF0E3, 0xE0E3, 0xE8C4, 0xFEDC,   // 0x0120 (288)
+0xF7FE, 0xFFBE, 0xFFBD, 0xE8E3, 0xF0A6, 0xE8E4, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3,   // 0x0130 (304)
+0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8A3, 0xE904, 0xFFBE, 0xF7DF, 0xFFBE, 0xFFFD, 0xE8A4, 0xE8E6, 0xFFDD, 0xFFBD, 0xFFBF, 0xFFBE,   // 0x0140 (320)
+0xE905, 0xE0C3, 0xE8E4, 0xE0E4, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4,   // 0x0150 (336)
+0xE8E4, 0xE8E4, 0xE905, 0xE8A4, 0xE103, 0xFFDE, 0xFFDF, 0xFFBD, 0xFFBF, 0xFF7C, 0xF7DF, 0xFFBF, 0xFFBF, 0xF7DD, 0xF8E4, 0xE8E5,   // 0x0160 (352)
+0xF0C5, 0xF0E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4,   // 0x0170 (368)
+0xF0A4, 0xE8E4, 0xE8E4, 0xF0C5, 0xFFBE, 0xF7BF, 0xFFDF, 0xF7DF, 0xFFBF, 0xFFFE, 0xFFBE, 0xF0C4, 0xE8C4, 0xE0C5, 0xF0E4, 0xE0E4,   // 0x0180 (384)
+0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E4, 0xF0C5,   // 0x0190 (400)
+0xE8E5, 0xE8C3, 0xF0C6, 0xF7FE, 0xF79E, 0xFFDE, 0xFF9F, 0xF7FE, 0xE8C4, 0xE8E3, 0xF8C4, 0xF0E4, 0xE8C5, 0xE8E4, 0xE8E5, 0xE945,   // 0x01A0 (416)
+0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8C4, 0xE8E4, 0xF0A4, 0xF0C5,   // 0x01B0 (432)
+0xE0E4, 0xFFDE, 0xFF9F, 0xFFBE, 0xFF9F, 0xF7FE, 0xF0C3, 0xE0E5, 0xE8E3, 0xE904, 0xE8C5, 0xF0E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09,   // 0x01C0 (448)
+0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E4, 0xE904, 0xE8E3, 0xE0E5, 0xFFDE, 0xFF9E,   // 0x01D0 (464)
+0xFFBF, 0xFFBF, 0xFFDE, 0xFFDE, 0xFFDE, 0xE8C5, 0xF0C4, 0xF0A5, 0xE904, 0xE8C5, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB,   // 0x01E0 (480)
+0x98A2, 0xA882, 0xB8A3, 0xC8E2, 0xD8A3, 0xE0C5, 0xE0E5, 0xE8E4, 0xF0C5, 0xE8A4, 0xE904, 0xFFBC, 0xFFFF, 0xFF9E, 0xFF9F, 0xFFDE,   // 0x01F0 (496)
+0xFFDF, 0xFF9E, 0xFFDF, 0xFFDD, 0xF0E4, 0xE8E4, 0xE0E4, 0xF0E4, 0xE905, 0xE925, 0xF168, 0xEA29, 0xEA8B, 0xF2AC, 0x9882, 0xA883,   // 0x0200 (512)
+0xB0E2, 0xC8C4, 0xE0C4, 0xE8C4, 0xE8C4, 0xF0C3, 0xE8E4, 0xF105, 0xF7DF, 0xFFBF, 0xF77D, 0xFFDF, 0xE125, 0xE8A5, 0xF7DD, 0xFFDE,   // 0x0210 (528)
+0xFFBF, 0xFF9D, 0xF0C4, 0xD8E5, 0xF0E4, 0xE8E4, 0xE8E5, 0xF165, 0xF167, 0xF228, 0xF28A, 0xF2AB, 0x90C3, 0xB083, 0xB0A2, 0xC8A4,   // 0x0220 (544)
+0xE0A5, 0xE8C4, 0xE8E4, 0xE8E3, 0xE8E5, 0xFFBE, 0xFF9E, 0xFFBF, 0xFFDE, 0xE8E4, 0xE8E4, 0xE903, 0xF8A4, 0xFFBE, 0xFFFF, 0xFFBE,   // 0x0230 (560)
+0xFFBE, 0xF0E5, 0xF085, 0xE902, 0xE8E5, 0xE944, 0xF1A7, 0xEA29, 0xEA8A, 0xF2CB, 0xA063, 0xA8A2, 0xB8A4, 0xC8A4, 0xE0C4, 0xE0E4,   // 0x0240 (576)
+0xF0A4, 0xE106, 0xFFBD, 0xFFDE, 0xFFDE, 0xF7FD, 0xF0C4, 0xF0A4, 0xE0E3, 0xF0C5, 0xE8E4, 0xE906, 0xF79F, 0xFFDF, 0xFFDE, 0xFF7C,   // 0x0250 (592)
+0xE0C4, 0xE904, 0xF106, 0xE965, 0xE988, 0xF1E9, 0xF24A, 0xEACC, 0xA0A3, 0xA882, 0xB083, 0xC8E4, 0xD8C2, 0xE0C3, 0xE8C6, 0xFFBD,   // 0x0260 (608)
+0xFFBF, 0xFF9E, 0xF7BE, 0xE904, 0xE8E4, 0xE8E5, 0xF0C4, 0xE0E4, 0xE8C4, 0xE8E3, 0xFF1C, 0xFFBE, 0xFF9F, 0xF7BD, 0xFFDE, 0xF0E3,   // 0x0270 (624)
+0xE105, 0xF125, 0xE9A8, 0xEA28, 0xEA89, 0xEACC, 0xA062, 0xA0A3, 0xB8C4, 0xC0E3, 0xD8C3, 0xE8E4, 0xFFBC, 0xFFBF, 0xFFBF, 0xFFBF,   // 0x0280 (640)
+0xF0C5, 0xF0C4, 0xE104, 0xF0C4, 0xE8C4, 0xE904, 0xF0C3, 0xE0E4, 0xE0C5, 0xFFDE, 0xFFDF, 0xFF9F, 0xFFBE, 0xE8C5, 0xF104, 0xF164,   // 0x0290 (656)
+0xE987, 0xEA29, 0xF28A, 0xEAAB, 0x98A2, 0xA8A4, 0xB882, 0xC8E4, 0xD8A4, 0xE8C7, 0xFFBE, 0xFFDF, 0xFFDE, 0xE8C4, 0xE8C4, 0xE904,   // 0x02A0 (672)
+0xE103, 0xF0C4, 0xF0C5, 0xE8A3, 0xE8C4, 0xE8E5, 0xE904, 0xE8E5, 0xFFDC, 0xFFBE, 0xFF9F, 0xFFDE, 0xE8E6, 0xE944, 0xE9A7, 0xF20A,   // 0x02B0 (688)
+0xF26B, 0xEAEB, 0x9883, 0xA883, 0xB0E4, 0xC8A3, 0xD8C5, 0xF79C, 0xFFDE, 0xFF9E, 0xE8E3, 0xF0C4, 0xE8E3, 0xF0A4, 0xE0E5, 0xE8E4,   // 0x02C0 (704)
+0xE0E3, 0xE8C5, 0xE8C5, 0xE8E3, 0xF8C3, 0xE8E5, 0xE8A5, 0xFFDE, 0xFF9F, 0xFFDE, 0xFFDE, 0xE946, 0xF186, 0xF1E9, 0xF26B, 0xF2AA,   // 0x02D0 (720)
+0x9882, 0xA0A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4,   // 0x02E0 (736)
+0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE905, 0xE925, 0xE986, 0xF1E8, 0xEA6A, 0xF2AB, 0x9882, 0xA0A3,   // 0x02F0 (752)
+0xB0A3, 0xC0C3, 0xD0C4, 0xD8C4, 0xE0C4, 0xE0C4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4,   // 0x0300 (768)
+0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE8C4, 0xE8E5, 0xE946, 0xF1C7, 0xEA69, 0xEA8A, 0x9883, 0xA0A3, 0xA8A3, 0xB8C3,   // 0x0310 (784)
+0xC8C4, 0xD0C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4,   // 0x0320 (800)
+0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xE8E4, 0xE905, 0xF146, 0xF1E8, 0xF249, 0x9883, 0x9883, 0xA8A3, 0xB0A3, 0xB8A3, 0xC0C3,   // 0x0330 (816)
+0xC8A4, 0xC8A4, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3,   // 0x0340 (832)
+0xC8C3, 0xC8C3, 0xD0A4, 0xD8C4, 0xE0E4, 0xF125, 0xF187, 0xF1E8, 0x9883, 0xA083, 0xA083, 0xB0A3, 0xB8A3, 0xB8C3, 0xC0C4, 0xC0C4,   // 0x0350 (848)
+0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3,   // 0x0360 (864)
+0xC8A4, 0xC8C3, 0xD0E3, 0xE0E4, 0xE925, 0xE967, 0x98A3, 0xA0A3, 0xA883, 0xB0A3, 0xB8A3, 0xB8A2, 0xC082, 0xC082, 0xB8A3, 0xB8A3,   // 0x0370 (880)
+0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xC0A3, 0xC0C3,   // 0x0380 (896)
+0xC8C3, 0xE0A4, 0xE0E5, 0xE946, };

_718/_718.ino

@@ -0,0 +1,340 @@
+
+// This program requires the UTFT library.
+
+#define imagedatatype  unsigned short
+//#include <UTFT_Buttons.h>
+#include <UTouch.h>
+#include <UTFT.h>
+//#include <UTFT_tinyFAT.h>
+#include <SdFat.h>
+//#include <SdFatUtil.h>
+SdFat sd;
+SdFile myFile;
+//#include <Time.h>
+//#include <rtc_clock.h>
+#include <MP1090S.h>
+#include <Wire.h>
+//RTC_clock rtc_clock(XTAL);
+
+//*********************RTC*************************************************************
+#include <DS3231.h>
+// Init the DS3231 using the hardware interface
+DS3231  rtc(A2, A3);
+
+// Init a Time-data structure
+Time  t;
+
+
+//**************BMP085****************************************************************
+#define BMP085_ADDRESS 0x77        // I2C address of BMP085
+
+const unsigned char OSS = 0;       // Oversampling Setting
+
+//float temperatur;
+float pressure;
+boolean rawp=0;
+// Calibration values of BMP085:
+short ac1;
+short ac2; 
+short ac3; 
+unsigned short ac4;
+unsigned short ac5;
+unsigned short ac6;
+short b1; 
+short b2;
+short mb;
+short mc;
+short md;
+long b5; 
+// temul[24]max t
+// temul[25]min t
+//*****************************************************************************
+word temdom[24]={256,254,260,264,265,266,270,268,259,255,250,249,256,254,260,264,265,266,270,268,259,255,250,249};
+word temul[26]={256,254,260,264,265,266,270,268,259,255,250,249,256,254,260,264,265,266,270,268,259,255,250,249,490,152};// max t=49.0  min 15.2
+word pres[24]={756,754,760,764,765,766,770,768,759,755,750,749,756,754,760,764,765,766,770,768,759,755,750,749};
+word time1[28]={1000,1100,1200,1300,1400,1500,1600,1700,1800,1900,2000,2100,2200,2300,0,100,200,300,400,500,600,700,800,900,16081,12004,20021,6454};//max 16.08.14 12:00    min 2.02.14  6:45
+word hug[24]={756,754,760,764,765,766,770,768,759,755,750,749,756,754,760,764,765,766,770,768,759,755,750,749};
+byte h[24]={25,25,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,25,25};
+byte sun[24]={0,0,0,0,0,0,0,0,20,20,20,20,20,20,20,20,20,20,20,20,20,0,0,0};
+word t1[24]={201,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t2[24]={202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t3[24]={203,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t4[24]={204,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t5[24]={205,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word bat[5]={300,300,300,300,300};
+byte h1[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h2[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h3[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h4[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h5[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+//word temul[24]={256,254,260,264,265,266,270,268,259,255,250,249,256,254,260,264,265,266,270,268,259,255,250,249};
+//*********************************************************************************
+
+extern uint8_t SevenSegNumFont[];
+extern uint8_t SmallFont[];
+extern uint8_t BigFont[];
+
+extern uint8_t Ubuntubold[];
+
+
+extern imagedatatype aandelen[];
+extern imagedatatype fotos[];
+extern imagedatatype instellingen[];
+extern imagedatatype radio[];
+extern imagedatatype klok[];
+extern imagedatatype cl[];
+extern imagedatatype pr[];
+extern imagedatatype le[];
+extern imagedatatype xf[];
+extern imagedatatype ad[];
+extern imagedatatype mi[];
+extern imagedatatype jar[];
+extern imagedatatype wer[];
+extern imagedatatype open[];//40
+extern imagedatatype del[];//40
+extern imagedatatype flr[];//40
+extern imagedatatype ints[];//40
+extern imagedatatype clokk[];//40
+extern imagedatatype dom1[];
+byte volume=7;
+byte rad=0;
+long StationFrequency;
+int vetzav;//napr vetra
+int vetczav;//skorost vetra
+int vetdzav;//skorost vetra dr
+int preszav;
+int vet;//napr vetra
+int vetc;//skorost vetra
+int vetd;//skorost vetra dr
+byte q=1;
+ byte hour1;
+byte hourp;//время пропуска данных massiv 623
+byte dd=0;// флаг перехода времени через 00
+  byte min1;
+ byte sec;
+ byte date;
+ byte mon;
+ word year1;
+ byte dow ;
+ byte night;
+int clockCenterX=300;
+int clockCenterY=230;
+int oldsec=0;
+char* str[] = {"MON","TUE","WED","THU","FRI","SAT","SUN"};
+const int chipSelect = 10;
+byte ptoday=0;//погода сегодня 0-солн 1-перемен обл 2-пасмурно 3-дождь 4- снег 5- туман 6-гроза
+byte pzav=0; //pogoda zavtra
+byte tu;
+//**********************************
+byte ntdat;//номер датчика
+byte zndat;//знак температуры 0+
+  int hourd1;//время прихода данных час
+  int mind1;//мин
+   int hourd2=2;//время прихода данных час
+  int mind2=2;//мин
+   int hourd3;//время прихода данных час
+  int mind3;//мин
+   int hourd4=4;//время прихода данных час
+  int mind4=4;//мин
+   int hourd5=5;//время прихода данных час
+  int mind5=5;//мин
+ boolean fh=0;// флаг данных одного часа записываются данные в файл только один раз в час
+ 
+ int hourdu=77;//время прихода данных час
+ int mindu=77;//мин
+ 
+  word h11=100;
+  word h12=100;
+  word h13=100;
+  word h14=100;
+  word h15=100;
+  word t11=202;
+  word t12=202;
+  word t13=202;
+  word t14=202;
+  word t15=202;
+ //********************************************
+ byte tud;
+byte  hu;
+byte   hud;
+ int volt;
+byte  zn;
+byte  znzav;
+byte tuzav;
+ byte tudzav;
+unsigned long currentMillis = millis();
+unsigned long previousMillis = 0; 
+int tab=0;
+boolean graf=0;
+byte colorgraf=0;
+ byte mon1;
+word years1;
+byte days1;
+int w=0;//счетчик строк при чтении из файла
+String bufer="";
+char* name; 
+boolean fa=0;//флаг изменения макс темп
+boolean fi=0;//флаг изменения мин темп
+boolean bt=0;//флаг показа барометра
+//boolean priemt=0;//флаг приема данных
+ long interval;  // interval at which to blink (milliseconds)
+
+//UTFT myGLCD(ITDB50,38,39,40,41);   // Remember to change the model parameter to suit your display module!
+UTFT myGLCD(TFT01_70,38,39,40,41);
+UTouch      myTouch(42,43,44,45,46);//TCLK, TCS, TDIN, TDOUT и IRQ.Папа
+//UTouch      myTouch(59,61,60,15,14);//TCLK, TCS, TDIN, TDOUT и IRQ.Вова
+//UTouch      myTouch(19,16,17,15,14);//TCLK, TCS, TDIN, TDOUT и IRQ.Вова
+//UTFT_Buttons  myButtons(&myGLCD, &myTouch);
+//int x,y;
+//UTFT_tinyFAT myFiles(&myGLCD);
+
+unsigned short pic1[0x320];
+
+
+ int color = 0;
+word colorlist[] = {VGA_WHITE, VGA_BLACK, VGA_RED, VGA_BLUE, VGA_GREEN, VGA_FUCHSIA, VGA_YELLOW, VGA_AQUA};
+int  bsize = 4;
+//unsigned short pic2[0x6400];
+//unsigned short pic3[0x6400];
+byte brightness=0;
+byte br;
+byte constbr=100;
+boolean c=0;
+boolean fcl=0;//флаг закрытия файла
+
+ // int pressed_button;
+  boolean default_colors = true;
+  
+boolean fsec=1;
+//**************************DHT11**********************************
+//#include "DHT.h"
+//#define DHTPIN 3     // what pin we're connected to
+//#define DHTTYPE DHT22   // DHT 22  (AM2302)
+//int humidity=50;
+//DHT dht(DHTPIN, DHTTYPE);
+  int tdc=20;
+ int tdd=0;
+  int hdc=50;
+ int hdd=0;
+//**************************************************************
+//#define SSID "VOVA-47" // введите ваш SSID
+//#define PASS "vovak26102003" // введите ваш пароль
+//#define DST_IP "188.226.224.148" //api.openweathermap.org
+boolean raw1=0;
+byte wifi=0;
+boolean fwifi=1;
+byte wifih=10;// час обновления данных
+byte wifim=15;// минуты
+//****************************************************************
+  int per=1;//номер передачи
+  //****************************************
+  int hour9;
+  int min9;
+  int t9;
+  int h9;
+  int osv9;
+  boolean zn9=0;
+    //****************************************
+int tfl=25;// temp flower
+int vfl=50;// vlaga flower
+int osv=37;// svet flower
+int dfl=12;// time flower
+
+int tfl2=26;// temp flower
+int vfl2=55;// vlaga flower
+int dfl2=13;// time flower
+
+int tfl3=27;// temp flower
+int vfl3=52;// vlaga flower
+int dfl3=14;// time flower
+  
+  //************************************
+  
+void setup()
+{   
+ rtc.begin();
+    Wire.begin();
+      Serial.begin(9600);       // скорость обмена по уарт  
+      delay(200);
+  Serial3.begin(9600);       // скорость обмена по уарт  
+//  delay(200);
+Serial2.begin(9600);       // скорость обмена по уарт WIFI 
+//Serial2.begin(115200);       // скорость обмена по уарт WIFI 
+  Serial2.setTimeout(5000);
+  bmp085Calibration();
+  delay(1000);
+ pinMode(65, OUTPUT);	
+ digitalWrite(65, LOW); 
+ Serial3.print(1); 
+ 
+ pinMode(18, OUTPUT);// reset WIFI 
+ digitalWrite(18, LOW);
+ delay(100);
+ digitalWrite(18, HIGH);
+ pinMode(53, OUTPUT);// reset nrf 
+ digitalWrite(53, LOW);
+ delay(100);
+ digitalWrite(53, HIGH);
+ // dumpRegisters();
+  //dps.dumpCalData();
+// uart(); 
+  pinMode(12, OUTPUT);
+   br=constbr+brightness;
+  analogWrite(12, 0);
+
+  delay(800);  // catch Due reset problem
+    pinMode(10, OUTPUT);
+  myGLCD.InitLCD();
+  myGLCD.setFont( BigFont);
+  myGLCD.fillScr(VGA_BLUE);
+//sd.begin(chipSelect, SPI_FULL_SPEED );
+sd.begin(chipSelect, SPI_HALF_SPEED );
+// file system
+SdFat sd;
+
+ myTouch.InitTouch();
+  myTouch.setPrecision(PREC_HI);
+ // dht.begin();
+  dtu21();
+ //    rtc_clock.init();
+ //readmasclok();
+ readmasrab(); 
+////  rtc.setTime(12, 39, 0);     // Set the time to 12:00:00 (24hr format)
+//rtc.setDate(29, 11, 2015);   // Set the date to January 1st, 2014
+//rtc.setDOW(THURSDAY); 
+
+     t = rtc.getTime();
+  years1=t.year;
+  days1=t.date;
+  mon1=t.mon;
+//  dow=calcDOW(days1, mon1, years1);
+//  rtc.setDOW(dow);
+dow=t.dow ;
+hour1=t.hour;
+min1=t.min; 
+delay(100);
+ 
+//  myButtons.setTextFont(BigFont);
+ // myButtons.setSymbolFont(Dingbats1_XL);
+//dtu21();
+// esp8266();
+ br=constbr+brightness;
+  analogWrite(12, br);
+}
+
+//myFiles.loadBitmap(0, 0, 320, 240, "33.raw");
+
+void loop()
+{
+ if (t.date==0)
+  {
+    setClock();
+  }  
+ 
+  
+  
+  
+  
+  
+  menu();
+}

_718/aandelen.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: aandelen.jpg
+// Time generated: 24.03.2014 12:01:54
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short aandelen[0x1900] ={
+0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0021, 0x0021, 0x0001, 0x0000, 0x0001, 0x0821, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0010 (16)
+0x0020, 0x0021, 0x0021, 0x0001, 0x0000, 0x0000, 0x0000, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0800,   // 0x0020 (32)
+0x0800, 0x0800, 0x0000, 0x0000, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0030 (48)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0040 (64)
+0x0001, 0x0801, 0x0821, 0x0000, 0x0000, 0x0820, 0x1021, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0820, 0x0800, 0x0000,   // 0x0050 (80)
+0x1000, 0x0800, 0x0820, 0x1061, 0x0841, 0x0000, 0x0000, 0x0001, 0x0882, 0x0842, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0060 (96)
+0x0000, 0x0001, 0x0021, 0x0042, 0x0041, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0070 (112)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0080 (128)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0821, 0x1062,   // 0x0090 (144)
+0x0842, 0x0001, 0x0001, 0x1042, 0x0021, 0x0000, 0x0801, 0x0842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x00A0 (160)
+0x0800, 0x1040, 0x1020, 0x0000, 0x0000, 0x0042, 0x0883, 0x0063, 0x0001, 0x0001, 0x0001, 0x0001, 0x0021, 0x0841, 0x0021, 0x0000,   // 0x00B0 (176)
+0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00C0 (192)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,   // 0x00D0 (208)
+0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00E0 (224)
+0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x18A3, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0840,   // 0x00F0 (240)
+0x1040, 0x0820, 0x0000, 0x0000, 0x10A2, 0x0022, 0x0001, 0x0021, 0x0042, 0x0022, 0x2126, 0x52CC, 0x6BAF, 0x94D4, 0xBE19, 0xD6FD,   // 0x0100 (256)
+0xE73E, 0xDF5E, 0xDF5F, 0xD73E, 0xD73E, 0xDF3F, 0xDF3F, 0xD71E, 0xD71E, 0xDF1E, 0xDF3E, 0xDF3F, 0xDF3F, 0xDF3E, 0xDF1E, 0xDF1E,   // 0x0110 (272)
+0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF3E, 0xDF3E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E,   // 0x0120 (288)
+0xDF1F, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDEFE, 0xDEFE, 0xDEFE, 0xDF1E, 0xDF1E, 0xDF1F, 0xDEFE, 0xDF1D, 0xF7BE,   // 0x0130 (304)
+0xE75F, 0xC65A, 0xA536, 0x94B4, 0x5AED, 0x18E5, 0x0022, 0x10A3, 0x0021, 0x0000, 0x0021, 0x0841, 0x0021, 0x0000, 0x0000, 0x0020,   // 0x0140 (320)
+0x0800, 0x1020, 0x0820, 0x0000, 0x0001, 0x0001, 0x0001, 0x0002, 0x1926, 0x7412, 0xC69C, 0xDF5F, 0xD71D, 0xD6FD, 0xD6DD, 0xCEBC,   // 0x0150 (336)
+0xC6BC, 0xC6BD, 0xC6BD, 0xC6DE, 0xC6FE, 0xC6DE, 0xC6BE, 0xC6BE, 0xC6BD, 0xC6BE, 0xC6DE, 0xC6DE, 0xC6DE, 0xC6BE, 0xC6BE, 0xC6BE,   // 0x0160 (352)
+0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC69E, 0xC69E, 0xC69E, 0xC69E, 0xC69E,   // 0x0170 (368)
+0xC69E, 0xCE9E, 0xC69D, 0xC69D, 0xCEBE, 0xCEBE, 0xCEBE, 0xC69D, 0xC69D, 0xCE9E, 0xCEBE, 0xCEBE, 0xCEBE, 0xCEBE, 0xCE9D, 0xC65C,   // 0x0180 (384)
+0xC67C, 0xCEDE, 0xCEDE, 0xBE5B, 0xC69C, 0xC67B, 0x8453, 0x2147, 0x0022, 0x0001, 0x0001, 0x0001, 0x0041, 0x0021, 0x0000, 0x0000,   // 0x0190 (400)
+0x0800, 0x0820, 0x0820, 0x0000, 0x0001, 0x0002, 0x2167, 0x6BF2, 0xA5D9, 0xC6DD, 0xC6DD, 0xBE7C, 0xC69C, 0xC6BD, 0xCEDD, 0xCEFE,   // 0x01A0 (416)
+0xCEFF, 0xC6FF, 0xBEFF, 0xBEBE, 0xBEBE, 0xC6DF, 0xC6DF, 0xBEDF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF,   // 0x01B0 (432)
+0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xC6DF, 0xC6DF, 0xC6DF, 0xBEBF, 0xBEBF, 0xC6DF, 0xC6DF, 0xC6DF,   // 0x01C0 (448)
+0xC6BF, 0xC6BF, 0xC6BF, 0xC6BF, 0xC6BF, 0xC6BF, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BF, 0xCEBF, 0xC6BE, 0xCEBE, 0xC6BE, 0xC6BE, 0xCEFF,   // 0x01D0 (464)
+0xCF1F, 0xC6BE, 0xC6BD, 0xD71F, 0xD71F, 0xCEDE, 0xC67C, 0xB61A, 0x7412, 0x2167, 0x0001, 0x0001, 0x0000, 0x0021, 0x0020, 0x0000,   // 0x01E0 (480)
+0x0800, 0x1082, 0x1062, 0x0000, 0x0001, 0x424B, 0xA599, 0xDF7F, 0xCF3F, 0xBEBD, 0xBEBE, 0xC6DE, 0xBEBE, 0xBE9D, 0xBE7D, 0xB67D,   // 0x01F0 (496)
+0xB67D, 0xB69E, 0xB69E, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEBF, 0xBEBF, 0xBEDF, 0xBEDF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEDF, 0xB6BF,   // 0x0200 (512)
+0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF,   // 0x0210 (528)
+0xBEBF, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9E, 0xBE9E, 0xBE7E, 0xBE7E, 0xBE9E, 0xBE9E, 0xAE3D,   // 0x0220 (544)
+0xAE7D, 0xBEDE, 0xBEDE, 0xB65C, 0xBEBD, 0xCF1F, 0xCF1F, 0xBE7C, 0xCEFE, 0x9516, 0x3A2A, 0x0883, 0x0001, 0x0021, 0x0021, 0x0000,   // 0x0230 (560)
+0x0841, 0x0020, 0x0000, 0x0042, 0x3A2A, 0x8CF6, 0xBEBD, 0xBEDE, 0xAE5D, 0xB69E, 0xB6BE, 0xB6BE, 0xB6BE, 0xBEDF, 0xBEBE, 0xBEBF,   // 0x0240 (576)
+0xB6BF, 0xB6BF, 0xAE9F, 0xAEBF, 0xAE9F, 0xB69F, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB69F, 0xB69F, 0xAE9F, 0xB69F, 0xB6BF, 0xB6BF,   // 0x0250 (592)
+0xAE9F, 0xAE9F, 0xAE9F, 0xB69F, 0xB69F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F,   // 0x0260 (608)
+0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEBF, 0xBEBF, 0xB6BF, 0xB69F, 0xBE9F, 0xBEBF, 0xBEDF, 0xBEDF,   // 0x0270 (624)
+0xBEDF, 0xB6DF, 0xB6DF, 0xB6BF, 0xB69E, 0xB67E, 0xB69E, 0xBEBE, 0xBE9D, 0xCF1F, 0x9D57, 0x2167, 0x0022, 0x0001, 0x0021, 0x0000,   // 0x0280 (640)
+0x0821, 0x0000, 0x0000, 0x2147, 0x9D77, 0xB65C, 0xB67D, 0xB6BF, 0xB6BF, 0xAE9E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE9E,   // 0x0290 (656)
+0xAE9F, 0xAE7F, 0xA69F, 0xA69F, 0xA69F, 0xAE7F, 0xAE5F, 0xBEBF, 0xBEFF, 0xAE5E, 0xAE7F, 0xB69F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE7F,   // 0x02A0 (672)
+0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xA69F, 0xAE9F, 0xAE9F, 0xAE9F,   // 0x02B0 (688)
+0xAE7F, 0xAE9F, 0xAE7F, 0xAE9F, 0xAE7F, 0xAE7E, 0xAE9E, 0xBF3F, 0xB6DF, 0xAE7E, 0xAE9F, 0xAE7E, 0xAE9E, 0xAE9E, 0xAE9F, 0xAE9F,   // 0x02C0 (704)
+0xAE9F, 0xAE9F, 0xAE9F, 0xAE9E, 0xAE9E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE7D, 0xBEBE, 0xBE9D, 0x9517, 0x1126, 0x0001, 0x0001, 0x0021,   // 0x02D0 (720)
+0x0822, 0x0000, 0x0863, 0x4AAD, 0xB61B, 0xBE7D, 0xAE7E, 0xB69F, 0xAE9F, 0xA67E, 0xA65F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xA67F,   // 0x02E0 (736)
+0xA67F, 0xA67F, 0xA69F, 0xA69F, 0xA67F, 0xA67F, 0xAE3E, 0xB69F, 0xBEDF, 0xAE5E, 0xAE7E, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F,   // 0x02F0 (752)
+0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xA67F, 0xAE7F, 0xA67F, 0xA67F, 0xA69F, 0xA69F, 0xA69F, 0xA67F, 0xA67F,   // 0x0300 (768)
+0xA67F, 0xA67F, 0xA67E, 0xA67E, 0xA67E, 0xA67E, 0xA69E, 0xBF1F, 0xAEBF, 0xA65E, 0xAE7E, 0xA67E, 0xA67E, 0xAE7E, 0xA67E, 0xA67F,   // 0x0310 (784)
+0xA69F, 0xA67F, 0xA67F, 0xA67F, 0xA67F, 0xA67F, 0xAE7E, 0xAE7E, 0xAE7E, 0xB67D, 0xBE9E, 0xADFA, 0x42AD, 0x0863, 0x0001, 0x0022,   // 0x0320 (800)
+0x0001, 0x0000, 0x2167, 0x8474, 0xB65D, 0xB67E, 0xAE5E, 0xA65E, 0xA65F, 0x9E3E, 0x9E5F, 0xA67F, 0xA65F, 0xA65F, 0xA65F, 0xA65F,   // 0x0330 (816)
+0xA67F, 0x9E7F, 0x9E7F, 0x9E7F, 0x9E5F, 0xA63E, 0xA61E, 0xB69F, 0xBEDF, 0xA63E, 0xA63E, 0xAE5E, 0xA65E, 0xAE5E, 0xA65E, 0xA65E,   // 0x0340 (832)
+0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0x9E5F, 0x9E7E, 0x9E7E, 0x9E7E, 0x9E7E, 0x9E7E,   // 0x0350 (848)
+0x9E5F, 0x9E7E, 0x9E7E, 0xA67E, 0x9E5E, 0x9E5E, 0xA67E, 0xB6FF, 0xAEBE, 0x9E5D, 0xA67E, 0x9E5E, 0xA65E, 0xA67E, 0xA67E, 0x9E7F,   // 0x0360 (864)
+0x9E7F, 0x9E7F, 0x9E7F, 0x9E7F, 0xA67F, 0xA67F, 0xA67E, 0xA67E, 0xA67E, 0xA63D, 0xAE5D, 0xB65D, 0x7C95, 0x2168, 0x0001, 0x0001,   // 0x0370 (880)
+0x0002, 0x0000, 0x3A0A, 0xA5BA, 0xB63C, 0xAE3D, 0xA63E, 0x9E5E, 0x9E3F, 0x9E3F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F,   // 0x0380 (896)
+0x9E5F, 0x9E5F, 0x9E5F, 0x965F, 0x9E3F, 0x9E1E, 0x9DFE, 0xAE7E, 0xB6BF, 0xA61E, 0xA61E, 0xA63E, 0x9E1E, 0xA63E, 0xA63E, 0x9E3E,   // 0x0390 (912)
+0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E5F, 0x9E5F, 0x9E5E, 0x9E5E, 0x9E5E, 0x9E5E, 0x9E5E,   // 0x03A0 (928)
+0x9E5E, 0x9E5E, 0x9E5E, 0x9E5E, 0x9E3E, 0x9E3E, 0x9E5E, 0xB6FF, 0xA69E, 0x9E3D, 0x9E5E, 0x9E3D, 0x9E3E, 0x9E5E, 0x9E5E, 0x9E5E,   // 0x03B0 (944)
+0x965F, 0x965F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5E, 0x9E5E, 0x9E5E, 0x9DFD, 0xA61C, 0xB65D, 0xADFB, 0x3A2C, 0x0001, 0x0002,   // 0x03C0 (960)
+0x0002, 0x0000, 0x428D, 0xB67D, 0xA5FC, 0x9DFD, 0x9E1E, 0x9E5F, 0x961F, 0x961F, 0x963F, 0x963F, 0x963F, 0x963F, 0x963E, 0x963E,   // 0x03D0 (976)
+0x963F, 0x963F, 0x963F, 0x963F, 0x963F, 0x9E1E, 0x9DFE, 0xAE7F, 0xB6BF, 0x9DFE, 0x9E1E, 0x9E1E, 0x9E1E, 0x9E1E, 0x9E1F, 0x9E3F,   // 0x03E0 (992)
+0x9E1F, 0x9E1F, 0x9E1F, 0x961F, 0x963F, 0x963F, 0x961F, 0x961F, 0x963F, 0x963F, 0x963F, 0x963F, 0x963F, 0x963E, 0x963E, 0x963E,   // 0x03F0 (1008)
+0x963E, 0x963E, 0x963E, 0x963E, 0x961E, 0x961E, 0x963E, 0xAEDF, 0xA67F, 0x961D, 0x9E3E, 0x9E1E, 0x9E3E, 0x9E3E, 0x9E3E, 0x963F,   // 0x0400 (1024)
+0x963F, 0x963F, 0x963F, 0x963F, 0x961F, 0x963F, 0x963F, 0x9E1E, 0x9E1E, 0x9DFD, 0x9DFD, 0xA61D, 0xB65D, 0x428E, 0x0001, 0x0003,   // 0x0410 (1040)
+0x0023, 0x0001, 0x428D, 0xBE7D, 0xA5DC, 0x9DDC, 0x95FE, 0x961F, 0x8DFF, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x961E, 0x961E, 0x961E,   // 0x0420 (1056)
+0x961E, 0x95FE, 0x95FE, 0x8E1F, 0x961E, 0x95FE, 0x95DE, 0xA65F, 0xAE9F, 0x9DFE, 0x95FE, 0x95FE, 0x95FE, 0x95FE, 0x961F, 0x961F,   // 0x0430 (1072)
+0x95FF, 0x95FF, 0x8E1F, 0x8DFF, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x961F, 0x961E, 0x961E, 0x961E, 0x961E,   // 0x0440 (1088)
+0x961E, 0x961E, 0x961E, 0x961E, 0x95FE, 0x8DFE, 0x961E, 0xAEBF, 0x9E5E, 0x95DD, 0x961E, 0x95FE, 0x961E, 0x961E, 0x961E, 0x961E,   // 0x0450 (1104)
+0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x961F, 0x95FF, 0x961E, 0x95FE, 0x9E1E, 0x9DFD, 0x9DDC, 0xB65D, 0x428E, 0x0002, 0x0003,   // 0x0460 (1120)
+0x0024, 0x0002, 0x426D, 0xB63D, 0xA5DC, 0x95DC, 0x8DDD, 0x8DFE, 0x8DDE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DDE,   // 0x0470 (1136)
+0x8DFD, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DDD, 0x8DDE, 0x9E5F, 0xA67F, 0x95DE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DFF, 0x8DFF,   // 0x0480 (1152)
+0x8DFF, 0x8DFF, 0x8DFF, 0x85FF, 0x85FF, 0x85FF, 0x85FF, 0x85FF, 0x85FF, 0x8DFF, 0x8DFF, 0x8DFF, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE,   // 0x0490 (1168)
+0x8DFE, 0x8DFF, 0x8DFE, 0x8DFE, 0x8DDE, 0x8DDE, 0x95DE, 0xA67F, 0x9E1E, 0x8DBD, 0x95FE, 0x8DDD, 0x95DE, 0x95DE, 0x95FE, 0x8DFE,   // 0x04A0 (1184)
+0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DDE, 0x8DDE, 0x95DE, 0x95FE, 0x9DFD, 0x9DBC, 0xAE1D, 0x3A6E, 0x0002, 0x0003,   // 0x04B0 (1200)
+0x0002, 0x0001, 0x322C, 0xA5FC, 0x9DFD, 0x95FD, 0x8DBD, 0x859D, 0x85BE, 0x8DFF, 0x8DFF, 0x8DDF, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE,   // 0x04C0 (1216)
+0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DBE, 0x8DBE, 0x9E3F, 0xA67F, 0x8DDE, 0x8DBE, 0x85BE, 0x85BE, 0x85DE, 0x8DDF, 0x85DF,   // 0x04D0 (1232)
+0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF,   // 0x04E0 (1248)
+0x8DDE, 0x8DDF, 0x8DDE, 0x8DDE, 0x8DBE, 0x8DBE, 0x8DDE, 0xA65F, 0x95FF, 0x8D9E, 0x8DBE, 0x8DBE, 0x8DBE, 0x8DBE, 0x8DDE, 0x8DDE,   // 0x04F0 (1264)
+0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DBD, 0x959C, 0x959C, 0xA5FD, 0x3A6E, 0x0003, 0x0003,   // 0x0500 (1280)
+0x0001, 0x0000, 0x3A4D, 0x961D, 0x85BD, 0x85BE, 0x7DBE, 0x7D9D, 0x8DDE, 0x859D, 0x859D, 0x85BE, 0x85BF, 0x85BF, 0x85BF, 0x85BE,   // 0x0510 (1296)
+0x85BE, 0x85BE, 0x7DBF, 0x7DBF, 0x7DBF, 0x859E, 0x855D, 0x95FE, 0xA69F, 0x8DBE, 0x7D7E, 0x7D9E, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF,   // 0x0520 (1312)
+0x7DDF, 0x7DDF, 0x7DDF, 0x7DDF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x85BF, 0x85BF,   // 0x0530 (1328)
+0x85DF, 0x85BF, 0x85BE, 0x85BE, 0x859D, 0x857C, 0x859D, 0xA69F, 0x961E, 0x7D5C, 0x8DBE, 0x859D, 0x857D, 0x859E, 0x859E, 0x8DBF,   // 0x0540 (1344)
+0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BE, 0x8D9D, 0x8D7B, 0x959B, 0x9DDC, 0x3A4D, 0x0002, 0x0003,   // 0x0550 (1360)
+0x0000, 0x0000, 0x326D, 0x8E1E, 0x7D9E, 0x75BF, 0x759F, 0x7D7E, 0x8DBE, 0x857D, 0x857D, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F,   // 0x0560 (1376)
+0x7D9F, 0x7D9E, 0x759F, 0x759F, 0x759F, 0x7D7E, 0x7D3D, 0x95FE, 0xA69F, 0x85BE, 0x7D7E, 0x7D7E, 0x7D9F, 0x759F, 0x759F, 0x759F,   // 0x0570 (1392)
+0x759F, 0x759F, 0x759F, 0x759F, 0x759F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x757E, 0x7D9F, 0x7DBF, 0x7DDF, 0x7D9F, 0x757F,   // 0x0580 (1408)
+0x755E, 0x7D7E, 0x859E, 0x85BE, 0x7D9D, 0x7D5C, 0x857C, 0xA6BF, 0x961E, 0x7D5C, 0x859E, 0x7D7D, 0x7D7E, 0x857F, 0x859F, 0x859F,   // 0x0590 (1424)
+0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x859E, 0x859D, 0x8D9C, 0x8D9B, 0x9DDC, 0x3A4D, 0x0002, 0x0003,   // 0x05A0 (1440)
+0x0000, 0x0000, 0x324D, 0x8DFE, 0x757E, 0x6D9F, 0x6D7F, 0x755E, 0x859E, 0x7D5C, 0x7D5D, 0x7D7E, 0x757F, 0x757F, 0x757F, 0x757F,   // 0x05B0 (1456)
+0x757F, 0x757E, 0x757F, 0x6D9F, 0x757F, 0x7D5E, 0x7D1D, 0x8DDE, 0x9E5F, 0x7D7E, 0x753E, 0x755E, 0x757F, 0x757E, 0x6D7F, 0x6D7F,   // 0x05C0 (1472)
+0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x755E, 0x757F, 0x759F, 0x759F, 0x759F, 0x759F, 0x757F, 0x757E,   // 0x05D0 (1488)
+0x755D, 0x7D5D, 0x7D7D, 0x7D9D, 0x7D7C, 0x753C, 0x7D5D, 0x9E9F, 0x8DFE, 0x753D, 0x7D9E, 0x755E, 0x757E, 0x7D7F, 0x7D9F, 0x755F,   // 0x05E0 (1504)
+0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757E, 0x7D7E, 0x7D7D, 0x857C, 0x857B, 0x95BB, 0x324D, 0x0003, 0x0003,   // 0x05F0 (1520)
+0x0800, 0x0000, 0x322C, 0x85BE, 0x6D5D, 0x6D7E, 0x655E, 0x6D3E, 0x7D7E, 0x7D5D, 0x753D, 0x755E, 0x6D7F, 0x6D5F, 0x6D7F, 0x6D7F,   // 0x0600 (1536)
+0x755E, 0x6D5E, 0x6D7F, 0x6D7F, 0x6D5F, 0x753E, 0x751D, 0x8DBE, 0x9E3F, 0x7D5E, 0x6D1D, 0x6D3E, 0x757E, 0x6D5E, 0x6D5E, 0x6D5E,   // 0x0610 (1552)
+0x6D5F, 0x6D5F, 0x6D5F, 0x6D5F, 0x6D5E, 0x755E, 0x755E, 0x755E, 0x755E, 0x755F, 0x757F, 0x6D5F, 0x6D3E, 0x6D3E, 0x755E, 0x755D,   // 0x0620 (1568)
+0x753C, 0x6CFB, 0x6CFA, 0x751B, 0x751C, 0x751C, 0x753C, 0x9E7F, 0x85BE, 0x6D1D, 0x757F, 0x6D5E, 0x6D5E, 0x6D7F, 0x6D7F, 0x6D5E,   // 0x0630 (1584)
+0x6D5E, 0x6D5E, 0x6D5E, 0x6D5E, 0x6D5E, 0x6D5F, 0x6D5E, 0x6D5E, 0x755E, 0x755D, 0x7D5C, 0x7D5B, 0x8D7B, 0x324E, 0x0003, 0x0004,   // 0x0640 (1600)
+0x0801, 0x0000, 0x322D, 0x85BE, 0x6D3D, 0x655E, 0x653E, 0x653E, 0x755E, 0x6D1D, 0x6D1D, 0x6D3F, 0x653F, 0x653F, 0x655F, 0x653F,   // 0x0650 (1616)
+0x6D3E, 0x655E, 0x655F, 0x655F, 0x653F, 0x6D3E, 0x6CFD, 0x859E, 0x961F, 0x755E, 0x6D1D, 0x6D1E, 0x6D5E, 0x6D3E, 0x653E, 0x655E,   // 0x0660 (1632)
+0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D1E, 0x64FE, 0x6D3F, 0x755F, 0x6D3D, 0x6CFC, 0x6CFA,   // 0x0670 (1648)
+0x6D1A, 0x7D3B, 0x7D3B, 0x753B, 0x74FB, 0x6CFB, 0x6CFC, 0x963F, 0x7D9E, 0x64FE, 0x6D5F, 0x653F, 0x653E, 0x5D5F, 0x655F, 0x655F,   // 0x0680 (1664)
+0x655E, 0x655E, 0x655E, 0x655F, 0x655F, 0x655F, 0x655E, 0x655E, 0x6D5E, 0x755E, 0x753D, 0x751B, 0x857C, 0x322E, 0x0004, 0x0005,   // 0x0690 (1680)
+0x0801, 0x0000, 0x2A0D, 0x7D9E, 0x651D, 0x5D1E, 0x5D1E, 0x651E, 0x6D5E, 0x6D1D, 0x651E, 0x653F, 0x5D3F, 0x5D3F, 0x5D3F, 0x5D3F,   // 0x06A0 (1696)
+0x653E, 0x653E, 0x653E, 0x5D3F, 0x653F, 0x651E, 0x64DD, 0x7D7E, 0x8DFF, 0x6D1E, 0x64FD, 0x651E, 0x653E, 0x651E, 0x651E, 0x653E,   // 0x06B0 (1712)
+0x653E, 0x653E, 0x651E, 0x651E, 0x651E, 0x651E, 0x6D1E, 0x651E, 0x6D1E, 0x6D1E, 0x64DE, 0x6D1F, 0x753E, 0x64DB, 0x5C79, 0x6D1A,   // 0x06C0 (1728)
+0x9E7D, 0xBF5F, 0xBF3F, 0xA67E, 0x7D3C, 0x647A, 0x6CDC, 0x8DFF, 0x757F, 0x5CDE, 0x5D3F, 0x551F, 0x553E, 0x555F, 0x555E, 0x5D5F,   // 0x06D0 (1744)
+0x5D5E, 0x5D5F, 0x5D5F, 0x5D5F, 0x5D3F, 0x5D3E, 0x653E, 0x653D, 0x653D, 0x6D3D, 0x753D, 0x74FC, 0x855C, 0x322F, 0x0004, 0x0045,   // 0x06E0 (1760)
+0x0802, 0x0000, 0x2A0D, 0x7D7D, 0x5CFD, 0x54FE, 0x54FE, 0x5CFE, 0x653F, 0x64FD, 0x5CFE, 0x551F, 0x551F, 0x551F, 0x551F, 0x551F,   // 0x06F0 (1776)
+0x5D1E, 0x5D1E, 0x5D1E, 0x5D1E, 0x5D1E, 0x64FD, 0x5CBD, 0x755E, 0x85FF, 0x651E, 0x5CDD, 0x5CFD, 0x5D1E, 0x5CFE, 0x5CFE, 0x5CFE,   // 0x0700 (1792)
+0x5D1E, 0x5D1E, 0x5D1E, 0x5CFE, 0x5CFE, 0x5CFE, 0x5CFE, 0x5CFE, 0x64FE, 0x64FE, 0x6CFF, 0x6CDD, 0x649B, 0x5C79, 0x74FA, 0xA67E,   // 0x0710 (1808)
+0xCF9F, 0xEFFF, 0xEFFF, 0xD7BF, 0x95BC, 0x5C39, 0x6C9B, 0x8DDF, 0x753F, 0x549D, 0x5D1F, 0x54FE, 0x4D1E, 0x4D3E, 0x555E, 0x553E,   // 0x0720 (1824)
+0x551E, 0x551F, 0x551F, 0x551F, 0x551E, 0x5D1E, 0x5D1D, 0x5D1C, 0x651C, 0x64FC, 0x6CDB, 0x6CBB, 0x7D1B, 0x2A2E, 0x0003, 0x0045,   // 0x0730 (1840)
+0x0801, 0x0000, 0x29ED, 0x755E, 0x54DD, 0x54FE, 0x4CFF, 0x4CDE, 0x651F, 0x54DE, 0x54DE, 0x551F, 0x4CFF, 0x4CFF, 0x551F, 0x54FF,   // 0x0740 (1856)
+0x5CFE, 0x5CFD, 0x5CFE, 0x5CFE, 0x5CFE, 0x5CDD, 0x5C9D, 0x6D3E, 0x7DDF, 0x5D1E, 0x54BD, 0x54DD, 0x5CFE, 0x54FE, 0x54FE, 0x54FE,   // 0x0750 (1872)
+0x54FF, 0x54FF, 0x54FF, 0x54FF, 0x54FF, 0x5CFF, 0x5CFF, 0x54FF, 0x5CFE, 0x64FE, 0x6CDE, 0x5C3A, 0x5418, 0x751A, 0xAE9E, 0xD7DF,   // 0x0760 (1888)
+0xDFDF, 0xCF5F, 0xCF5F, 0xEFFF, 0xA5FB, 0x5BD7, 0x6C9B, 0x8DBF, 0x751D, 0x547C, 0x5CFE, 0x54FE, 0x4D1D, 0x4D3D, 0x555E, 0x4D1D,   // 0x0770 (1904)
+0x4CFE, 0x54DF, 0x54DF, 0x54DF, 0x54DE, 0x54DD, 0x5CFC, 0x5CFC, 0x64FB, 0x5CBB, 0x5C39, 0x5C18, 0x7499, 0x29CC, 0x0002, 0x0023,   // 0x0780 (1920)
+0x0001, 0x0002, 0x21ED, 0x64DC, 0x54DD, 0x44BE, 0x44DF, 0x4CDF, 0x54DE, 0x54DF, 0x4CBE, 0x44BE, 0x4D1F, 0x44DF, 0x44DF, 0x54FE,   // 0x0790 (1936)
+0x5D1F, 0x5CDC, 0x54BC, 0x4C9C, 0x4C9C, 0x549C, 0x54BC, 0x6D5F, 0x759F, 0x54DD, 0x54BD, 0x5CFE, 0x54FE, 0x4C9D, 0x4C9D, 0x4CDE,   // 0x07A0 (1952)
+0x54DE, 0x4CDE, 0x54FF, 0x54FF, 0x54DF, 0x4C9E, 0x4CBF, 0x54DF, 0x54DF, 0x549D, 0x649C, 0x53D8, 0x6C79, 0xAE3E, 0xDFDF, 0xDFFF,   // 0x07B0 (1968)
+0xBEBC, 0xAE3B, 0xDFBF, 0xF7FF, 0xBEBD, 0x7479, 0x63F8, 0x853D, 0x7D5F, 0x6CDD, 0x549C, 0x445A, 0x54DC, 0x553D, 0x4CDB, 0x449C,   // 0x07C0 (1984)
+0x54FE, 0x54FF, 0x4C9F, 0x445E, 0x5CFF, 0x5CFE, 0x54BB, 0x549A, 0x43F7, 0x6CDB, 0x961F, 0xA63E, 0x9DBC, 0x320C, 0x0001, 0x0062,   // 0x07D0 (2000)
+0x0002, 0x0003, 0x21CD, 0x5CBC, 0x54FE, 0x44DF, 0x44DF, 0x44DF, 0x449E, 0x4C9E, 0x4CDE, 0x4CFF, 0x4D1F, 0x3C9E, 0x3C5D, 0x449D,   // 0x07E0 (2016)
+0x5CBC, 0x549B, 0x549B, 0x549B, 0x4C7A, 0x4C5B, 0x4C5B, 0x75BE, 0x8E5F, 0x443A, 0x4C9D, 0x4C9C, 0x445B, 0x54FE, 0x4CDE, 0x4CBE,   // 0x07F0 (2032)
+0x44BD, 0x44BE, 0x4CBE, 0x449E, 0x449E, 0x44BE, 0x4CBF, 0x4CDF, 0x44BE, 0x4C7C, 0x5C7A, 0x53B6, 0x8D3A, 0xD7BF, 0xE7FF, 0xA5F9,   // 0x0800 (2048)
+0x63F2, 0x7453, 0xC6DD, 0xDF7F, 0xBE9E, 0x84B8, 0x63F6, 0x8D9D, 0x7CFC, 0x5C39, 0x5459, 0x4C38, 0x4C78, 0x4C79, 0x4C7A, 0x54BC,   // 0x0810 (2064)
+0x54DE, 0x54BF, 0x4C5F, 0x4C5F, 0x54BE, 0x547B, 0x4418, 0x5457, 0x64DA, 0x9E5E, 0xD7DF, 0xE7FF, 0xDF9F, 0x4ACE, 0x0000, 0x0040,   // 0x0820 (2080)
+0x0002, 0x0003, 0x19CD, 0x549C, 0x4CDE, 0x44BF, 0x3CDF, 0x44DF, 0x3C9E, 0x449E, 0x3C9E, 0x3C9F, 0x3CBF, 0x3C7E, 0x44BE, 0x54BD,   // 0x0830 (2096)
+0x547A, 0x43F8, 0x4C18, 0x5459, 0x545A, 0x4C39, 0x43F9, 0x64FC, 0x7DDF, 0x54BC, 0x4C5A, 0x443A, 0x445B, 0x54BD, 0x4C9C, 0x4C9C,   // 0x0840 (2112)
+0x449D, 0x4CBD, 0x4CBE, 0x3C5D, 0x3C5D, 0x4CFF, 0x44BF, 0x3C9F, 0x447E, 0x4C5C, 0x53F7, 0x7479, 0xB69D, 0xEFFF, 0xDF9F, 0xAE1B,   // 0x0850 (2128)
+0x84D7, 0x84F6, 0xAE1B, 0xDF9F, 0xDF5F, 0x955A, 0x5B73, 0x9DDD, 0x7CDA, 0x4354, 0x53F6, 0x7D5C, 0x85BE, 0x64FA, 0x4C38, 0x549B,   // 0x0860 (2144)
+0x4C7C, 0x4C5E, 0x4C3F, 0x545F, 0x545D, 0x4BF9, 0x4BF8, 0x64D9, 0xA69E, 0xD7DF, 0xEFFF, 0xEFFF, 0xFFFF, 0x5B4E, 0x0000, 0x0000,   // 0x0870 (2160)
+0x0003, 0x0003, 0x118D, 0x3BFA, 0x343C, 0x243D, 0x2C5F, 0x34BF, 0x349E, 0x3C9E, 0x3C9F, 0x349F, 0x347E, 0x3C9E, 0x4CDE, 0x4C9B,   // 0x0880 (2176)
+0x4418, 0x4BD6, 0x751B, 0xA69E, 0xAEBE, 0x751C, 0x3B96, 0x4C39, 0x757E, 0x549A, 0x5CBA, 0x4C3A, 0x3BD8, 0x4C3A, 0x3BD9, 0x3BD9,   // 0x0890 (2192)
+0x443B, 0x4C7C, 0x4CDD, 0x445C, 0x445D, 0x54FF, 0x3C7E, 0x3C5E, 0x445E, 0x4C3A, 0x4395, 0x95DB, 0xDFDF, 0xD77E, 0x8D39, 0x7476,   // 0x08A0 (2208)
+0x6BF4, 0x63B3, 0x7436, 0xC6DD, 0xF7FF, 0xB65B, 0x5352, 0x9D9B, 0x74B7, 0x5373, 0x74B8, 0xBEFF, 0xD7FF, 0xAEDF, 0x6CDB, 0x4418,   // 0x08B0 (2224)
+0x43FA, 0x4C3D, 0x545F, 0x543F, 0x545D, 0x4BF9, 0x5C79, 0x961E, 0xCFBF, 0xCF7F, 0x955B, 0x5332, 0x6392, 0x2147, 0x0000, 0x10C1,   // 0x08C0 (2240)
+0x0024, 0x0004, 0x096D, 0x2398, 0x1B9A, 0x0B9B, 0x13DD, 0x243E, 0x2C3D, 0x345E, 0x3C9F, 0x3CBF, 0x3CBE, 0x3C7D, 0x3C3B, 0x3BF8,   // 0x08D0 (2256)
+0x53F7, 0x7CFB, 0xBEFE, 0xDFFF, 0xDFFF, 0xCF7F, 0x95DC, 0x8DBE, 0x8DDE, 0x4375, 0x43B6, 0x4BB6, 0x5437, 0x85FD, 0x967D, 0x6D5B,   // 0x08E0 (2272)
+0x3BD8, 0x3BB8, 0x443A, 0x445B, 0x4C7C, 0x4C9D, 0x3C3C, 0x445D, 0x443C, 0x3BD8, 0x5C78, 0xBEFD, 0xEFFF, 0xCF5F, 0x8D7B, 0x7C98,   // 0x08F0 (2288)
+0x6C17, 0x6C36, 0x84D9, 0xB67E, 0xDFDF, 0xCF5D, 0x9579, 0x9DBB, 0x6C54, 0x6C55, 0xBEDE, 0xE7DF, 0xEFFF, 0xEFFF, 0xB6FF, 0x5458,   // 0x0900 (2304)
+0x4419, 0x4C5D, 0x4C3E, 0x4BDD, 0x4BFB, 0x3B76, 0x5456, 0xBF7F, 0xD7FF, 0xA63E, 0x6419, 0x5B75, 0x6BD5, 0x29CB, 0x0041, 0x0861,   // 0x0910 (2320)
+0x0024, 0x0004, 0x096D, 0x2398, 0x0B7A, 0x037B, 0x039C, 0x0BDC, 0x13BB, 0x1BBB, 0x23FC, 0x241D, 0x345C, 0x23FA, 0x2B98, 0x4C19,   // 0x0920 (2336)
+0x857C, 0xC73F, 0xE7FF, 0xC71D, 0x9DBA, 0xD77F, 0xD7BF, 0xC71F, 0x95BC, 0x4B53, 0x3AD1, 0x6457, 0xA67E, 0xC75F, 0xD7FF, 0xB6FF,   // 0x0930 (2352)
+0x6D1C, 0x4C18, 0x43B8, 0x43F9, 0x4C5A, 0x4C5B, 0x443B, 0x445C, 0x33D9, 0x43F8, 0xA69E, 0xDFFF, 0xBF3D, 0x7D18, 0x6416, 0x5BD6,   // 0x0940 (2368)
+0x5BD7, 0x5BF8, 0x6C38, 0x6418, 0xAE7C, 0xE7FF, 0xBF3E, 0x95B9, 0x6C53, 0x9577, 0xE7FF, 0xD75F, 0xCEFF, 0xDF7F, 0xD79F, 0x755C,   // 0x0950 (2384)
+0x4C59, 0x3BDA, 0x3B9B, 0x335A, 0x3337, 0x1A93, 0x4BF5, 0xD7FF, 0xE7FF, 0x8519, 0x3272, 0x4AF4, 0x4AF2, 0x196A, 0x0001, 0x0000,   // 0x0960 (2400)
+0x0004, 0x0004, 0x096D, 0x23BA, 0x139B, 0x037B, 0x037C, 0x039C, 0x035A, 0x0B59, 0x137A, 0x0B7A, 0x1379, 0x0B17, 0x2BB8, 0x755D,   // 0x0970 (2416)
+0xBF3F, 0xE7FF, 0xE7BF, 0xA5DA, 0x7C96, 0xBE9E, 0xE7BF, 0xEFDF, 0xB65D, 0x5351, 0x6C15, 0xAE7D, 0xE7FF, 0xE7FF, 0xE7FF, 0xDFFF,   // 0x0980 (2432)
+0xBF3F, 0x85BD, 0x5418, 0x43D7, 0x4C19, 0x441A, 0x441A, 0x3BFA, 0x3BDA, 0x651B, 0xC7BF, 0xDFFF, 0xB6DD, 0x6C98, 0x5C18, 0x6C9B,   // 0x0990 (2448)
+0x74BD, 0x645B, 0x53D9, 0x645A, 0xAEBD, 0xE7FF, 0xDFFF, 0xBF1D, 0xBEDC, 0xDF7E, 0xEFFF, 0xBE5C, 0xADDC, 0xC6BE, 0xD7BF, 0xA6DF,   // 0x09A0 (2464)
+0x4C78, 0x1AF5, 0x22F8, 0x22F8, 0x1294, 0x22F3, 0x7539, 0xD7FF, 0xCFDF, 0x7D1A, 0x4B16, 0x5376, 0x5B95, 0x21CD, 0x0043, 0x0021,   // 0x09B0 (2480)
+0x0004, 0x0004, 0x116D, 0x23DA, 0x13BB, 0x039B, 0x039C, 0x039B, 0x0B59, 0x1379, 0x137A, 0x0B38, 0x02D6, 0x0AD6, 0x5CFB, 0xBF9F,   // 0x09C0 (2496)
+0xDFFF, 0xAE3C, 0x6BF4, 0x42AE, 0x42AE, 0x4AEF, 0xADDA, 0xF7FF, 0xE7BF, 0xAE1B, 0xCF1D, 0xF7FF, 0xD77E, 0x8D58, 0x6C56, 0xB67B,   // 0x09D0 (2512)
+0xEFFF, 0xB6FF, 0x5C57, 0x4375, 0x4BB7, 0x43D7, 0x4BD8, 0x3336, 0x5479, 0xB73F, 0xD7FF, 0xAEFD, 0x6CF7, 0x4BD6, 0x5418, 0x53FA,   // 0x09E0 (2528)
+0x5C5C, 0x543B, 0x3B78, 0x4BD8, 0x5417, 0x8599, 0xD7DF, 0xDFFF, 0xF7FF, 0xEFDF, 0xB67B, 0x5350, 0x31ED, 0x7C56, 0xD79F, 0xCFFF,   // 0x09F0 (2544)
+0x5497, 0x0A52, 0x1AB5, 0x22F6, 0x01F0, 0x4C16, 0xBF7F, 0xD7FF, 0x85BA, 0x4395, 0x3293, 0x3AB5, 0x63D7, 0x29AD, 0x0003, 0x0022,   // 0x0A00 (2560)
+0x0005, 0x0046, 0x118E, 0x2357, 0x2399, 0x133A, 0x0B5A, 0x1B7A, 0x2379, 0x2337, 0x2316, 0x1AD4, 0x22F4, 0x6CFB, 0xBF3F, 0xE7FF,   // 0x0A10 (2576)
+0xBF5F, 0x6CB8, 0x4353, 0x4352, 0x4B53, 0x3AB1, 0x6417, 0xBE9E, 0xEFFF, 0xE7FF, 0xDFFF, 0xC73F, 0x8D9B, 0x53B6, 0x3AD2, 0x8D7A,   // 0x0A20 (2592)
+0xEFFF, 0xD7BF, 0x8539, 0x4333, 0x2A90, 0x3AD2, 0x2A50, 0x53D6, 0xAE7D, 0xD7FF, 0xC77F, 0x85BC, 0x4C19, 0x3BB8, 0x4C3A, 0x43FB,   // 0x0A30 (2608)
+0x4C3C, 0x4C5D, 0x441C, 0x43FA, 0x3378, 0x4BF8, 0x7D7C, 0xAF1F, 0xA69E, 0x7D7A, 0x6C78, 0x3AF3, 0x32B3, 0x5C39, 0xA65F, 0xDFFF,   // 0x0A40 (2624)
+0xA6BD, 0x5C98, 0x32D2, 0x11CD, 0x1A0F, 0x8599, 0xDFFF, 0xBF9F, 0x6498, 0x4376, 0x4B57, 0x4B57, 0x6BF8, 0x31CD, 0x0004, 0x0023,   // 0x0A50 (2640)
+0x0004, 0x0005, 0x092B, 0x1A93, 0x1294, 0x0274, 0x02B6, 0x1AF6, 0x22F5, 0x22D3, 0x1A30, 0x32D2, 0x853B, 0xCF9F, 0xD7FF, 0x961D,   // 0x0A60 (2656)
+0x43D7, 0x22D3, 0x2314, 0x2B55, 0x2B35, 0x3336, 0x2294, 0x4C17, 0x85BC, 0x64B8, 0x5417, 0x3335, 0x22B4, 0x2AB4, 0x2AB3, 0x4BB6,   // 0x0A70 (2672)
+0x95FB, 0xDFFF, 0xC73F, 0x5BD4, 0x116C, 0x198D, 0x220E, 0x9D7A, 0xF7FF, 0xD7BF, 0x6CDB, 0x3378, 0x2317, 0x2317, 0x2B79, 0x237A,   // 0x0A80 (2688)
+0x237A, 0x237A, 0x2B9A, 0x2359, 0x2338, 0x1AF6, 0x22F6, 0x64DD, 0x43B9, 0x1274, 0x22B4, 0x22D5, 0x2B37, 0x2B37, 0x4BF8, 0xA69E,   // 0x0A90 (2704)
+0xDFFF, 0xD79F, 0x8D98, 0x4B10, 0x6435, 0xB6DD, 0xD7FF, 0x8DFD, 0x3355, 0x2AF5, 0x4B99, 0x4B98, 0x63B7, 0x218C, 0x0004, 0x0003,   // 0x0AA0 (2720)
+0x0041, 0x0000, 0x328C, 0x963C, 0x759A, 0x6DBA, 0x5D5B, 0x447A, 0x3396, 0x3334, 0x4BD5, 0x8DBB, 0xDFBF, 0xDFFF, 0x9E7E, 0x4419,   // 0x0AB0 (2736)
+0x12B4, 0x2B77, 0x33B8, 0x33B8, 0x33B9, 0x3379, 0x2B37, 0x4C5A, 0x6D5C, 0x33B6, 0x2315, 0x2B16, 0x3357, 0x3B78, 0x3357, 0x3334,   // 0x0AC0 (2752)
+0x64B8, 0xC79F, 0xDFFF, 0xA65C, 0x7CD9, 0x8D78, 0xAE3B, 0xE79E, 0xE7FF, 0x9E3D, 0x4BF9, 0x2B57, 0x2359, 0x2BBB, 0x341C, 0x2C1C,   // 0x0AD0 (2768)
+0x2BFC, 0x2BFC, 0x2BDC, 0x23BB, 0x2BBB, 0x2B9A, 0x2B99, 0x6D5E, 0x4C5B, 0x2B38, 0x3399, 0x2338, 0x2B78, 0x2B78, 0x3398, 0x5459,   // 0x0AE0 (2784)
+0xAEBE, 0xE7FF, 0xDFDF, 0xB6DD, 0xC77E, 0xDFFF, 0xB73F, 0x64FC, 0x3397, 0x2B58, 0x3B99, 0x4BB8, 0x63F8, 0x29CE, 0x0005, 0x0024,   // 0x0AF0 (2800)
+0x0040, 0x0000, 0x5B8D, 0xFFFF, 0xE7FF, 0xDFFF, 0xC7FF, 0xAF7F, 0x9EDD, 0x969C, 0xBF5D, 0xDFFF, 0xC79F, 0x7D7B, 0x3BB6, 0x1AF5,   // 0x0B00 (2816)
+0x1B58, 0x2BFB, 0x2399, 0x1B79, 0x2BBA, 0x2379, 0x2338, 0x4C7C, 0x657D, 0x33B7, 0x2357, 0x2B98, 0x3BDA, 0x33BA, 0x2B37, 0x2315,   // 0x0B10 (2832)
+0x3396, 0x64FA, 0x9EDE, 0xC7FF, 0xE7FF, 0xF7FF, 0xD7FF, 0xBF1D, 0x74F8, 0x2B34, 0x2356, 0x2359, 0x239A, 0x2BFB, 0x23FC, 0x23DC,   // 0x0B20 (2848)
+0x1BBC, 0x1BDC, 0x23FD, 0x23DC, 0x23DC, 0x23BA, 0x239A, 0x653F, 0x445C, 0x2339, 0x33BA, 0x2B79, 0x237A, 0x2379, 0x1B37, 0x1AF4,   // 0x0B30 (2864)
+0x3375, 0x64D8, 0x963C, 0xA6BE, 0xAEBE, 0x85FB, 0x5479, 0x2B77, 0x2B99, 0x2B79, 0x3379, 0x4398, 0x5BD8, 0x21AE, 0x0005, 0x0025,   // 0x0B40 (2880)
+0x1060, 0x0000, 0x428A, 0xAEBB, 0x8DFA, 0x861B, 0x96BE, 0xA77F, 0xBFDF, 0xBFFF, 0xBF9F, 0x9E9F, 0x755D, 0x3BB8, 0x1AF6, 0x1B59,   // 0x0B50 (2896)
+0x2BFD, 0x23FD, 0x139C, 0x139B, 0x23DC, 0x2BDC, 0x237A, 0x447C, 0x5D7E, 0x2BD8, 0x1B78, 0x2399, 0x2BDB, 0x2BFC, 0x239A, 0x2378,   // 0x0B60 (2912)
+0x2376, 0x2396, 0x5D1D, 0x7E3F, 0x863D, 0x759C, 0x5CDC, 0x4C59, 0x3BD7, 0x2B96, 0x2399, 0x23DB, 0x23FD, 0x241D, 0x1BFD, 0x1BDD,   // 0x0B70 (2928)
+0x1BFD, 0x1C1D, 0x1C1D, 0x241D, 0x241D, 0x23DC, 0x23DB, 0x5D7F, 0x449C, 0x239A, 0x341C, 0x23BB, 0x23DB, 0x23DB, 0x23DA, 0x2BFA,   // 0x0B80 (2944)
+0x1B56, 0x2355, 0x4C59, 0x5CDA, 0x4C59, 0x33B7, 0x2357, 0x1B79, 0x23BA, 0x2BDB, 0x33DB, 0x43DA, 0x5C1A, 0x21CF, 0x0005, 0x0025,   // 0x0B90 (2960)
+0x1040, 0x0000, 0x1946, 0x4372, 0x2AF2, 0x12D3, 0x1B56, 0x343A, 0x4479, 0x3C18, 0x3BD8, 0x3397, 0x2316, 0x2B79, 0x239B, 0x139B,   // 0x0BA0 (2976)
+0x1BDE, 0x0B7D, 0x1BDF, 0x1C1F, 0x1BDE, 0x23DD, 0x1B7B, 0x3C9D, 0x5DBF, 0x345B, 0x23DA, 0x1BBA, 0x23BB, 0x23BC, 0x1BBC, 0x1BBA,   // 0x0BB0 (2992)
+0x1377, 0x0B35, 0x23B8, 0x1B99, 0x0AF7, 0x0AB7, 0x1317, 0x1B77, 0x2397, 0x1B97, 0x1BBA, 0x1BFC, 0x241D, 0x1BFD, 0x13FD, 0x1C1E,   // 0x0BC0 (3008)
+0x1C3F, 0x1C3E, 0x13FD, 0x13FD, 0x1C1D, 0x1BDC, 0x1BDB, 0x5D9F, 0x3CBD, 0x1B9B, 0x241C, 0x1BDB, 0x1BFC, 0x23FC, 0x23FB, 0x1BDB,   // 0x0BD0 (3024)
+0x1BBA, 0x23B8, 0x2397, 0x1315, 0x1315, 0x1B77, 0x1B99, 0x139A, 0x1BDC, 0x23DC, 0x2BBB, 0x3BDA, 0x4BF9, 0x19AE, 0x0005, 0x0024,   // 0x0BE0 (3040)
+0x0002, 0x0002, 0x216B, 0x53B7, 0x3B97, 0x1B37, 0x1318, 0x1379, 0x1B79, 0x1317, 0x2358, 0x2B99, 0x1B18, 0x239B, 0x23DC, 0x1BFE,   // 0x0BF0 (3056)
+0x13FE, 0x13FD, 0x1C5F, 0x1C5F, 0x13DE, 0x243E, 0x1BDC, 0x34BD, 0x55DF, 0x2C7C, 0x1C1B, 0x1BDC, 0x1BFD, 0x1C1D, 0x1C1D, 0x243C,   // 0x0C00 (3072)
+0x243B, 0x13B9, 0x13B9, 0x0B79, 0x0B59, 0x137A, 0x1BFC, 0x241B, 0x1BD9, 0x1378, 0x13BA, 0x1C1D, 0x1C3E, 0x141D, 0x143E, 0x1C7E,   // 0x0C10 (3088)
+0x1C9E, 0x145E, 0x141E, 0x143D, 0x1C3D, 0x1C1D, 0x1C1C, 0x5DDF, 0x3CFD, 0x1BDC, 0x243D, 0x1BFC, 0x1C1D, 0x1C3D, 0x1C1C, 0x0BBB,   // 0x0C20 (3104)
+0x13FC, 0x241C, 0x1BD9, 0x1358, 0x23DA, 0x2C1B, 0x1BFB, 0x0B7B, 0x243D, 0x243E, 0x2BFC, 0x3BFB, 0x541A, 0x21CF, 0x0005, 0x0025,   // 0x0C30 (3120)
+0x0005, 0x0004, 0x218E, 0x53FA, 0x3BBA, 0x2BBC, 0x1BBD, 0x1BBC, 0x139B, 0x23DB, 0x2BFB, 0x2BDA, 0x2BDB, 0x1BBB, 0x1C1C, 0x1C1D,   // 0x0C40 (3136)
+0x143D, 0x1C7F, 0x1C7E, 0x145E, 0x1C5E, 0x2C5E, 0x1BFC, 0x3CFE, 0x55DF, 0x245B, 0x13FB, 0x1C1D, 0x245E, 0x245F, 0x1C3E, 0x1C3D,   // 0x0C50 (3152)
+0x1C7D, 0x1C5C, 0x13FA, 0x141B, 0x1C1D, 0x13DC, 0x0BBC, 0x13FC, 0x1C3B, 0x1C3B, 0x1C3C, 0x1C5D, 0x1C3E, 0x141D, 0x13FD, 0x1C7E,   // 0x0C60 (3168)
+0x1C9F, 0x145E, 0x141D, 0x249E, 0x249E, 0x1BFC, 0x1BFC, 0x55DF, 0x3CFD, 0x1BFC, 0x2C7E, 0x243D, 0x245D, 0x1C3D, 0x141D, 0x1C7F,   // 0x0C70 (3184)
+0x13FD, 0x141C, 0x245D, 0x2C3C, 0x1BFC, 0x241C, 0x1C3D, 0x1C1E, 0x1C3E, 0x241D, 0x23FC, 0x3BFB, 0x545A, 0x220F, 0x0025, 0x0025,   // 0x0C80 (3200)
+0x0026, 0x0004, 0x19AE, 0x4C3A, 0x2BB9, 0x23DC, 0x13FD, 0x13DD, 0x0BBA, 0x1BDB, 0x1BDA, 0x241A, 0x2C5A, 0x243A, 0x1C5C, 0x1C5C,   // 0x0C90 (3216)
+0x143C, 0x1C7D, 0x145D, 0x145D, 0x1C7D, 0x243D, 0x13DC, 0x34DE, 0x55DF, 0x245B, 0x141B, 0x1C5D, 0x245F, 0x1C5E, 0x1C3E, 0x141C,   // 0x0CA0 (3232)
+0x143C, 0x1C5C, 0x145C, 0x147D, 0x1C7E, 0x143E, 0x141D, 0x143D, 0x1C5C, 0x1C5C, 0x1C5D, 0x1C5D, 0x1C5D, 0x143D, 0x143D, 0x147E,   // 0x0CB0 (3248)
+0x145F, 0x145E, 0x143E, 0x1C7E, 0x247E, 0x13FC, 0x1BFC, 0x4D9F, 0x3CDD, 0x1BFB, 0x245C, 0x245D, 0x1C5D, 0x1C3D, 0x143D, 0x1C7F,   // 0x0CC0 (3264)
+0x141D, 0x141C, 0x243D, 0x243D, 0x1BDC, 0x13FC, 0x1C3E, 0x247F, 0x143E, 0x1BFD, 0x23DB, 0x33D9, 0x5439, 0x19CD, 0x0004, 0x0003,   // 0x0CD0 (3280)
+0x0024, 0x0003, 0x21CD, 0x54BB, 0x345B, 0x245C, 0x1C7D, 0x1C9E, 0x1C7C, 0x1C5C, 0x245A, 0x245A, 0x2459, 0x245A, 0x1C7B, 0x1C9B,   // 0x0CE0 (3296)
+0x1C9C, 0x1C9C, 0x1C9C, 0x1C9B, 0x249C, 0x2C7D, 0x243C, 0x3D1E, 0x55FF, 0x247B, 0x1C5C, 0x247E, 0x247E, 0x247F, 0x249F, 0x1C7E,   // 0x0CF0 (3312)
+0x147C, 0x147C, 0x147C, 0x147D, 0x147E, 0x1C7E, 0x1C7E, 0x1C7E, 0x1C9D, 0x1C9D, 0x1C7D, 0x1C7D, 0x1C7E, 0x1C9E, 0x1C9E, 0x1C7E,   // 0x0D00 (3328)
+0x1C9E, 0x1C9E, 0x1C7E, 0x1C7D, 0x249D, 0x245C, 0x245C, 0x55DF, 0x453E, 0x243B, 0x247C, 0x247D, 0x247D, 0x249E, 0x1C9E, 0x1C9F,   // 0x0D10 (3344)
+0x1C9F, 0x1C9E, 0x1C7D, 0x247D, 0x247E, 0x247E, 0x1C7F, 0x1C7F, 0x1C7F, 0x2C9F, 0x347D, 0x3C5A, 0x64BA, 0x2A2E, 0x0003, 0x0003,   // 0x0D20 (3360)
+0x0043, 0x0002, 0x19ED, 0x4CBB, 0x2C5B, 0x1C5C, 0x149D, 0x149E, 0x149D, 0x147C, 0x1C7B, 0x1C7A, 0x1C7A, 0x1C7B, 0x1C7B, 0x1C9C,   // 0x0D30 (3376)
+0x1C9C, 0x1C9C, 0x1C9C, 0x249C, 0x247C, 0x2C7D, 0x241C, 0x3D1D, 0x55FF, 0x247A, 0x1C5B, 0x247D, 0x247E, 0x1C7E, 0x249F, 0x1C9E,   // 0x0D40 (3392)
+0x1C9C, 0x1C9C, 0x1C9D, 0x149D, 0x147E, 0x1C7E, 0x1C7E, 0x147D, 0x147D, 0x1C7C, 0x1C9D, 0x1C9D, 0x1C9D, 0x1C9D, 0x1C9D, 0x1C9E,   // 0x0D50 (3408)
+0x1C9E, 0x1C9D, 0x1C9E, 0x1C9D, 0x249D, 0x245C, 0x245B, 0x55DF, 0x3D1D, 0x1C1B, 0x247B, 0x249C, 0x247D, 0x1C7D, 0x1CBE, 0x1CBE,   // 0x0D60 (3424)
+0x14BF, 0x1CBE, 0x249E, 0x249E, 0x247E, 0x249E, 0x249E, 0x1C9F, 0x1C9F, 0x247E, 0x2C5B, 0x3C39, 0x5C99, 0x220D, 0x0002, 0x0002,   // 0x0D70 (3440)
+0x0063, 0x0002, 0x222D, 0x551B, 0x34BB, 0x24BD, 0x1CFE, 0x1CFF, 0x1CFE, 0x1CBE, 0x1CBD, 0x24DD, 0x24BD, 0x24BE, 0x24BE, 0x24BF,   // 0x0D80 (3456)
+0x24BF, 0x24DF, 0x24DF, 0x2CBF, 0x2CBE, 0x2CBE, 0x245B, 0x3D3D, 0x561F, 0x2CBB, 0x247B, 0x24BD, 0x24BE, 0x24BF, 0x24BF, 0x24DE,   // 0x0D90 (3472)
+0x24FD, 0x24FD, 0x1CFE, 0x1CDE, 0x1CDF, 0x1CBF, 0x1CBF, 0x1CBE, 0x1CDD, 0x24DD, 0x24DE, 0x24DE, 0x24DE, 0x24DE, 0x24DE, 0x24DF,   // 0x0DA0 (3488)
+0x24DF, 0x24DE, 0x24DE, 0x24DD, 0x2CBD, 0x2C9B, 0x247B, 0x5DFF, 0x455D, 0x245B, 0x2C9C, 0x2CBD, 0x24BD, 0x24BD, 0x1CDE, 0x1CFE,   // 0x0DB0 (3504)
+0x1CFE, 0x1CDE, 0x24BE, 0x24BE, 0x24BE, 0x24BE, 0x24BF, 0x24BF, 0x24DF, 0x24BE, 0x2C7B, 0x3C59, 0x5CB8, 0x222C, 0x0003, 0x0002,   // 0x0DC0 (3520)
+0x0043, 0x0002, 0x220D, 0x551B, 0x34BB, 0x24BD, 0x14FF, 0x1CFF, 0x14FF, 0x1CDF, 0x1CBE, 0x1C9D, 0x1C9D, 0x1C9E, 0x1C9E, 0x1CBE,   // 0x0DD0 (3536)
+0x1C9F, 0x1C9F, 0x1C9F, 0x1C9F, 0x249E, 0x2C9E, 0x245B, 0x3D5D, 0x563F, 0x24BA, 0x249B, 0x24BD, 0x24BE, 0x24BE, 0x24DF, 0x24DD,   // 0x0DE0 (3552)
+0x1CDC, 0x1CDC, 0x1CBD, 0x1CBE, 0x1CBE, 0x1C9E, 0x1C9E, 0x1CBE, 0x1CBD, 0x1CBD, 0x1CBD, 0x1CBD, 0x1CBD, 0x1CBE, 0x1CBD, 0x1CBE,   // 0x0DF0 (3568)
+0x1CBE, 0x1CBD, 0x1CBD, 0x24BD, 0x24BC, 0x247B, 0x247B, 0x55FF, 0x455D, 0x245B, 0x249C, 0x24BC, 0x24BD, 0x24DD, 0x1CDE, 0x1CDE,   // 0x0E00 (3584)
+0x14DE, 0x1CDD, 0x1CBD, 0x24BD, 0x24BE, 0x1CBE, 0x1CBE, 0x1CBF, 0x1CBE, 0x24DE, 0x34DC, 0x3C99, 0x5CF9, 0x224C, 0x0002, 0x0002,   // 0x0E10 (3600)
+0x0023, 0x0002, 0x220D, 0x54FB, 0x34BC, 0x24BE, 0x1CFF, 0x151F, 0x14FF, 0x14DF, 0x1CFF, 0x24FF, 0x24FF, 0x1CFF, 0x1CFF, 0x1CFF,   // 0x0E20 (3616)
+0x1CFF, 0x1CFF, 0x24FF, 0x24DF, 0x2CDF, 0x2CDE, 0x247B, 0x457D, 0x565F, 0x24DB, 0x24BB, 0x24DD, 0x2CDE, 0x24DF, 0x2CFF, 0x24FE,   // 0x0E30 (3632)
+0x1CFD, 0x24FD, 0x251E, 0x251F, 0x24FF, 0x251F, 0x24FF, 0x251F, 0x251E, 0x251E, 0x251E, 0x251E, 0x251F, 0x24FF, 0x251F, 0x251F,   // 0x0E40 (3648)
+0x251F, 0x251E, 0x24FE, 0x251E, 0x2CFD, 0x249C, 0x24BB, 0x5E3F, 0x457D, 0x247B, 0x24BD, 0x2CFD, 0x24FE, 0x24FE, 0x1D1E, 0x1D1E,   // 0x0E50 (3664)
+0x1D1E, 0x1CFD, 0x24FD, 0x24DE, 0x24DE, 0x24DE, 0x24FF, 0x1CFF, 0x1CFF, 0x24FE, 0x2CDC, 0x3CB9, 0x5CF8, 0x224C, 0x0022, 0x0002,   // 0x0E60 (3680)
+0x0023, 0x0002, 0x220D, 0x5D1B, 0x3CBB, 0x24DE, 0x1D1F, 0x1D3F, 0x1D1F, 0x151F, 0x1CFE, 0x1CFE, 0x1CFE, 0x1D1E, 0x151F, 0x151F,   // 0x0E70 (3696)
+0x151F, 0x151F, 0x1CFF, 0x1CFF, 0x24FE, 0x24DE, 0x1C7B, 0x3D7D, 0x565E, 0x24BA, 0x1C9B, 0x24DD, 0x24DE, 0x24DE, 0x24FE, 0x24FE,   // 0x0E80 (3712)
+0x1CFD, 0x1D1D, 0x1CFD, 0x1CFE, 0x1CFF, 0x1CFF, 0x1CFF, 0x1CFF, 0x1D1E, 0x1D1E, 0x1CFE, 0x1CFE, 0x1CFE, 0x1CFE, 0x1CFE, 0x1CFF,   // 0x0E90 (3728)
+0x1CFF, 0x1CFE, 0x1CFE, 0x24FE, 0x24DD, 0x249C, 0x249B, 0x561F, 0x3D7D, 0x1C9C, 0x24DD, 0x24FD, 0x1CFD, 0x1CFE, 0x1D1E, 0x151E,   // 0x0EA0 (3744)
+0x1D3D, 0x1D1D, 0x24FD, 0x24DD, 0x24DE, 0x1CFE, 0x1CFE, 0x1D1E, 0x1CFE, 0x1CFE, 0x2CDC, 0x34B9, 0x54F8, 0x224C, 0x0022, 0x0022,   // 0x0EB0 (3760)
+0x0043, 0x0002, 0x222D, 0x653B, 0x44DB, 0x351E, 0x255F, 0x259F, 0x1D5F, 0x1D7F, 0x255E, 0x257D, 0x257D, 0x1D7D, 0x1D7E, 0x1D7E,   // 0x0EC0 (3776)
+0x1D7F, 0x1D7E, 0x1D7E, 0x255D, 0x255D, 0x2D3E, 0x24DC, 0x45BE, 0x5E9F, 0x2D3B, 0x2D1D, 0x2D3E, 0x2D5F, 0x2D3F, 0x2D5F, 0x2D5F,   // 0x0ED0 (3792)
+0x2D5F, 0x255E, 0x255F, 0x255F, 0x253F, 0x253F, 0x253F, 0x253F, 0x253F, 0x253E, 0x253F, 0x253F, 0x253F, 0x253F, 0x253F, 0x255F,   // 0x0EE0 (3808)
+0x255F, 0x253F, 0x253F, 0x253F, 0x2D3E, 0x2D1D, 0x2CFD, 0x5E9F, 0x4DDF, 0x2CFD, 0x2D3E, 0x2D5F, 0x2D5F, 0x2D5F, 0x257F, 0x259F,   // 0x0EF0 (3824)
+0x257E, 0x257E, 0x2D5E, 0x2D5F, 0x2D3F, 0x255F, 0x255F, 0x257F, 0x257F, 0x255F, 0x2D1D, 0x3CDA, 0x5519, 0x226D, 0x0023, 0x0023,   // 0x0F00 (3840)
+0x0023, 0x0002, 0x21EB, 0x651A, 0x4CDB, 0x3D1D, 0x2D3F, 0x251E, 0x257F, 0x257E, 0x1D5D, 0x1D1C, 0x255D, 0x257D, 0x255C, 0x1D5C,   // 0x0F10 (3856)
+0x1D5C, 0x1D5C, 0x1D7D, 0x1D7D, 0x253D, 0x24FD, 0x1C9B, 0x3D9D, 0x567F, 0x24DB, 0x1CFC, 0x251D, 0x1CFE, 0x251F, 0x253F, 0x253F,   // 0x0F20 (3872)
+0x255F, 0x2D5F, 0x255F, 0x1D1E, 0x1CFF, 0x1D1F, 0x253F, 0x1D1F, 0x1D1E, 0x255E, 0x255F, 0x1D3F, 0x1D3F, 0x255F, 0x1D3F, 0x1D1F,   // 0x0F30 (3888)
+0x1D1F, 0x253E, 0x253E, 0x2D3E, 0x2D3D, 0x24DC, 0x24FC, 0x565F, 0x3D9D, 0x1CBC, 0x251D, 0x251D, 0x251E, 0x253F, 0x253E, 0x1D1D,   // 0x0F40 (3904)
+0x253E, 0x253E, 0x251E, 0x251E, 0x253F, 0x253F, 0x1CFF, 0x14DE, 0x251F, 0x355F, 0x3D3D, 0x3D1A, 0x5D7B, 0x2A6E, 0x0003, 0x0023,   // 0x0F50 (3920)
+0x0065, 0x0003, 0x2A0C, 0x6D5B, 0x5D3C, 0x4D5D, 0x353E, 0x2D1E, 0x2D9F, 0x2D9F, 0x255E, 0x2D3D, 0x359D, 0x359D, 0x357D, 0x357C,   // 0x0F60 (3936)
+0x2D7D, 0x2D7D, 0x259E, 0x2D9E, 0x2D7E, 0x353D, 0x2CFC, 0x4DFE, 0x5EBF, 0x24FB, 0x2D5E, 0x2D7E, 0x253E, 0x2D7F, 0x2D9F, 0x2D5F,   // 0x0F70 (3952)
+0x2D5F, 0x359F, 0x2D5F, 0x355F, 0x2D7F, 0x2D7F, 0x359F, 0x1D1E, 0x1D1E, 0x35DF, 0x2D7F, 0x255F, 0x2D5F, 0x2D9F, 0x253E, 0x253E,   // 0x0F80 (3968)
+0x2D7E, 0x359E, 0x2D5D, 0x355D, 0x2D5D, 0x2D1C, 0x2D3C, 0x569F, 0x3DBD, 0x24FC, 0x355E, 0x355D, 0x2D3E, 0x355E, 0x355E, 0x355F,   // 0x0F90 (3984)
+0x359F, 0x357F, 0x2D5F, 0x357F, 0x357F, 0x2D7F, 0x2D5F, 0x24FE, 0x357F, 0x457E, 0x453C, 0x44DA, 0x657B, 0x2A6E, 0x0003, 0x0043,   // 0x0FA0 (4000)
+0x0064, 0x0023, 0x222C, 0x6CF9, 0x5D1A, 0x3479, 0x2C9B, 0x3D5E, 0x2D3D, 0x1CFC, 0x24FC, 0x353C, 0x353C, 0x2CFA, 0x351B, 0x355C,   // 0x0FB0 (4016)
+0x355C, 0x251B, 0x1D1C, 0x1D3D, 0x2D3D, 0x2D1B, 0x34DA, 0x4D9C, 0x563F, 0x2CDB, 0x2D1B, 0x2D5C, 0x253C, 0x2D3C, 0x2D3C, 0x2D3D,   // 0x0FC0 (4032)
+0x351D, 0x351D, 0x249B, 0x351C, 0x3D5D, 0x351C, 0x3D5D, 0x2CDB, 0x24DB, 0x353D, 0x24FC, 0x353D, 0x353D, 0x2CFC, 0x2CFC, 0x353D,   // 0x0FD0 (4048)
+0x355D, 0x2D1B, 0x2CFA, 0x2D1B, 0x2D1B, 0x2CFA, 0x2CFA, 0x561F, 0x3D7C, 0x24BA, 0x353B, 0x2CFB, 0x2CFC, 0x351C, 0x353C, 0x3D5D,   // 0x0FE0 (4064)
+0x355D, 0x24DC, 0x1CBB, 0x2D3D, 0x1CDC, 0x2D1D, 0x3D9E, 0x351D, 0x2CDC, 0x3CFC, 0x4D1B, 0x4CD9, 0x6519, 0x222D, 0x0003, 0x0063,   // 0x0FF0 (4080)
+0x0022, 0x0002, 0x2A4B, 0x6D18, 0x6D5A, 0x551A, 0x4D5D, 0x55FF, 0x561F, 0x45BE, 0x3D7D, 0x45BD, 0x4DFD, 0x3D5B, 0x457B, 0x4DFE,   // 0x1000 (4096)
+0x4DDD, 0x3D9D, 0x359D, 0x35BE, 0x3DDE, 0x4DBD, 0x4D9C, 0x55FC, 0x5E5E, 0x4DBC, 0x459C, 0x45DC, 0x4DDD, 0x45BC, 0x45BD, 0x4DBC,   // 0x1010 (4112)
+0x4D7C, 0x4D9C, 0x5DDD, 0x453B, 0x44FA, 0x559C, 0x4D7C, 0x5DFD, 0x5DFD, 0x4D7C, 0x559C, 0x5DDD, 0x559E, 0x4D7C, 0x4D7C, 0x55BD,   // 0x1020 (4128)
+0x55DD, 0x4D9C, 0x457B, 0x4D9C, 0x4DBC, 0x4DBC, 0x4DBC, 0x669F, 0x55FD, 0x457C, 0x4DDD, 0x4DBC, 0x4DDD, 0x4DDD, 0x4DDD, 0x3D5C,   // 0x1030 (4144)
+0x4DBD, 0x459D, 0x3D5C, 0x45BD, 0x3D5C, 0x459D, 0x55DE, 0x4D7D, 0x55BE, 0x5D9C, 0x659C, 0x75BB, 0x6D59, 0x226D, 0x0024, 0x0064,   // 0x1040 (4160)
+0x0062, 0x0021, 0x2A2A, 0x7558, 0x7DDB, 0x8EBF, 0x767F, 0x5DDD, 0x663D, 0x5E1E, 0x5DFE, 0x665E, 0x7F1F, 0x663E, 0x661E, 0x667E,   // 0x1050 (4176)
+0x5E5E, 0x565F, 0x567F, 0x569F, 0x569F, 0x5E9F, 0x5E7F, 0x5EBF, 0x5EDF, 0x569F, 0x567F, 0x56BF, 0x5EBF, 0x567F, 0x5E7F, 0x5E7F,   // 0x1060 (4192)
+0x5E5F, 0x663E, 0x6E5E, 0x76BF, 0x769F, 0x6E5E, 0x5DFD, 0x6E7D, 0x6E5D, 0x5E1D, 0x767F, 0x65DD, 0x5DDD, 0x6E5F, 0x663F, 0x55FE,   // 0x1070 (4208)
+0x5E1E, 0x5E5F, 0x5E5F, 0x669F, 0x5E9F, 0x565F, 0x565F, 0x66FF, 0x567F, 0x4E1F, 0x565F, 0x565F, 0x567F, 0x565F, 0x5E5F, 0x665F,   // 0x1080 (4224)
+0x5DFD, 0x6E3E, 0x7EDF, 0x7EFF, 0x769F, 0x65FD, 0x65DD, 0x763E, 0x6DDC, 0x6DBB, 0x863D, 0x965D, 0x7518, 0x220B, 0x0023, 0x0043,   // 0x1090 (4240)
+0x0021, 0x0000, 0x1105, 0x4BB0, 0x7D98, 0x9EDE, 0x865D, 0x4D19, 0x3C77, 0x4519, 0x4D39, 0x5DBB, 0x86DE, 0x559B, 0x4539, 0x3D3A,   // 0x10A0 (4256)
+0x353B, 0x357D, 0x359E, 0x35BF, 0x2D9F, 0x35BE, 0x2D9E, 0x2D9D, 0x2D9D, 0x2DBE, 0x259D, 0x25DD, 0x2DDE, 0x257D, 0x2D7C, 0x357D,   // 0x10B0 (4272)
+0x355C, 0x3D3C, 0x3D3C, 0x76DE, 0x875F, 0x55BC, 0x4539, 0x34D8, 0x34D8, 0x3D19, 0x55BC, 0x3498, 0x3498, 0x5DBD, 0x4DBD, 0x351B,   // 0x10C0 (4288)
+0x2D1B, 0x357D, 0x2D7D, 0x35BE, 0x2D9E, 0x2D9E, 0x2D9E, 0x35DF, 0x259E, 0x255D, 0x2D9E, 0x2D9E, 0x2D9E, 0x2D9E, 0x355C, 0x4D9B,   // 0x10D0 (4304)
+0x44F8, 0x65DA, 0x8EFF, 0x7E7E, 0x7E7D, 0x5D38, 0x4475, 0x6539, 0x5CF7, 0x4C35, 0x5455, 0x74D6, 0x4350, 0x1107, 0x0002, 0x0022,   // 0x10E0 (4320)
+0x0041, 0x0020, 0x0062, 0x2249, 0x7D36, 0xB73E, 0xB79F, 0x8E7C, 0x5CF7, 0x75FB, 0x7E5D, 0x8EDD, 0xAFFF, 0x6E3C, 0x559B, 0x4D9B,   // 0x10F0 (4336)
+0x3D9C, 0x45FE, 0x463F, 0x361F, 0x35FF, 0x3E3F, 0x3E1F, 0x361E, 0x35FE, 0x361F, 0x363F, 0x363F, 0x361E, 0x35FE, 0x3DFE, 0x3DBD,   // 0x1100 (4352)
+0x3D9C, 0x4DBC, 0x76BF, 0x8F7F, 0x8F5F, 0x7EBF, 0x5D9A, 0x767D, 0x765C, 0x5559, 0x8EFE, 0x7E3C, 0x6DFC, 0x767F, 0x769F, 0x5E1E,   // 0x1110 (4368)
+0x4DBD, 0x45BD, 0x3DBE, 0x35BE, 0x35FF, 0x361F, 0x361F, 0x361F, 0x361F, 0x361F, 0x3E1F, 0x3E3F, 0x3E3F, 0x3E1F, 0x45BC, 0x4539,   // 0x1120 (4384)
+0x65DB, 0x975E, 0xAFFF, 0x8EBE, 0xAFBF, 0x969C, 0x6D38, 0x8DFA, 0xA6DD, 0x9E3B, 0x8D98, 0x7D16, 0x328B, 0x08E5, 0x0042, 0x0042,   // 0x1130 (4400)
+0x0040, 0x0020, 0x0000, 0x08C4, 0x5390, 0xBEFC, 0xE7FF, 0xBF9E, 0x7DDA, 0x8E7C, 0x9EFE, 0xA77F, 0xB7FF, 0x6DFA, 0x4D79, 0x4DBB,   // 0x1140 (4416)
+0x45DD, 0x461E, 0x3E3F, 0x363F, 0x35FF, 0x465F, 0x3E3E, 0x361E, 0x3E1E, 0x3E1E, 0x467F, 0x3E3E, 0x3DFD, 0x461D, 0x4E1D, 0x4DDC,   // 0x1150 (4432)
+0x4DBB, 0x5DDB, 0xA7BF, 0xA79F, 0x9F5F, 0xA77F, 0x6DDA, 0xA75E, 0x96FC, 0x5D16, 0xC7BF, 0xD7FF, 0xAF5E, 0x7E3C, 0x8EBE, 0x8F3F,   // 0x1160 (4448)
+0x6E7D, 0x4DBC, 0x563F, 0x4E5F, 0x3E1E, 0x35DE, 0x361F, 0x35FE, 0x35FE, 0x3E1F, 0x3E3F, 0x3E3E, 0x461E, 0x3DDD, 0x3D9B, 0x55BB,   // 0x1170 (4464)
+0x5578, 0x763B, 0x9F3E, 0x867D, 0x9EFE, 0xA6DD, 0xAF1E, 0xCFFF, 0xB6BC, 0xCF5E, 0xD75E, 0x84F5, 0x2166, 0x0001, 0x0021, 0x0001,   // 0x1180 (4480)
+0x0021, 0x0021, 0x0000, 0x0021, 0x1967, 0x84F5, 0xCF7F, 0xC79F, 0xAEBC, 0x9E9C, 0xA6FE, 0xAF7F, 0xAFBF, 0x6DFA, 0x4D7A, 0x4DDB,   // 0x1190 (4496)
+0x461D, 0x463E, 0x3E5F, 0x367F, 0x3E7F, 0x467F, 0x465F, 0x463E, 0x465E, 0x465E, 0x4E9F, 0x467E, 0x461D, 0x4E5E, 0x4E3D, 0x563D,   // 0x11A0 (4512)
+0x663D, 0x767D, 0xA77F, 0x9F5E, 0xA75E, 0xB7BF, 0x8E9B, 0xAF9F, 0xA73D, 0x7DF9, 0xBFBF, 0xD7FF, 0xAEFC, 0x75D9, 0x867B, 0x8EFE,   // 0x11B0 (4528)
+0x661C, 0x4579, 0x4DFD, 0x45FD, 0x461E, 0x465F, 0x467F, 0x3E3E, 0x3E5E, 0x467F, 0x4E7F, 0x4E7F, 0x4E7F, 0x4E3D, 0x4DFC, 0x55DB,   // 0x11C0 (4544)
+0x65FB, 0x7E5C, 0x7E5C, 0x6D99, 0xAF7E, 0xBFBE, 0xB6FD, 0xC75F, 0xCF5D, 0xBE7A, 0x84B4, 0x428B, 0x0861, 0x0000, 0x0041, 0x0862,   // 0x11D0 (4560)
+0x0000, 0x0821, 0x0822, 0x0000, 0x0000, 0x08C4, 0x536F, 0xA61A, 0xC73C, 0xB6FD, 0x963A, 0x7DD9, 0x7E3B, 0x765C, 0x661B, 0x561C,   // 0x11E0 (4576)
+0x4E3E, 0x4E5E, 0x465F, 0x3E9F, 0x469F, 0x467F, 0x465F, 0x4E7F, 0x4E7F, 0x4E7F, 0x467F, 0x4E7F, 0x4E7E, 0x4E5E, 0x563D, 0x55FC,   // 0x11F0 (4592)
+0x5DFC, 0x769E, 0x761D, 0x4CB6, 0x4496, 0x7E1B, 0x8E7C, 0x8E9C, 0x96DD, 0x9EFD, 0x967B, 0x8E3A, 0x9EDC, 0xB7DF, 0xB7FF, 0x8F1E,   // 0x1200 (4608)
+0x6E5C, 0x5E3C, 0x5E5D, 0x4E1D, 0x4E3E, 0x4E5F, 0x465F, 0x4E7F, 0x467E, 0x467E, 0x465E, 0x4E5E, 0x4E5E, 0x4E5E, 0x563D, 0x55FC,   // 0x1210 (4624)
+0x555A, 0x763B, 0x9F5D, 0x971D, 0x9EBD, 0x7537, 0x6473, 0x9E19, 0xCF1C, 0x8472, 0x1945, 0x0062, 0x0000, 0x0000, 0x0000, 0x0021,   // 0x1220 (4640)
+0x0801, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x08A4, 0x21A8, 0x42ED, 0x5C11, 0x5C53, 0x5C94, 0x6557, 0x6DB9, 0x6E1B, 0x665C,   // 0x1230 (4656)
+0x5EBE, 0x569E, 0x4E5E, 0x463D, 0x463E, 0x4E5F, 0x4E5F, 0x4E5F, 0x4E5F, 0x4E7F, 0x4E7F, 0x4E7F, 0x4E7F, 0x565E, 0x565E, 0x55FD,   // 0x1240 (4672)
+0x559B, 0x555A, 0x4D19, 0x5518, 0x54F7, 0x4495, 0x54B6, 0x54D6, 0x4494, 0x4453, 0x54B4, 0x5CD4, 0x75B8, 0x96DD, 0x96FE, 0x765C,   // 0x1250 (4688)
+0x559A, 0x559A, 0x5E5D, 0x66BF, 0x5E9F, 0x4E5E, 0x4E7F, 0x4E5F, 0x4E5E, 0x4E5E, 0x4E7E, 0x565E, 0x4E5E, 0x565E, 0x5E3D, 0x5DFC,   // 0x1260 (4704)
+0x6DFC, 0x4CF8, 0x3414, 0x5CB6, 0x4C13, 0x6CF6, 0x8536, 0x3AAD, 0x1946, 0x0083, 0x0021, 0x0000, 0x0000, 0x0800, 0x0000, 0x0000,   // 0x1270 (4720)
+0x0800, 0x0000, 0x0800, 0x0001, 0x0022, 0x0001, 0x0000, 0x0022, 0x1126, 0x2A2A, 0x5C11, 0x7D57, 0x7D98, 0x7DFA, 0x761A, 0x6E3B,   // 0x1280 (4736)
+0x6E7C, 0x6E9D, 0x669D, 0x66DE, 0x6EDF, 0x66BF, 0x669F, 0x66BF, 0x66BF, 0x66BF, 0x66BF, 0x66BF, 0x66BF, 0x669F, 0x6E9F, 0x76DF,   // 0x1290 (4752)
+0x7E9F, 0x6DFC, 0x6DBC, 0x96BE, 0x96DE, 0x6DBB, 0x865D, 0x8E7D, 0x863C, 0x7DFA, 0x7DDA, 0x7578, 0x6D77, 0x75B9, 0x761B, 0x6DDA,   // 0x12A0 (4768)
+0x65BB, 0x663C, 0x6E9E, 0x6EBF, 0x6EBF, 0x669F, 0x669F, 0x66BF, 0x66BF, 0x66BF, 0x669F, 0x669F, 0x6EBF, 0x6E9F, 0x6E7E, 0x767E,   // 0x12B0 (4784)
+0x869E, 0x7E1C, 0x6D99, 0x7DDA, 0x6D16, 0x6453, 0x42CD, 0x08C5, 0x0021, 0x0000, 0x0000, 0x0000, 0x0841, 0x0840, 0x0820, 0x0000,   // 0x12C0 (4800)
+0x0801, 0x0000, 0x0821, 0x0821, 0x0821, 0x0000, 0x0000, 0x0001, 0x0022, 0x0043, 0x0905, 0x19E9, 0x32ED, 0x43B0, 0x5C73, 0x64F5,   // 0x12D0 (4816)
+0x6D58, 0x6557, 0x5D16, 0x54F5, 0x54F6, 0x5CF7, 0x5CF8, 0x5CF8, 0x5518, 0x5518, 0x5518, 0x5538, 0x5518, 0x5D18, 0x5CF7, 0x6518,   // 0x12E0 (4832)
+0x6517, 0x5C75, 0x5C55, 0x74F7, 0x74F7, 0x5433, 0x64B5, 0x6CF6, 0x6CB4, 0x6CD5, 0x7D57, 0x74D5, 0x5C33, 0x5412, 0x5C53, 0x5C74,   // 0x12F0 (4848)
+0x5CB5, 0x64F6, 0x5CF6, 0x54B5, 0x54D6, 0x5D17, 0x5D17, 0x5517, 0x5517, 0x5D17, 0x5D17, 0x5D17, 0x5CF7, 0x5CF7, 0x64F7, 0x64F7,   // 0x1300 (4864)
+0x64D6, 0x5C75, 0x4BD2, 0x32CE, 0x1A2B, 0x08C5, 0x0000, 0x0001, 0x0883, 0x0863, 0x0001, 0x0021, 0x0821, 0x0000, 0x0000, 0x0000,   // 0x1310 (4880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0021, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0042, 0x0043, 0x0002, 0x0001,   // 0x1320 (4896)
+0x0001, 0x0001, 0x0001, 0x0021, 0x0021, 0x0001, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,   // 0x1330 (4912)
+0x0022, 0x0022, 0x0001, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000,   // 0x1340 (4928)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,   // 0x1350 (4944)
+0x0042, 0x0022, 0x0022, 0x0043, 0x0042, 0x0042, 0x0022, 0x0001, 0x0002, 0x0822, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1360 (4960)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0040, 0x0840, 0x0820, 0x0020, 0x0021, 0x0042, 0x0022, 0x0001, 0x0042, 0x0042, 0x0002, 0x0021,   // 0x1370 (4976)
+0x0021, 0x0021, 0x0021, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0000, 0x0000,   // 0x1380 (4992)
+0x0001, 0x0041, 0x0041, 0x0000, 0x0020, 0x0861, 0x0021, 0x0020, 0x0020, 0x0020, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0001,   // 0x1390 (5008)
+0x0000, 0x0000, 0x0000, 0x0021, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0021,   // 0x13A0 (5024)
+0x0021, 0x0021, 0x0021, 0x0001, 0x0001, 0x0041, 0x0041, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0841, 0x0821, 0x0000,   // 0x13B0 (5040)
+0x0060, 0x0040, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0021, 0x0001, 0x0001, 0x0000,   // 0x13C0 (5056)
+0x0820, 0x0820, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000,   // 0x13D0 (5072)
+0x0021, 0x0841, 0x0862, 0x0001, 0x0001, 0x0841, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0023, 0x0002, 0x0002, 0x0001, 0x0001,   // 0x13E0 (5088)
+0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x13F0 (5104)
+0x0000, 0x0041, 0x0861, 0x0020, 0x0841, 0x0020, 0x0000, 0x0821, 0x0801, 0x0821, 0x0821, 0x0000, 0x0821, 0x0841, 0x0841, 0x0000,   // 0x1400 (5120)
+0x0020, 0x0020, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1410 (5136)
+0x0800, 0x0800, 0x0820, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1420 (5152)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0822,   // 0x1430 (5168)
+0x0821, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0820,   // 0x1440 (5184)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0821, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1450 (5200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1460 (5216)
+0x0000, 0x0000, 0x0840, 0x0841, 0x0000, 0x0000, 0x0820, 0x0840, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, 0x0000,   // 0x1470 (5232)
+0x0000, 0x0021, 0x0000, 0x0020, 0x0021, 0x0021, 0x0000, 0x18E4, 0x3186, 0x2104, 0x0841, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000,   // 0x1480 (5248)
+0x0000, 0x0020, 0x0000, 0x2104, 0x31A6, 0x2124, 0x0000, 0x0000, 0x0841, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x1490 (5264)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0820, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14A0 (5280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x2104, 0x2945, 0x18E3,   // 0x14B0 (5296)
+0x0841, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0841, 0x0000, 0x10A2, 0x0020, 0x0000,   // 0x14C0 (5312)
+0x0000, 0x0000, 0x0841, 0x0000, 0x0020, 0x10A2, 0x0000, 0xA514, 0xFFFF, 0xE71C, 0x1082, 0x0000, 0x0000, 0x0000, 0x0840, 0x0020,   // 0x14D0 (5328)
+0x0000, 0x0000, 0x0861, 0xCE79, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0x0020, 0x0000, 0x0020, 0x0841, 0x1082, 0x0861, 0x0000, 0x0000,   // 0x14E0 (5344)
+0x0000, 0x0841, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14F0 (5360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0xD69A, 0xFFFF, 0xBDD7,   // 0x1500 (5376)
+0x0020, 0x0000, 0x0861, 0x0861, 0x0000, 0x0000, 0x0000, 0x0841, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1510 (5392)
+0x0020, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xA514, 0xFFFF, 0xE71C, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1520 (5408)
+0x0000, 0x0000, 0x0020, 0xC638, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0x0000, 0x0020, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1530 (5424)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0841, 0x0882, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1540 (5440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x39C7, 0xD6BA, 0xFFFF, 0xBDD7,   // 0x1550 (5456)
+0x1082, 0x0000, 0x0000, 0x0000, 0x0020, 0x2965, 0x2945, 0x2104, 0x18C3, 0x0020, 0x0000, 0x0861, 0x2945, 0x2945, 0x2124, 0x2104,   // 0x1560 (5472)
+0x10A2, 0x0000, 0x0000, 0x0020, 0x10A2, 0x2104, 0x1082, 0xAD55, 0xFFFF, 0xDEFB, 0x10A2, 0x0000, 0x1082, 0x2104, 0x2104, 0x2945,   // 0x1570 (5488)
+0x10A2, 0x0000, 0x0861, 0xCE59, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0x1082, 0x2104, 0x2104, 0x2104, 0x10A2, 0x0020, 0x0020, 0x2124,   // 0x1580 (5504)
+0x2104, 0x2104, 0x2104, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1590 (5520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0xFFFF, 0xE73C, 0xEF7D, 0xFFFF,   // 0x15A0 (5536)
+0xF79E, 0x2104, 0x0000, 0x0000, 0x2124, 0xD69A, 0xFFDF, 0xFFFF, 0xDEFB, 0x2124, 0x0000, 0x7BEF, 0xFFFF, 0xFFFF, 0xF79E, 0xFFFF,   // 0x15B0 (5552)
+0xC638, 0x10A2, 0x0020, 0x0000, 0x632C, 0xFFFF, 0xF7BE, 0xFFDF, 0xFFFF, 0xD6BA, 0x18C3, 0x0000, 0x8410, 0xFFFF, 0xF79E, 0xFFFF,   // 0x15C0 (5568)
+0x94B2, 0x0000, 0x0000, 0xC618, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0xAD55, 0xFFFF, 0xEF5D, 0xFFFF, 0x6B6D, 0x0000, 0x2965, 0xF79E,   // 0x15D0 (5584)
+0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0x632C, 0x0000, 0x0000, 0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15E0 (5600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4A49, 0xEF7D, 0x18C3, 0x7BEF, 0xFFFF,   // 0x15F0 (5616)
+0xD6BA, 0x18E3, 0x0000, 0x0841, 0x0000, 0x0020, 0x0000, 0x6B6D, 0xFFFF, 0xFFFF, 0x2945, 0x5AEB, 0xFFFF, 0xFFFF, 0x18E3, 0x632C,   // 0x1600 (5632)
+0xFFFF, 0xF7BE, 0x18E3, 0x8410, 0xFFFF, 0xE73C, 0x0841, 0x8C51, 0xFFFF, 0xDEFB, 0x0020, 0xA514, 0xFFFF, 0xD69A, 0x18E3, 0xBDD7,   // 0x1610 (5648)
+0xFFFF, 0xC618, 0x0000, 0xC618, 0xFFFF, 0xAD55, 0x1082, 0xD6BA, 0xFFFF, 0xA514, 0x1082, 0xDEDB, 0xFFFF, 0x8C71, 0x0861, 0xEF7D,   // 0x1620 (5664)
+0xFFFF, 0x7BCF, 0x10A2, 0xFFDF, 0xFFFF, 0x8410, 0x0000, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1630 (5680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0xFFFF, 0x3186, 0x8C51, 0xFFFF,   // 0x1640 (5696)
+0xF79E, 0x4208, 0x0000, 0x0000, 0x31A6, 0xEF5D, 0xFFFF, 0xF79E, 0xFFFF, 0xFFFF, 0x2945, 0x5ACB, 0xFFFF, 0xFFFF, 0x18E3, 0x6B6D,   // 0x1650 (5712)
+0xFFFF, 0xE73C, 0x10A2, 0x7BCF, 0xFFFF, 0xEF5D, 0x0841, 0x9492, 0xFFFF, 0xDEFB, 0x1082, 0xA514, 0xFFFF, 0xFFFF, 0xFFDF, 0xD6BA,   // 0x1660 (5728)
+0xEF7D, 0xAD75, 0x0000, 0xC618, 0xFFFF, 0xAD75, 0x0000, 0xD6BA, 0xFFFF, 0xF79E, 0xF7BE, 0xEF5D, 0xFFFF, 0x7BEF, 0x0861, 0xE73C,   // 0x1670 (5744)
+0xFFFF, 0x8430, 0x2104, 0xF79E, 0xFFFF, 0x8C51, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1680 (5760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8430, 0xFFFF, 0xEF5D, 0xFFDF, 0xEF5D, 0xE73C,   // 0x1690 (5776)
+0xFFFF, 0xFFFF, 0x4A49, 0x4208, 0xFFFF, 0xFFFF, 0x31A6, 0x4A69, 0xFFFF, 0xFFFF, 0x2945, 0x5AEB, 0xFFFF, 0xFFDF, 0x2124, 0x6B6D,   // 0x16A0 (5792)
+0xFFFF, 0xF7BE, 0x10A2, 0x8410, 0xFFFF, 0xE71C, 0x0841, 0x9492, 0xFFFF, 0xD69A, 0x0020, 0xA534, 0xFFFF, 0xCE59, 0x0841, 0x0000,   // 0x16B0 (5808)
+0x0000, 0x0000, 0x0020, 0xC638, 0xFFFF, 0xAD75, 0x0020, 0xD69A, 0xFFFF, 0xAD75, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0xEF7D,   // 0x16C0 (5824)
+0xFFFF, 0x73AE, 0x10A2, 0xFFDF, 0xFFFF, 0x8410, 0x0000, 0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16D0 (5840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9CD3, 0xDEFB, 0x0000, 0x0000, 0x0000, 0x4A69,   // 0x16E0 (5856)
+0xFFFF, 0xFFFF, 0x52AA, 0x39E7, 0xF7BE, 0xFFFF, 0x4228, 0x5ACB, 0xFFFF, 0xFFFF, 0x2945, 0x5AEB, 0xFFFF, 0xFFFF, 0x18E3, 0x6B6D,   // 0x16F0 (5872)
+0xFFFF, 0xF79E, 0x10A2, 0x738E, 0xFFFF, 0xEF7D, 0x2104, 0x94B2, 0xFFFF, 0xDEFB, 0x0020, 0x94B2, 0xFFFF, 0xDEDB, 0x2104, 0x0841,   // 0x1700 (5888)
+0x10A2, 0x0841, 0x0000, 0xC638, 0xFFFF, 0xB596, 0x10A2, 0xBDF7, 0xFFFF, 0xBDD7, 0x0861, 0x1082, 0x1082, 0x0000, 0x2124, 0xE73C,   // 0x1710 (5904)
+0xFFFF, 0x7BEF, 0x2124, 0xFFDF, 0xFFFF, 0x8430, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1720 (5920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8C51, 0xCE59, 0x0841, 0x0000, 0x0000, 0x4228,   // 0x1730 (5936)
+0xEF7D, 0xFFFF, 0x5AEB, 0x0000, 0x18E3, 0xCE79, 0xFFFF, 0xFFDF, 0xF7BE, 0xFFDF, 0x2945, 0x5ACB, 0xFFFF, 0xE73C, 0x18E3, 0x6B6D,   // 0x1740 (5952)
+0xFFFF, 0xE73C, 0x2945, 0x0000, 0x4208, 0xF79E, 0xFFFF, 0xF7BE, 0xFFFF, 0xD6BA, 0x18E3, 0x0000, 0x630C, 0xFFFF, 0xF79E, 0xFFFF,   // 0x1750 (5968)
+0xFFFF, 0xAD75, 0x0861, 0xB5B6, 0xFFFF, 0xAD75, 0x0000, 0x0000, 0x9492, 0xFFFF, 0xEF7D, 0xFFDF, 0xFFFF, 0x8C71, 0x0861, 0xE71C,   // 0x1760 (5984)
+0xFFFF, 0x73AE, 0x1082, 0xEF5D, 0xFFFF, 0x7BCF, 0x0000, 0x0861, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1770 (6000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0861, 0x0841, 0x0000,   // 0x1780 (6016)
+0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000, 0x0000,   // 0x1790 (6032)
+0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17A0 (6048)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0000,   // 0x17B0 (6064)
+0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0861, 0x1082, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17C0 (6080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17D0 (6096)
+0x0000, 0x0000, 0x0861, 0x0861, 0x0000, 0x0020, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0020, 0x0020, 0x0000, 0x0841, 0x0020,   // 0x17E0 (6112)
+0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0841, 0x0861, 0x0000, 0x0020, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000,   // 0x17F0 (6128)
+0x0000, 0x0000, 0x0000, 0x0861, 0x0861, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0861, 0x0841, 0x0000, 0x0000, 0x0000,   // 0x1800 (6144)
+0x0020, 0x0020, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1810 (6160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0020, 0x0000, 0x0000, 0x0841,   // 0x1820 (6176)
+0x0861, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0020, 0x0000, 0x0841, 0x0000, 0x0841,   // 0x1830 (6192)
+0x0841, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0861, 0x0861, 0x0000, 0x0000, 0x0841,   // 0x1840 (6208)
+0x0020, 0x0000, 0x0020, 0x0000, 0x0000, 0x0020, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0841,   // 0x1850 (6224)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0861, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1860 (6240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000,   // 0x1870 (6256)
+0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0000, 0x10A2, 0x1082, 0x0000, 0x0000, 0x0000, 0x0020, 0x0861, 0x0020, 0x0000, 0x0000,   // 0x1880 (6272)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0841, 0x0000, 0x0020, 0x1082, 0x1082, 0x0020, 0x0000, 0x0020, 0x0841, 0x0000,   // 0x1890 (6288)
+0x0000, 0x0020, 0x0841, 0x0841, 0x0020, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0841, 0x1082, 0x0020, 0x0000, 0x0020, 0x0020,   // 0x18A0 (6304)
+0x0000, 0x0020, 0x0861, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18B0 (6320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0861, 0x0841,   // 0x18C0 (6336)
+0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0841, 0x0000, 0x1082, 0x0841,   // 0x18D0 (6352)
+0x0020, 0x10A2, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x1082, 0x0841, 0x0000,   // 0x18E0 (6368)
+0x0000, 0x0000, 0x0841, 0x0000, 0x0000, 0x0020, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0841,   // 0x18F0 (6384)
+0x0000, 0x0020, 0x0841, 0x0000, 0x0000, 0x0841, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1900 (6400)
+};

_718/acloc.ino

@@ -0,0 +1,529 @@
+
+
+void drawDisplay()
+{
+  //t = rtc.getTime();
+//  t.hour=rtc_clock.get_hours();
+//  t.min=rtc_clock.get_minutes()
+// sec=t.sec;
+  t = rtc.getTime();
+min1= t.min;
+hour1=t.hour;
+  drawSec(t.sec);
+  oldsec=t.sec;
+if (t.sec==0)
+{
+  if(( t.hour>5)&&( t.hour<7)&&(t.min>29))
+{night=0;
+savefld();//запись новой даты в файлы полива цветов
+}
+else
+{night=1;
+}
+
+ drawMin(t.min);
+  drawHour(t.hour, t.min);
+    myGLCD.setColor(255, 255, 255);
+  myGLCD.setBackColor(0, 0, 0);
+   myGLCD.setFont( SevenSegNumFont);
+//   myGLCD.print(rtc_clock.get_hours(), clockCenterX+92+111+32, clockCenterY-8-20);
+  if (night==1) 
+{  myGLCD.setColor(192, 192, 255);
+
+}
+else
+{  myGLCD.setColor(255,255, 255);
+
+}  
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340, clockCenterY-8-20);
+    myGLCD.printNumI(t.hour, clockCenterX+340+32, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,clockCenterX+340, clockCenterY-8-20);
+  }
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340+96, clockCenterY-8-20);
+    myGLCD.printNumI(t.min, clockCenterX+340+128, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, clockCenterX+340+96, clockCenterY-8-20);
+  }
+  
+}
+if (q==1)
+{ drawMin(t.min);
+  drawHour(t.hour, t.min);
+  printDate();
+}
+if( (hour1==0) && (min1==0))
+{ 
+  printDate();
+}
+}
+//****************************************************************************
+void drawMark(int h)
+{
+  float x1, y1, x2, y2;
+  
+  h=h*30;
+  h=h+270;
+  
+  x1=2*110*cos(h*0.0175);
+  y1=2*110*sin(h*0.0175);
+  x2=2*100*cos(h*0.0175);
+  y2=2*100*sin(h*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+}
+
+void drawSec(int s)
+{
+  float x1, y1, x2, y2;
+  int ps = s-1;
+  
+  myGLCD.setColor(0, 0, 0);
+  if (ps==-1)
+    ps=59;
+  ps=ps*6;
+  ps=ps+270;
+  
+  x1=2*95*cos(ps*0.0175);
+  y1=2*95*sin(ps*0.0175);
+  x2=2*80*cos(ps*0.0175);
+  y2=2*80*sin(ps*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+
+  myGLCD.setColor(255,255,255);
+  s=s*6;
+  s=s+270;
+  
+  x1=2*95*cos(s*0.0175);
+  y1=2*95*sin(s*0.0175);
+  x2=2*80*cos(s*0.0175);
+  y2=2*80*sin(s*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+}
+
+void drawMin(int m)
+{
+  float x1, y1, x2, y2, x3, y3, x4, y4;
+  int pm = m-1;
+  
+  myGLCD.setColor(0, 0, 0);
+  if (pm==-1)
+    pm=59;
+  pm=pm*6;
+  pm=pm+270;
+  
+  x1=2*80*cos(pm*0.0175);
+  y1=2*80*sin(pm*0.0175);
+  x2=2*5*cos(pm*0.0175);
+  y2=2*5*sin(pm*0.0175);
+  x3=2*30*cos((pm+4)*0.0175);
+  y3=2*30*sin((pm+4)*0.0175);
+  x4=2*30*cos((pm-4)*0.0175);
+  y4=2*30*sin((pm-4)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+
+  myGLCD.setColor(0, 255, 0);
+  m=m*6;
+  m=m+270;
+  
+  x1=2*80*cos(m*0.0175);
+  y1=2*80*sin(m*0.0175);
+  x2=2*5*cos(m*0.0175);
+  y2=2*5*sin(m*0.0175);
+  x3=2*30*cos((m+4)*0.0175);
+  y3=2*30*sin((m+4)*0.0175);
+  x4=2*30*cos((m-4)*0.0175);
+  y4=2*30*sin((m-4)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+}
+
+void drawHour(int h, int m)
+{
+  float x1, y1, x2, y2, x3, y3, x4, y4;
+  int ph = h;
+  
+  myGLCD.setColor(0, 0, 0);
+  if (m==0)
+  {
+    ph=((ph-1)*30)+((m+59)/2);
+  }
+  else
+  {
+    ph=(ph*30)+((m-1)/2);
+  }
+  ph=ph+270;
+  
+  x1=2*60*cos(ph*0.0175);
+  y1=2*60*sin(ph*0.0175);
+  x2=2*5*cos(ph*0.0175);
+  y2=2*5*sin(ph*0.0175);
+  x3=2*20*cos((ph+5)*0.0175);
+  y3=2*20*sin((ph+5)*0.0175);
+  x4=2*20*cos((ph-5)*0.0175);
+  y4=2*20*sin((ph-5)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+
+  myGLCD.setColor(255, 255, 0);
+  h=(h*30)+(m/2);
+  h=h+270;
+  
+  x1=2*60*cos(h*0.0175);
+  y1=2*60*sin(h*0.0175);
+  x2=2*5*cos(h*0.0175);
+  y2=2*5*sin(h*0.0175);
+  x3=2*20*cos((h+5)*0.0175);
+  y3=2*20*sin((h+5)*0.0175);
+  x4=2*20*cos((h-5)*0.0175);
+  y4=2*20*sin((h-5)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+}
+
+
+
+//**************************************************
+void printDate()
+{
+  myGLCD.setFont( Ubuntubold);
+ // Time t_temp;
+  
+  //t_temp = rtc.getTime();
+ 
+if (night==1) 
+{   myGLCD.setColor(142, 142, 200);//ночной календарь
+  myGLCD.setBackColor(0,38,92);
+}
+else
+{  myGLCD.setColor(0, 0, 255);
+  myGLCD.setBackColor(255, 255, 255);
+}  
+  dow= t.dow;
+
+   myGLCD.print(str[dow-1], 272+450-80, 24);
+//  myGLCD.print(rtc.getDOWStr(FORMAT_SHORT), 256+450, 8);
+  if (t.date<10)
+    myGLCD.printNumI(t.date, 272+450-50, 58);
+  else
+    myGLCD.printNumI(t.date, 264+450-50, 58);
+  myGLCD.printNumI(t.mon, 256+450-50, 92);
+  myGLCD.printNumI(t.year, 248+450-50, 126);
+   myGLCD.setFont(BigFont);
+}
+
+void clearDate()
+{
+  if (night==1) 
+{ myGLCD.setColor (0,38,92);
+ }
+else
+{  myGLCD.setColor(255, 255, 255);
+  }
+  
+  myGLCD.fillRect(240+450-80, 15, 319+450, 166);
+  // myGLCD.fillRoundRect(240+450-80, 0, 319+450, 85+80);
+}
+//*************************************************************************
+//******************************************************************
+void clok()
+
+{   //t = rtc.getTime();
+ int a=0;
+ q=1;
+  int x, y;
+do
+  {
+ t = rtc.getTime();
+ 
+if( night==1 )
+{constbr=20;
+        br=constbr+brightness;
+       analogWrite(12, br);    
+}
+else
+{constbr=200;
+        br=constbr+brightness;
+       analogWrite(12, br);
+  if (rawp==1)
+  {rawp=0;
+  myGLCD.fillScr(VGA_AQUA);//выход утром в RAW
+  byte bait;
+byte bait1;
+ int w; 
+ sd.chdir("/");
+  delay (100);
+
+   myFile.open("33.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 96000; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>399){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, 2*m, 400, 1, pic1, 2);
+ m=m+1;
+ }
+  } 
+  myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok  
+ kalend(); 
+  
+  
+  
+  
+  
+  
+  
+  raw();
+  }
+       
+}
+
+if (q==1)
+{
+  
+  // Clear screen
+  myGLCD.clrScr();
+  
+  // Draw Clockface
+  myGLCD.setColor(0, 0, 255);
+  myGLCD.setBackColor(0, 0, 0);
+  for (int i=0; i<5; i++)
+  {
+    myGLCD.drawCircle(clockCenterX, clockCenterY, 230-i);//119-i
+  }
+  for (int i=0; i<5; i++)
+  {
+    myGLCD.drawCircle(clockCenterX, clockCenterY, 2*i);
+  }
+  
+  myGLCD.setColor(192, 192, 255);
+   myGLCD.setFont( SevenSegNumFont);
+  myGLCD.print("3", clockCenterX+92+111-16, clockCenterY-8-20);
+  myGLCD.print("6", clockCenterX-32+12, clockCenterY+95+111-30);
+  myGLCD.print("9", clockCenterX-109-111, clockCenterY-8-20);
+  myGLCD.print("12", clockCenterX-32, clockCenterY-109-111);
+  for (int i=0; i<12; i++)
+  {
+    if ((i % 3)!=0)
+      drawMark(i);
+  }
+  // myGLCD.setFont(BigFont);
+   
+   // Draw calendar
+if (night==1) 
+{ myGLCD.setColor(0,38,92);
+
+}
+else
+{ myGLCD.setColor(255, 255, 255);
+
+}
+
+ // myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(240+450-80, 0, 319+450, 85+80);
+  
+if (night==1) 
+{ myGLCD.setColor(255, 255, 255);
+
+}
+else
+{  myGLCD.setColor(0, 0, 0);
+
+}  
+ // myGLCD.setColor(0, 0, 0); 
+ 
+  for (int i=0; i<14; i++)
+  {
+    myGLCD.drawLine(249+450-80+(i*10), 0, 248+450-80+(i*10), 7);
+    myGLCD.drawLine(250+450-80+(i*10), 0, 249+450-80+(i*10), 7);
+    myGLCD.drawLine(251+450-80+(i*10), 0, 250+450-80+(i*10), 7);
+  }
+myGLCD.setFont( BigFont);
+  // Draw SET button
+  myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(260+450, 200+200, 319+450, 239+200);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(260+450, 200+200, 319+450, 239+200);
+  myGLCD.setBackColor(64, 64, 128);
+  myGLCD.print("SET", 266+450, 212+200);
+  myGLCD.setBackColor(0, 0, 0);
+  // Draw exit button
+    myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(260+450, 200+150, 319+450, 239+150);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(260+450, 200+150, 319+450, 239+150);
+  myGLCD.setBackColor(64, 64, 128);
+  myGLCD.print("EXT", 266+450, 212+150);
+  myGLCD.setBackColor(0, 0, 0);
+  
+  
+  if (night==1) 
+{  myGLCD.setColor(192, 192, 255);
+
+}
+else
+{  myGLCD.setColor(255,255, 255);
+
+}  
+  
+ 
+  myGLCD.setBackColor(0, 0, 0);
+  myGLCD.setFont( SevenSegNumFont);
+
+ t = rtc.getTime();
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340, clockCenterY-8-20);
+    myGLCD.printNumI(t.hour, clockCenterX+340+32, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,clockCenterX+340, clockCenterY-8-20);
+  }
+  myGLCD.print(":",clockCenterX+340+64, clockCenterY-8-20);
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340+96, clockCenterY-8-20);
+    myGLCD.printNumI(t.min, clockCenterX+340+128, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, clockCenterX+340+96, clockCenterY-8-20);
+  }
+ 
+}  
+
+  if (t.date==0)
+  {
+    setClock();
+  }
+
+ drawDisplay();
+// printDate();
+q=0;
+
+    
+
+    if (myTouch.dataAvailable())
+    {
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      if (((y>=200+200) && (y<=239+200)) && ((x>=260+450) && (x<=319+450)))
+      {
+        myGLCD.setColor (255, 0, 0);
+        myGLCD.drawRoundRect(260+450, 200+200, 319+450, 239+200);
+        setClock();
+      }
+       if (((y>=200+150) && (y<=239+150)) && ((x>=260+450) && (x<=319+450)))
+      {
+        if (c==1)
+        {
+          menu();
+        }
+        myGLCD.setColor (255, 0, 0);
+        myGLCD.drawRoundRect(260+450, 200+150, 319+450, 239+150);
+        menu();
+      }
+      
+    }
+//**********TOUCH    
+    delay(10);
+     t = rtc.getTime();
+ // rawp=1 ; 
+ if (rawp==1)   
+{   if (t.sec==17)
+  {  prognoz();
+    q=1;
+    delay(5000);
+  } 
+   if (t.sec==37)
+  {  nightgraf();
+  q=1;
+  delay(5000);
+    } 
+   if ((sec==10) || (sec==29) )
+{
+ if(Serial.available()) {  
+ priem();
+}
+ 
+ }
+}
+ //**************************massiv******************
+//  t = rtc.getTime();
+ if (t.min==0)
+ {
+if ((t.sec==0)||(t.sec==1))
+  {
+  //  printmassiv();
+  if (fsec==1)
+  {uart();
+  bmp085();
+  uart();
+  savemastd();
+  
+  
+  fsec=0;  //delay (300); 
+  if(t.hour==23)
+  {sdwrite();
+   savemasclok();
+   saveminmax();//запись макс  мин и средних значений датчиков за день
+  } 
+  if((t.hour>=0)||(t.hour<23))
+  {
+   savemasclok();//запись времени на sd 12:56 15/05/14 и массива rab
+  } 
+  
+  }    
+  }
+}
+//*****************************************************
+ if (t.min>3)
+ {fsec=1;
+ }
+ //***************************************************************** 
+
+
+
+} while (a<1);
+}

_718/ad.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: +.jpg
+// Time generated: 12.04.2014 22:13:58
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short ad[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x211F, 0x211F, 0x213F, 0x191F, 0x193F, 0x191F, 0x213F, 0x211F,   // 0x0010 (16)
+0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211E, 0x191F, 0x211F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FE, 0x18FF, 0x18FF, 0x18FE, 0x18FF, 0x211F, 0x18DD, 0x20FF, 0x18DF, 0x20FF,   // 0x0030 (48)
+0x18DE, 0x18FF, 0x18FF, 0x20FF, 0x18FE, 0x18FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x18BF, 0x18BF, 0x189F, 0x18DF, 0x109F, 0x10DE, 0x10BF, 0x18DF, 0x10BF,   // 0x0050 (80)
+0x109E, 0x18DF, 0x10BF, 0x10DF, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x089F, 0x089F, 0x085F, 0x087F, 0x085E, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087E, 0x087F, 0x109F, 0x085E,   // 0x0070 (112)
+0x085F, 0x107F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x085F, 0x003F, 0x005F, 0x085F, 0x085F, 0x005F, 0x007E, 0x003F, 0x005F, 0x085F, 0x005F, 0x005F, 0x003F, 0x003F, 0x085F, 0x083F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E,   // 0x00A0 (160)
+0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005E, 0x001F, 0x083F, 0x001F, 0x003F, 0x001E, 0x003F, 0x001E, 0x003F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x081F, 0x081F, 0x081E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x081F,   // 0x00E0 (224)
+0xF7FF, 0xF7FF, 0xEFFF, 0x081E, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0013, 0x0017, 0x0019, 0x0019, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF,   // 0x0100 (256)
+0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0016, 0x0017,   // 0x0110 (272)
+0x0018, 0x001D, 0x001D, 0x001E, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001E, 0xFFDF, 0xFFFF, 0xFFFF, 0x001F,   // 0x0120 (288)
+0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0017, 0x0018, 0x001C,   // 0x0130 (304)
+0x001E, 0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001E,   // 0x0140 (320)
+0x001F, 0x003F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0015, 0x0019, 0x001B, 0x001D, 0x001D,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E, 0x001E, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001E, 0x005F, 0x001F, 0x081E,   // 0x0170 (368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0xF7FF, 0xF7FF, 0xF7FF, 0x213F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0016, 0x0019, 0x001A, 0x001D, 0x001F, 0x001D, 0xF7FF, 0xFFDF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFFD, 0xFFDF, 0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0018, 0x0018, 0x001C, 0x001F, 0x001E, 0x001F, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xF7FF, 0xFFFF, 0xF7FE, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001D, 0x001F, 0x081F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFE, 0xFFFF,   // 0x01D0 (464)
+0xFFFF, 0xF7FF, 0xFFFE, 0xFFFE, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xFFFE, 0xFFFF,   // 0x01F0 (496)
+0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x081F, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFE, 0x001F,   // 0x0210 (528)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x005F, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F,   // 0x0250 (592)
+0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001E, 0x001F, 0x003F, 0x001F, 0x001E, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x003E, 0xFFFF, 0xFFFE, 0xF7FF, 0x003E, 0x001F, 0x003E, 0x001E, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x001F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x081E, 0x081F, 0x081F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E,   // 0x0300 (768)
+0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B,   // 0x0340 (832)
+0x001B, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_718/bar.ino

@@ -0,0 +1,189 @@
+void bar(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+    myGLCD.setColor(0,0,255);
+    myGLCD.fillRoundRect(x-5, y-5, l+x+5, h+y+5);//рисуем синий пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+  myGLCD.fillRoundRect(x, y, pos*l/100+x, h+y);
+  myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,255);
+  myGLCD.print("BRIGHT", x-48+(l/2), y-25);
+  myGLCD.printNumI(abs(pos), x-10+(l/2), y+2);// уровень в процентах
+  
+  
+  
+  
+}
+
+
+void bright()
+{
+   int x=200;
+  int y=200;
+  int pos;
+  int h=20;//высота шкалы
+  int l=300;//длинна шкалы
+  
+
+//***************** 
+myGLCD.setColor(255, 255, 255);
+   myGLCD.drawBitmap (x+l-30, y-37, 30, 30, xf);
+    myGLCD.drawRoundRect (x+l-30, y-37, x+l-30+30, y-37+30);// Aandelend
+ //  myGLCD.setColor(255, 0, 0);
+ //    myGLCD.fillRoundRect ( x+l-30, y-37, x+l-30+30, y-37+30);
+ //    myGLCD.setColor(255, 255, 255);
+ //     myGLCD.setBackColor(255,0,0);
+ //    myGLCD.setFont(BigFont); 
+ //    myGLCD.drawRoundRect ( x+l-30, y-37, x+l-30+30, y-37+30); //X
+ //    myGLCD.print("X", x+l-30+8, y-37+7);
+//*********************************** 
+//***************** 
+ //  myGLCD.setColor(0, 0, 255);
+ //    myGLCD.fillRoundRect ( x+l-30, y+26, x+l-30+30, y+26+30);
+  //   myGLCD.setColor(255, 255, 255);
+    //  myGLCD.setBackColor(0,0,255);
+    // myGLCD.setFont(BigFont); 
+    myGLCD.drawBitmap (x+l-30, y+26, 30, 30, pr);
+     myGLCD.drawRoundRect ( x+l-30, y+26, x+l-30+30, y+26+30); //>>
+    // myGLCD.print(">", x+l-30+8, y+26+7);
+//*********************************** 
+//***************** 
+//   myGLCD.setColor(0, 0, 255);
+//     myGLCD.fillRoundRect (  x+l-60, y+26,  x+l-60+30, y+26+30);
+//     myGLCD.setColor(255, 255, 255);
+ //     myGLCD.setBackColor(0,0,255);
+   //  myGLCD.setFont(BigFont); 
+     myGLCD.drawBitmap (x+l-60, y+26, 30, 30, ad);
+     myGLCD.drawRoundRect (  x+l-60, y+26,  x+l-60+30, y+26+30); //+
+    // myGLCD.print("+", x+l-60+8, y+26+7);
+//*********************************** 
+     myGLCD.drawBitmap (x, y+26, 30, 30, le);
+     myGLCD.drawRoundRect (  x, y+26,  x+30, y+26+30); //<
+//***************** 
+ //  myGLCD.setColor(0, 0, 255);
+ //    myGLCD.fillRoundRect (  x+30, y+26,  x+30+30, y+26+30);
+ //    myGLCD.setColor(255, 255, 255);
+    //  myGLCD.setBackColor(0,0,255);
+    // myGLCD.setFont(BigFont);
+    myGLCD.drawBitmap (x+30, y+26, 30, 30, mi); 
+     myGLCD.drawRoundRect (  x+30, y+26,  x+30+30, y+26+30); //-
+    // myGLCD.print("-", x+30+8, y+26+7);
+//*********************************** 
+//***************** 
+//   myGLCD.setColor(0, 0, 255);
+ //    myGLCD.fillRoundRect (  x, y+26,  x+30, y+26+30);
+  //   myGLCD.setColor(255, 255, 255);
+   //   myGLCD.setBackColor(0,0,255);
+     //myGLCD.setFont(BigFont); 
+
+  //   myGLCD.print("<", x+8, y+26+7);
+//*********************************** 
+
+ pos=100*br/255;  
+bar(x,y, pos,l,h);
+
+  interval = 5000;
+  previousMillis =millis();
+while(1)
+{ 
+
+ 
+   currentMillis = millis();
+  
+ if(currentMillis - previousMillis >= interval) 
+ {
+    // save the last time you blinked the LED 
+    previousMillis = currentMillis;
+    interval = 10000;
+     previousMillis=0;
+    return;
+   
+ }
+  
+    if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+     int x1=myTouch.getX();
+      int y1=myTouch.getY();
+      
+      if ((y1>=y-37) && (y1<=y-37+30))  // Upper row
+      {
+        
+        if ((x1>= x+l-30) && (x1<= x+l-30+30))  // Aandelend
+           {waitForIt1( x+l-30, y-37, x+l-30+30, y-37+30);
+           interval = 10000;
+            previousMillis=0;
+             return;
+           }
+      }
+  
+   if ((y1>=y+26) && (y1<=y+26+30))  // Upper row
+      {
+        
+        if ((x1>= x+l-30) && (x1<= x+l-30+30))  //>
+      {brightness=brightness+25;
+       br=constbr+brightness;
+      if (br>255)
+      {br=255;
+     brightness=55;
+      }
+      waitForIt1( x+l-30, y+26, x+l-30+30, y+26+30);
+       pos=100*br/255 ; 
+        bar(x,y, pos,l,h);
+        analogWrite(12, br);
+        
+      }
+        if ((x1>= x+l-60) && (x1<= x+l-60+30))  // +
+          {brightness=brightness+1;
+          br=constbr+brightness;
+      if (br>255)
+      {br=255;
+     brightness=55;
+      }
+       waitForIt1(  x+l-60, y+26,  x+l-60+30, y+26+30);
+       pos=100*br/255 ; 
+        bar(x,y, pos,l,h);
+        analogWrite(12, br);
+        
+      }
+     
+      if ((x1>= x+30) && (x1<= x+30+30))  //- 
+       {brightness=brightness-1;
+        br=constbr+brightness;
+      if (br<1)
+      {br=1;
+      }
+       waitForIt1 (  x+30, y+26,  x+30+30, y+26+30);
+       pos=100*br/255;  
+       bar(x,y, pos,l,h);
+        analogWrite(12, br);
+      } 
+      
+       if ((x1>= x) && (x1<= x+30))  //<
+       {brightness=brightness-25;
+        br=constbr+brightness;
+      if (br<1)
+      {br=1;
+      }
+       waitForIt1 (  x, y+26,  x+30, y+26+30);
+       pos=100*br/255;  
+        bar(x,y, pos,l,h);
+        analogWrite(12, br);
+      } 
+      
+      
+      }        
+  
+  previousMillis = currentMillis; 
+    }  
+  
+ 
+}
+}

_718/bmp085.ino

@@ -0,0 +1,181 @@
+//----------------------------------------------------------------------------------------------------------
+void bmp085()
+{float temperature;
+temperature = bmp085GetTemperature(bmp085ReadUT());
+  pressure = bmp085GetPressure(bmp085ReadUP())*10.023/1333;
+ // pressureNN = pressure / pressureCorrection;
+  
+  
+ // Serial.print("Temperature: ");
+//  Serial.print(temperature,1);
+//  Serial.print(" C, Pressure: ");
+//  Serial.print(pressure,1);
+//  Serial.print(" hPa in 103m height above sea level, Pressure-NN: ");
+//  Serial.print(pressureNN,1);
+//  Serial.println(" hPa");
+  delay(500);
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Stores all of the bmp085's calibration values into global variables
+// Calibration values are required to calculate temp and pressure
+// This function should be called at the beginning of the program
+void bmp085Calibration()
+{
+  ac1 = bmp085ReadInt(0xAA);
+  ac2 = bmp085ReadInt(0xAC);
+  ac3 = bmp085ReadInt(0xAE);
+  ac4 = bmp085ReadInt(0xB0);
+  ac5 = bmp085ReadInt(0xB2);
+  ac6 = bmp085ReadInt(0xB4);
+  b1 = bmp085ReadInt(0xB6);
+  b2 = bmp085ReadInt(0xB8);
+  mb = bmp085ReadInt(0xBA);
+  mc = bmp085ReadInt(0xBC);
+  md = bmp085ReadInt(0xBE);
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Calculate temperature given ut.
+// Value returned will be in units of 0.1 deg C
+short bmp085GetTemperature(unsigned short ut)
+{
+  long x1, x2;
+  
+  x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
+  x2 = ((long)mc << 11)/(x1 + md);
+  b5 = x1 + x2;
+
+  return ((b5 + 8)>>4);  
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Calculate pressure given up
+// calibration values must be known
+// b5 is also required so bmp085GetTemperature(...) must be called first.
+// Value returned will be pressure in units of Pa.
+long bmp085GetPressure(unsigned long up)
+{
+  long x1, x2, x3, b3, b6, p;
+  unsigned long b4, b7;
+  
+  b6 = b5 - 4000;
+  // Calculate B3
+  x1 = (b2 * (b6 * b6)>>12)>>11;
+  x2 = (ac2 * b6)>>11;
+  x3 = x1 + x2;
+  b3 = (((((long)ac1)*4 + x3)<<OSS) + 2)>>2;
+  
+  // Calculate B4
+  x1 = (ac3 * b6)>>13;
+  x2 = (b1 * ((b6 * b6)>>12))>>16;
+  x3 = ((x1 + x2) + 2)>>2;
+  b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
+  
+  b7 = ((unsigned long)(up - b3) * (50000>>OSS));
+  if (b7 < 0x80000000)
+    p = (b7<<1)/b4;
+  else
+    p = (b7/b4)<<1;
+    
+  x1 = (p>>8) * (p>>8);
+  x1 = (x1 * 3038)>>16;
+  x2 = (-7357 * p)>>16;
+  p += (x1 + x2 + 3791)>>4;
+  
+  return p;
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read 1 byte from the BMP085 at 'address'
+char bmp085Read(unsigned char address)
+{
+  unsigned char data;
+  
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(address);
+  Wire.endTransmission();
+  
+  Wire.requestFrom(BMP085_ADDRESS, 1);
+  while(!Wire.available())
+    ;
+    
+  return Wire.read();
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read 2 bytes from the BMP085
+// First byte will be from 'address'
+// Second byte will be from 'address'+1
+short bmp085ReadInt(unsigned char address)
+{
+  unsigned char msb, lsb;
+  
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(address);
+  Wire.endTransmission();
+  
+  Wire.requestFrom(BMP085_ADDRESS, 2);
+  while(Wire.available()<2)
+    ;
+  msb = Wire.read();
+  lsb = Wire.read();
+  
+  return (short) msb<<8 | lsb;
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read the uncompensated temperature value
+unsigned short bmp085ReadUT()
+{
+  unsigned short ut;
+  
+  // Write 0x2E into Register 0xF4
+  // This requests a temperature reading
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(0xF4);
+  Wire.write(0x2E);
+  Wire.endTransmission();
+  
+  // Wait at least 4.5ms
+  delay(10);
+  
+  // Read two bytes from registers 0xF6 and 0xF7
+  ut = bmp085ReadInt(0xF6);
+  return ut;
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read the uncompensated pressure value
+unsigned long bmp085ReadUP()
+{
+  unsigned char msb, lsb, xlsb;
+  unsigned long up = 0;
+  
+  // Write 0x34+(OSS<<6) into register 0xF4
+  // Request a pressure reading w/ oversampling setting
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(0xF4);
+  Wire.write(0x34 + (OSS<<6));
+  Wire.endTransmission();
+  
+  // Wait for conversion, delay time dependent on OSS
+  delay(2 + (3<<OSS));
+  
+  // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB)
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(0xF6);
+  Wire.endTransmission();
+  Wire.requestFrom(BMP085_ADDRESS, 3);
+  
+  // Wait for data to become available
+  while(Wire.available() < 3) ;
+  msb = Wire.read();
+  lsb = Wire.read();
+  xlsb = Wire.read();
+  
+  up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS);
+  
+  return up;
+}
+//---------------------------------------------------------------------------------------------------------

_718/cl.c

@@ -0,0 +1,808 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: cl.jpg
+// Time generated: 30.03.2014 12:02:55
+// Dimensions    : 160x80 pixels
+// Size          : 25 600 Bytes
+
+const unsigned short cl[0x3200] ={
+0xD657, 0xDEB8, 0xE6D8, 0xE6D7, 0xE6D7, 0xDED7, 0xDEB7, 0xE6D7, 0xDED7, 0xE6D8, 0xE6F8, 0xE6D8, 0xE6D8, 0xDED7, 0xE6F8, 0xE6F8,   // 0x0010 (16)
+0xE718, 0xE718, 0xE718, 0xE718, 0xE718, 0xE718, 0xEF38, 0xEF38, 0xEF38, 0xEF38, 0xEF38, 0xEF38, 0xEF39, 0xEF59, 0xEF59, 0xEF59,   // 0x0020 (32)
+0xEF59, 0xEF59, 0xEF59, 0xF77A, 0xCE76, 0x41E6, 0x2143, 0x2123, 0x2123, 0x2123, 0x2122, 0x2123, 0x2143, 0x2123, 0x2143, 0x2943,   // 0x0030 (48)
+0x2943, 0x2964, 0x3164, 0x3184, 0x3184, 0x3184, 0x39C5, 0x39C5, 0x39C5, 0x39C5, 0x41E6, 0x41E6, 0x4206, 0x41E6, 0x4A27, 0x4A26,   // 0x0040 (64)
+0x4A26, 0x4226, 0x4A26, 0x4A27, 0x4A27, 0x4A47, 0x4A46, 0x4A47, 0x4A27, 0x4A47, 0x5267, 0x5247, 0x5268, 0x5268, 0x5247, 0x5247,   // 0x0050 (80)
+0x4A27, 0x5227, 0x5248, 0x5248, 0x5268, 0x5268, 0x5248, 0x5228, 0x4A48, 0x5248, 0x4A48, 0x4A28, 0x4A27, 0x5227, 0x4A27, 0x4A27,   // 0x0060 (96)
+0x4A27, 0x5247, 0x5267, 0x5247, 0x5267, 0x5268, 0x5247, 0x4A47, 0x5247, 0x5248, 0x5268, 0x5268, 0x5248, 0x5268, 0x5268, 0x5268,   // 0x0070 (112)
+0x4A27, 0x4207, 0x4207, 0x4207, 0x41E6, 0x41C6, 0x39C6, 0x39C6, 0x39C6, 0x39A6, 0x39A6, 0x39A6, 0x3985, 0x3185, 0x3185, 0x3185,   // 0x0080 (128)
+0x3985, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3985, 0x39A6, 0x31A5, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185,   // 0x0090 (144)
+0x3985, 0x3185, 0x3185, 0x3985, 0x3185, 0x39A6, 0x31A5, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3165, 0x3145, 0x2924, 0x2943,   // 0x00A0 (160)
+0xD6D8, 0xE6F9, 0xE719, 0xE719, 0xE719, 0xE719, 0xE739, 0xE739, 0xE739, 0xE739, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A,   // 0x00B0 (176)
+0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5B, 0xEF5B, 0xEF5B, 0xEF5B, 0xEF7B, 0xEF7B, 0xEF7B, 0xEF7A, 0xEF7B, 0xF79B, 0xF79B, 0xF79A,   // 0x00C0 (192)
+0xEF7A, 0xF77A, 0xF79A, 0xFFDB, 0xDEF7, 0x39E6, 0x2964, 0x2944, 0x2963, 0x2943, 0x2943, 0x2944, 0x2964, 0x2964, 0x2964, 0x2983,   // 0x00D0 (208)
+0x3163, 0x3184, 0x2963, 0x3184, 0x2984, 0x3184, 0x39A4, 0x39A5, 0x31A5, 0x31A5, 0x39A5, 0x39C4, 0x41E5, 0x4205, 0x41E5, 0x4205,   // 0x00E0 (224)
+0x4206, 0x4206, 0x4206, 0x4206, 0x4226, 0x4226, 0x4226, 0x4A47, 0x4A26, 0x4A26, 0x4A46, 0x4A46, 0x5267, 0x4A67, 0x4A47, 0x4A66,   // 0x00F0 (240)
+0x4A46, 0x4A46, 0x4A46, 0x4A26, 0x4A46, 0x4A67, 0x4A67, 0x4A46, 0x4A66, 0x4A66, 0x4A66, 0x4A66, 0x4A66, 0x4A67, 0x5287, 0x4A67,   // 0x0100 (256)
+0x5AA7, 0x5AC8, 0x5AC8, 0x5AE8, 0x62E8, 0x6309, 0x5AE8, 0x5AE8, 0x62E8, 0x6308, 0x62E8, 0x6308, 0x62E8, 0x6308, 0x6309, 0x6309,   // 0x0110 (272)
+0x5AC7, 0x5AC7, 0x5AA7, 0x5AC8, 0x5AC8, 0x5AC7, 0x5AC8, 0x5AC8, 0x62E8, 0x5AC7, 0x62E8, 0x5AE8, 0x5AC7, 0x5AC8, 0x5AC8, 0x5AC8,   // 0x0120 (288)
+0x5AC8, 0x5AC8, 0x5AE8, 0x5AC8, 0x62C8, 0x62C8, 0x5AC8, 0x62C8, 0x5AC7, 0x5AC7, 0x5AC7, 0x5AA7, 0x5AA7, 0x5AA7, 0x5AA7, 0x5AC7,   // 0x0130 (304)
+0x5AC8, 0x5AC8, 0x5AC7, 0x5AC8, 0x5AC7, 0x5AC7, 0x5AA7, 0x5AA7, 0x5AC7, 0x5AA7, 0x5AC7, 0x5AA7, 0x5AA7, 0x5A87, 0x39C4, 0x2943,   // 0x0140 (320)
+0xEF9D, 0xEF9E, 0xEF9E, 0xEF9E, 0xEF9E, 0xEF7F, 0xEF9F, 0xEF9F, 0xEF9E, 0xEF9E, 0xF79F, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF,   // 0x0150 (336)
+0xF7DF, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DE,   // 0x0160 (352)
+0xF7BE, 0xF79E, 0xF79E, 0xF7BE, 0xDF1B, 0x3A08, 0x2125, 0x2124, 0x2124, 0x2124, 0x2124, 0x2105, 0x2104, 0x2124, 0x2124, 0x2124,   // 0x0170 (368)
+0x2124, 0x2125, 0x2125, 0x2125, 0x2125, 0x2125, 0x2125, 0x2925, 0x2124, 0x2944, 0x2144, 0x2145, 0x2925, 0x2125, 0x2124, 0x2124,   // 0x0180 (384)
+0x2145, 0x2145, 0x2125, 0x2945, 0x2945, 0x2945, 0x2945, 0x2966, 0x2966, 0x2946, 0x2946, 0x2966, 0x2945, 0x2946, 0x2965, 0x2965,   // 0x0190 (400)
+0x2966, 0x2945, 0x2945, 0x2946, 0x2945, 0x2945, 0x2125, 0x2125, 0x2105, 0x2104, 0x2105, 0x2104, 0x2104, 0x2104, 0x2104, 0x2104,   // 0x01A0 (416)
+0x2103, 0x18E3, 0x2103, 0x18E3, 0x18E3, 0x18E3, 0x18E3, 0x18E3, 0x1903, 0x18E3, 0x18E3, 0x20E3, 0x18E3, 0x2103, 0x2103, 0x20E3,   // 0x01B0 (432)
+0x1903, 0x1903, 0x2103, 0x2103, 0x1903, 0x2103, 0x2103, 0x20E3, 0x2103, 0x2103, 0x2103, 0x2104, 0x2104, 0x18E3, 0x2103, 0x18E3,   // 0x01C0 (448)
+0x2104, 0x1903, 0x2103, 0x2103, 0x2104, 0x20E4, 0x20E4, 0x20E4, 0x2103, 0x2103, 0x2103, 0x2103, 0x18E3, 0x2103, 0x2103, 0x1903,   // 0x01D0 (464)
+0x18E3, 0x18E3, 0x18E3, 0x2103, 0x2103, 0x2103, 0x2103, 0x2103, 0x20E3, 0x2103, 0x2103, 0x2103, 0x18E3, 0x18E3, 0x18E3, 0x2103,   // 0x01E0 (480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01F0 (496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0200 (512)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF9D, 0x4A8A, 0x29A7, 0x31A7, 0x2987, 0x2966, 0x2986, 0x2966, 0x2986, 0x29A6, 0x29A6, 0x29A6,   // 0x0210 (528)
+0x29A7, 0x31A7, 0x31A7, 0x31A7, 0x39C8, 0x31C7, 0x31C8, 0x31E8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39C8, 0x31C8,   // 0x0220 (544)
+0x39C8, 0x39E8, 0x39E9, 0x4209, 0x4209, 0x4229, 0x3A29, 0x424A, 0x424A, 0x424A, 0x424A, 0x424A, 0x424A, 0x4229, 0x3A09, 0x3A09,   // 0x0230 (560)
+0x3A09, 0x3A09, 0x422A, 0x424A, 0x4229, 0x39E8, 0x39E8, 0x39C7, 0x31C7, 0x31C7, 0x31A7, 0x2986, 0x31A7, 0x31A7, 0x3187, 0x2986,   // 0x0240 (576)
+0x2986, 0x31A7, 0x31A7, 0x31A7, 0x3186, 0x3187, 0x3187, 0x3187, 0x2986, 0x2986, 0x3186, 0x3186, 0x2986, 0x2986, 0x3186, 0x3186,   // 0x0250 (592)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2966, 0x2986, 0x2986, 0x2966, 0x2966, 0x2966, 0x3186, 0x2986, 0x2965, 0x2986,   // 0x0260 (608)
+0x3186, 0x2966, 0x2965, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2965, 0x2944, 0x2165, 0x2145, 0x2945, 0x2945, 0x2944,   // 0x0270 (624)
+0x2145, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2144, 0x2144, 0x2144, 0x2945, 0x2944, 0x2124, 0x2144, 0x2144, 0x2124, 0x2104,   // 0x0280 (640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0290 (656)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x02A0 (672)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0x6B6F, 0x4A6A, 0x422A, 0x424A, 0x424A, 0x426A, 0x426A, 0x428A, 0x428B, 0x4AAC, 0x4A8B,   // 0x02B0 (688)
+0x4AAC, 0x52CC, 0x52CD, 0x5B0D, 0x5B0D, 0x5B0D, 0x5B4E, 0x636F, 0x638F, 0x6370, 0x6B90, 0x6B90, 0x6B90, 0x73B1, 0x73B1, 0x7BF2,   // 0x02C0 (704)
+0x83F3, 0x83F3, 0x8413, 0x8434, 0x8454, 0x8C75, 0x8C95, 0x8CB5, 0x9CF7, 0x9D18, 0x9D17, 0x9D17, 0x9D17, 0x94D6, 0x94B6, 0x94D6,   // 0x02D0 (720)
+0x94B6, 0x94D6, 0x94B6, 0x8C75, 0x8413, 0x73D2, 0x6B91, 0x6B71, 0x6B70, 0x6350, 0x634F, 0x634F, 0x632F, 0x5B0E, 0x5B0E, 0x5AED,   // 0x02E0 (736)
+0x52CD, 0x52CD, 0x5AED, 0x52ED, 0x52CC, 0x4AAC, 0x4A8B, 0x4A8B, 0x426B, 0x424A, 0x424A, 0x424A, 0x422A, 0x3A29, 0x3A29, 0x4229,   // 0x02F0 (752)
+0x4229, 0x4229, 0x4209, 0x3A09, 0x3A08, 0x3A08, 0x3A09, 0x4209, 0x3A08, 0x3A08, 0x39E8, 0x3A08, 0x3A08, 0x4269, 0x3A29, 0x3208,   // 0x0300 (768)
+0x3A08, 0x3A28, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x31E7, 0x31E8, 0x31E7, 0x31C7, 0x31A6, 0x29A6, 0x31C7, 0x31A7, 0x3186, 0x31A6,   // 0x0310 (784)
+0x31A6, 0x31A6, 0x3186, 0x3186, 0x2966, 0x2965, 0x2965, 0x2945, 0x2986, 0x2966, 0x2966, 0x3186, 0x2986, 0x2986, 0x2986, 0x2965,   // 0x0320 (800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0330 (816)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0340 (832)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE9B, 0x73F0, 0x530C, 0x52EC, 0x5B2D, 0x636E, 0x638E, 0x6BAF, 0x73F0, 0x7C31, 0x7C52,   // 0x0350 (848)
+0x7C31, 0x7431, 0x7C72, 0x84B3, 0x8CB4, 0x94D4, 0x9D36, 0xA576, 0xA597, 0xADB7, 0xB5D8, 0xBE19, 0xC65A, 0xCEBB, 0xCEBB, 0xDEFB,   // 0x0360 (864)
+0xDF1C, 0xDF1C, 0xDF1C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C,   // 0x0370 (880)
+0xE73C, 0xE73C, 0xE73C, 0xE6FC, 0xDEFC, 0xDEFC, 0xD6DB, 0xD6BB, 0xD6BB, 0xCE9B, 0xCE9B, 0xC67B, 0xBE3A, 0xB5D9, 0xADB8, 0xA576,   // 0x0380 (896)
+0x94F5, 0x9515, 0x9515, 0x8CB4, 0x8493, 0x7C52, 0x7C52, 0x6BCF, 0x6B8F, 0x634E, 0x5B4D, 0x5B4D, 0x5B2D, 0x5B2D, 0x530D, 0x52EC,   // 0x0390 (912)
+0x52CB, 0x52CB, 0x52EC, 0x52CC, 0x4ACB, 0x4AAB, 0x52CB, 0x4AAA, 0x4A8B, 0x4A8A, 0x4A8A, 0x4AAB, 0x4AAB, 0x4ACB, 0x52CC, 0x4AAB,   // 0x03A0 (928)
+0x428A, 0x4AAB, 0x4A6A, 0x4A6A, 0x4AAA, 0x4A8A, 0x4249, 0x4229, 0x3A09, 0x3A08, 0x3A28, 0x39E8, 0x31C7, 0x39C7, 0x39C7, 0x3A08,   // 0x03B0 (944)
+0x39E8, 0x31C7, 0x31A7, 0x31A7, 0x3186, 0x3186, 0x2985, 0x2965, 0x2945, 0x2945, 0x2965, 0x31A6, 0x31A6, 0x31A6, 0x31A7, 0x3187,   // 0x03C0 (960)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03D0 (976)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03E0 (992)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x632D, 0x4AAB, 0x4ACB, 0x52CB, 0x52EC, 0x52EC, 0x5B2D, 0x634E, 0x5B4E, 0x6BAF,   // 0x03F0 (1008)
+0x6BCF, 0x5B6E, 0x638E, 0x638E, 0x6B8F, 0x6B8F, 0x6BAF, 0x73F0, 0x73F0, 0x7C11, 0x7C31, 0x7C51, 0x8471, 0x8492, 0x8CD3, 0x94F4,   // 0x0400 (1024)
+0x9514, 0x9D14, 0x9D35, 0xA535, 0xAD55, 0xAD96, 0xB5B7, 0xBDF8, 0xBE18, 0xBE18, 0xBE18, 0xBDF8, 0xBDF8, 0xBDF7, 0xBDF7, 0xBDF8,   // 0x0410 (1040)
+0xC618, 0xBDD7, 0xBDF8, 0xC618, 0xBDF8, 0xB5B7, 0xAD96, 0x9D34, 0x9D14, 0xA535, 0x94F4, 0x8CD3, 0x8CB3, 0x8492, 0x8471, 0x7C31,   // 0x0420 (1056)
+0x7C30, 0x7C31, 0x7C11, 0x73F0, 0x6BF0, 0x6BCF, 0x638E, 0x5B0D, 0x5B2D, 0x530C, 0x52EC, 0x52EB, 0x52CB, 0x52CC, 0x52CC, 0x4AAB,   // 0x0430 (1072)
+0x52AB, 0x4AAB, 0x4AAB, 0x4AAB, 0x4AAB, 0x4A8B, 0x4AAA, 0x4A8A, 0x4A8A, 0x4AAB, 0x52CB, 0x52CB, 0x530C, 0x4AAB, 0x4AAB, 0x4AAB,   // 0x0440 (1088)
+0x4AAB, 0x4AAB, 0x4A6A, 0x424A, 0x4269, 0x4249, 0x4229, 0x4229, 0x4229, 0x4249, 0x4229, 0x39E8, 0x31A7, 0x31C7, 0x31C7, 0x3A08,   // 0x0450 (1104)
+0x3A08, 0x31C7, 0x31A7, 0x3186, 0x3186, 0x3186, 0x2965, 0x2965, 0x2965, 0x2145, 0x2945, 0x2965, 0x2986, 0x2985, 0x2965, 0x3186,   // 0x0460 (1120)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0470 (1136)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0480 (1152)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CD4, 0x4229, 0x4249, 0x4229, 0x3A29, 0x3A29, 0x4249, 0x3A29, 0x4269, 0x4249, 0x4249,   // 0x0490 (1168)
+0x424A, 0x3A49, 0x3A29, 0x4249, 0x4229, 0x4229, 0x4249, 0x4249, 0x428A, 0x4289, 0x428A, 0x4AAB, 0x4AAB, 0x4ACB, 0x4AAB, 0x4A8A,   // 0x04A0 (1184)
+0x4AAB, 0x4AAB, 0x52CB, 0x52EB, 0x4AEB, 0x530C, 0x5B2C, 0x5B4D, 0x5B4D, 0x636E, 0x638E, 0x638E, 0x6B8E, 0x6BAF, 0x638E, 0x638E,   // 0x04B0 (1200)
+0x6BAF, 0x6BAF, 0x638F, 0x638E, 0x636E, 0x5B2D, 0x52EC, 0x530C, 0x52CC, 0x4AAB, 0x4AAA, 0x4AAA, 0x4AAA, 0x4AAB, 0x4AAB, 0x4A8B,   // 0x04C0 (1216)
+0x4A8A, 0x4AAB, 0x52CB, 0x4AAA, 0x4AAA, 0x4269, 0x4249, 0x4229, 0x4229, 0x3A29, 0x3A49, 0x3A08, 0x4229, 0x4229, 0x4229, 0x4229,   // 0x04D0 (1232)
+0x4229, 0x4229, 0x4229, 0x3A08, 0x3A28, 0x4229, 0x4229, 0x424A, 0x4249, 0x4A6A, 0x4A8A, 0x4A8A, 0x4A8A, 0x4A6A, 0x4A6A, 0x4A6A,   // 0x04E0 (1248)
+0x4249, 0x3A08, 0x39E8, 0x3A08, 0x3208, 0x31E8, 0x39E8, 0x39E8, 0x31E8, 0x31E7, 0x31C7, 0x31C7, 0x31A7, 0x31A6, 0x31C7, 0x31C7,   // 0x04F0 (1264)
+0x31E7, 0x31C7, 0x3186, 0x3186, 0x3186, 0x3186, 0x2966, 0x2965, 0x2965, 0x2165, 0x2144, 0x2124, 0x2145, 0x2125, 0x2145, 0x2124,   // 0x0500 (1280)
+0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0510 (1296)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0520 (1312)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73D, 0x4A6A, 0x31E9, 0x3A08, 0x3A08, 0x31E7, 0x31E7, 0x31E7, 0x31E7, 0x39E8, 0x39E8,   // 0x0530 (1328)
+0x31E7, 0x31E7, 0x31E7, 0x39E7, 0x39E7, 0x39E8, 0x31E7, 0x31C7, 0x31E8, 0x3A09, 0x3A29, 0x3A29, 0x3A28, 0x3A48, 0x4228, 0x3A08,   // 0x0540 (1344)
+0x3A08, 0x3A08, 0x3A28, 0x4249, 0x4229, 0x3A29, 0x426A, 0x4AAA, 0x4A8A, 0x4A8A, 0x428A, 0x4ACB, 0x52CC, 0x4ACC, 0x4AAB, 0x4A8A,   // 0x0550 (1360)
+0x4AAB, 0x4A8B, 0x426A, 0x426A, 0x424A, 0x4249, 0x3A29, 0x3A49, 0x4228, 0x3A08, 0x3A08, 0x39E8, 0x3A08, 0x3A29, 0x3A09, 0x3A09,   // 0x0560 (1376)
+0x3A08, 0x3A29, 0x3A29, 0x3A08, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x3A08, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x31C7, 0x31C7, 0x31E8,   // 0x0570 (1392)
+0x31C8, 0x31C8, 0x31E8, 0x39E8, 0x39E8, 0x3A08, 0x3A08, 0x3A09, 0x3A09, 0x3A09, 0x4229, 0x4229, 0x3A08, 0x4229, 0x4229, 0x3A08,   // 0x0580 (1408)
+0x39E8, 0x39C8, 0x31C7, 0x31A7, 0x31C7, 0x31C7, 0x31A7, 0x31A7, 0x31A7, 0x31A7, 0x29A6, 0x29A6, 0x29A6, 0x29A6, 0x29A6, 0x31C7,   // 0x0590 (1424)
+0x2986, 0x2986, 0x2986, 0x31A7, 0x39A7, 0x2965, 0x2945, 0x2145, 0x2945, 0x2145, 0x2124, 0x1924, 0x2104, 0x2103, 0x2104, 0x2104,   // 0x05A0 (1440)
+0xEFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x05B0 (1456)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x05C0 (1472)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC639, 0x424A, 0x2967, 0x31A7, 0x29A7, 0x2987, 0x2986, 0x2986, 0x2986, 0x29A7,   // 0x05D0 (1488)
+0x2987, 0x2986, 0x31A7, 0x31A7, 0x3186, 0x3187, 0x31A7, 0x31A7, 0x31A7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C8, 0x31C8,   // 0x05E0 (1504)
+0x39C8, 0x39E8, 0x31C7, 0x31C6, 0x39E7, 0x39C7, 0x39E7, 0x3A08, 0x4229, 0x4269, 0x428A, 0x4AAB, 0x428A, 0x3A4A, 0x3A29, 0x3A08,   // 0x05F0 (1520)
+0x3A08, 0x3A28, 0x3A08, 0x3A08, 0x3A08, 0x3A08, 0x3A08, 0x39E7, 0x39E8, 0x39E8, 0x39E7, 0x31C7, 0x31E8, 0x39C8, 0x39E8, 0x39E8,   // 0x0600 (1536)
+0x39E8, 0x39E9, 0x39E9, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31A6, 0x31A6, 0x31A6,   // 0x0610 (1552)
+0x31C7, 0x31C7, 0x31C6, 0x31C6, 0x31E7, 0x3207, 0x39E7, 0x3A07, 0x3A08, 0x3A08, 0x3A08, 0x3A08, 0x3A07, 0x3A07, 0x3A07, 0x31E7,   // 0x0620 (1568)
+0x31C7, 0x31C7, 0x31A7, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x2986, 0x2965, 0x2986, 0x2986, 0x29A6,   // 0x0630 (1584)
+0x2986, 0x2965, 0x2945, 0x2965, 0x2965, 0x2965, 0x2945, 0x2945, 0x2945, 0x2145, 0x2124, 0x2124, 0x2124, 0x2103, 0x2103, 0x18E3,   // 0x0640 (1600)
+0xE7BF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0650 (1616)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0660 (1632)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x8C73, 0x5B0E, 0x52AD, 0x4A4C, 0x528D, 0x528D, 0x52CD, 0x52AC,   // 0x0670 (1648)
+0x52AD, 0x52AC, 0x52AC, 0x52AC, 0x52AC, 0x528C, 0x528C, 0x4A8C, 0x526C, 0x4A6C, 0x4A6C, 0x4A4C, 0x4A4B, 0x4A4B, 0x4A4B, 0x4A4B,   // 0x0680 (1664)
+0x4A6C, 0x4A6C, 0x4A4B, 0x4A4C, 0x526C, 0x526D, 0x5A8D, 0x5AAE, 0x5AEE, 0x52AD, 0x52CD, 0x5AEE, 0x630E, 0x5B0E, 0x5AED, 0x5ACD,   // 0x0690 (1680)
+0x52CD, 0x52CD, 0x52CD, 0x52AC, 0x4A8C, 0x4A6C, 0x4A6C, 0x4A6C, 0x4A6B, 0x4A4B, 0x422A, 0x424B, 0x4A4B, 0x422A, 0x4A2A, 0x4A2A,   // 0x06A0 (1696)
+0x424A, 0x424A, 0x424A, 0x422A, 0x422A, 0x422A, 0x422B, 0x4A4B, 0x4A6C, 0x4A8C, 0x4A6C, 0x4A6C, 0x4A4C, 0x4A4B, 0x4A4B, 0x4A4B,   // 0x06B0 (1712)
+0x422B, 0x422B, 0x420B, 0x420A, 0x420A, 0x420A, 0x420A, 0x422A, 0x422A, 0x3A0A, 0x3A0A, 0x39EA, 0x3A09, 0x39E9, 0x39E9, 0x39E9,   // 0x06C0 (1728)
+0x31C8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x3188, 0x3188, 0x3188, 0x3988, 0x3188, 0x3188, 0x3188, 0x3187, 0x2967, 0x2126, 0x2105,   // 0x06D0 (1744)
+0x2145, 0x2964, 0x2945, 0x2945, 0x2144, 0x2145, 0x2145, 0x2945, 0x2145, 0x2144, 0x2124, 0x2124, 0x2104, 0x2104, 0x18E3, 0x18E3,   // 0x06E0 (1760)
+0xE79F, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06F0 (1776)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0700 (1792)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79F, 0xEF7E, 0xF79F, 0xF7BF, 0xF7BF, 0xF7DF,   // 0x0710 (1808)
+0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7DF, 0xFFDF, 0xFFBF, 0xF7BF, 0xF79F, 0xF79E, 0xF79E, 0xEF7E, 0xEF7D,   // 0x0720 (1824)
+0xEF7D, 0xEF5D, 0xEF5E, 0xEF7E, 0xEF5F, 0xEF5E, 0xF77F, 0xF79F, 0xF79F, 0xE73E, 0xEF3E, 0xEF5E, 0xF77F, 0xF79F, 0xF79F, 0xF7BF,   // 0x0730 (1840)
+0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF79F, 0xF79F, 0xF79E, 0xF77E, 0xF79E, 0xEF7E, 0xEF5E, 0xEF5D, 0xEF5D, 0xE73D, 0xE73D, 0xE73C,   // 0x0740 (1856)
+0xE71C, 0xE71C, 0xE6FC, 0xDEFC, 0xE6FC, 0xDEFC, 0xE71C, 0xE73D, 0xEF5E, 0xEF7F, 0xEF7F, 0xEF7F, 0xEF7E, 0xEF5E, 0xEF7F, 0xEF7F,   // 0x0750 (1872)
+0xEF5E, 0xEF3E, 0xEF5E, 0xE73E, 0xE73E, 0xE73D, 0xE73D, 0xE73D, 0xE71D, 0xDF1D, 0xDEFC, 0xDEDC, 0xDEDC, 0xDEDC, 0xD6BB, 0xD6BB,   // 0x0760 (1888)
+0xD6BB, 0xD69B, 0xD69A, 0xD69B, 0xCE7A, 0xCE7A, 0xCE7A, 0xCE7B, 0xCE7A, 0xCE7B, 0xCE7A, 0xD6BC, 0xD69B, 0xC65A, 0xB5B8, 0x9CD4,   // 0x0770 (1904)
+0x5AEE, 0x2968, 0x2105, 0x2945, 0x2946, 0x2944, 0x2144, 0x2145, 0x2144, 0x2145, 0x2145, 0x2124, 0x2124, 0x2124, 0x18E3, 0x18E3,   // 0x0780 (1920)
+0xE77E, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0790 (1936)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07A0 (1952)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07B0 (1968)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07C0 (1984)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07D0 (2000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07E0 (2016)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07F0 (2032)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0800 (2048)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0810 (2064)
+0xFFFF, 0xD69B, 0x73B1, 0x2947, 0x2125, 0x2145, 0x2144, 0x2144, 0x2145, 0x2145, 0x2125, 0x2124, 0x2124, 0x2104, 0x1903, 0x18E3,   // 0x0820 (2080)
+0xE79F, 0xEFDF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0830 (2096)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0840 (2112)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0850 (2128)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0860 (2144)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0870 (2160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0880 (2176)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0890 (2192)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08A0 (2208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08B0 (2224)
+0xFFFF, 0xFFFF, 0xFFFF, 0xC619, 0x39EA, 0x1905, 0x2165, 0x2145, 0x2145, 0x2145, 0x2945, 0x2925, 0x2124, 0x2104, 0x2103, 0x18E3,   // 0x08C0 (2240)
+0xDF7F, 0xE7DF, 0xEFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08D0 (2256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08E0 (2272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08F0 (2288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0900 (2304)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0910 (2320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0920 (2336)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0930 (2352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0940 (2368)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0950 (2384)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFD, 0x4A4B, 0x2126, 0x2946, 0x2145, 0x2945, 0x2945, 0x2945, 0x2124, 0x2104, 0x2103, 0x2103,   // 0x0960 (2400)
+0xDF7E, 0xEFDF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0970 (2416)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0980 (2432)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0990 (2448)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09A0 (2464)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09B0 (2480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09C0 (2496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09D0 (2512)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09E0 (2528)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09F0 (2544)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFD, 0x39EA, 0x2125, 0x2144, 0x2945, 0x2945, 0x2125, 0x2124, 0x2124, 0x2103, 0x1903,   // 0x0A00 (2560)
+0xDF5E, 0xEFBF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A10 (2576)
+0xFFFF, 0xF7BE, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7E, 0xEF9E, 0xEF9E, 0xEF9E, 0xEF9E, 0xF79E, 0xEF9E, 0xEF7D,   // 0x0A20 (2592)
+0xEF7D, 0xEF7D, 0xEF7E, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0A30 (2608)
+0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E,   // 0x0A40 (2624)
+0xF79E, 0xEF7E, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xFFDE, 0xFFDF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E,   // 0x0A50 (2640)
+0xF79E, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xF79E, 0xF7BE, 0xF79E, 0xEF9E, 0xEF9E, 0xF79E, 0xEF9E, 0xEF9D, 0xEF7D,   // 0x0A60 (2656)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0A70 (2672)
+0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0A80 (2688)
+0xEF9E, 0xEF9D, 0xEF9D, 0xEF9E, 0xEF9E, 0xEF9D, 0xEF9D, 0xEF9E, 0xEF9E, 0xF79E, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A90 (2704)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5F8, 0x2126, 0x2965, 0x2965, 0x2945, 0x2945, 0x2145, 0x2124, 0x2104, 0x2104,   // 0x0AA0 (2720)
+0xDF5E, 0xE7BF, 0xF7DF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0AB0 (2736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AC0 (2752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AD0 (2768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AE0 (2784)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AF0 (2800)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B00 (2816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B10 (2832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B20 (2848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B30 (2864)
+0x012B, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x634E, 0x2105, 0x2945, 0x2965, 0x2946, 0x2945, 0x2124, 0x2103, 0x2104,   // 0x0B40 (2880)
+0xDF5D, 0xE79F, 0xEFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0B50 (2896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B60 (2912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B70 (2928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B80 (2944)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B90 (2960)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BA0 (2976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BB0 (2992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BC0 (3008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BD0 (3024)
+0x012B, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xBDD8, 0x2126, 0x2945, 0x2946, 0x2966, 0x2965, 0x2145, 0x2104, 0x2104,   // 0x0BE0 (3040)
+0xE75E, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x012B,   // 0x0BF0 (3056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C00 (3072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C10 (3088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C20 (3104)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C30 (3120)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C40 (3136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C50 (3152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C60 (3168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C70 (3184)
+0x012B, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7E, 0x39EA, 0x2925, 0x2966, 0x2966, 0x2966, 0x2966, 0x2125, 0x2104,   // 0x0C80 (3200)
+0xDF5D, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0C90 (3216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CA0 (3232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CB0 (3248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CC0 (3264)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CD0 (3280)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CE0 (3296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CF0 (3312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D00 (3328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D10 (3344)
+0x012B, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x630E, 0x2105, 0x2966, 0x2945, 0x2966, 0x2965, 0x2125, 0x2104,   // 0x0D20 (3360)
+0xDF3D, 0xE7BF, 0xEFFF, 0xEFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0D30 (3376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D40 (3392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D50 (3408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D60 (3424)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D70 (3440)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D80 (3456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D90 (3472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DA0 (3488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DB0 (3504)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0x8432, 0x2105, 0x2966, 0x2945, 0x2145, 0x2125, 0x2124, 0x2104,   // 0x0DC0 (3520)
+0xDF5E, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0DD0 (3536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DE0 (3552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DF0 (3568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E00 (3584)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E10 (3600)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E20 (3616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E30 (3632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E40 (3648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E50 (3664)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0x8C53, 0x2105, 0x2145, 0x2145, 0x2124, 0x2125, 0x2104, 0x2104,   // 0x0E60 (3680)
+0xDF3D, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0E70 (3696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E80 (3712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E90 (3728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EA0 (3744)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EB0 (3760)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EC0 (3776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0ED0 (3792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EE0 (3808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EF0 (3824)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x8412, 0x1904, 0x2145, 0x2145, 0x2125, 0x2124, 0x2104, 0x1904,   // 0x0F00 (3840)
+0xDF3D, 0xE79F, 0xEFDF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0F10 (3856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F20 (3872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F30 (3888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F40 (3904)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F50 (3920)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F60 (3936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F70 (3952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F80 (3968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F90 (3984)
+0x012B, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x7BF1, 0x2105, 0x2166, 0x2165, 0x2144, 0x2125, 0x2104, 0x2104,   // 0x0FA0 (4000)
+0xD73D, 0xE77E, 0xEFBF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0FB0 (4016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FC0 (4032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FD0 (4048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FE0 (4064)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FF0 (4080)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1000 (4096)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1010 (4112)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1020 (4128)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1030 (4144)
+0x012B, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x73B0, 0x2105, 0x2145, 0x2145, 0x2124, 0x2125, 0x2104, 0x1904,   // 0x1040 (4160)
+0xD73D, 0xE77E, 0xEFBF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1050 (4176)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1060 (4192)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1070 (4208)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1080 (4224)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1090 (4240)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10A0 (4256)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10B0 (4272)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10C0 (4288)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10D0 (4304)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x6B6F, 0x2105, 0x2946, 0x2945, 0x2145, 0x2124, 0x2104, 0x1903,   // 0x10E0 (4320)
+0xD71D, 0xE79F, 0xE7BF, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x10F0 (4336)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1100 (4352)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1110 (4368)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1120 (4384)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1130 (4400)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1140 (4416)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1150 (4432)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1160 (4448)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1170 (4464)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x6B4F, 0x2105, 0x2945, 0x2145, 0x2144, 0x2145, 0x2124, 0x1903,   // 0x1180 (4480)
+0xDF1D, 0xE77E, 0xE7BF, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1190 (4496)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11A0 (4512)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11B0 (4528)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11C0 (4544)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11D0 (4560)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11E0 (4576)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11F0 (4592)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1200 (4608)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1210 (4624)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0x6B2E, 0x2104, 0x2945, 0x2945, 0x2125, 0x2124, 0x1903, 0x1903,   // 0x1220 (4640)
+0xDF1D, 0xE77E, 0xE7BF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1230 (4656)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1240 (4672)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1250 (4688)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1260 (4704)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1270 (4720)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1280 (4736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1290 (4752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12A0 (4768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12B0 (4784)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0x5ACD, 0x2125, 0x2945, 0x2945, 0x2125, 0x2124, 0x2124, 0x1903,   // 0x12C0 (4800)
+0xDF3D, 0xE77E, 0xEFBF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x12D0 (4816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12E0 (4832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12F0 (4848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1300 (4864)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1310 (4880)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1320 (4896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1330 (4912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1340 (4928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1350 (4944)
+0x012B, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xEFBF, 0x52AC, 0x2125, 0x2125, 0x2125, 0x2145, 0x2124, 0x2103, 0x1903,   // 0x1360 (4960)
+0xDF3D, 0xE79E, 0xEFBF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1370 (4976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1380 (4992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1390 (5008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13A0 (5024)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13B0 (5040)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13C0 (5056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13D0 (5072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13E0 (5088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13F0 (5104)
+0x012B, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xEF9E, 0x4A6B, 0x2125, 0x2145, 0x2125, 0x2144, 0x2124, 0x2104, 0x18E3,   // 0x1400 (5120)
+0xE77E, 0xEFDF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1410 (5136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1420 (5152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1430 (5168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1440 (5184)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1450 (5200)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1460 (5216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1470 (5232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1480 (5248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1490 (5264)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xEF7E, 0x422A, 0x2125, 0x2125, 0x2145, 0x2124, 0x2124, 0x2103, 0x18E3,   // 0x14A0 (5280)
+0x738E, 0x7BD0, 0x8431, 0xA556, 0xE73D, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x14B0 (5296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14C0 (5312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14D0 (5328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14E0 (5344)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14F0 (5360)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1500 (5376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1510 (5392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1520 (5408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1530 (5424)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xE75D, 0x420A, 0x2125, 0x2145, 0x2925, 0x2124, 0x2104, 0x2104, 0x18E3,   // 0x1540 (5440)
+0x10A2, 0x18C3, 0x18C3, 0x1904, 0x424A, 0x9D14, 0xFFDF, 0xFFFF, 0xF7FF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1550 (5456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1560 (5472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1570 (5488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1580 (5504)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1590 (5520)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15A0 (5536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15B0 (5552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15C0 (5568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15D0 (5584)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xE75D, 0x41E9, 0x2125, 0x2125, 0x2925, 0x2124, 0x2104, 0x2104, 0x2104,   // 0x15E0 (5600)
+0x18E3, 0x1904, 0x1924, 0x2124, 0x18E4, 0x2946, 0x8C52, 0xFFFF, 0xF7FF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0x012B,   // 0x15F0 (5616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1600 (5632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1610 (5648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1620 (5664)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1630 (5680)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1640 (5696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1650 (5712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1660 (5728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1670 (5744)
+0x012B, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xDF3D, 0x39C8, 0x2125, 0x2945, 0x2145, 0x2124, 0x2104, 0x2104, 0x2103,   // 0x1680 (5760)
+0x18C3, 0x18E4, 0x1904, 0x2103, 0x2124, 0x1904, 0x2146, 0xBE19, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1690 (5776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16A0 (5792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16B0 (5808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16C0 (5824)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16D0 (5840)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16E0 (5856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16F0 (5872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1700 (5888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1710 (5904)
+0x012B, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xD71C, 0x31A8, 0x2945, 0x2966, 0x2946, 0x2125, 0x2124, 0x2104, 0x18E3,   // 0x1720 (5920)
+0x10E3, 0x18E3, 0x1904, 0x2104, 0x2104, 0x2124, 0x18E4, 0x73F2, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1730 (5936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1740 (5952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1750 (5968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1760 (5984)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1770 (6000)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1780 (6016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1790 (6032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17A0 (6048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17B0 (6064)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7DF, 0xF7FF, 0xD6DC, 0x3187, 0x2945, 0x2966, 0x2946, 0x2124, 0x2104, 0x2125, 0x18E4,   // 0x17C0 (6080)
+0x18C3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x2104, 0x18E3, 0x5AEE, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x17D0 (6096)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17E0 (6112)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17F0 (6128)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1800 (6144)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1810 (6160)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1820 (6176)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1830 (6192)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1840 (6208)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1850 (6224)
+0x012B, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xCEBB, 0x2967, 0x2125, 0x2945, 0x2945, 0x2125, 0x2104, 0x2104, 0x2104,   // 0x1860 (6240)
+0x18C3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x2104, 0x1903, 0x52AD, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1870 (6256)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1880 (6272)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1890 (6288)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18A0 (6304)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18B0 (6320)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18C0 (6336)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18D0 (6352)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18E0 (6368)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18F0 (6384)
+0x012B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7FF, 0xCE9B, 0x2946, 0x2145, 0x2945, 0x2945, 0x2145, 0x2125, 0x2104, 0x2104,   // 0x1900 (6400)
+0x18C3, 0x18E3, 0x1903, 0x1904, 0x1904, 0x1904, 0x1903, 0x4A6B, 0xF79F, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1910 (6416)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1920 (6432)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1930 (6448)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1940 (6464)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1950 (6480)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1960 (6496)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1970 (6512)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1980 (6528)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1990 (6544)
+0x012B, 0xFFFF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7BF, 0xF7FF, 0xC67B, 0x2926, 0x2945, 0x2945, 0x2945, 0x2945, 0x2124, 0x2104, 0x1904,   // 0x19A0 (6560)
+0x18C3, 0x18E3, 0x1904, 0x1904, 0x2104, 0x2124, 0x1903, 0x4A2B, 0xEF7E, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x19B0 (6576)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19C0 (6592)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19D0 (6608)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19E0 (6624)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19F0 (6640)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A00 (6656)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A10 (6672)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A20 (6688)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A30 (6704)
+0x012B, 0xFFFF, 0xF7FF, 0xF7DF, 0xEFBF, 0xEFDF, 0xF7FF, 0xBE3A, 0x2126, 0x2945, 0x2945, 0x2145, 0x2144, 0x2124, 0x2104, 0x18E4,   // 0x1A40 (6720)
+0x18C3, 0x18E3, 0x18E4, 0x1904, 0x1904, 0x2124, 0x1903, 0x420A, 0xEF5E, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1A50 (6736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A60 (6752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A70 (6768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A80 (6784)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A90 (6800)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AA0 (6816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AB0 (6832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AC0 (6848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AD0 (6864)
+0x012B, 0xFFFF, 0xF7FF, 0xEFDF, 0xEFDF, 0xF7DF, 0xF7FF, 0xBE19, 0x2125, 0x2945, 0x2125, 0x2125, 0x2124, 0x2124, 0x18E3, 0x18E3,   // 0x1AE0 (6880)
+0x18C3, 0x18C3, 0x18E3, 0x18E3, 0x1904, 0x2124, 0x18E3, 0x39C9, 0xE73E, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1AF0 (6896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B00 (6912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B10 (6928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B20 (6944)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B30 (6960)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B40 (6976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B50 (6992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B60 (7008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B70 (7024)
+0x012B, 0xFFFF, 0xEFDF, 0xEFDF, 0xF7DF, 0xEFBF, 0xF7FF, 0xBE19, 0x2125, 0x2945, 0x2124, 0x2125, 0x2124, 0x2104, 0x2104, 0x18C3,   // 0x1B80 (7040)
+0x18C2, 0x18C3, 0x18E3, 0x1903, 0x1904, 0x1904, 0x18E3, 0x39A9, 0xE71D, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1B90 (7056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BA0 (7072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BB0 (7088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BC0 (7104)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BD0 (7120)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BE0 (7136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BF0 (7152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C00 (7168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C10 (7184)
+0x012B, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xEFBF, 0xF7FF, 0xB5F9, 0x2105, 0x2945, 0x2945, 0x2125, 0x2124, 0x2104, 0x2104, 0x18E3,   // 0x1C20 (7200)
+0x10C2, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1904, 0x3188, 0xDEFD, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1C30 (7216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C40 (7232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C50 (7248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C60 (7264)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C70 (7280)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C80 (7296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C90 (7312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CA0 (7328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CB0 (7344)
+0x012B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xD6DC, 0x3187, 0x2125, 0x2945, 0x2945, 0x2124, 0x2104, 0x2104, 0x18E3,   // 0x1CC0 (7360)
+0x18C2, 0x18E3, 0x18E4, 0x18E4, 0x18E4, 0x1904, 0x1903, 0x2968, 0xD6DC, 0xF7FF, 0xEFDF, 0xF7DF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1CD0 (7376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CE0 (7392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CF0 (7408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D00 (7424)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D10 (7440)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D20 (7456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D30 (7472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D40 (7488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D50 (7504)
+0x012B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF, 0xEFDF, 0xF7FF, 0x6B6F, 0x18E5, 0x2945, 0x2125, 0x2124, 0x2104, 0x2103, 0x18E3,   // 0x1D60 (7520)
+0x18E3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1903, 0x2967, 0xD6BC, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1D70 (7536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D80 (7552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D90 (7568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DA0 (7584)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DB0 (7600)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DC0 (7616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DD0 (7632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DE0 (7648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DF0 (7664)
+0x012B, 0xFFFF, 0xF7DF, 0xF7DF, 0xEFBF, 0xF7BF, 0xEF9F, 0xEFDF, 0xD6DC, 0x39C8, 0x18E4, 0x2945, 0x2924, 0x2124, 0x2124, 0x18E3,   // 0x1E00 (7680)
+0x18E3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1904, 0x2967, 0xD67B, 0xF7FF, 0xF7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1E10 (7696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E20 (7712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E30 (7728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E40 (7744)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E50 (7760)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E60 (7776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E70 (7792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E80 (7808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E90 (7824)
+0x012B, 0xF7FF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEFBF, 0xF7FF, 0xCE9A, 0x52CC, 0x2946, 0x2105, 0x18E4, 0x18E3, 0x10C3,   // 0x1EA0 (7840)
+0x18C3, 0x18E3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1924, 0x2946, 0xC63A, 0xF7FF, 0xEFDF, 0xEFFF, 0xF7FF, 0xEFFF, 0xFFFF, 0x012B,   // 0x1EB0 (7856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1EC0 (7872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1ED0 (7888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1EE0 (7904)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1EF0 (7920)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F00 (7936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F10 (7952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F20 (7968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F30 (7984)
+0x012B, 0xF7FF, 0xF7BF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xF7FF, 0xF7BF, 0xC65A, 0xA576, 0x9D35, 0x94B3, 0x8451,   // 0x1F40 (8000)
+0x10C3, 0x18E3, 0x18E3, 0x18E4, 0x1904, 0x1904, 0x1924, 0x18E5, 0xBDD9, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1F50 (8016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F60 (8032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F70 (8048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F80 (8064)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F90 (8080)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FA0 (8096)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FB0 (8112)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FC0 (8128)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FD0 (8144)
+0x012B, 0xF7FF, 0xF7BF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xEF9F, 0xEFBF, 0xEFBF, 0xEFBF, 0xE79F, 0xE75E, 0xD6FC, 0xCE9B,   // 0x1FE0 (8160)
+0x10C3, 0x10C3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1924, 0x18E4, 0xB5B8, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xEFFF, 0xFFFF, 0x012B,   // 0x1FF0 (8176)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2000 (8192)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2010 (8208)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2020 (8224)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2030 (8240)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2040 (8256)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2050 (8272)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2060 (8288)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2070 (8304)
+0x012B, 0xF7FF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xE79F, 0xEFBF, 0xEFBF, 0xE79F, 0xE77E, 0xDF3D, 0xD6FC, 0xCE9B, 0xC63A,   // 0x2080 (8320)
+0x18C3, 0x18E3, 0x1903, 0x1904, 0x1904, 0x2124, 0x1924, 0x18C4, 0xAD98, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xEFFF, 0xF7FF, 0x012B,   // 0x2090 (8336)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20A0 (8352)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20B0 (8368)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20C0 (8384)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20D0 (8400)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20E0 (8416)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20F0 (8432)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2100 (8448)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2110 (8464)
+0x012B, 0xF7DF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE7BF, 0xEFBF, 0xE79E, 0xE77E, 0xDF5E, 0xD6FD, 0xCE9B, 0xC639,   // 0x2120 (8480)
+0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x2125, 0x1924, 0x18C4, 0xAD77, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xEFFF, 0xF7FF, 0x012B,   // 0x2130 (8496)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2140 (8512)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2150 (8528)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2160 (8544)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2170 (8560)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2180 (8576)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2190 (8592)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21A0 (8608)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21B0 (8624)
+0x012B, 0xEFFF, 0xEFBF, 0xEFBF, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xEFBF, 0xE79F, 0xE77E, 0xDF3E, 0xD6FC, 0xCE9B, 0xBE19,   // 0x21C0 (8640)
+0x18E3, 0x18E3, 0x2104, 0x1904, 0x1904, 0x1924, 0x1924, 0x18E4, 0xA537, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xF7DF, 0xF7FF, 0x012B,   // 0x21D0 (8656)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21E0 (8672)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21F0 (8688)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2200 (8704)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2210 (8720)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2220 (8736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2230 (8752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2240 (8768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2250 (8784)
+0x012B, 0xEFDF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xEF9F, 0xEF9F, 0xE79F, 0xE77E, 0xDF3E, 0xD6FC, 0xCE9B, 0xBE19,   // 0x2260 (8800)
+0x18C3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x2124, 0x18C4, 0x9CF5, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0x012B,   // 0x2270 (8816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2280 (8832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2290 (8848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22A0 (8864)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22B0 (8880)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22C0 (8896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22D0 (8912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22E0 (8928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22F0 (8944)
+0x012B, 0xEFDF, 0xEF9F, 0xEFBF, 0xEF9F, 0xE79F, 0xEF9F, 0xEF9F, 0xE79F, 0xEF9F, 0xE79F, 0xE77E, 0xDF3D, 0xD6FC, 0xCE9B, 0xBE19,   // 0x2300 (8960)
+0x18E3, 0x18E3, 0x18E3, 0x18E4, 0x1904, 0x1924, 0x1924, 0x18C4, 0x94D5, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2310 (8976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2320 (8992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2330 (9008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2340 (9024)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2350 (9040)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2360 (9056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2370 (9072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2380 (9088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2390 (9104)
+0x012B, 0xE7DF, 0xEF9F, 0xEFBF, 0xE79F, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xE75E, 0xDF3D, 0xD6DC, 0xC67A, 0xBE18,   // 0x23A0 (9120)
+0x18E3, 0x18E4, 0x18E4, 0x1904, 0x1904, 0x1904, 0x1924, 0x18E4, 0x8C93, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xEFFF, 0x012B,   // 0x23B0 (9136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23C0 (9152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23D0 (9168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23E0 (9184)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23F0 (9200)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2400 (9216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2410 (9232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2420 (9248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2430 (9264)
+0x012B, 0xEFBF, 0xEFBF, 0xE7BF, 0xE79F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xDF7E, 0xDF3D, 0xD6DC, 0xC69A, 0xBE18,   // 0x2440 (9280)
+0x18E3, 0x1904, 0x18E4, 0x1904, 0x1904, 0x1904, 0x2125, 0x10C3, 0x8C53, 0xFFFF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2450 (9296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2460 (9312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2470 (9328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2480 (9344)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2490 (9360)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24A0 (9376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24B0 (9392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24C0 (9408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24D0 (9424)
+0x014B, 0xEFBF, 0xEF9F, 0xE7BF, 0xE79F, 0xE79E, 0xE79E, 0xE79E, 0xE79F, 0xE79F, 0xE77F, 0xE75E, 0xDF3D, 0xD6DC, 0xC69A, 0xBE18,   // 0x24E0 (9440)
+0x18E3, 0x18E4, 0x1904, 0x1904, 0x1904, 0x1904, 0x2125, 0x10C3, 0x8413, 0xFFFF, 0xF7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xEFFF, 0x012C,   // 0x24F0 (9456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2500 (9472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2510 (9488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2520 (9504)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2530 (9520)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2540 (9536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2550 (9552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2560 (9568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x014B, 0x012B,   // 0x2570 (9584)
+0x012B, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xE75E, 0xDF3D, 0xD6DC, 0xC69A, 0xBDF8,   // 0x2580 (9600)
+0x18E3, 0x1904, 0x1904, 0x1924, 0x2124, 0x2124, 0x2105, 0x18E3, 0x7BF3, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2590 (9616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25A0 (9632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25B0 (9648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25C0 (9664)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25D0 (9680)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25E0 (9696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25F0 (9712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2600 (9728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2610 (9744)
+0x012B, 0xEFBF, 0xEFBF, 0xE79F, 0xE79F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE79F, 0xE77E, 0xDF5E, 0xD73D, 0xD6DC, 0xC69A, 0xB618,   // 0x2620 (9760)
+0x18E3, 0x1904, 0x1904, 0x1924, 0x2124, 0x2124, 0x2125, 0x18E3, 0x7390, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2630 (9776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2640 (9792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2650 (9808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2660 (9824)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2670 (9840)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2680 (9856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2690 (9872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26A0 (9888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26B0 (9904)
+0x014B, 0xEFBF, 0xEF9F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE79F, 0xDF9E, 0xE79E, 0xE77E, 0xDF5E, 0xD73D, 0xD6FC, 0xC67A, 0xB618,   // 0x26C0 (9920)
+0x18E3, 0x1903, 0x1904, 0x1904, 0x1904, 0x1924, 0x1944, 0x1904, 0x4A4B, 0xEFBF, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x26D0 (9936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26E0 (9952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26F0 (9968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2700 (9984)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2710 (10000)
+0x012B, 0x014B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2720 (10016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2730 (10032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2740 (10048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2750 (10064)
+0x012B, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xE79F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE77E, 0xDF5E, 0xDF1D, 0xCEDB, 0xC67A, 0xBDF8,   // 0x2760 (10080)
+0x18E3, 0x18E3, 0x1904, 0x2104, 0x2104, 0x1924, 0x2124, 0x2125, 0x2147, 0xC67B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF,   // 0x2770 (10096)
+0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7DF, 0xDEFC, 0xC659, 0xC619, 0xC639, 0xC639, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x2780 (10112)
+0xC619, 0xC619, 0xBE18, 0xBE18, 0xBE18, 0xC619, 0xC619, 0xC619, 0xC639, 0xC639, 0xC639, 0xC639, 0xCE5A, 0xCE5A, 0xCE5A, 0xCE5A,   // 0x2790 (10128)
+0xCE59, 0xCE59, 0xC659, 0xC659, 0xCE59, 0xCE59, 0xCE59, 0xC659, 0xC659, 0xC659, 0xC659, 0xC659, 0xC659, 0xC639, 0xC639, 0xC639,   // 0x27A0 (10144)
+0xC639, 0xCE5A, 0xCE7A, 0xCE7A, 0xCE7A, 0xD67A, 0xD69A, 0xD69A, 0xD67A, 0xD69A, 0xD69A, 0xD67A, 0xCE7A, 0xCE7A, 0xCE7A, 0xCE7A,   // 0x27B0 (10160)
+0xD67A, 0xD69B, 0xD69B, 0xD69B, 0xD6BB, 0xD6BB, 0xDEBB, 0xDEBC, 0xDEDC, 0xDEDC, 0xDEDC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEDB, 0xDEDB,   // 0x27C0 (10176)
+0xDEDC, 0xDEDC, 0xDEBB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6DB, 0xDEDB, 0xDEDB, 0xDEDB,   // 0x27D0 (10192)
+0xDEDC, 0xD6BB, 0xD6BC, 0xDEDC, 0xDEDC, 0xDEDC, 0xDEFC, 0xDEFC, 0xDEDC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEDC, 0xDEDC,   // 0x27E0 (10208)
+0xDEFC, 0xDEDC, 0xDEDC, 0xDEDC, 0xDEFC, 0xE6FC, 0xE71D, 0xE71C, 0xE71C, 0xE71D, 0xE71D, 0xE73D, 0xE73E, 0xEF5E, 0xF7BF, 0xEFBF,   // 0x27F0 (10224)
+0xE7BF, 0xEFBF, 0xEFBF, 0xEFBF, 0xE79F, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE75E, 0xDF3E, 0xD71D, 0xCEBB, 0xC65A, 0xB5F8,   // 0x2800 (10240)
+0x18E3, 0x18E3, 0x1904, 0x2104, 0x2104, 0x2124, 0x2125, 0x2124, 0x18E5, 0x7BD1, 0xFFFF, 0xF7FF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF,   // 0x2810 (10256)
+0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2820 (10272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2830 (10288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2840 (10304)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2850 (10320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2860 (10336)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2870 (10352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2880 (10368)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7DF, 0xEFDF, 0xEFBF, 0xEF9F, 0xEFBF,   // 0x2890 (10384)
+0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xE77F, 0xE77E, 0xE75E, 0xDF3D, 0xD71D, 0xCEBC, 0xC65A, 0xB5F8,   // 0x28A0 (10400)
+0x2103, 0x1903, 0x1903, 0x1903, 0x2104, 0x2124, 0x2124, 0x2125, 0x2124, 0x2967, 0xD67B, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF,   // 0x28B0 (10416)
+0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28C0 (10432)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28D0 (10448)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28E0 (10464)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28F0 (10480)
+0xFFDF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2900 (10496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF,   // 0x2910 (10512)
+0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7DF,   // 0x2920 (10528)
+0xEFBF, 0xEFBF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0xEFDF, 0xEFDF, 0xF7DF, 0xF7DF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF,   // 0x2930 (10544)
+0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xE75E, 0xDF3E, 0xD6FD, 0xCEBC, 0xC65A, 0xB5F8,   // 0x2940 (10560)
+0x2104, 0x1903, 0x1903, 0x1903, 0x1903, 0x2124, 0x1904, 0x2125, 0x2125, 0x1904, 0x528C, 0xF79E, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF,   // 0x2950 (10576)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0xB5B7, 0x6B4D, 0x2965, 0x0020, 0x2945,   // 0x2960 (10592)
+0x6B6D, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x6B4D, 0x2965, 0x0020, 0x2965, 0x6B4D,   // 0x2970 (10608)
+0xBDD7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x6B4D, 0x2965, 0x0020, 0x2965, 0x6B4D, 0xBDD7, 0xFFFF,   // 0x2980 (10624)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x6B4D, 0x2965, 0x0020, 0x2965, 0x6B4D, 0xB5B6, 0xFFFF, 0xFFFF,   // 0x2990 (10640)
+0xFFDF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x29A0 (10656)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF,   // 0x29B0 (10672)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xEFBF,   // 0x29C0 (10688)
+0xF7DF, 0xF7DF, 0xF7BF, 0xF7DF, 0xEFDF, 0xF7DF, 0xEFDF, 0xEFBF, 0xEFDF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F,   // 0x29D0 (10704)
+0xEF9F, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xEF9F, 0xE79F, 0xE79F, 0xE77F, 0xE77E, 0xE75E, 0xDF3E, 0xD6FD, 0xCEBC, 0xC65A, 0xB5F8,   // 0x29E0 (10720)
+0x2123, 0x2103, 0x2103, 0x1903, 0x18E3, 0x1904, 0x1904, 0x2124, 0x2105, 0x2124, 0x1904, 0x634E, 0xF7BF, 0xFFFF, 0xF7FF, 0xF7FF,   // 0x29F0 (10736)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0x8C92, 0x10C2, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2A00 (10752)
+0x0000, 0x18C3, 0x8C92, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C92, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2A10 (10768)
+0x10A2, 0x9492, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x9492,   // 0x2A20 (10784)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x9492, 0xFFFF,   // 0x2A30 (10800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2A40 (10816)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2A50 (10832)
+0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF,   // 0x2A60 (10848)
+0xF7DF, 0xF7BF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F,   // 0x2A70 (10864)
+0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xDF5E, 0xDF3D, 0xD6FD, 0xCEBB, 0xC65A, 0xB5F8,   // 0x2A80 (10880)
+0x2944, 0x2965, 0x2144, 0x2124, 0x2103, 0x1904, 0x1904, 0x1904, 0x1924, 0x2125, 0x2125, 0x20E4, 0x632D, 0xEF3D, 0xFFFF, 0xFFFF,   // 0x2A90 (10896)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xAD75, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2AA0 (10912)
+0x0000, 0x0000, 0x0882, 0xAD75, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2AB0 (10928)
+0x0000, 0x1082, 0xAD75, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082,   // 0x2AC0 (10944)
+0xAD75, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0xAD55,   // 0x2AD0 (10960)
+0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DF, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2AE0 (10976)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xFFDF, 0xF7DF,   // 0x2AF0 (10992)
+0xF7DF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF,   // 0x2B00 (11008)
+0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F,   // 0x2B10 (11024)
+0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xDF5E, 0xDF3D, 0xD71D, 0xCEBB, 0xC65A, 0xB5F8,   // 0x2B20 (11040)
+0x3186, 0x39E7, 0x31C6, 0x3185, 0x2144, 0x2124, 0x1904, 0x1924, 0x1924, 0x2124, 0x2125, 0x2125, 0x1904, 0x422A, 0xB5D7, 0xFFDF,   // 0x2B30 (11056)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x52CB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2B40 (11072)
+0x0000, 0x0000, 0x0000, 0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2B50 (11088)
+0x0000, 0x0000, 0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2B60 (11104)
+0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB,   // 0x2B70 (11120)
+0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2B80 (11136)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF,   // 0x2B90 (11152)
+0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xEFBF, 0xEFBF, 0xEFBF, 0xF7DF, 0xF7DF, 0xEFDF, 0xEFBF, 0xEFBF, 0xEFBF,   // 0x2BA0 (11168)
+0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEFBF, 0xE7BF, 0xE7BF, 0xEF9F, 0xEF9F,   // 0x2BB0 (11184)
+0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xEF9F, 0xE79E, 0xE77E, 0xDF7E, 0xE75E, 0xDF3E, 0xDF1D, 0xD6FD, 0xCEBB, 0xC65A, 0xB5D8,   // 0x2BC0 (11200)
+0x2104, 0x31A6, 0x4207, 0x4207, 0x31A6, 0x2965, 0x2125, 0x2124, 0x1904, 0x2104, 0x2123, 0x2125, 0x2145, 0x18E5, 0x2146, 0x5B0D,   // 0x2BD0 (11216)
+0xA515, 0xD6BB, 0xEF7E, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7FF, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2BE0 (11232)
+0x0000, 0x0000, 0x0000, 0x18C3, 0xFFDF, 0xF7DF, 0xF7DF, 0xF7BF, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2BF0 (11248)
+0x0000, 0x0000, 0x18C3, 0xFFDF, 0xF7DF, 0xFFDF, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2C00 (11264)
+0x18E3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3,   // 0x2C10 (11280)
+0xFFFF, 0xFFDF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7DF, 0xF7BF, 0xF79E, 0xEF7E, 0xEF7D, 0xEF5D, 0xE75D, 0xE73C, 0xE73D,   // 0x2C20 (11296)
+0xE73C, 0xE73D, 0xE73C, 0xE73D, 0xE73C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDEFC, 0xDEFC, 0xD6DB, 0xDEFB, 0xDF1C,   // 0x2C30 (11312)
+0xD6FB, 0xD6FB, 0xDEFC, 0xDEFB, 0xD6DB, 0xDF1C, 0xEFBE, 0xF7FF, 0xEFDF, 0xEFDF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xE7BF, 0xE79F,   // 0x2C40 (11328)
+0xE79E, 0xE79E, 0xE79E, 0xE79E, 0xE79E, 0xE79E, 0xE77F, 0xE79F, 0xEF9F, 0xE77F, 0xE77F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xE77F,   // 0x2C50 (11344)
+0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE75E, 0xE75E, 0xDF5E, 0xDF5D, 0xDF3D, 0xDF1D, 0xD6FC, 0xCE9B, 0xC639, 0xB5F8,   // 0x2C60 (11360)
+0x18E3, 0x2103, 0x2124, 0x2145, 0x2145, 0x2945, 0x2125, 0x2104, 0x2124, 0x2123, 0x2104, 0x2124, 0x2125, 0x2124, 0x2124, 0x1904,   // 0x2C70 (11376)
+0x1904, 0x2986, 0x39E8, 0x4A6A, 0x528B, 0x4A8A, 0x4A6A, 0x4A8B, 0x528B, 0xEF7E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2C80 (11392)
+0xFFFF, 0xFFFF, 0xFFFF, 0xEF7E, 0x52CB, 0x52AB, 0x52CB, 0x52CB, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2C90 (11408)
+0xFFFF, 0xFFFF, 0xEF7D, 0x528A, 0x4A6A, 0x528A, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2CA0 (11424)
+0xF79E, 0x73CF, 0x73AF, 0x73CF, 0x6B8E, 0xEF9E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D,   // 0x2CB0 (11440)
+0x632D, 0x52CC, 0x632D, 0x632D, 0x630C, 0x5AEC, 0x5AEC, 0x5ACC, 0x5ACC, 0x528B, 0x4A6A, 0x4A6A, 0x4A49, 0x4A49, 0x4229, 0x4229,   // 0x2CC0 (11456)
+0x4208, 0x4208, 0x39E8, 0x39E8, 0x39C8, 0x39C8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39C8, 0x39E8, 0x39E8, 0x31C7, 0x31C7, 0x39E8,   // 0x2CD0 (11472)
+0x31C7, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x3A08, 0x52AB, 0x94F3, 0xEF9E, 0xEF9F, 0xE77F, 0xE77F, 0xE79F, 0xE77F, 0xE77E, 0xE77E,   // 0x2CE0 (11488)
+0xE75E, 0xE75E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xDF7E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE73E,   // 0x2CF0 (11504)
+0xE75E, 0xDF5E, 0xDF5E, 0xDF5E, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF1C, 0xD71C, 0xD6DC, 0xCE9B, 0xC659, 0xB5D8,   // 0x2D00 (11520)
+0x2944, 0x2124, 0x2145, 0x2125, 0x2144, 0x2144, 0x2144, 0x2944, 0x2944, 0x2944, 0x2124, 0x2124, 0x2124, 0x2124, 0x2124, 0x2144,   // 0x2D10 (11536)
+0x2145, 0x2145, 0x2124, 0x2125, 0x2125, 0x2124, 0x2125, 0x2945, 0x2145, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2D20 (11552)
+0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x2145, 0x2125, 0x2144, 0x2144, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2D30 (11568)
+0xFFFF, 0xFFFF, 0xB596, 0x2145, 0x2945, 0x2125, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2D40 (11584)
+0xB5B6, 0x2945, 0x2946, 0x2946, 0x2145, 0xB5B7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB596,   // 0x2D50 (11600)
+0x2945, 0x2965, 0x2945, 0x2945, 0x2145, 0x2125, 0x2945, 0x2945, 0x2925, 0x2925, 0x2945, 0x2945, 0x2945, 0x2945, 0x2965, 0x2945,   // 0x2D60 (11616)
+0x2946, 0x2945, 0x2945, 0x2945, 0x2946, 0x2145, 0x2145, 0x2945, 0x2945, 0x2965, 0x2965, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2D70 (11632)
+0x2966, 0x2965, 0x2946, 0x2946, 0x2966, 0x2966, 0x2945, 0x2104, 0x634D, 0xE75E, 0xE77E, 0xE75D, 0xDF5D, 0xDF5E, 0xDF3D, 0xDF5E,   // 0x2D80 (11648)
+0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xE73D, 0xDF3D, 0xDF3D, 0xE75D, 0xE75D, 0xDF5D, 0xDF3D,   // 0x2D90 (11664)
+0xDF5D, 0xDF5D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xD71D, 0xD6FC, 0xCEDB, 0xC69A, 0xBE59, 0xB5D8,   // 0x2DA0 (11680)
+0x3185, 0x2965, 0x2965, 0x2986, 0x2986, 0x2965, 0x2965, 0x2945, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2945, 0x2965, 0x2965,   // 0x2DB0 (11696)
+0x2986, 0x31C7, 0x31E7, 0x31C7, 0x3186, 0x2985, 0x2985, 0x2966, 0x2966, 0x6B8E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2DC0 (11712)
+0xFFFF, 0xFFFF, 0xF79E, 0x6B8E, 0x2966, 0x2986, 0x2965, 0x2965, 0x738E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2DD0 (11728)
+0xFFFF, 0xF79E, 0x6B8E, 0x2966, 0x2966, 0x2966, 0x738E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E,   // 0x2DE0 (11744)
+0x73AE, 0x2966, 0x2986, 0x2986, 0x3186, 0x738E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x738E,   // 0x2DF0 (11760)
+0x2966, 0x2966, 0x2965, 0x2966, 0x2966, 0x2965, 0x2945, 0x2946, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2E00 (11776)
+0x2965, 0x2945, 0x2945, 0x2965, 0x2965, 0x2965, 0x2145, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2E10 (11792)
+0x2945, 0x2945, 0x2946, 0x2946, 0x2966, 0x2966, 0x2966, 0x2966, 0x2124, 0x8C71, 0xEF7E, 0xDF1C, 0xDEFC, 0xDEFC, 0xDF1C, 0xDF1C,   // 0x2E20 (11808)
+0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1C, 0xDF1D, 0xDF1D, 0xDF3C, 0xDF1C, 0xDF1D, 0xDF3C,   // 0x2E30 (11824)
+0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDEFC, 0xDEFC, 0xD71C, 0xD71C, 0xD6FC, 0xD6FC, 0xD6FC, 0xD6DB, 0xCEBB, 0xC67A, 0xC639, 0xBDF8,   // 0x2E40 (11840)
+0x3186, 0x31A6, 0x31A7, 0x31A6, 0x31A6, 0x3186, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2985, 0x2986, 0x2986, 0x3186, 0x31A6,   // 0x2E50 (11856)
+0x31A6, 0x31C7, 0x31E7, 0x31C7, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x8C71, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2E60 (11872)
+0xFFFF, 0xEF7D, 0x8C71, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x8C51, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2E70 (11888)
+0xEF7D, 0x8C71, 0x31C7, 0x31A6, 0x3186, 0x3186, 0x31A6, 0x8C71, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0x8C71,   // 0x2E80 (11904)
+0x31C6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A7, 0x8C72, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0x8C51, 0x3186,   // 0x2E90 (11920)
+0x3186, 0x3186, 0x3186, 0x3186, 0x2965, 0x2965, 0x2965, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2EA0 (11936)
+0x2965, 0x2945, 0x2965, 0x2965, 0x2965, 0x2966, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2946, 0x2945, 0x2945, 0x2945,   // 0x2EB0 (11952)
+0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2965, 0x2925, 0x4208, 0xD6BA, 0xDEFC, 0xD6FC, 0xD6FC, 0xD6DB, 0xDEFC,   // 0x2EC0 (11968)
+0xD6FB, 0xD6FB, 0xDEFC, 0xDEFB, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFB, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xD6FC,   // 0x2ED0 (11984)
+0xD6FC, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DC, 0xD6BB, 0xCEBB, 0xCE9B, 0xCE9B, 0xCE9A, 0xC65A, 0xC639, 0xBE19,   // 0x2EE0 (12000)
+0x2986, 0x2986, 0x31A6, 0x31A6, 0x2985, 0x3186, 0x2985, 0x2985, 0x2965, 0x2985, 0x2985, 0x2985, 0x2986, 0x3186, 0x2986, 0x2986,   // 0x2EF0 (12016)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x31A6, 0x6B6D, 0xAD55, 0xDEDB, 0xFFDF, 0xDEFB,   // 0x2F00 (12032)
+0xAD75, 0x6B6D, 0x31A6, 0x39C6, 0x31C6, 0x31C6, 0x31C7, 0x31C7, 0x31A6, 0x31C6, 0x6B6D, 0xAD75, 0xDEFB, 0xFFDF, 0xDEFB, 0xAD55,   // 0x2F10 (12048)
+0x6B6D, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31C6, 0x31A6, 0x39C6, 0x6B6D, 0xAD55, 0xDEFB, 0xFFDF, 0xDEFB, 0xAD55, 0x6B6D, 0x31A6,   // 0x2F20 (12064)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x6B6D, 0xAD55, 0xDEFB, 0xFFDF, 0xDEFB, 0xAD75, 0x6B6D, 0x3186, 0x31A6,   // 0x2F30 (12080)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x3186,   // 0x2F40 (12096)
+0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3166, 0x3166, 0x2965, 0x2965, 0x3186, 0x2965, 0x2965, 0x3165,   // 0x2F50 (12112)
+0x2965, 0x3165, 0x2965, 0x3166, 0x3166, 0x3166, 0x2966, 0x2966, 0x3166, 0x31A6, 0xBDF7, 0xDF1C, 0xDEDB, 0xD6DB, 0xDEFB, 0xDEFB,   // 0x2F60 (12128)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xD6FB,   // 0x2F70 (12144)
+0xDEFB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6BB, 0xD6BB, 0xD6BB, 0xCEBA, 0xCE9A, 0xCE9A, 0xCE7A, 0xC679, 0xC659, 0xC639,   // 0x2F80 (12160)
+0x2985, 0x2985, 0x2985, 0x29A6, 0x2985, 0x2985, 0x2985, 0x2985, 0x2985, 0x3186, 0x2986, 0x2985, 0x2985, 0x3185, 0x2985, 0x2985,   // 0x2F90 (12176)
+0x2985, 0x2985, 0x2985, 0x2985, 0x2985, 0x2986, 0x2986, 0x3186, 0x2986, 0x3186, 0x3186, 0x3186, 0x3185, 0x31A6, 0x3186, 0x3186,   // 0x2FA0 (12192)
+0x3186, 0x31A6, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A7, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x2FB0 (12208)
+0x31A5, 0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3185, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x2FC0 (12224)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x2FD0 (12240)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186,   // 0x2FE0 (12256)
+0x3186, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3166, 0x3186, 0x3186, 0x3186, 0x3166, 0x3186, 0x3166,   // 0x2FF0 (12272)
+0x3165, 0x3165, 0x3186, 0x3166, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x39C6, 0xC618, 0xE73C, 0xDF1B, 0xDF1B, 0xDF1B, 0xE71B,   // 0x3000 (12288)
+0xE73B, 0xE73C, 0xE73C, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73C, 0xDF3C, 0xE71C, 0xE71C, 0xE71B, 0xDF1B,   // 0x3010 (12304)
+0xDF1B, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xD6DB, 0xD6DB, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xCE9A, 0xCE9A, 0xCE9A, 0xCE9A,   // 0x3020 (12320)
+0x2985, 0x2985, 0x29A5, 0x2985, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3185, 0x3185, 0x2985,   // 0x3030 (12336)
+0x29A5, 0x29A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x3040 (12352)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31C6,   // 0x3050 (12368)
+0x31C6, 0x31C6, 0x31A6, 0x31A6, 0x39C6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x39C6, 0x39C6, 0x39C6, 0x31A6,   // 0x3060 (12384)
+0x31A6, 0x3186, 0x31A6, 0x3185, 0x3185, 0x3185, 0x3186, 0x3185, 0x3186, 0x31A6, 0x39C7, 0x39E7, 0x39E7, 0x4228, 0x4208, 0x4228,   // 0x3070 (12400)
+0x4A49, 0x4228, 0x4208, 0x4208, 0x41E8, 0x41E7, 0x41E7, 0x39C7, 0x39C7, 0x39C7, 0x39C7, 0x39C7, 0x39A7, 0x39A6, 0x39A6, 0x39A6,   // 0x3080 (12416)
+0x39C7, 0x39C7, 0x39C7, 0x39C7, 0x39A7, 0x31A7, 0x31A6, 0x39A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186,   // 0x3090 (12432)
+0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x31A6, 0x39C7, 0x39C7, 0x4208, 0xCE79, 0xE73C, 0xE73B, 0xE73B, 0xE73B, 0xE75B,   // 0x30A0 (12448)
+0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE73C, 0xE73C, 0xE75C, 0xE75C, 0xE73C, 0xE73B, 0xE73B, 0xE73B,   // 0x30B0 (12464)
+0xE73B, 0xE73B, 0xE71B, 0xE71B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDEFB, 0xDEDA, 0xDEDA, 0xDEDA, 0xD6DA, 0xD6FB, 0xDEFB, 0xDEFB,   // 0x30C0 (12480)
+0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31C6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x30D0 (12496)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x30E0 (12512)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A5, 0x31A6, 0x31A6, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A5, 0x31A5,   // 0x30F0 (12528)
+0x3185, 0x2985, 0x31A6, 0x3185, 0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3185, 0x3185, 0x2965, 0x3165, 0x2944, 0x2924,   // 0x3100 (12544)
+0x2924, 0x2924, 0x2924, 0x2924, 0x2944, 0x2945, 0x3185, 0x3185, 0x31A6, 0x39C6, 0x39E7, 0x41E7, 0x41E7, 0x4208, 0x41E7, 0x4208,   // 0x3110 (12560)
+0x4208, 0x39C7, 0x39C7, 0x39C7, 0x39A7, 0x39A6, 0x39A6, 0x39A6, 0x3185, 0x3185, 0x3185, 0x3165, 0x3165, 0x3165, 0x3165, 0x3165,   // 0x3120 (12576)
+0x3145, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2924, 0x2924, 0x2924, 0x2944, 0x2924, 0x2925, 0x2924, 0x2924, 0x2924, 0x2945,   // 0x3130 (12592)
+0x2945, 0x2945, 0x2925, 0x2965, 0x2985, 0x3186, 0x39C7, 0x39C7, 0x31A7, 0x4208, 0xCE79, 0xE73B, 0xE71A, 0xE73A, 0xE73A, 0xE73A,   // 0x3140 (12608)
+0xE73B, 0xE73B, 0xE73B, 0xE75B, 0xE75B, 0xE75B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B,   // 0x3150 (12624)
+0xE73B, 0xE73B, 0xE73A, 0xE73A, 0xDF1A, 0xDF1A, 0xDF1A, 0xDF1A, 0xDEFA, 0xDEFA, 0xDEFA, 0xDEFA, 0xDEFA, 0xDF1A, 0xDF1A, 0xDF1A,   // 0x3160 (12640)
+0x2966, 0x2966, 0x2965, 0x2966, 0x2965, 0x2965, 0x2985, 0x2985, 0x2985, 0x3185, 0x3186, 0x3186, 0x3186, 0x3185, 0x2965, 0x2965,   // 0x3170 (12656)
+0x2965, 0x2965, 0x2965, 0x2965, 0x2985, 0x2985, 0x2985, 0x3185, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3185, 0x3186, 0x2985,   // 0x3180 (12672)
+0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2985, 0x2965, 0x2965, 0x2945, 0x2945, 0x2965, 0x2965, 0x2965, 0x3186, 0x3186,   // 0x3190 (12688)
+0x3185, 0x3185, 0x3185, 0x3185, 0x3165, 0x3165, 0x2944, 0x2944, 0x2924, 0x2103, 0x2103, 0x20E3, 0x18E2, 0x18C2, 0x18C2, 0x18C2,   // 0x31A0 (12704)
+0x20C2, 0x20C3, 0x20C3, 0x20C3, 0x20E3, 0x2124, 0x2104, 0x2104, 0x2103, 0x2924, 0x2924, 0x2904, 0x2104, 0x2104, 0x2924, 0x2104,   // 0x31B0 (12720)
+0x2104, 0x2104, 0x2104, 0x2104, 0x20E3, 0x20E3, 0x20E3, 0x20E3, 0x20C2, 0x18C2, 0x18C2, 0x18C2, 0x2103, 0x2103, 0x2103, 0x2103,   // 0x31C0 (12736)
+0x2924, 0x2904, 0x2104, 0x2103, 0x2904, 0x2924, 0x2924, 0x2924, 0x2904, 0x2924, 0x2924, 0x2924, 0x2904, 0x2903, 0x2104, 0x2104,   // 0x31D0 (12752)
+0x2924, 0x2925, 0x31A6, 0x3186, 0x39C7, 0x39C7, 0x39E7, 0x4208, 0x39E8, 0x4A6A, 0xC617, 0xDEDA, 0xE71B, 0xE71B, 0xE71B, 0xE71B,   // 0x31E0 (12768)
+0xE73B, 0xE71B, 0xE71C, 0xE71B, 0xE71B, 0xE71C, 0xE71C, 0xE71B, 0xE71B, 0xE71C, 0xE71B, 0xE71B, 0xE71B, 0xE71C, 0xE71B, 0xE71B,   // 0x31F0 (12784)
+0xE71C, 0xE73B, 0xE73B, 0xE73B, 0xE71B, 0xDF3B, 0xDF3B, 0xE71B, 0xE71B, 0xE71B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDF1B, 0xD6FA,   // 0x3200 (12800)
+};

_718/clokk.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: clokk.jpg
+// Time generated: 14.09.2015 16:54:41
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short clokk[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00D0 (208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0110 (272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0120 (288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01A0 (416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01B0 (432)
+0x001F, 0x089D, 0x297A, 0x31D5, 0x31AF, 0x31AA, 0x29A7, 0x2966, 0x2145, 0x2946, 0x2966, 0x2986, 0x31AA, 0x29AF, 0x29B3, 0x31BA,   // 0x01C0 (448)
+0x10BD, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01D0 (464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x107E, 0x2178,   // 0x0200 (512)
+0x39D1, 0x2987, 0x2145, 0x2105, 0x2124, 0x2125, 0x2966, 0x2987, 0x31A7, 0x31A7, 0x2987, 0x2966, 0x2145, 0x2125, 0x2125, 0x2125,   // 0x0210 (528)
+0x2967, 0x31CE, 0x2996, 0x089D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0220 (544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BE, 0x31B5, 0x31A9, 0x2145,   // 0x0250 (592)
+0x2124, 0x2966, 0x39E9, 0x4AAC, 0x73F1, 0x84B5, 0x9538, 0x9D99, 0xA5BA, 0xA5BA, 0x9D9A, 0x9D58, 0x8CD6, 0x7413, 0x52ED, 0x3A09,   // 0x0260 (608)
+0x2166, 0x2125, 0x2125, 0x2988, 0x31D3, 0x18DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0270 (624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0290 (656)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F, 0x2996, 0x2989, 0x2125, 0x2125, 0x31C8,   // 0x02A0 (672)
+0x5B4F, 0x8CF7, 0xAE3C, 0xBE9E, 0xBEBF, 0xC6DF, 0xBEBF, 0xBEBE, 0xBEBF, 0xBEBF, 0xBEBE, 0xBEBE, 0xBEBF, 0xC6DF, 0xBE9F, 0xB63C,   // 0x02B0 (688)
+0x9538, 0x6390, 0x3A09, 0x2125, 0x2124, 0x2987, 0x31D4, 0x10BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x193C, 0x31AC, 0x2945, 0x2145, 0x39E9, 0x7412, 0xAE1B,   // 0x02F0 (752)
+0xBEBF, 0xBEBF, 0xBE9E, 0xBE9E, 0xC6BF, 0xBEBF, 0xBEBF, 0xBE9E, 0xBE7D, 0xB67D, 0xBE9E, 0xBEBF, 0xBEBF, 0xBEBF, 0xBE9F, 0xBE9E,   // 0x0300 (768)
+0xBEBF, 0xBEBF, 0xB63C, 0x7C74, 0x424A, 0x2145, 0x2125, 0x318A, 0x297A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0310 (784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0330 (816)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31B8, 0x2966, 0x2145, 0x2986, 0x6B90, 0xAE1C, 0xC6BF, 0xBE9E,   // 0x0340 (832)
+0xBE9E, 0xC6DF, 0xB67E, 0xA5BA, 0x84B5, 0x6370, 0x52ED, 0x4AAC, 0x426B, 0x426A, 0x4A8B, 0x52CD, 0x5B4F, 0x7C74, 0x9D99, 0xB65D,   // 0x0350 (848)
+0xC6BF, 0xBE9E, 0xBE9E, 0xBEBF, 0xB65D, 0x7C33, 0x31C8, 0x2145, 0x2146, 0x39F4, 0x005F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0360 (864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0380 (896)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31B3, 0x2945, 0x2145, 0x424A, 0x9D79, 0xBEDF, 0xBE9E, 0xBE9E, 0xC6DF,   // 0x0390 (912)
+0xADFB, 0x73F2, 0x426B, 0x2986, 0x2145, 0x2145, 0x2145, 0x2966, 0x2966, 0x2966, 0x2966, 0x2965, 0x2145, 0x2145, 0x2966, 0x422A,   // 0x03A0 (928)
+0x6391, 0xA5BA, 0xBEBF, 0xBEBE, 0xBE9E, 0xBEDF, 0xADFB, 0x52ED, 0x2125, 0x2145, 0x31CF, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03B0 (944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03D0 (976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x31F3, 0x2125, 0x2145, 0x530E, 0xAE3C, 0xBEBF, 0xBE9E, 0xBEDF, 0xADFB, 0x6BB1,   // 0x03E0 (992)
+0x31C8, 0x2125, 0x2966, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2986, 0x2966,   // 0x03F0 (1008)
+0x1925, 0x2987, 0x632F, 0xA59A, 0xC6DF, 0xBE9F, 0xBE9E, 0xBE9E, 0x6BD1, 0x2966, 0x2125, 0x31AE, 0x087F, 0x001F, 0x001F, 0x001F,   // 0x0400 (1024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0420 (1056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x31F4, 0x2125, 0x2126, 0x6BB1, 0xBE9E, 0xBE9E, 0xBE9E, 0xBE9E, 0x7C73, 0x31C8, 0x2125,   // 0x0430 (1072)
+0x2966, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987, 0x2986,   // 0x0440 (1088)
+0x2986, 0x2966, 0x2125, 0x2987, 0x6BD1, 0xB65D, 0xBEBF, 0xBE9E, 0xC6DF, 0x8474, 0x2966, 0x2125, 0x31CF, 0x085F, 0x001F, 0x001F,   // 0x0450 (1104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0470 (1136)
+0x001F, 0x001F, 0x001F, 0x001F, 0x39F5, 0x2125, 0x2145, 0x6BD2, 0xBEBF, 0xBE7E, 0xBEBF, 0xADFB, 0x52CD, 0x2125, 0x2966, 0x2987,   // 0x0480 (1152)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2987, 0x2986, 0x2986, 0x2966, 0x2987, 0x2166, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0490 (1168)
+0x2987, 0x3186, 0x2987, 0x2986, 0x2125, 0x424A, 0x9D79, 0xC6BF, 0xBE7E, 0xC6DF, 0x84B5, 0x2966, 0x2125, 0x31D0, 0x005F, 0x001F,   // 0x04A0 (1184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04C0 (1216)
+0x001F, 0x001F, 0x001F, 0x31BA, 0x2145, 0x2125, 0x6390, 0xBEBF, 0xBE9E, 0xBEDF, 0x9D58, 0x31C8, 0x2145, 0x2987, 0x2986, 0x2986,   // 0x04D0 (1232)
+0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x8495, 0xA59A, 0x4AAC, 0x2166, 0x2987, 0x2987, 0x2986, 0x2987,   // 0x04E0 (1248)
+0x2987, 0x2987, 0x2986, 0x2987, 0x2986, 0x2945, 0x2986, 0x84B5, 0xC6DF, 0xB69E, 0xC6DF, 0x7C54, 0x2145, 0x2125, 0x39D5, 0x001F,   // 0x04F0 (1264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0510 (1296)
+0x001F, 0x001F, 0x18FE, 0x2988, 0x2125, 0x52CC, 0xBE9E, 0xBE9E, 0xC6DF, 0x9538, 0x29A7, 0x2946, 0x2987, 0x2986, 0x2987, 0x2987,   // 0x0520 (1312)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xBE9E, 0xC6FF, 0x8494, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x0530 (1328)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x2146, 0x7C74, 0xC6BF, 0xBE9E, 0xBEBF, 0x6390, 0x2125, 0x2945, 0x297C,   // 0x0540 (1344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0560 (1376)
+0x001F, 0x001F, 0x39F0, 0x2125, 0x3A09, 0xADFC, 0xBE9E, 0xBEBF, 0xA599, 0x31A8, 0x2946, 0x2987, 0x2986, 0x2987, 0x2986, 0x2987,   // 0x0570 (1392)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x0580 (1408)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2946, 0x8CD6, 0xBEBF, 0xBE9E, 0xB67E, 0x4AAC, 0x2125, 0x31AB,   // 0x0590 (1424)
+0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05B0 (1456)
+0x001F, 0x299C, 0x2145, 0x2166, 0x8CD6, 0xC6DF, 0xBE9E, 0xB65D, 0x3A2A, 0x2945, 0x3187, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987,   // 0x05C0 (1472)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x05D0 (1488)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x29A7, 0xA5BA, 0xC6BF, 0xBEBE, 0xA5BA, 0x3187, 0x2125,   // 0x05E0 (1504)
+0x31D6, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0600 (1536)
+0x003F, 0x31ED, 0x2104, 0x52ED, 0xBE9F, 0xBE7E, 0xBEBF, 0x636F, 0x2125, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0610 (1552)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x0620 (1568)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2145, 0x4A8B, 0xBE7E, 0xB69E, 0xC6BF, 0x6BD1, 0x2124,   // 0x0630 (1584)
+0x29A9, 0x10BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0650 (1616)
+0x297B, 0x2145, 0x2967, 0x9D79, 0xBEBF, 0xBEBF, 0x9517, 0x2946, 0x2986, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0660 (1632)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x424A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0670 (1648)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2125, 0x7432, 0xBEDF, 0xBE9E, 0xAE1C, 0x39E9,   // 0x0680 (1664)
+0x2105, 0x31F7, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06A0 (1696)
+0x31F0, 0x2105, 0x5B0E, 0xBEBF, 0xBE7E, 0xBE7D, 0x426B, 0x2946, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2987, 0x2987, 0x2987,   // 0x06B0 (1712)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x06C0 (1728)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x31A8, 0xADFB, 0xBE9E, 0xC6DF, 0x73F2,   // 0x06D0 (1744)
+0x2125, 0x31AA, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FE,   // 0x06F0 (1776)
+0x2966, 0x2145, 0x9517, 0xBEBF, 0xC6DF, 0x84B5, 0x2125, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986,   // 0x0700 (1792)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2166, 0x3A2A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2986, 0x2986, 0x2986, 0x2987,   // 0x0710 (1808)
+0x2986, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2125, 0x6BB1, 0xC6DF, 0xBE9E, 0xA5DB,   // 0x0720 (1824)
+0x31A7, 0x2125, 0x299B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x29B7,   // 0x0740 (1856)
+0x2125, 0x422A, 0xB65D, 0xBE9E, 0xB67E, 0x4A8B, 0x2145, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987,   // 0x0750 (1872)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x3A2A, 0xB65D, 0xC6DF, 0x7C74, 0x2125, 0x2986, 0x2986, 0x2986, 0x2987,   // 0x0760 (1888)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2966, 0x31C8, 0xAE3C, 0xBE9E, 0xBEBE,   // 0x0770 (1904)
+0x5AED, 0x1904, 0x39F1, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31CE,   // 0x0790 (1936)
+0x1904, 0x6BB1, 0xC6DF, 0xBEBF, 0x9537, 0x2945, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x07A0 (1952)
+0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2987, 0x2166, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2125, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x07B0 (1968)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2966, 0x2125, 0x7C74, 0xBEBF, 0xBEBF,   // 0x07C0 (1984)
+0x84B5, 0x2125, 0x31A9, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109E, 0x29A9,   // 0x07E0 (2016)
+0x2125, 0x9517, 0xBEBF, 0xC6DF, 0x63B1, 0x2125, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x07F0 (2032)
+0x2966, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2165, 0x422A, 0xB67D, 0xC6DF, 0x7C74, 0x2145, 0x2986, 0x2987, 0x2986, 0x2986,   // 0x0800 (2048)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2145, 0x4AAC, 0xBE9E, 0xBEBE,   // 0x0810 (2064)
+0xA5BA, 0x2986, 0x2146, 0x213D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x191C, 0x2165,   // 0x0830 (2096)
+0x31A7, 0xA5DB, 0xBEBE, 0xBE9E, 0x426B, 0x2146, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0840 (2112)
+0x2987, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2166, 0x422A, 0xB65D, 0xC6DF, 0x8494, 0x2125, 0x2987, 0x2986, 0x2986, 0x2986,   // 0x0850 (2128)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2966, 0x31C8, 0xAE1C, 0xBE9E,   // 0x0860 (2144)
+0xB65D, 0x424A, 0x2105, 0x29B8, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x2999, 0x2125,   // 0x0880 (2176)
+0x426B, 0xB67D, 0xBE9E, 0xADFB, 0x31C8, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0890 (2192)
+0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2946, 0x4229, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2986, 0x2986, 0x2986,   // 0x08A0 (2208)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2945, 0x9517, 0xBEBF,   // 0x08B0 (2224)
+0xBEBE, 0x5B0E, 0x2104, 0x31B3, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39F4, 0x2104,   // 0x08D0 (2256)
+0x52ED, 0xBEBE, 0xBEBF, 0x9537, 0x2145, 0x2987, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x08E0 (2272)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2145, 0x3A09, 0xB67D, 0xC6DF, 0x7C74, 0x1905, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x08F0 (2288)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987, 0x2125, 0x7C74, 0xBEBF,   // 0x0900 (2304)
+0xBEDF, 0x6BD1, 0x2104, 0x29AE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31CE, 0x2105,   // 0x0920 (2336)
+0x6370, 0xBEBF, 0xBEDF, 0x8CD6, 0x2145, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0930 (2352)
+0x2987, 0x2986, 0x2987, 0x2986, 0x2987, 0x2986, 0x2986, 0x8495, 0xBE9E, 0xBE9E, 0xAE1B, 0x4AAC, 0x2145, 0x2986, 0x2987, 0x2986,   // 0x0940 (2368)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2125, 0x6BD1, 0xC6DF,   // 0x0950 (2384)
+0xBEDF, 0x8495, 0x2145, 0x296B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x214B, 0x2126,   // 0x0970 (2416)
+0x6BB1, 0xC6DF, 0xBEBF, 0x7C74, 0x2125, 0x2986, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0980 (2432)
+0x2986, 0x2987, 0x2986, 0x2987, 0x2987, 0x2145, 0x6BB0, 0xC6DF, 0xB67E, 0xB67E, 0xBEBE, 0xA5DA, 0x31C8, 0x2966, 0x2967, 0x2986,   // 0x0990 (2448)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987, 0x2125, 0x5B4F, 0xBEBF,   // 0x09A0 (2464)
+0xBEBF, 0x8CD6, 0x2145, 0x212A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x2129, 0x2125,   // 0x09C0 (2496)
+0x6BD1, 0xC6BF, 0xBEBF, 0x7434, 0x2125, 0x2986, 0x2986, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x09D0 (2512)
+0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2125, 0x8CD6, 0xBEDF, 0xB67E, 0xB67D, 0xB67E, 0xB67E, 0x422A, 0x2946, 0x2986, 0x2986,   // 0x09E0 (2528)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2125, 0x5B2E, 0xBEBF,   // 0x09F0 (2544)
+0xBEBF, 0x8CD7, 0x2145, 0x212A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x212A, 0x2125,   // 0x0A10 (2576)
+0x6BD1, 0xC6BF, 0xBEBF, 0x7C54, 0x2125, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0A20 (2592)
+0x2986, 0x2966, 0x2966, 0x2987, 0x2986, 0x2125, 0x7C54, 0xC6FF, 0xB69D, 0xBE7E, 0xB67E, 0xBE7E, 0x4AAC, 0x2125, 0x2966, 0x2986,   // 0x0A30 (2608)
+0x2966, 0x2986, 0x2986, 0x2986, 0x2966, 0x2966, 0x2986, 0x2967, 0x2986, 0x2966, 0x2966, 0x2986, 0x2967, 0x2125, 0x5B2F, 0xBEBE,   // 0x0A40 (2624)
+0xBEBF, 0x8CD6, 0x2945, 0x212A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x298C, 0x2125,   // 0x0A60 (2656)
+0x6390, 0xC6DF, 0xBEBF, 0x84B5, 0x2145, 0x2986, 0x2966, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0A70 (2672)
+0x2987, 0x2966, 0x2986, 0x2986, 0x2987, 0x2966, 0x3A29, 0xADFB, 0xC6DF, 0xBEDF, 0xBE9E, 0xBE9E, 0xADFC, 0x424A, 0x2125, 0x2986,   // 0x0A80 (2688)
+0x2986, 0x2967, 0x2987, 0x2966, 0x2967, 0x2986, 0x2966, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986, 0x3187, 0x2125, 0x6390, 0xBEBF,   // 0x0A90 (2704)
+0xBEBF, 0x84B6, 0x2125, 0x214A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31F2, 0x1904,   // 0x0AB0 (2736)
+0x5B0E, 0xBEBF, 0xBEBF, 0x8CF7, 0x2945, 0x2987, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0AC0 (2752)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x3187, 0x2145, 0x3A09, 0x7413, 0x8495, 0xB65C, 0xBE9E, 0xBEBF, 0xAE1C, 0x426A, 0x2125,   // 0x0AD0 (2768)
+0x2987, 0x3187, 0x2966, 0x2987, 0x2987, 0x2966, 0x2987, 0x2966, 0x2986, 0x2966, 0x2987, 0x2986, 0x2986, 0x2125, 0x7433, 0xBEBF,   // 0x0AE0 (2784)
+0xBEBF, 0x7433, 0x2124, 0x298E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x29B7, 0x2125,   // 0x0B00 (2816)
+0x4A8B, 0xBE9E, 0xBEBE, 0x9D9A, 0x2986, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0B10 (2832)
+0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2966, 0x2987, 0x2966, 0x2125, 0x2104, 0x52CC, 0xB65D, 0xBE9E, 0xBEBE, 0xAE1C, 0x426A,   // 0x0B20 (2848)
+0x2125, 0x2987, 0x2987, 0x2986, 0x2986, 0x2986, 0x2967, 0x2967, 0x2986, 0x2986, 0x2966, 0x2986, 0x2986, 0x2945, 0x8CD6, 0xBEBF,   // 0x0B30 (2864)
+0xBEBF, 0x5B4F, 0x1904, 0x31B1, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x215A, 0x2125,   // 0x0B50 (2896)
+0x39E8, 0xAE3C, 0xBE9E, 0xB65D, 0x3A2A, 0x2945, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0B60 (2912)
+0x2966, 0x2987, 0x2986, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2967, 0x2125, 0x52CD, 0xB65E, 0xBE9E, 0xC69F, 0xAE3C,   // 0x0B70 (2928)
+0x4AAC, 0x2125, 0x2986, 0x2987, 0x2986, 0x2987, 0x2966, 0x2986, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0xA5BA, 0xBEBF,   // 0x0B80 (2944)
+0xBE9E, 0x4AAC, 0x2105, 0x31D7, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18DE, 0x2987,   // 0x0BA0 (2976)
+0x2146, 0x9558, 0xBEBF, 0xBEBF, 0x5B2F, 0x2145, 0x2966, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0BB0 (2992)
+0x2986, 0x2966, 0x2987, 0x2966, 0x2986, 0x2986, 0x2986, 0x2987, 0x2966, 0x2967, 0x2986, 0x2125, 0x52CC, 0xB65D, 0xBE9E, 0xBE9F,   // 0x0BC0 (3008)
+0xB65D, 0x4AAC, 0x2125, 0x2987, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2946, 0x424A, 0xB67E, 0xBE9E,   // 0x0BD0 (3024)
+0xAE1C, 0x31C8, 0x2145, 0x297C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31ED,   // 0x0BF0 (3056)
+0x1904, 0x7C33, 0xC6DF, 0xBEBF, 0x8495, 0x2125, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0C00 (3072)
+0x2986, 0x2986, 0x2987, 0x2986, 0x2966, 0x2986, 0x2987, 0x2986, 0x2967, 0x3187, 0x2986, 0x2967, 0x2125, 0x52CD, 0xBE9E, 0xBE9E,   // 0x0C10 (3088)
+0xBE9E, 0xB63D, 0x426B, 0x2125, 0x2986, 0x2986, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2125, 0x6BB1, 0xBEBF, 0xBEBF,   // 0x0C20 (3104)
+0x9517, 0x2145, 0x29A7, 0x18DE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31D4,   // 0x0C40 (3136)
+0x2104, 0x4AAC, 0xBE9E, 0xBE9E, 0xAE1C, 0x31E8, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0C50 (3152)
+0x2967, 0x2966, 0x2986, 0x2967, 0x2967, 0x2966, 0x2967, 0x2966, 0x2986, 0x2967, 0x2986, 0x2986, 0x2966, 0x2125, 0x5B0E, 0xBE9E,   // 0x0C60 (3168)
+0xBE9E, 0xBEBF, 0xAE1C, 0x424A, 0x2125, 0x2987, 0x2986, 0x2966, 0x2986, 0x2966, 0x2967, 0x2966, 0x2986, 0xA599, 0xBEBF, 0xC6DF,   // 0x0C70 (3184)
+0x63B0, 0x1904, 0x31CE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x217C,   // 0x0C90 (3216)
+0x2125, 0x2986, 0xA5BA, 0xBEBE, 0xC6DF, 0x6BD2, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2967, 0x2967, 0x2966, 0x2986,   // 0x0CA0 (3232)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2125, 0x5B0D,   // 0x0CB0 (3248)
+0xB67D, 0xBE9E, 0xBEBF, 0xAE1C, 0x424B, 0x2125, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2125, 0x52ED, 0xBEBF, 0xBE9E, 0xB63D,   // 0x0CC0 (3264)
+0x3A09, 0x1904, 0x31F8, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F,   // 0x0CE0 (3296)
+0x31CB, 0x1904, 0x6BB1, 0xC6DF, 0xBE9E, 0xADFB, 0x31A7, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2986, 0x2966,   // 0x0CF0 (3312)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x1905,   // 0x0D00 (3328)
+0x52CC, 0xBE7E, 0xBE9E, 0xBEBE, 0xAE1C, 0x424A, 0x2125, 0x2966, 0x2986, 0x2966, 0x2966, 0x2946, 0x9538, 0xBEBE, 0xBEBF, 0x84B5,   // 0x0D10 (3344)
+0x2125, 0x2967, 0x18FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D30 (3376)
+0x31D7, 0x2104, 0x31C8, 0xAE1C, 0xBE9E, 0xBEDF, 0x73F2, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2986,   // 0x0D40 (3392)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986,   // 0x0D50 (3408)
+0x2125, 0x52CC, 0xBE7D, 0xBE9E, 0xBEBE, 0xAE1C, 0x422A, 0x2145, 0x2986, 0x2966, 0x2125, 0x5B0E, 0xBEBF, 0xBE7E, 0xBE9E, 0x4A6B,   // 0x0D60 (3424)
+0x20E4, 0x3A12, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D80 (3456)
+0x10BE, 0x2988, 0x1904, 0x73D2, 0xC6DF, 0xBE9E, 0xB65E, 0x424A, 0x2925, 0x2966, 0x2966, 0x2967, 0x2967, 0x2986, 0x2966, 0x2967,   // 0x0D90 (3472)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0DA0 (3488)
+0x2967, 0x2105, 0x52CC, 0xB67E, 0xBEBF, 0xC6FF, 0x7C74, 0x2125, 0x2966, 0x2946, 0x31A7, 0xA5DB, 0xBE9E, 0xBEDF, 0x84D6, 0x2125,   // 0x0DB0 (3504)
+0x2146, 0x213C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DD0 (3536)
+0x001F, 0x39F7, 0x2104, 0x29A7, 0xA5BA, 0xBE9E, 0xC6BF, 0x9D79, 0x2966, 0x2966, 0x2967, 0x2967, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0DE0 (3552)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0DF0 (3568)
+0x2986, 0x2967, 0x2125, 0x52AC, 0xAE1C, 0xB65D, 0x52ED, 0x2145, 0x2966, 0x2125, 0x84B5, 0xC6DF, 0xBE9E, 0xB65D, 0x3A29, 0x1904,   // 0x0E00 (3584)
+0x39F2, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E20 (3616)
+0x001F, 0x109F, 0x31AA, 0x1904, 0x52ED, 0xBE9E, 0xBE9E, 0xC6DF, 0x7C54, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0E30 (3632)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0E40 (3648)
+0x2966, 0x2986, 0x2966, 0x2145, 0x31A7, 0x31C8, 0x2146, 0x2967, 0x2105, 0x636F, 0xBEBF, 0xB69D, 0xBEBF, 0x6BB1, 0x2105, 0x2966,   // 0x0E50 (3664)
+0x211D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E70 (3696)
+0x001F, 0x001F, 0x299A, 0x2145, 0x2125, 0x6BF1, 0xC6DF, 0xBE9E, 0xBEBF, 0x6BD1, 0x2125, 0x2966, 0x2966, 0x2986, 0x2986, 0x2966,   // 0x0E80 (3712)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0E90 (3728)
+0x2966, 0x2966, 0x2967, 0x2986, 0x2946, 0x2966, 0x2967, 0x2105, 0x52ED, 0xB67E, 0xBE9E, 0xBEDF, 0x8CD6, 0x2124, 0x2125, 0x39F6,   // 0x0EA0 (3744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EC0 (3776)
+0x001F, 0x001F, 0x001F, 0x39F2, 0x2125, 0x2145, 0x8CD6, 0xC6DF, 0xBE9E, 0xBE9F, 0x6BF1, 0x2125, 0x2946, 0x2967, 0x2966, 0x2986,   // 0x0ED0 (3792)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0EE0 (3808)
+0x2967, 0x2966, 0x2987, 0x2966, 0x2966, 0x2966, 0x2124, 0x5B0E, 0xB67D, 0xBE9E, 0xBEDE, 0x9D9A, 0x31A7, 0x2125, 0x31CD, 0x085F,   // 0x0EF0 (3824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F10 (3856)
+0x001F, 0x001F, 0x001F, 0x087F, 0x31CD, 0x2105, 0x2986, 0x9538, 0xC6DF, 0xBE9E, 0xBEBF, 0x7C74, 0x3187, 0x2125, 0x2966, 0x2967,   // 0x0F20 (3872)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2967, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0F30 (3888)
+0x2987, 0x2966, 0x2967, 0x2966, 0x2925, 0x2946, 0x73F2, 0xBE9E, 0xBE9E, 0xBEBF, 0xA5FB, 0x39E9, 0x2105, 0x2988, 0x211E, 0x001F,   // 0x0F40 (3904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F60 (3936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x18FE, 0x31AB, 0x1904, 0x31A7, 0x9558, 0xBEDF, 0xBE9E, 0xC6BF, 0xA59A, 0x4AAB, 0x2125, 0x2145,   // 0x0F70 (3952)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0F80 (3968)
+0x2966, 0x2966, 0x2946, 0x2105, 0x3A2A, 0x9538, 0xBEBF, 0xBE9E, 0xC6DF, 0xADDB, 0x3A09, 0x2104, 0x2987, 0x215C, 0x001F, 0x001F,   // 0x0F90 (3984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FB0 (4016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FE, 0x31AA, 0x2104, 0x2966, 0x8CB6, 0xC6BF, 0xBE9E, 0xBEBE, 0xBE9E, 0x8474, 0x39E9,   // 0x0FC0 (4032)
+0x2125, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2967,   // 0x0FD0 (4048)
+0x2145, 0x2125, 0x31A8, 0x73F2, 0xB65D, 0xBEBF, 0xBE7E, 0xC6DF, 0x9D59, 0x31E8, 0x2105, 0x2967, 0x297C, 0x001F, 0x001F, 0x001F,   // 0x0FE0 (4064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1000 (4096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FE, 0x31CC, 0x2105, 0x2145, 0x6BB0, 0xBE7E, 0xBEBF, 0xBE9E, 0xC6DF, 0xB63C,   // 0x1010 (4112)
+0x7C74, 0x428B, 0x2145, 0x2125, 0x2125, 0x2146, 0x2946, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2946, 0x2145, 0x2125, 0x2125,   // 0x1020 (4128)
+0x3A2A, 0x73F2, 0xADFB, 0xBEDF, 0xBE9E, 0xBE9E, 0xC6BF, 0x7C54, 0x2986, 0x1905, 0x2988, 0x295C, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1030 (4144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1050 (4176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10DE, 0x31AD, 0x2125, 0x2104, 0x4A8B, 0x9D58, 0xBEDF, 0xBE9E, 0xBE9E,   // 0x1060 (4192)
+0xBEDF, 0xBE9E, 0x9538, 0x73F1, 0x4AAC, 0x3A09, 0x3187, 0x2946, 0x2145, 0x2146, 0x2946, 0x2986, 0x31E8, 0x428B, 0x6BB0, 0x8CF7,   // 0x1070 (4208)
+0xB65D, 0xC6DF, 0xBE9E, 0xBE9E, 0xC6DF, 0xA5DB, 0x5B0D, 0x2125, 0x2105, 0x298A, 0x215C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1080 (4224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10A0 (4256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x31F4, 0x2145, 0x2104, 0x2946, 0x5B4F, 0xA5BA, 0xBEBF,   // 0x10B0 (4272)
+0xBEBF, 0xBE9E, 0xBEBE, 0xC6DF, 0xBE9E, 0xAE3C, 0xA5DA, 0x9D59, 0x9537, 0x9537, 0x9558, 0xA5BA, 0xAE1C, 0xBE9E, 0xBEBF, 0xBEBF,   // 0x10C0 (4288)
+0xBE9E, 0xBEBE, 0xC6BF, 0xAE1C, 0x6BD1, 0x2987, 0x20E4, 0x2125, 0x31D1, 0x10BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10D0 (4304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10F0 (4336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x215B, 0x31AC, 0x2125, 0x18E4, 0x2966, 0x5B2E,   // 0x1100 (4352)
+0x9538, 0xB65D, 0xC6DF, 0xC6DF, 0xBEBE, 0xBEBE, 0xBE9E, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBE9F, 0xBEBE, 0xBE9F, 0xC6BF, 0xC6BF,   // 0x1110 (4368)
+0xBE7D, 0x9D79, 0x6390, 0x31A7, 0x1904, 0x2104, 0x298A, 0x3199, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1120 (4384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1140 (4416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F, 0x31B9, 0x298B, 0x2125, 0x18E4,   // 0x1150 (4432)
+0x2125, 0x3A09, 0x5B4F, 0x8495, 0x9D79, 0xADFB, 0xB65D, 0xBEBE, 0xBEBF, 0xBEBE, 0xBEBE, 0xB67D, 0xAE1C, 0x9D9A, 0x8CD5, 0x6390,   // 0x1160 (4448)
+0x424A, 0x2145, 0x1904, 0x2125, 0x2989, 0x31D6, 0x089E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1170 (4464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1190 (4496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085E, 0x319A, 0x31CF,   // 0x11A0 (4512)
+0x2967, 0x2104, 0x18E4, 0x2104, 0x2965, 0x31A7, 0x424A, 0x4AAC, 0x52CD, 0x52ED, 0x4ACC, 0x426A, 0x31A7, 0x2966, 0x2104, 0x18E4,   // 0x11B0 (4528)
+0x2104, 0x2166, 0x31CD, 0x29B7, 0x109E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11C0 (4544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11E0 (4576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11F0 (4592)
+0x18FD, 0x2177, 0x3211, 0x31CB, 0x2967, 0x2145, 0x2125, 0x2125, 0x2125, 0x2125, 0x2125, 0x2105, 0x2145, 0x2966, 0x29AA, 0x39F0,   // 0x1200 (4608)
+0x2996, 0x191C, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1210 (4624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1230 (4656)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1240 (4672)
+0x001F, 0x001F, 0x001F, 0x10BE, 0x213B, 0x2157, 0x2954, 0x1911, 0x18CF, 0x18EF, 0x18F0, 0x2154, 0x2156, 0x215A, 0x10DE, 0x003F,   // 0x1250 (4688)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1260 (4704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1280 (4736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1290 (4752)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12A0 (4768)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12B0 (4784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12D0 (4816)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12E0 (4832)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12F0 (4848)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1330 (4912)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1340 (4928)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x211F, 0x421F, 0x191F, 0x001F, 0x001F, 0x001F, 0x001F, 0x41FF, 0x41FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x317F, 0x3A1F, 0x107F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x319F, 0xCE7F,   // 0x1460 (5216)
+0xFFFF, 0xFFDF, 0xFFDF, 0xCE7F, 0x107F, 0x001F, 0x211F, 0xFFFF, 0xCE7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1470 (5232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xE6FF, 0xFFFF, 0x211F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x737F, 0x9CFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xCE7F, 0xFFFF,   // 0x14B0 (5296)
+0xCE7F, 0x7BFF, 0xE6FF, 0xFFDF, 0x7BFF, 0x001F, 0x62FF, 0xFFFF, 0x9CFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14C0 (5312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xFFDF, 0xF77F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x7BFF, 0xFFFF, 0x83FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x9CFF, 0xFFFF, 0xCE7F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x191F, 0xBDFF, 0xAD7F, 0x001F, 0x8C7F, 0xFFFF, 0x739F, 0x001F, 0x527F, 0xD67F, 0xFFFF, 0xD67F, 0x6B7F, 0x001F,   // 0x1510 (5392)
+0x001F, 0x001F, 0x62FF, 0xBDFF, 0xFFFF, 0xAD7F, 0x297F, 0x001F, 0x41FF, 0xFFFF, 0xBE1F, 0x317F, 0xBDFF, 0xBDFF, 0x631F, 0x001F,   // 0x1520 (5408)
+0x001F, 0x001F, 0x001F, 0x737F, 0xBDFF, 0x8C7F, 0xDEFF, 0xEF7F, 0x7BFF, 0x001F, 0x001F, 0x4A7F, 0xDEFF, 0xFFDF, 0xB57F, 0x3A1F,   // 0x1530 (5424)
+0x001F, 0x737F, 0xEF7F, 0xFFFF, 0xD67F, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xCE9F, 0xFFFF, 0x41FF,   // 0x1550 (5456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xC5FF, 0xFFFF, 0x317F, 0x421F, 0xFFFF, 0xFFDF, 0x9CFF, 0xE6FF, 0xFFFF, 0x62FF,   // 0x1560 (5472)
+0x001F, 0x5AFF, 0xFFFF, 0xE6FF, 0xB57F, 0xFFFF, 0xBDFF, 0x001F, 0x7BFF, 0xFFDF, 0xAD7F, 0xEF7F, 0xFFFF, 0x62FF, 0x001F, 0x001F,   // 0x1570 (5488)
+0x001F, 0x001F, 0x001F, 0xBDFF, 0xFFFF, 0xF77F, 0x9CFF, 0xFFDF, 0xFFDF, 0x001F, 0x41FF, 0xFFFF, 0xEF7F, 0x9CFF, 0xEF7F, 0xE6FF,   // 0x1580 (5504)
+0x001F, 0x8C7F, 0xFFFF, 0xFFDF, 0xBDFF, 0x107F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0x001F, 0xAD7F, 0xFFFF, 0x7BFF, 0x001F, 0x41FF, 0xFFDF, 0xAD7F,   // 0x15B0 (5552)
+0x001F, 0xEF7F, 0xFFFF, 0x317F, 0x001F, 0x6B9F, 0x737F, 0x001F, 0xAD7F, 0xFFFF, 0xFFDF, 0xFFFF, 0x737F, 0x001F, 0x001F, 0x001F,   // 0x15C0 (5568)
+0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0x317F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0x9CFF, 0xFFFF, 0x947F, 0x41FF, 0xBDFF, 0xFFFF,   // 0x15D0 (5584)
+0x297F, 0x211F, 0xFFDF, 0xD67F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFDF, 0xFFDF, 0x109F,   // 0x15F0 (5616)
+0x001F, 0x001F, 0x8C7F, 0x8C7F, 0x41FF, 0x319F, 0xFFDF, 0xBDFF, 0x001F, 0xE6FF, 0xFFDF, 0x317F, 0x001F, 0x631F, 0xFFFF, 0xC5FF,   // 0x1600 (5632)
+0x299F, 0xFFFF, 0xCE7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xEF7F, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C7F, 0x001F, 0x001F, 0x001F,   // 0x1610 (5648)
+0x001F, 0x001F, 0x317F, 0xFFDF, 0xD67F, 0x001F, 0x319F, 0xFFFF, 0xC5FF, 0x001F, 0xE6FF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x1620 (5664)
+0x421F, 0x5AFF, 0xFFFF, 0x9CFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xEF7F, 0xFFDF, 0x8C7F,   // 0x1640 (5696)
+0x211F, 0x737F, 0xFFFF, 0xEF7F, 0x107F, 0x737F, 0xFFFF, 0x947F, 0x001F, 0xBDFF, 0xFFDF, 0x4A7F, 0x089F, 0xC5FF, 0xFFDF, 0x8C7F,   // 0x1650 (5712)
+0x211F, 0xFFFF, 0xCE7F, 0x001F, 0x8C7F, 0xE6FF, 0x6B9F, 0x20FF, 0xFFFF, 0xEF7F, 0x41FF, 0xFFFF, 0xE6FF, 0x001F, 0x001F, 0x41FF,   // 0x1660 (5728)
+0x317F, 0x001F, 0x5AFF, 0xFFFF, 0x8C7F, 0x001F, 0x737F, 0xFFFF, 0x947F, 0x001F, 0xAD7F, 0xFFFF, 0x191F, 0x211F, 0x7BFF, 0x62FF,   // 0x1670 (5744)
+0x001F, 0x83FF, 0xFFFF, 0x737F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7BFF, 0xFFDF, 0xFFFF,   // 0x1690 (5776)
+0xFFFF, 0xFFDF, 0xFFFF, 0x527F, 0x001F, 0x9CFF, 0xFFDF, 0x5AFF, 0x001F, 0x529F, 0xFFFF, 0xFFDF, 0xEF7F, 0xFFFF, 0xEF7F, 0x107F,   // 0x16A0 (5792)
+0x001F, 0xBE1F, 0xFFDF, 0xFFFF, 0xFFDF, 0xE6FF, 0x109F, 0x527F, 0xFFFF, 0xAD7F, 0x001F, 0xCE7F, 0xFFFF, 0x299F, 0x41FF, 0xFFFF,   // 0x16B0 (5808)
+0xBDFF, 0x001F, 0x9D1F, 0xFFFF, 0x62FF, 0x001F, 0x9CFF, 0xFFFF, 0x62FF, 0x001F, 0x631F, 0xFFDF, 0xF77F, 0xEF7F, 0xFFFF, 0x83FF,   // 0x16C0 (5824)
+0x001F, 0x9CFF, 0xFFDF, 0xE6FF, 0x527F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x62FF, 0xC5FF,   // 0x16E0 (5856)
+0xC5FF, 0x737F, 0x211F, 0x001F, 0x001F, 0x947F, 0xBDFF, 0x317F, 0x001F, 0x001F, 0x4A9F, 0xAD7F, 0xBDFF, 0x9CFF, 0x211F, 0x001F,   // 0x16F0 (5872)
+0x001F, 0x211F, 0x739F, 0xBDFF, 0x7BFF, 0x211F, 0x001F, 0x631F, 0xBDFF, 0x62FF, 0x001F, 0x41FF, 0x7BFF, 0x39FF, 0x631F, 0xC5FF,   // 0x1700 (5888)
+0x62FF, 0x001F, 0x947F, 0xBDFF, 0x299F, 0x001F, 0x947F, 0xBE1F, 0x211F, 0x001F, 0x001F, 0x421F, 0x9CDF, 0xB57F, 0x631F, 0x001F,   // 0x1710 (5904)
+0x001F, 0x299F, 0xA4FF, 0xBDFF, 0x317F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1740 (5952)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1750 (5968)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1790 (6032)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_718/del.c

@@ -0,0 +1,108 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: del.jpg
+// Time generated: 04.05.2014 19:24:57
+// Dimensions    : 40x40 pixels
+// Size          : 3 200 Bytes
+
+const unsigned short del[0x640] ={
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0010 (16)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0020 (32)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0030 (48)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0040 (64)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0050 (80)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0060 (96)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0070 (112)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0080 (128)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0090 (144)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00A0 (160)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00B0 (176)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00C0 (192)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00D0 (208)
+0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x2B14, 0x0020, 0x0020, 0x0020, 0x0021, 0x0020, 0x0021, 0x2B14,   // 0x00E0 (224)
+0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00F0 (240)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x039F, 0x037F, 0x2B34, 0x0001, 0x0020,   // 0x0100 (256)
+0x0021, 0x2B14, 0x2B14, 0x2B15, 0x2B14, 0x2B14, 0x0020, 0x0020, 0x0021, 0x0021, 0x2B14, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0110 (272)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0120 (288)
+0x037F, 0x037F, 0x037F, 0x0B7D, 0x0020, 0x0000, 0x2AF3, 0x2AF3, 0x2AF3, 0x2B13, 0x2B13, 0x2AF3, 0x2AF3, 0x2AF3, 0x2AF3, 0x2B13,   // 0x0130 (304)
+0x2AF3, 0x0020, 0x0000, 0x0000, 0x139E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0140 (320)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0020, 0x0000, 0x2AB0, 0x2B35, 0x2B76,   // 0x0150 (336)
+0x3355, 0x2B35, 0x2B34, 0x2B14, 0x2B14, 0x2B34, 0x2B75, 0x2B97, 0x2BB8, 0x2B77, 0x2B13, 0x0000, 0x0041, 0x035E, 0x039F, 0x037F,   // 0x0160 (352)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0170 (368)
+0x037F, 0x037F, 0x0841, 0x32D0, 0x343C, 0x343B, 0x33F9, 0x33B7, 0x3375, 0x2B34, 0x2B13, 0x2B13, 0x2B13, 0x2B34, 0x2B55, 0x3397,   // 0x0180 (384)
+0x33D9, 0x341B, 0x3C7D, 0x34BE, 0x0021, 0x037E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0190 (400)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x035F, 0x0021, 0xCE79, 0x4C7C, 0x33FA, 0x2BB8, 0x2B78,   // 0x01A0 (416)
+0x2B76, 0x2B35, 0x2B14, 0x2B33, 0x2B13, 0x3314, 0x3355, 0x3397, 0x33D9, 0x341B, 0x3C5D, 0x3C7E, 0x0021, 0x035E, 0x037F, 0x037F,   // 0x01B0 (432)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x01C0 (448)
+0x037F, 0x037F, 0x139C, 0x0020, 0xCE59, 0x8538, 0x751A, 0x5C79, 0x43D7, 0x3375, 0x3334, 0x2B14, 0x2B14, 0x2B34, 0x3355, 0x3396,   // 0x01D0 (464)
+0x33B6, 0x4396, 0x0020, 0x0000, 0x0000, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x01E0 (480)
+0x037F, 0x037F, 0x039E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x8539, 0x0020, 0x0000, 0x4A69, 0x4A69,   // 0x01F0 (496)
+0xCE59, 0x7C31, 0x636E, 0x4AAC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x116B, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0200 (512)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0210 (528)
+0x037F, 0x037F, 0x037F, 0x855B, 0xB63B, 0x9578, 0x0021, 0x0020, 0x0000, 0x0020, 0x0001, 0x0021, 0x0000, 0x0020, 0x0021, 0x0021,   // 0x0220 (544)
+0x12B5, 0x0AD6, 0x0AB8, 0x0A96, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0230 (560)
+0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0xB61A, 0x9579, 0x6C77, 0x3B34,   // 0x0240 (576)
+0x1293, 0x0294, 0x0AF6, 0x1379, 0x13BC, 0x1BFE, 0x143F, 0x141F, 0x13BD, 0x0B3B, 0x0AB8, 0x0A97, 0x037F, 0x039F, 0x037F, 0x037F,   // 0x0250 (592)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0xE8E4, 0xE8E4, 0xE8E4,   // 0x0260 (608)
+0x037F, 0x037F, 0x037F, 0x855A, 0xB61A, 0x9D79, 0x6C77, 0x6455, 0x5C35, 0x8BF4, 0xE8E4, 0x5251, 0x137A, 0x13DC, 0x13FE, 0x13DE,   // 0x0270 (624)
+0x137C, 0x0B19, 0x0AB8, 0x3233, 0xE8E5, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0280 (640)
+0x037F, 0x037F, 0x039F, 0x0B5F, 0x0B5E, 0xE8E4, 0xE105, 0xB96A, 0xE8E4, 0x037F, 0x037F, 0x855B, 0x857B, 0xA5D9, 0xCEDC, 0xFFFF,   // 0x0290 (656)
+0xFFFF, 0xFFFF, 0xE8E4, 0xFFDF, 0x341B, 0x13BC, 0x13FE, 0x13DE, 0x137C, 0x12F9, 0x0A97, 0x0A96, 0xE8E5, 0x037F, 0x037F, 0x037F,   // 0x02A0 (672)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7E, 0xE105, 0x037F, 0x037F,   // 0x02B0 (688)
+0xE8E4, 0xE0E5, 0x037F, 0x855B, 0xFFDF, 0xE8E4, 0xE8E4, 0xFFDF, 0xFFFF, 0xFFFF, 0xE8E4, 0xFFFF, 0x33FA, 0x12D8, 0xE8E4, 0xE8C4,   // 0x02C0 (704)
+0x12D7, 0x0AF9, 0x5211, 0xE8E4, 0xE8E4, 0xE8E5, 0x037F, 0x0B7E, 0xE8E4, 0xE8E4, 0x037E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x02D0 (720)
+0x037F, 0x037F, 0x037F, 0x0B7F, 0x0B5E, 0xE105, 0x037F, 0x037F, 0x0B7F, 0xE8C4, 0x0B7E, 0x853A, 0xE8E4, 0xFFDF, 0xFFDF, 0xE8E4,   // 0x02E0 (736)
+0x4B32, 0xFFFF, 0xE8C4, 0xFFDF, 0x4A52, 0xE8E4, 0x12D8, 0x12D8, 0xE8C4, 0x0A97, 0x2255, 0x1296, 0xE8C4, 0x037F, 0x0B7F, 0xE8C4,   // 0x02F0 (752)
+0x037F, 0x0B7E, 0xE8E4, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7E, 0xE8E5, 0x037F, 0x037F,   // 0x0300 (768)
+0x0B5F, 0xE8E4, 0x0B5E, 0x8539, 0xE8E4, 0xFFFF, 0xFFFF, 0xE8E4, 0x4B32, 0xFFFF, 0xE8E4, 0xFFFF, 0xFFDF, 0xE8E4, 0x239B, 0x13BD,   // 0x0310 (784)
+0xE8E4, 0x0A96, 0x0A97, 0x1296, 0xE8C5, 0x039F, 0x0B7E, 0xE8E4, 0x037F, 0x039F, 0xE8C4, 0x0B7F, 0x037F, 0x039F, 0x037F, 0x037F,   // 0x0320 (800)
+0x037F, 0x037F, 0x037F, 0x037F, 0x0B5E, 0xE8E5, 0x037F, 0x037F, 0x037F, 0xE8C4, 0x0B7F, 0x853A, 0xE8E4, 0xE8E4, 0xE8E4, 0xE8E4,   // 0x0330 (816)
+0x4B32, 0x4250, 0xE8E4, 0xFFDF, 0xFFFF, 0xE8C4, 0xE8E4, 0xE8E4, 0x1AB7, 0x1296, 0x0A97, 0x0A96, 0xE8E4, 0x037F, 0x037F, 0xE8E4,   // 0x0340 (832)
+0xE8E4, 0xE8C4, 0xE8E4, 0x035E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7F, 0x0B7E, 0xE105, 0x037F, 0x037F,   // 0x0350 (848)
+0xE8C4, 0xE8C4, 0x037F, 0x853A, 0xE8E4, 0x5353, 0x5332, 0x4B32, 0x4B32, 0x4230, 0xE8C4, 0xFFFF, 0xFFFF, 0xE8E4, 0x0AD8, 0x12D8,   // 0x0360 (864)
+0x12D8, 0x0AD8, 0x0A97, 0x0A96, 0xE8C5, 0x037F, 0x037F, 0xE8E4, 0x0B7E, 0x0B7F, 0x037F, 0x0B5F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0370 (880)
+0x037F, 0x037F, 0x039F, 0x037F, 0x0B5E, 0xE0E5, 0xE105, 0xE0E5, 0xE8E4, 0x0B5F, 0x037F, 0x855A, 0xE8C5, 0xFF1C, 0xCD97, 0xE8C5,   // 0x0380 (896)
+0x4B32, 0x3A2F, 0xE8E4, 0xFFFF, 0xFFFF, 0xE8E4, 0x12F8, 0x131A, 0xE8E4, 0x0A96, 0x0A97, 0x0A96, 0xE8E4, 0x037F, 0x037E, 0xE8E4,   // 0x0390 (912)
+0x037F, 0x037F, 0xE8E4, 0x0B7F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7E, 0xE8C4, 0xE8E4, 0xE8E4,   // 0x03A0 (928)
+0x035E, 0x037F, 0x037F, 0x855A, 0xB5D9, 0xE8E4, 0xF0C4, 0x12D7, 0x4B53, 0x424F, 0xE8E4, 0xE924, 0xFFFF, 0x12D7, 0xE8E4, 0xE8C4,   // 0x03B0 (944)
+0x12D8, 0x1296, 0x0A97, 0x0A96, 0xE8C4, 0xE8E4, 0x037F, 0x037F, 0xE8E4, 0xE8E4, 0x0B7E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x03C0 (960)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0xADFA, 0x5353, 0x5352, 0x4B53,   // 0x03D0 (976)
+0x4374, 0x4B32, 0x4B52, 0x8456, 0xFFFF, 0x12F8, 0x12F8, 0x12D8, 0x12D8, 0x0A97, 0x0AB7, 0x1A75, 0x0B7F, 0x037F, 0x037F, 0x037F,   // 0x03E0 (992)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x03F0 (1008)
+0x037F, 0x037F, 0x037F, 0x853B, 0xADFA, 0xD6DC, 0xFFFF, 0xFFFF, 0x5C36, 0xAE1A, 0xA5FA, 0x853A, 0xFFFF, 0xB67C, 0x23DB, 0x033A,   // 0x0400 (1024)
+0x0AD8, 0x0A97, 0x0AB7, 0x0A97, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0410 (1040)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0xAE1A, 0xB63A, 0xFFFF, 0xFFFF,   // 0x0420 (1056)
+0xFFDF, 0xEF9E, 0xFFFF, 0xFFFF, 0xFFFF, 0x8D9B, 0x1B5A, 0x1B79, 0x0AD9, 0x0A97, 0x0AD8, 0x0A97, 0x037F, 0x037F, 0x037F, 0x039F,   // 0x0430 (1072)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0440 (1088)
+0x037F, 0x037F, 0x037F, 0x855A, 0x855B, 0xA5D9, 0xB5F8, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x3333, 0x2B14, 0x2AF5,   // 0x0450 (1104)
+0x22B4, 0x12B5, 0x0A97, 0x0A97, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0460 (1120)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x853B, 0x855B, 0x7C74, 0x6BD0, 0x6390,   // 0x0470 (1136)
+0x42EF, 0x8CB4, 0xBDD7, 0xBDD6, 0x6413, 0x1A72, 0x1AB2, 0x1A51, 0x11EF, 0x11EF, 0x0A97, 0x0A97, 0x037E, 0x037F, 0x037F, 0x037F,   // 0x0480 (1152)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0490 (1168)
+0x037F, 0x039F, 0x037F, 0x855A, 0x855A, 0x6BD0, 0x6BD1, 0x5B8F, 0x42CE, 0x5B70, 0x7C31, 0x7C32, 0x2A6E, 0x224F, 0x2270, 0x1230,   // 0x04A0 (1184)
+0x0A10, 0x0A96, 0x0AB6, 0x0A97, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x04B0 (1200)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0x855B, 0x8C92, 0x73F1, 0x5B4E,   // 0x04C0 (1216)
+0x52CC, 0x424B, 0x320A, 0x21A8, 0x2188, 0x2167, 0x1126, 0x0907, 0x0908, 0x09AD, 0x2A2C, 0x0AD8, 0x039F, 0x037F, 0x037F, 0x037F,   // 0x04D0 (1232)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x04E0 (1248)
+0x037F, 0x037F, 0x037F, 0x855B, 0x855B, 0x8C51, 0x73AE, 0x73CF, 0x636E, 0x52CC, 0x3A2A, 0x29E9, 0x29A9, 0x2168, 0x1947, 0x1926,   // 0x04F0 (1264)
+0x1906, 0x2124, 0x18E3, 0x031B, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0500 (1280)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x857A, 0x7B8D, 0x31A6, 0x4208,   // 0x0510 (1296)
+0x52AA, 0x5ACC, 0x4A4A, 0x31A7, 0x2966, 0x2946, 0x2125, 0x2104, 0x18E3, 0x1061, 0x3184, 0x5C7A, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0520 (1312)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0530 (1328)
+0x037F, 0x037F, 0x037F, 0x039F, 0x6C99, 0x7B8C, 0x41E7, 0x3186, 0x3186, 0x3165, 0x2103, 0x1082, 0x1062, 0x1081, 0x1061, 0x1082,   // 0x0540 (1344)
+0x10A2, 0x3165, 0x83CD, 0x549C, 0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0550 (1360)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x035F, 0x0BBF, 0x6479, 0x7C52, 0x738D,   // 0x0560 (1376)
+0x630B, 0x5AA9, 0x4A27, 0x39C6, 0x39C6, 0x41E6, 0x5268, 0x62EA, 0x73AE, 0x8474, 0x547B, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F,   // 0x0570 (1392)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0580 (1408)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x13DF, 0x343D, 0x547B, 0x5C9A, 0x6CB8, 0x74B8, 0x74B8, 0x6CB8, 0x649A, 0x547C,   // 0x0590 (1424)
+0x2C1E, 0x0BBF, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05A0 (1440)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x035F,   // 0x05B0 (1456)
+0x035F, 0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05C0 (1472)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05D0 (1488)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05E0 (1504)
+0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05F0 (1520)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0600 (1536)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0610 (1552)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0620 (1568)
+0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0630 (1584)
+0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0640 (1600)
+};

_718/dom1.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: dom1.jpg
+// Time generated: 09.09.2018 15:00:45
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short dom1[0x1900] ={
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0010 (16)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0020 (32)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0030 (48)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0040 (64)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0050 (80)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xF7BE, 0xE71C,   // 0x0060 (96)
+0xDEFB, 0xDEFB, 0xDEFB, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C,   // 0x0070 (112)
+0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C,   // 0x0080 (128)
+0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE73C, 0xEF5D,   // 0x0090 (144)
+0xF79E, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00A0 (160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xDEFB, 0xC638, 0xCE59, 0xCE79, 0xDEFB,   // 0x00B0 (176)
+0xDEDB, 0xDEDB, 0xD6BA, 0xD6BA, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x00C0 (192)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x00D0 (208)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xCE79, 0xCE79,   // 0x00E0 (224)
+0xCE79, 0xD69A, 0xDEFB, 0xEF7D, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00F0 (240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xBDF7, 0xD69A, 0xE71C, 0xE73C, 0xE73C, 0xE73C,   // 0x0100 (256)
+0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0110 (272)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0120 (288)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0130 (304)
+0xE73C, 0xDEFB, 0xD69A, 0xCE59, 0xD69A, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0140 (320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xCE79, 0xCE59, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C,   // 0x0150 (336)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0160 (352)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0170 (368)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0180 (384)
+0xEF5D, 0xEF5D, 0xEF7D, 0xE73C, 0xDEDB, 0xC638, 0xD6BA, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xB596, 0xDEDB, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01A0 (416)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01B0 (432)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01C0 (448)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01D0 (464)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xD69A, 0xCE59, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01E0 (480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xC618, 0xE73C, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01F0 (496)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0200 (512)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0210 (528)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0220 (544)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xDEDB, 0xC638, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0230 (560)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xC638, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0240 (576)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0250 (592)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0260 (608)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0270 (624)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xDEDB, 0xC638, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0280 (640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xC638, 0xDEFB, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0290 (656)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02A0 (672)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02B0 (688)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02C0 (704)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xDEDB, 0xCE59, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x02D0 (720)
+0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0xDEDB, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02E0 (736)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02F0 (752)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0300 (768)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0310 (784)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xCE79, 0xD6BA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0320 (800)
+0xFFFF, 0xFFFF, 0xF79E, 0xCE79, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0330 (816)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0340 (832)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0350 (848)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0360 (864)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE71C, 0xC638, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0370 (880)
+0xFFFF, 0xFFFF, 0xDEFB, 0xD6BA, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0380 (896)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0390 (912)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03A0 (928)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03B0 (944)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xD69A, 0xD69A, 0xFFDF, 0xFFDF, 0xFFFF,   // 0x03C0 (960)
+0xFFFF, 0xF79E, 0xD6BA, 0xE71C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03D0 (976)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03E0 (992)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03F0 (1008)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0400 (1024)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE71C, 0xCE59, 0xEF5D, 0xFFDF, 0xFFFF,   // 0x0410 (1040)
+0xFFFF, 0xE71C, 0xD6BA, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0420 (1056)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0430 (1072)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0440 (1088)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0450 (1104)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xCE79, 0xDEDB, 0xFFDF, 0xFFDF,   // 0x0460 (1120)
+0xFFFF, 0xDEDB, 0xDEDB, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0470 (1136)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0480 (1152)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0490 (1168)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04A0 (1184)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xD6BA, 0xCE79, 0xF79E, 0xFFDF,   // 0x04B0 (1200)
+0xFFDF, 0xD6BA, 0xDEFB, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04C0 (1216)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04D0 (1232)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04E0 (1248)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04F0 (1264)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xDEFB, 0xCE59, 0xEF5D, 0xF7BE,   // 0x0500 (1280)
+0xFFDF, 0xD6BA, 0xE71C, 0xF79E, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0510 (1296)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D,   // 0x0520 (1312)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0530 (1328)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0540 (1344)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xE73C, 0xCE59, 0xE73C, 0xF7BE,   // 0x0550 (1360)
+0xF7BE, 0xD69A, 0xE71C, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0560 (1376)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0570 (1392)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0580 (1408)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0590 (1424)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xE71C, 0xF7BE,   // 0x05A0 (1440)
+0xF7BE, 0xCE79, 0xE73C, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x05B0 (1456)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x05C0 (1472)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x05D0 (1488)
+0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x05E0 (1504)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x05F0 (1520)
+0xF79E, 0xCE79, 0xE73C, 0xEF5D, 0xEF5D, 0xEF7D, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E,   // 0x0600 (1536)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0610 (1552)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C,   // 0x0620 (1568)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0630 (1584)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0640 (1600)
+0xF7BE, 0xCE79, 0xE73C, 0xEF5D, 0xE73C, 0xEF5D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0650 (1616)
+0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0660 (1632)
+0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0670 (1648)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0680 (1664)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0690 (1680)
+0xF7BE, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE,   // 0x06A0 (1696)
+0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x06B0 (1712)
+0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x06C0 (1728)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x06D0 (1744)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x06E0 (1760)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE,   // 0x06F0 (1776)
+0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D,   // 0x0700 (1792)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0710 (1808)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0720 (1824)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0730 (1840)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D,   // 0x0740 (1856)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0750 (1872)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0760 (1888)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0770 (1904)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0780 (1920)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0790 (1936)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07A0 (1952)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07B0 (1968)
+0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07C0 (1984)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x07D0 (2000)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07E0 (2016)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73D, 0xE73C,   // 0x07F0 (2032)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0800 (2048)
+0xE73D, 0xE73C, 0xE73D, 0xE73D, 0xEF3C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0810 (2064)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0820 (2080)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0830 (2096)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D,   // 0x0840 (2112)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0850 (2128)
+0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE73D, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0860 (2144)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0870 (2160)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0880 (2176)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE75D, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0890 (2192)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08A0 (2208)
+0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08B0 (2224)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x08C0 (2240)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08D0 (2256)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE75C, 0xE73D, 0xE73C,   // 0x08E0 (2272)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08F0 (2288)
+0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0900 (2304)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0910 (2320)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0920 (2336)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE75C, 0xE73D,   // 0x0930 (2352)
+0xE73D, 0xE75D, 0xEF5D, 0xE75D, 0xE77D, 0xEF7E, 0xEF7E, 0xEF7E, 0xE79E, 0xE79E, 0xE79E, 0xEF9E, 0xE7BE, 0xE7BE, 0xE7BF, 0xE7BF,   // 0x0940 (2368)
+0xE79F, 0xE7BF, 0xE79E, 0xEF3C, 0xE73C, 0xE73D, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0950 (2384)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0960 (2400)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0970 (2416)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF9E, 0xE7DF, 0xE7BF, 0xE7BF, 0xE7BF, 0xE79F, 0xE7BE, 0xE79F,   // 0x0980 (2432)
+0xE79E, 0xE79E, 0xE79E, 0xE77E, 0xDF5D, 0xDF3D, 0xDF1C, 0xDF1C, 0xDEFB, 0xDEDA, 0xE6BA, 0xDE99, 0xDE99, 0xE678, 0xE657, 0xDE37,   // 0x0990 (2448)
+0xE5F6, 0xDDD5, 0xE69A, 0xE77E, 0xEF3D, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x09A0 (2464)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x09B0 (2480)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x09C0 (2496)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xDE58, 0xE554, 0xE573, 0xE552, 0xE531, 0xE4F1, 0xE4D0, 0xE4AF,   // 0x09D0 (2512)
+0xE48E, 0xE46E, 0xE44D, 0xE40C, 0xE3EB, 0xE3AA, 0xE369, 0xEB49, 0xEB28, 0xEB07, 0xEAE7, 0xEAC6, 0xF2A6, 0xF285, 0xF265, 0xF264,   // 0x09E0 (2528)
+0xF243, 0xF1E3, 0xEB49, 0xDEDA, 0xE7BF, 0xEF3C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x09F0 (2544)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0A00 (2560)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0A10 (2576)
+0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xD6BB, 0x934B, 0xE1A0, 0xF1E1, 0xF1C1, 0xF9C1, 0xF9A0, 0xF9A0, 0xF9A0,   // 0x0A20 (2592)
+0xF980, 0xF980, 0xF980, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960,   // 0x0A30 (2608)
+0xF960, 0xF960, 0xF940, 0xE3AB, 0xDF5D, 0xE79E, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0A40 (2624)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0A50 (2640)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0A60 (2656)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0x9D14, 0x528A, 0xA9E3, 0xF940, 0xF980, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9A0,   // 0x0A70 (2672)
+0xF9A0, 0xF9A0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0A80 (2688)
+0xF9E0, 0xF9C0, 0xF9A0, 0xF180, 0xE44E, 0xDF9E, 0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE75C, 0xE73D, 0xE73D, 0xE73C, 0xE73C, 0xE73C,   // 0x0A90 (2704)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0AA0 (2720)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0AB0 (2736)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xCE79, 0x632D, 0x530C, 0x730B, 0xE203, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0AC0 (2752)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0AD0 (2768)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF1A1, 0xDD11, 0xE7BF, 0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C,   // 0x0AE0 (2784)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0AF0 (2800)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0B00 (2816)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0x8C71, 0x52AA, 0x632C, 0x9514, 0xDD11, 0xF180, 0xF9A0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0B10 (2832)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0B20 (2848)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF1E2, 0xDDB5, 0xE7BF, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C,   // 0x0B30 (2864)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0B40 (2880)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0B50 (2896)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xC618, 0x5AEB, 0x5AEB, 0x7BAE, 0xD6DB, 0xE73C, 0xE369, 0xF940, 0xF9C0, 0xF9E0, 0xF9C0,   // 0x0B60 (2912)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0B70 (2928)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF940, 0xEA64, 0xDE57, 0xE7BF, 0xE73C, 0xE73C, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0B80 (2944)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0B90 (2960)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0BA0 (2976)
+0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE71C, 0x8410, 0x5ACB, 0x632C, 0xA534, 0xEF5D, 0xDF5D, 0xD5F6, 0xF223, 0xF960, 0xF9C0, 0xF9C0,   // 0x0BB0 (2992)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0BC0 (3008)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF940, 0xEAE7, 0xDEDA, 0xEF9E, 0xE73D, 0xE75C, 0xE73C, 0xE73D, 0xE73C, 0xE73D,   // 0x0BD0 (3024)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0BE0 (3040)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0BF0 (3056)
+0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xAD75, 0x5ACB, 0x630C, 0x8410, 0xDEFB, 0xE73C, 0xDF1C, 0xDF5D, 0xDC8F, 0xF180, 0xF9A0, 0xF9E0,   // 0x0C00 (3072)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0C10 (3088)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF940, 0xE369, 0xE71C, 0xE79E, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73D,   // 0x0C20 (3104)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0C30 (3120)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0C40 (3136)
+0xE73C, 0xE73C, 0xEF5D, 0xDEDB, 0x738E, 0x5AEB, 0x6B4D, 0xBDB7, 0xEF5D, 0xDEFB, 0xE6DB, 0xE75D, 0xD6DA, 0xE328, 0xF960, 0xF9C0,   // 0x0C50 (3152)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0C60 (3168)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF940, 0xDC0D, 0xE75D, 0xE75D, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0C70 (3184)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0C80 (3200)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0C90 (3216)
+0xE73C, 0xE73C, 0xEF7D, 0x9CF3, 0x5ACB, 0x630C, 0x8C71, 0xE73C, 0xE71B, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF7E, 0xDDB4, 0xF203, 0xF960,   // 0x0CA0 (3232)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0CB0 (3248)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF961, 0xE4D0, 0xE77E, 0xE75D, 0xE73C, 0xE73C, 0xE73D,   // 0x0CC0 (3264)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0CD0 (3280)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0CE0 (3296)
+0xE73C, 0xEF5D, 0xCE79, 0x632C, 0x630C, 0x6B6D, 0xC638, 0xE73C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFC, 0xE71C, 0xD75D, 0xDC2D, 0xF180,   // 0x0CF0 (3312)
+0xF9A0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0D00 (3328)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF1C0, 0xDD73, 0xE79E, 0xE75D, 0xE73C, 0xE73D,   // 0x0D10 (3344)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0D20 (3360)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0D30 (3376)
+0xE73C, 0xEF5D, 0x8C51, 0x5AEB, 0x632C, 0x9CD3, 0xEF5D, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF5D, 0xD699, 0xEAE7,   // 0x0D40 (3392)
+0xF960, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0D50 (3408)
+0xF9E0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF202, 0xDE17, 0xEF7E, 0xE75C, 0xE73D,   // 0x0D60 (3424)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0D70 (3440)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0D80 (3456)
+0xEF7D, 0xBDD7, 0x5AEB, 0x630C, 0x73AE, 0xD69A, 0xE73C, 0xDEFB, 0xDEFC, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFC, 0xE6DB, 0xDF7E, 0xDD73,   // 0x0D90 (3472)
+0xF202, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0DA0 (3488)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF960, 0xEA84, 0xDE99, 0xE77D, 0xE73C,   // 0x0DB0 (3504)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0DC0 (3520)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D,   // 0x0DD0 (3536)
+0xDEFB, 0x73AE, 0x5AEB, 0x630C, 0xAD75, 0xEF5D, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF1C, 0xD75D,   // 0x0DE0 (3552)
+0xE3EC, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0DF0 (3568)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF920, 0xE2E7, 0xE6BA, 0xE75D,   // 0x0E00 (3584)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0E10 (3600)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D,   // 0x0E20 (3616)
+0xCE79, 0x94B2, 0x9492, 0x8C51, 0xD6BA, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFC, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF7D,   // 0x0E30 (3632)
+0xD679, 0xEAA5, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9E0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0,   // 0x0E40 (3648)
+0xF9C0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9C1, 0xF1E1, 0xE9E1, 0xE1E2, 0xD1E2, 0xDB27, 0xE3AB, 0xDE17, 0xE75D,   // 0x0E50 (3664)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0E60 (3680)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0E70 (3696)
+0xEF5D, 0xF79E, 0xF79E, 0xCE79, 0xCE59, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF1C, 0xDF1C, 0xDF1C, 0xE71B, 0xDEFC, 0xDEFB, 0xDEFB,   // 0x0E80 (3712)
+0xDF9E, 0xDD12, 0xF1C1, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9C0, 0xF9C1,   // 0x0E90 (3728)
+0xF1E2, 0xEA02, 0xE243, 0xDA84, 0xDAC6, 0xCB08, 0xBB6B, 0xABCD, 0xA40F, 0x9C70, 0x9CB2, 0x8472, 0xCEBB, 0xE7BF, 0xE75D, 0xE73C,   // 0x0EA0 (3744)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0EB0 (3760)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0EC0 (3776)
+0xE73C, 0xE73C, 0xE73C, 0xCE59, 0xCE59, 0xE71C, 0xDEFB, 0xDEFB, 0xDEDB, 0xDE79, 0xDEBA, 0xDEDB, 0xDEFC, 0xDF1B, 0xDEFB, 0xDEFB,   // 0x0ED0 (3792)
+0xE71C, 0xD75D, 0xE3AB, 0xF180, 0xF9A0, 0xF9A0, 0xF9C0, 0xF1C1, 0xF1E2, 0xEA02, 0xE243, 0xDA85, 0xD2E7, 0xCB29, 0xBB8B, 0xB3ED,   // 0x0EE0 (3808)
+0xAC50, 0xACB2, 0xA514, 0x9D55, 0x9D76, 0x9D96, 0x9D97, 0xA5B7, 0xA596, 0xAD96, 0xA576, 0x9CF3, 0xD6BB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0EF0 (3824)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0F00 (3840)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0F10 (3856)
+0xE73C, 0xEF3D, 0xEF5D, 0xCE59, 0xCE59, 0xE73C, 0xDEFB, 0xDF3C, 0xDE37, 0xE2A6, 0xEAA6, 0xE34A, 0xDCB1, 0xDEDA, 0xDF1C, 0xDEFC,   // 0x0F20 (3872)
+0xE6DB, 0xDF5E, 0xD657, 0xD2C7, 0xCAA6, 0xC349, 0xBBAB, 0xB3ED, 0xAC50, 0xA4B1, 0xA513, 0x9D55, 0x9D76, 0x9D97, 0x9D97, 0x9DB7,   // 0x0F30 (3888)
+0xAD96, 0xA596, 0xA575, 0xA555, 0xA555, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA534, 0xA534, 0x9CD3, 0xDEDB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0F40 (3904)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0F50 (3920)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0F60 (3936)
+0xE73C, 0xE73D, 0xEF5D, 0xCE79, 0xC638, 0xE71C, 0xDEFB, 0xDF3D, 0xDE37, 0xF202, 0xF900, 0xF8C0, 0xEAC7, 0xD6BB, 0xE73D, 0xDEFB,   // 0x0F70 (3952)
+0xDEFB, 0xE71B, 0xDF1C, 0x9D14, 0x9D35, 0x9D97, 0x9D96, 0x9D97, 0xA5B7, 0xA5B6, 0xAD96, 0xAD75, 0xAD55, 0xAD34, 0xAD34, 0xAD55,   // 0x0F80 (3968)
+0xAD55, 0xA534, 0xAD55, 0xAD34, 0xAD35, 0xA514, 0x9492, 0x8C51, 0x94B2, 0xA534, 0xA534, 0x9CF3, 0xDEFB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0F90 (3984)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0FA0 (4000)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0FB0 (4016)
+0xE73C, 0xE73C, 0xEF5D, 0xCE79, 0xC618, 0xE73C, 0xDEFB, 0xDF3D, 0xDE58, 0xEA85, 0xF980, 0xF960, 0xEB48, 0xDEFB, 0xDF3D, 0xDEFB,   // 0x0FC0 (4032)
+0xDEFC, 0xE71B, 0xDEDB, 0x9D14, 0xA534, 0xAD54, 0xAD34, 0xAD34, 0x9CD3, 0x94B2, 0x9492, 0x8C51, 0xA514, 0xAD55, 0xA535, 0x8C72,   // 0x0FD0 (4048)
+0x8430, 0x840F, 0x8C50, 0xA534, 0xB596, 0x8C71, 0x630C, 0x52AA, 0x7BEF, 0xAD55, 0xA514, 0xA514, 0xDEFB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0FE0 (4064)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0FF0 (4080)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x1000 (4096)
+0xE73C, 0xE73D, 0xEF5D, 0xD69A, 0xBDD7, 0xE73C, 0xDEFB, 0xDF3D, 0xDE79, 0xEAA5, 0xF940, 0xF960, 0xEB49, 0xDEDB, 0xDF3C, 0xDEFB,   // 0x1010 (4112)
+0xDEFB, 0xE71C, 0xD6BB, 0x9CF3, 0xA514, 0xAD55, 0xAD55, 0xA515, 0x6B6D, 0x632C, 0x630C, 0x5AEB, 0x94B2, 0xAD75, 0x9CF3, 0x6B4C,   // 0x1020 (4128)
+0x5AEB, 0x5ACB, 0x738E, 0xA534, 0xB596, 0x8C51, 0x630C, 0x5AEB, 0x8430, 0xAD55, 0x9CF3, 0xAD55, 0xE71C, 0xEF5D, 0xE73C, 0xE73C,   // 0x1030 (4144)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1040 (4160)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x1050 (4176)
+0xE73C, 0xE73C, 0xE73C, 0xD69A, 0xB5B7, 0xE73C, 0xDEFB, 0xDF3C, 0xDE99, 0xE285, 0xF8E0, 0xF900, 0xEB28, 0xDEFC, 0xDF3D, 0xDEFB,   // 0x1060 (4192)
+0xDEFB, 0xE71C, 0xD6BA, 0x9CF3, 0xA514, 0xAD55, 0xA554, 0xA514, 0x632D, 0x630C, 0x632C, 0x632C, 0x9CD2, 0xAD75, 0x9CF3, 0x6B4D,   // 0x1070 (4208)
+0x630C, 0x630C, 0x7BCF, 0xAD55, 0xAD75, 0x8410, 0x5AEB, 0x5AEB, 0x8C71, 0xAD75, 0x9CD3, 0xB5B6, 0xE73C, 0xEF5D, 0xE73C, 0xE73C,   // 0x1080 (4224)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1090 (4240)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x10A0 (4256)
+0xE73C, 0xE73C, 0xE73C, 0xD6BA, 0xB5B6, 0xE73C, 0xDEFB, 0xDF1C, 0xDEFA, 0xDC90, 0xEAC8, 0xEA04, 0xE38B, 0xDEDB, 0xDF3D, 0xDEFB,   // 0x10B0 (4272)
+0xDEFB, 0xE73D, 0xD679, 0x9CF3, 0xA534, 0xAD55, 0xA534, 0xA514, 0x6B4D, 0x632C, 0x632C, 0x6B4D, 0x9CF3, 0xAD55, 0x9CF3, 0x6B4D,   // 0x10C0 (4288)
+0x630B, 0x630C, 0x7BCF, 0xAD75, 0xAD55, 0x73AE, 0x5ACB, 0x632C, 0x94B2, 0xAD75, 0x9CD3, 0xBDD7, 0xE73C, 0xEF5D, 0xE73C, 0xE73C,   // 0x10D0 (4304)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x10E0 (4320)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x10F0 (4336)
+0xE73C, 0xE73C, 0xE75D, 0xDEDB, 0xB5B6, 0xE73C, 0xDEFB, 0xDEFC, 0xDEFC, 0xDF3C, 0xD6BA, 0xDDF6, 0xDDF7, 0xDEFB, 0xDEFC, 0xDEFB,   // 0x1100 (4352)
+0xDEFB, 0xE73C, 0xCE79, 0x9CD3, 0xA514, 0xAD34, 0xAD55, 0xA514, 0x6B4D, 0x632C, 0x630C, 0x634C, 0xA514, 0xAD75, 0x9CF3, 0x632C,   // 0x1110 (4368)
+0x632C, 0x630B, 0x7BCF, 0xAD75, 0xA534, 0x8C51, 0x8430, 0x9492, 0xA534, 0xAD55, 0x94B2, 0xC638, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C,   // 0x1120 (4384)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1130 (4400)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x1140 (4416)
+0xE73C, 0xEF5D, 0xEF7D, 0xDEFB, 0xB596, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF1C, 0xDF5D, 0xDF7E, 0xDF5D, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x1150 (4432)
+0xDEFB, 0xE73D, 0xCE58, 0x9CF4, 0xA534, 0xA534, 0xAD35, 0x9D13, 0x630C, 0x630C, 0x630C, 0x6B6D, 0xA534, 0xAD55, 0x9CD3, 0x632C,   // 0x1160 (4448)
+0x632C, 0x630C, 0x7BEF, 0xAD55, 0xAD55, 0xAD55, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0x9492, 0xB5B6, 0xE71C, 0xEF7D, 0xEF5D, 0xE73C,   // 0x1170 (4464)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1180 (4480)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D,   // 0x1190 (4496)
+0xEF7D, 0xE73C, 0xD6BA, 0xBDD7, 0xAD75, 0xEF5D, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x11A0 (4512)
+0xDEFB, 0xE73C, 0xC638, 0xA514, 0xA534, 0xA534, 0xAD55, 0xA514, 0x8410, 0x8C51, 0x9492, 0x9CD3, 0xA534, 0xAD55, 0x94B2, 0x632C,   // 0x11B0 (4528)
+0x630C, 0x632C, 0x8410, 0xAD75, 0xAD75, 0xAD55, 0xA534, 0x9CF3, 0x9CD3, 0x9CD3, 0x8C71, 0x9CF3, 0xB596, 0xC638, 0xDEDB, 0xEF5D,   // 0x11C0 (4544)
+0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x11D0 (4560)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xE71C,   // 0x11E0 (4576)
+0xCE79, 0xBDD7, 0xAD75, 0xA514, 0x9CF3, 0xD6BA, 0xE71C, 0xE73C, 0xE73C, 0xE73C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x11F0 (4592)
+0xDEFB, 0xE73C, 0xC618, 0x9CF3, 0xA534, 0xA534, 0xA534, 0xA534, 0xAD55, 0xAD55, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0x94B2, 0x630C,   // 0x1200 (4608)
+0x630C, 0x5AEB, 0x7BEF, 0xA514, 0x94B2, 0x9492, 0x94B2, 0x94B2, 0x9CD3, 0x9CF3, 0xA514, 0xA534, 0xA534, 0xA534, 0xAD75, 0xC618,   // 0x1210 (4624)
+0xDEDB, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1220 (4640)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xE73C, 0xCE59, 0xB5B6,   // 0x1230 (4656)
+0xAD55, 0xA534, 0xA534, 0xAD55, 0x9CF3, 0xA514, 0xA534, 0xB5B6, 0xC638, 0xD6BA, 0xE71C, 0xEF5D, 0xE73C, 0xE71C, 0xDEFB, 0xDEFB,   // 0x1240 (4672)
+0xDEFB, 0xEF5D, 0xBDF7, 0x9CF3, 0xA534, 0xAD55, 0xA534, 0xA534, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0x8C51, 0x52AA,   // 0x1250 (4688)
+0x632C, 0x6B4D, 0x8410, 0x9CF3, 0x9CD3, 0x9CF3, 0xA514, 0xA534, 0xAD55, 0xAD55, 0xAD75, 0xAD55, 0xAD55, 0xA534, 0xA534, 0xA534,   // 0x1260 (4704)
+0xAD75, 0xBDF7, 0xDEFB, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1270 (4720)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xE73C, 0xCE79, 0xB5B6, 0xAD55, 0xA534,   // 0x1280 (4736)
+0xA534, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xA514, 0xA514, 0x9CF3, 0x9CF3, 0xA514, 0xAD55, 0xB5B6, 0xC638, 0xDEDB, 0xE71C, 0xE73C,   // 0x1290 (4752)
+0xE73C, 0xEF5D, 0xBDD7, 0x9CF3, 0xA534, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA514, 0x9CD3, 0x94B2, 0x9492, 0x94B2, 0x9492, 0x8C51,   // 0x12A0 (4768)
+0x9CD3, 0xA514, 0xA534, 0xAD55, 0xAD55, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55,   // 0x12B0 (4784)
+0xA534, 0xA534, 0xB596, 0xCE59, 0xE73C, 0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEDB, 0xF79E,   // 0x12C0 (4800)
+0xF79E, 0xCE79, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xD6BA, 0xBDD7, 0xAD55, 0xA534, 0xA534, 0xAD55,   // 0x12D0 (4816)
+0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA534, 0xA514, 0x9CF3, 0xA514, 0xA514, 0xA534, 0xB5B6,   // 0x12E0 (4832)
+0xCE59, 0xE71C, 0xB5B6, 0xA514, 0xA514, 0x9CF3, 0x9CD3, 0x9492, 0x9492, 0x94B2, 0x9CD3, 0x9CF3, 0xA514, 0xA534, 0xAD55, 0xAD75,   // 0x12F0 (4848)
+0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55,   // 0x1300 (4864)
+0xAD55, 0xAD55, 0xA534, 0xAD55, 0xBDD7, 0xDEDB, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1310 (4880)
+0xF7BE, 0xD6BA, 0xE71C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xE73C, 0xC638, 0xAD75, 0xAD55, 0xAD55, 0xAD75, 0xAD75, 0xAD75,   // 0x1320 (4896)
+0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA514,   // 0x1330 (4912)
+0xA514, 0xA514, 0x9492, 0x8C71, 0x9492, 0x94B2, 0x9CF3, 0xA514, 0xA534, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75,   // 0x1340 (4928)
+0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75,   // 0x1350 (4944)
+0xAD55, 0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xB596, 0xCE79, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1360 (4960)
+0xF7BE, 0xD6BA, 0xE71C, 0xEF7D, 0xE73C, 0xEF5D, 0xEF7D, 0xDEDB, 0xBDD7, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75,   // 0x1370 (4976)
+0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB596, 0xB596, 0xB596, 0xB596, 0xAD75,   // 0x1380 (4992)
+0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xAD75, 0xAD75, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xAD75, 0xAD75, 0xAD75,   // 0x1390 (5008)
+0xAD75, 0xB596, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xAD75,   // 0x13A0 (5024)
+0xAD75, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xB596, 0xC638, 0xE73C, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x13B0 (5040)
+0xFFDF, 0xDEDB, 0xE71C, 0xEF7D, 0xEF7D, 0xEF5D, 0xCE59, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB5B6, 0xB596, 0xB596,   // 0x13C0 (5056)
+0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596,   // 0x13D0 (5072)
+0xB596, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596,   // 0x13E0 (5088)
+0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596,   // 0x13F0 (5104)
+0xB596, 0xB5B6, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xC618, 0xE73C, 0xEF7D, 0xEF7D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1400 (5120)
+0xFFDF, 0xDEDB, 0xDEFB, 0xF79E, 0xE71C, 0xC618, 0xB596, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1410 (5136)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1420 (5152)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1430 (5168)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1440 (5184)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xBDF7, 0xDEFB, 0xF79E, 0xE71C, 0xCE59, 0xE71C, 0xEF7D,   // 0x1450 (5200)
+0xFFFF, 0xDEFB, 0xDEDB, 0xE71C, 0xBDF7, 0xB5B6, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1460 (5216)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1470 (5232)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1480 (5248)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1490 (5264)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xB5B6, 0xC618, 0xE71C, 0xDEFB, 0xCE59, 0xE73C, 0xEF7D,   // 0x14A0 (5280)
+0xFFFF, 0xEF5D, 0xC618, 0xC618, 0xBDD7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14B0 (5296)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14C0 (5312)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14D0 (5328)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14E0 (5344)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDD7, 0xC638, 0xC638, 0xD69A, 0xEF5D, 0xEF7D,   // 0x14F0 (5360)
+0xFFFF, 0xF7BE, 0xC638, 0xBDF7, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1500 (5376)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1510 (5392)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1520 (5408)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1530 (5424)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xBDD7, 0xBDD7, 0xDEFB, 0xEF5D, 0xEF7D,   // 0x1540 (5440)
+0xFFFF, 0xFFFF, 0xD6BA, 0xBDF7, 0xC638, 0xC618, 0xC618, 0xC638, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1550 (5456)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1560 (5472)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1570 (5488)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1580 (5504)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xB5B6, 0xC638, 0xE73C, 0xEF5D, 0xF79E,   // 0x1590 (5520)
+0xFFFF, 0xFFFF, 0xEF7D, 0xBDF7, 0xC638, 0xCE59, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15A0 (5536)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15B0 (5552)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15C0 (5568)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15D0 (5584)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xCE59, 0xC618, 0xB5B6, 0xD69A, 0xEF5D, 0xEF7D, 0xF7BE,   // 0x15E0 (5600)
+0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0xC618, 0xCE79, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x15F0 (5616)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1600 (5632)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1610 (5648)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1620 (5664)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xB5B6, 0xC618, 0xE71C, 0xEF5D, 0xEF7D, 0xFFDF,   // 0x1630 (5680)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xC618, 0xC638, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1640 (5696)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1650 (5712)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1660 (5728)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1670 (5744)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xBDD7, 0xBDD7, 0xDEDB, 0xE73C, 0xEF5D, 0xF7BE, 0xFFDF,   // 0x1680 (5760)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xBDF7, 0xCE79, 0xD69A, 0xD69A, 0xD69A, 0xCE79, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x1690 (5776)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16A0 (5792)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16B0 (5808)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16C0 (5824)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xCE79, 0xBDF7, 0xB5B6, 0xD69A, 0xE73C, 0xE73C, 0xEF7D, 0xF7BE, 0xFFFF,   // 0x16D0 (5840)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xBDF7, 0xCE79, 0xD6BA, 0xD6BA, 0xD6BA, 0xD69A, 0xD69A, 0xD6BA, 0xD69A, 0xD69A,   // 0x16E0 (5856)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16F0 (5872)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x1700 (5888)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x1710 (5904)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD6BA, 0xDEDB, 0xCE79, 0xBDD7, 0xB596, 0xD69A, 0xE73C, 0xE73C, 0xEF7D, 0xF7BE, 0xFFDF, 0xFFFF,   // 0x1720 (5920)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xC618, 0xCE59, 0xD6BA, 0xDEDB, 0xDEDB, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1730 (5936)
+0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1740 (5952)
+0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1750 (5968)
+0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1760 (5984)
+0xD6BA, 0xD6BA, 0xDEDB, 0xDEDB, 0xD6BA, 0xCE59, 0xB5B6, 0xB5B6, 0xD69A, 0xE73C, 0xE73C, 0xEF5D, 0xF79E, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x1770 (6000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xC638, 0xC638, 0xD69A, 0xDEDB, 0xDEFB, 0xDEFB, 0xDEDB, 0xDEDB,   // 0x1780 (6016)
+0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB,   // 0x1790 (6032)
+0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB,   // 0x17A0 (6048)
+0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEFB,   // 0x17B0 (6064)
+0xDEFB, 0xDEFB, 0xDEDB, 0xD69A, 0xC618, 0xB596, 0xBDF7, 0xDEDB, 0xE73C, 0xE73C, 0xEF5D, 0xF79E, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x17C0 (6080)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF79E, 0xD6BA, 0xC618, 0xC638, 0xCE79, 0xD6BA, 0xDEDB, 0xDEFB,   // 0x17D0 (6096)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x17E0 (6112)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x17F0 (6128)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEDB,   // 0x1800 (6144)
+0xD6BA, 0xCE79, 0xBDF7, 0xB5B6, 0xBDD7, 0xCE79, 0xDEFB, 0xE73C, 0xE73C, 0xEF7D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1810 (6160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xEF5D, 0xD6BA, 0xC638, 0xC618, 0xC618, 0xC638,   // 0x1820 (6176)
+0xCE59, 0xC638, 0xC638, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xC638, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1830 (6192)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1840 (6208)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xC638, 0xC618, 0xBDF7,   // 0x1850 (6224)
+0xBDD7, 0xB5B6, 0xC618, 0xCE79, 0xDEFB, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1860 (6240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF79E, 0xEF5D, 0xDEFB, 0xD6BA, 0xCE79,   // 0x1870 (6256)
+0xCE59, 0xCE59, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x1880 (6272)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x1890 (6288)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xCE59, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xCE59,   // 0x18A0 (6304)
+0xD69A, 0xDEDB, 0xE71C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18B0 (6320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF7BE, 0xF79E, 0xEF7D, 0xEF7D,   // 0x18C0 (6336)
+0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x18D0 (6352)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x18E0 (6368)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x18F0 (6384)
+0xEF5D, 0xEF5D, 0xE73C, 0xEF5D, 0xEF5D, 0xF79E, 0xF7BE, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1900 (6400)
+};

_718/dtu21.ino

@@ -0,0 +1,101 @@
+void dtu21()
+{ //Set the address of the HTU21D. This detail is hidden at the bototm of page 10 of the datasheet.
+ const int I2C_address = 0x40; // I2C write address. Note that 'const' has been declared. If you try to write to this variable
+ // anywhere else in your code you'll get a compilation error. This prevents you from doing silly things. 
+ 
+ const int TempCode = 0xE3; // A temperature measurement is executed with this command code. See page 11 of datasheet.
+ const int HumidCode = 0xE5; // A humidity measurement is executed with this command code. See page 11 of datasheet.
+ 
+ long Temperature; //Perform our calculation using LONG to prevent overflow at high measuremetn values when using 14bit mode.
+ long Humidity; 
+ 
+ float TemperatureFL; //Variable to store our final calculated temperature measurement
+ float HumidityFL; 
+ 
+ delay(100); // a short delay to let everything stabilise
+ 
+
+ delay(10); //add a small delay to slow things down
+ 
+ RequestMeas(I2C_address, TempCode); //Request the current temperature
+ Temperature = ReadMeas(I2C_address); //read the result
+ 
+ //We must now convert our temp measurement into an actual proper temperature value
+ //According to page 15, the conversion equation is: Temp = -46.85 + 175.72 x TeampMeas / 2^16
+ //Becasue the result will have decimal places in the result we must use a Float datatype.
+// TemperatureFL = (Temperature/65536.0)*175.72-46.85 ; 
+  TemperatureFL = (Temperature/65536.0)*175.72-46.85-1.1 ; 
+ 
+ delay(100); //add a small delay to slow things down
+ 
+ RequestMeas(I2C_address, HumidCode); //Request the current humidity
+ Humidity = ReadMeas(I2C_address); //read the result
+ 
+ //We must now convert our humidity measurement into an actual proper humidity value
+ //According to page 15, the conversion equation is: Humidity = 6 + 125 x TeampMeas / 2^16
+ //Becasue the result will have decimal places in the result we must use a Float datatype.
+ //HumidityFL = -6 + 125*(Humidity/pow(2, 16)); 
+ HumidityFL =(Humidity/65536.0)*125.0-6.0; 
+ 
+ 
+  tdc=TemperatureFL;
+ tdd=abs(TemperatureFL*10-tdc*10);
+  hdc=HumidityFL;
+ hdd=HumidityFL*10-hdc*10;
+ if(hdc>99)
+ {hdc=99;
+ hdd=9;
+ }
+
+  
+ 
+}
+
+void RequestMeas(int Address, int CommandCode)
+{
+ Wire.beginTransmission(Address); // The HTU21D will respond to its address
+ Wire.write(CommandCode); // request the measurement, ie temperature or humidity
+ Wire.endTransmission();
+ return;
+}
+ 
+long ReadMeas(int Address)
+{
+ //A measurement from the HTU21D is returned in 3 consecutive bytes. See page 11 of the datasheet
+ //the order of returend data is: [DATA (Most Sig Byte)], [DATA (Least Sig Byte)], [Checksum]
+ //We will ignore the checksum to save computation time and complexity. Page 14 of the datasheet details how to calculate the checksum
+ 
+ byte DataHIGH; //The location to store the high measurement byte
+ byte DataLOW; //The low measurement byte
+ byte CRC; //If you want to compute the CRC feel free to do so.
+ 
+ long Data; //The temporary memory location we are storing our data in as we receive it from the HTU21D
+ //Each packet of data is only 8bits in length, but if we do a bit shift we can store the 2 packets of
+ //measurement data in a variable. Remember you can only return 1 variable when a function finishes.
+ //Ideally, we'd use an int to store the result, however, at high measurement values in 14bit mode, an int overflows.
+ //To prevent overflow, we must use a single long (32bits). 
+ 
+ Wire.requestFrom(Address, 3); //We are requesting data from the HTU21D and there will be 3x bytes that must be read.
+ while(Wire.available()) // Check for data from the HTU21D
+ {
+ DataHIGH = Wire.read(); // Read high byte
+ DataLOW = Wire.read(); // Read low byte
+ CRC = Wire.read(); // Read the CRC byte
+ } 
+ 
+ //OK, so now we are going to 'pack' our 2x bytes of data measuremetns into a single int so only 1 variable is returned.
+ //To do this, we will use the left bitshift operator '<<'. What this does is push all the bits across to the left.
+ //FUN FACT: performing a left bit shift is equivalent to multiplication by 2 for each shift. The reverse is true for right
+ //bitshift which is equivalent to dividing by 2. This is a far more efficient method to perform multiply or divide by 2.
+ 
+ Data = DataHIGH; //The data sits in the low byte of 'int Data'.
+ //Ie, Data = [00000000][00000000][00000000][8 bits of DataHIGH]
+ //data[1] << 8
+ //Data = Data << 8; //Shift all the bits to the left for 8 bits. The old locations fill with zeros.
+ Data = Data<<8;
+ //Ie, Data = [00000000][00000000][8 bits of DataHIGH][00000000]
+ Data = Data + DataLOW; //Now simply add the low byte of data to the int.
+ //Ie, Data = [00000000][00000000][8 bits of DataHIGH][8 bits of DataLOW]
+ 
+ return Data; //return our measurement.
+}

_718/fileread.ino

@@ -0,0 +1,124 @@
+void readfile()
+{w=0;
+bufer="";
+int a=0,b=0;
+byte st=0;
+int cardSize;
+
+   myGLCD.setColor(22,18,70); 
+
+   myGLCD.fillRoundRect (380,145, 630, 475);
+ myGLCD.setColor(VGA_WHITE); 
+  myGLCD.drawRoundRect (380,145, 630, 475); 
+  
+
+myGLCD.setFont(SmallFont);
+ myGLCD.setColor(255,255,255);
+    myGLCD.setBackColor(0,38,92);
+
+
+
+  myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+     
+
+  clc();
+  
+   myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE);
+
+  sd.chdir("/");
+  delay(100);
+ myFile.open(name, O_READ);
+cardSize=myFile.fileSize();
+// myGLCD.print("cardSize=",10,10);
+// myGLCD.printNumI(cardSize,10,30);
+ st=0;
+ w=0;
+for (int i=0 ; i < cardSize; i = i++)
+{       char ByteRead=myFile.read();  //чтение данных с порта
+            if (ByteRead==char(13))//окончание строки 
+            {  analyzer();   //передача данных на обработку
+             myFile.read();
+                bufer="";
+                st=0;
+              } 
+            else {
+              bufer=bufer+char(ByteRead);
+                  st++;
+                 if(st>28)
+                 {st=0;
+                   analyzer();
+                    bufer="";
+                      }
+ }   ///накопление данных в буфер
+ if (fcl==1)
+ {fcl=0;
+ goto clos;
+ }
+ 
+ }
+ analyzer();   //передача данных на обработку
+clos:
+  myFile.close();
+  
+  myGLCD.setColor(22,18,70); 
+  myGLCD.setBackColor(VGA_WHITE); 
+  myGLCD.print("    pres  exit  to return  ",393,463);
+    myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE); 
+
+}
+
+//**************************************************************************
+
+
+
+
+void analyzer()
+{ myGLCD.setFont(SmallFont);
+  myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE); 
+  
+  w++;
+myGLCD.print(bufer,385,147-12+12*w);
+delay(100);
+boolean b=0;
+if(w>25)
+{w=0;
+  myGLCD.setColor(22,18,70); 
+  myGLCD.setBackColor(VGA_WHITE); 
+  myGLCD.print("   pres touch to continion  ",393,463);
+    myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE); 
+ while(b<1)
+{delay(200);
+   if (myTouch.dataAvailable()) 
+{  
+   myTouch.read();
+     int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+        if ((x>=380) && (x<=630))  // open
+      { 
+            if ((y>=150) && (y<=470))  // 640, 240,  680, 280); //open
+      
+     { b=2;
+       myGLCD.setColor(22,18,70); 
+
+   myGLCD.fillRoundRect (380,145, 630, 475);
+ myGLCD.setColor(VGA_WHITE); 
+  myGLCD.drawRoundRect (380,145, 630, 475); 
+     }
+      }
+      
+      if ((x<380) || (x>630))  // open
+    {fcl=1;
+      b=2;
+    }
+}
+}
+
+
+}
+}

_718/flr.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: flr.jpg
+// Time generated: 09.09.2015 19:21:28
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short flr[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00D0 (208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001E, 0x18FB, 0x52DA, 0x94DD, 0xBDFF, 0xB5DF, 0xADBF, 0xB5DE, 0xB5DF, 0xADBE, 0xADBE, 0xB5BF, 0xAD9E, 0xAD9E, 0xB5DF, 0xB5DF,   // 0x0110 (272)
+0xB5BF, 0xAD9F, 0xADBE, 0x9D7D, 0xB5DF, 0xADBF, 0xADBF, 0xAD9E, 0xA55E, 0xB5DF, 0xB5DF, 0xA55D, 0xAD7E, 0xAD5D, 0xA55E, 0xA57E,   // 0x0120 (288)
+0xB5BF, 0xADDF, 0xADDF, 0xADBF, 0xADBE, 0xB5BE, 0xB5BE, 0xB5BF, 0xB5DF, 0xB5DE, 0xBDFF, 0xAD9D, 0x6BBC, 0x299C, 0x001E, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31DC,   // 0x0150 (336)
+0x94BD, 0xC65E, 0xCEBD, 0xC69C, 0xCEDD, 0xCEDD, 0xCEBD, 0xC69D, 0xC6BC, 0xC6DC, 0xC6DB, 0xC6BC, 0xCEBC, 0xCEBD, 0xCEBD, 0xCEDD,   // 0x0160 (352)
+0xC6BC, 0xCE9C, 0xCEDD, 0xC69C, 0xCEBD, 0xCEDD, 0xC69C, 0xCEBC, 0xCE7C, 0xCEBC, 0xD6DC, 0xC69B, 0xCEBB, 0xCEBB, 0xCE9B, 0xCEBC,   // 0x0170 (368)
+0xCEBD, 0xC6DD, 0xC6BD, 0xC6BC, 0xCEBC, 0xCE9C, 0xCEBC, 0xCEBC, 0xC6DC, 0xCEDC, 0xD6FD, 0xD71D, 0xD6DC, 0xBE3C, 0x9D3D, 0x425D,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x633C, 0xBE3D,   // 0x01A0 (416)
+0xCEBC, 0xCEBC, 0xCEDD, 0xC69D, 0xC6BD, 0xC6BD, 0xC69D, 0xC6BD, 0xBEBC, 0xBEBB, 0xBEBB, 0xC6BB, 0xC6BC, 0xC69C, 0xC69C, 0xC69C,   // 0x01B0 (432)
+0xC67C, 0xC69C, 0xCEBD, 0xCEDD, 0xBE9D, 0xC6BC, 0xB5F9, 0x9D15, 0x94B3, 0x9491, 0x9CF4, 0xB5D8, 0xCE7A, 0xD6BC, 0xCE9B, 0xC67C,   // 0x01C0 (448)
+0xC69C, 0xBEBD, 0xBEBC, 0xBE9C, 0xC69C, 0xCE7B, 0xC69C, 0xC6BC, 0xBEBD, 0xBEBD, 0xC6BD, 0xCEDD, 0xD71D, 0xD71E, 0xD71D, 0xC65C,   // 0x01D0 (464)
+0x6B7C, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087C, 0x73FC, 0xBE5D, 0xC69B,   // 0x01F0 (496)
+0xBE7C, 0xC69D, 0xBE9D, 0xBE7D, 0xBE9E, 0xBE9E, 0xBE9D, 0xBE9D, 0xBE9B, 0xBEBB, 0xBEBB, 0xBE9C, 0xC69C, 0xC69B, 0xBE7B, 0xBE9B,   // 0x0200 (512)
+0xC6DC, 0xBE9C, 0xBE7C, 0xBE7C, 0xBE5B, 0xB5F9, 0x6A0A, 0xD864, 0xE064, 0xD884, 0xC043, 0x730D, 0xC69B, 0xCE9C, 0xC65B, 0xC69C,   // 0x0210 (528)
+0xBE7C, 0xBEBC, 0xBEBC, 0xBEBC, 0xC69C, 0xC69C, 0xC69C, 0xBE9D, 0xB6BE, 0xB69D, 0xBEBD, 0xBE9D, 0xC69D, 0xCEDD, 0xD71D, 0xD6FD,   // 0x0220 (544)
+0xC67D, 0x73DD, 0x003C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x5B3C, 0xB63C, 0xC6BC, 0xBE9C,   // 0x0240 (576)
+0xBE5C, 0xBE9D, 0xBE9E, 0xB69E, 0xB67D, 0xB67D, 0xB65C, 0xBE7C, 0xBE9C, 0xB6BB, 0xB69C, 0xB69D, 0xBE7C, 0xBE5B, 0xB67B, 0xBEBC,   // 0x0250 (592)
+0xB6BD, 0xB69C, 0xAE7D, 0xAE5B, 0xBE7B, 0x936E, 0xE043, 0xF864, 0xF864, 0xF863, 0xF864, 0xC843, 0x83F0, 0xC63A, 0xC63A, 0xC67B,   // 0x0260 (608)
+0xC69C, 0xBE7B, 0xB67C, 0xB67C, 0xBE7C, 0xBE7C, 0xBE7D, 0xB67D, 0xAE7E, 0xB67E, 0xB6BE, 0xB6BD, 0xBE9D, 0xC6DD, 0xC6DD, 0xC6BC,   // 0x0270 (624)
+0xCEBC, 0xC67D, 0x6B7D, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x52DD, 0xADDC, 0xB67B, 0xBE9C, 0xBE7D,   // 0x0290 (656)
+0xBE7D, 0xB67D, 0xAE7D, 0xAE7D, 0xB69D, 0xAE9D, 0xB65C, 0xBE7B, 0xB67B, 0xB67C, 0xAE7C, 0xADFC, 0x94D5, 0x92AC, 0x79E8, 0x6BD0,   // 0x02A0 (672)
+0x8D78, 0xAE7D, 0xAE7C, 0xA65C, 0x9D35, 0xE0A4, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xC002, 0x9472, 0xC6BB, 0xC69C,   // 0x02B0 (688)
+0xB69D, 0xB67D, 0xB67C, 0xB67D, 0xB67D, 0xB67D, 0xB67E, 0xB65E, 0xB67E, 0xAE7E, 0xAE7D, 0xAE7D, 0xB67D, 0xB67D, 0xBE7D, 0xBE7C,   // 0x02C0 (704)
+0xBE7C, 0xC6BB, 0xADDB, 0x423D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x637B, 0xB61C, 0xBE9D, 0xB67D, 0xB65D,   // 0x02E0 (736)
+0xB65C, 0xB65D, 0xAE5D, 0xA65E, 0xAE7E, 0xAE7D, 0xAE5C, 0xB65A, 0xB65B, 0xB67C, 0xAE1C, 0x626B, 0xC884, 0xF864, 0xF864, 0xD884,   // 0x02F0 (752)
+0xA105, 0x8451, 0xB679, 0xBE79, 0xA533, 0xE063, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF043, 0x8B0D, 0xC69C, 0xB65E,   // 0x0300 (768)
+0xB67E, 0xAE7D, 0xB69C, 0xB67C, 0xAE5D, 0xB67D, 0xB65D, 0xB67D, 0xB67D, 0xAE7D, 0xAE7E, 0xAE7E, 0xAE5D, 0xB65D, 0xB67D, 0xB67D,   // 0x0310 (784)
+0xB65C, 0xBE7B, 0xB63C, 0x5B3C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213B, 0x8CFB, 0xB67D, 0xB69E, 0xAE5D, 0xAE3C,   // 0x0330 (816)
+0xAE5D, 0xAE7D, 0xAE7E, 0xA65E, 0xA65D, 0xA65C, 0xAE7C, 0xB67B, 0xB65A, 0xAE5B, 0x8CD5, 0xC083, 0xF863, 0xF884, 0xF884, 0xF884,   // 0x0340 (832)
+0xF864, 0xC822, 0x942E, 0xE716, 0xAD11, 0xD863, 0xF863, 0xF884, 0xF864, 0xF863, 0xF864, 0xF883, 0xF864, 0xA8A5, 0xB61A, 0xB67D,   // 0x0350 (848)
+0xAE7D, 0xB67D, 0xBE9C, 0xBE7B, 0xB65D, 0xB65D, 0xB65D, 0xB69D, 0xAE7D, 0xAE7D, 0xAE5D, 0xAE7D, 0xAE9D, 0xAE7D, 0xAE5D, 0xAE5C,   // 0x0360 (864)
+0xB65C, 0xB65C, 0xBE7B, 0x8CDB, 0x18DB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x3A1B, 0xA5BB, 0xAE7D, 0xA65D, 0xAE5D, 0xAE5D,   // 0x0380 (896)
+0xA61C, 0xA63C, 0xA63D, 0x9E3D, 0xA65D, 0xA65C, 0xAE7D, 0xAE7D, 0xAE9D, 0xAE7D, 0x7A6B, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864,   // 0x0390 (912)
+0xF884, 0xF864, 0xC905, 0xCE32, 0x9C6D, 0xD863, 0xF884, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF864, 0xC8A5, 0xB5F8, 0xB67D,   // 0x03A0 (928)
+0xB67D, 0xB67D, 0xBE9C, 0xBE5A, 0x9D78, 0x8473, 0x8C95, 0x8C94, 0x8CB5, 0x8CD6, 0xA61B, 0xAE7E, 0xAE5D, 0xAE5D, 0xA63D, 0xAE5D,   // 0x03B0 (944)
+0xAE3C, 0xAE3C, 0xB65B, 0xA59B, 0x39FC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ABC, 0xA5FC, 0xAE7D, 0x9E3D, 0xA63D, 0xA63D,   // 0x03D0 (976)
+0xA63C, 0xA65D, 0xA65D, 0x9E5D, 0xA65C, 0xA63B, 0xAE5B, 0xAE9D, 0xA67D, 0xA67C, 0x8AAB, 0xF864, 0xF864, 0xF884, 0xF884, 0xF884,   // 0x03E0 (992)
+0xF884, 0xF884, 0xF843, 0xA268, 0x944D, 0xE064, 0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xF864, 0xF863, 0xC084, 0x94F2, 0xB67D,   // 0x03F0 (1008)
+0xAE7E, 0xB69D, 0xBE7A, 0x8451, 0x7947, 0xB8A4, 0xE064, 0xE064, 0xE064, 0xB8A4, 0x89C9, 0x7BB0, 0xA61C, 0xAE5E, 0xA65D, 0xAE5D,   // 0x0400 (1024)
+0xAE3D, 0xAE3D, 0xAE5C, 0xADFC, 0x5B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBE, 0xAE5D, 0xAE9E, 0xA67E, 0xA65E, 0xA61C,   // 0x0420 (1056)
+0xA61C, 0xA63C, 0x9E3D, 0x9E5D, 0xA65C, 0xA61A, 0xAE3B, 0xAE7D, 0xAE7D, 0xA65C, 0x8A4A, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864,   // 0x0430 (1072)
+0xF884, 0xF863, 0xF883, 0xE884, 0x7A68, 0xD8A4, 0xF863, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xB802, 0x8C91, 0xB67C,   // 0x0440 (1088)
+0xB69D, 0xAE1A, 0x826A, 0xA0C4, 0xF864, 0xF864, 0xF864, 0xF884, 0xF863, 0xF884, 0xF864, 0xE063, 0x8209, 0x9579, 0xA65D, 0xA65D,   // 0x0450 (1104)
+0xA65D, 0xA63D, 0xAE3C, 0xAE3C, 0x635D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x741E, 0xAE5C, 0xAEBE, 0xA69E, 0xA65E, 0xA63D,   // 0x0470 (1136)
+0xA61C, 0x9DFC, 0x961C, 0x9E3D, 0x9E3C, 0xA61A, 0xA63A, 0xAE5D, 0xA65C, 0xAE5B, 0x83EE, 0xE063, 0xF884, 0xF884, 0xF884, 0xF884,   // 0x0480 (1152)
+0xF884, 0xF884, 0xF884, 0xF864, 0x7883, 0xD884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xB802, 0x9CD1, 0xB67C,   // 0x0490 (1168)
+0x9536, 0xB0E6, 0xF043, 0xF864, 0xF884, 0xF864, 0xF863, 0xF863, 0xF883, 0xF864, 0xF884, 0xF864, 0xF043, 0x7168, 0x9E1B, 0xA63E,   // 0x04A0 (1184)
+0xA63D, 0xA61D, 0xAE3C, 0xA5FC, 0x5B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xA63C, 0xAEDF, 0xA67E, 0xA65E, 0xA65D,   // 0x04C0 (1216)
+0xA65D, 0x9E1C, 0x9E1C, 0x9E3D, 0x95DA, 0xBCB5, 0xBCB4, 0xADD8, 0xB65B, 0xC6B8, 0xCE93, 0xA884, 0xF864, 0xF864, 0xF884, 0xF864,   // 0x04D0 (1232)
+0xF864, 0xF863, 0xF884, 0xF864, 0xC884, 0xE084, 0xF863, 0xF884, 0xF863, 0xF883, 0xF884, 0xF884, 0xF863, 0xC002, 0xAD30, 0xBE17,   // 0x04E0 (1248)
+0x9002, 0xF843, 0xF884, 0xF884, 0xF863, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xF863, 0xF864, 0xF883, 0xE823, 0x732F, 0x9E1D,   // 0x04F0 (1264)
+0x9E3E, 0x9E3D, 0xA61C, 0x9DBB, 0x5B3D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0xADFD, 0xAE7E, 0xAE7E, 0xA65D, 0xA67E,   // 0x0510 (1296)
+0xA63D, 0xA63D, 0xA5FC, 0x7C33, 0xCA6B, 0xF884, 0xF884, 0xE987, 0xEACA, 0xFB4B, 0xED6E, 0x8A88, 0xE843, 0xF884, 0xF864, 0xF884,   // 0x0520 (1312)
+0xF884, 0xF884, 0xF884, 0xF884, 0xC084, 0xA884, 0xF884, 0xF884, 0xF863, 0xF884, 0xF863, 0xF884, 0xF863, 0xC8A4, 0x8C6E, 0x8A69,   // 0x0530 (1328)
+0xF843, 0xF864, 0xF884, 0xF864, 0xF884, 0xF884, 0xF883, 0xF884, 0xF863, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xA0E6, 0x95BB,   // 0x0540 (1344)
+0x961D, 0x961D, 0x9E1C, 0x9DDC, 0x5AFD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x635E, 0xA5FD, 0xAE3E, 0xA65E, 0xA65E, 0xA65D,   // 0x0560 (1376)
+0xA67E, 0xA5DB, 0x8A4A, 0xE043, 0xF863, 0xF884, 0xF883, 0xF884, 0xF884, 0xF863, 0xF843, 0xD904, 0xA883, 0xF864, 0xF883, 0xF884,   // 0x0570 (1392)
+0xF864, 0xF864, 0xF884, 0xF884, 0xF084, 0xC064, 0xF883, 0xF884, 0xF864, 0xF863, 0xF883, 0xF864, 0xF864, 0x90E5, 0x6187, 0xE863,   // 0x0580 (1408)
+0xF864, 0xF864, 0xF884, 0xF884, 0xF863, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF863, 0xB0A4, 0x7CD6,   // 0x0590 (1424)
+0x961D, 0x8DFD, 0x961C, 0x9DBB, 0x52FD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x635D, 0xA5DD, 0xA61E, 0xA63E, 0x9E3D, 0x9E5D,   // 0x05B0 (1456)
+0x9DFB, 0x9926, 0xF843, 0xF863, 0xF884, 0xF864, 0xF884, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xD863, 0xD884, 0xF884, 0xF863,   // 0x05C0 (1472)
+0xF883, 0xF864, 0xF863, 0xF884, 0xF864, 0xC084, 0xF884, 0xF863, 0xF884, 0xF864, 0xF884, 0xF884, 0xF064, 0x78C4, 0xE864, 0xF864,   // 0x05D0 (1488)
+0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xF863, 0xF843, 0xB0C5, 0x7CF8,   // 0x05E0 (1504)
+0x8E1E, 0x8DFD, 0x961C, 0x95BB, 0x52DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0x9DBD, 0x9E1E, 0x9E1E, 0x9E3E, 0x963D,   // 0x0600 (1536)
+0x7433, 0xC149, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xD864, 0xF064, 0xF884,   // 0x0610 (1552)
+0xF864, 0xF883, 0xF863, 0xF864, 0xF884, 0xE844, 0xF863, 0xF844, 0xF863, 0xF884, 0xF863, 0xF864, 0xA884, 0xD883, 0xF864, 0xF863,   // 0x0620 (1568)
+0xE084, 0xC884, 0xF884, 0xF863, 0xF864, 0xF884, 0xF884, 0xF883, 0xF884, 0xF884, 0xF863, 0xF863, 0xF8A5, 0xF928, 0x8967, 0x8DBB,   // 0x0630 (1584)
+0x85FD, 0x85FD, 0x8DFC, 0x8D9B, 0x52DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533D, 0x959D, 0x95DD, 0x95DD, 0x95FD, 0x8DFD,   // 0x0650 (1616)
+0x5B71, 0xD312, 0xF842, 0xF884, 0xF863, 0xF864, 0xF864, 0xF883, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xF864, 0xB883, 0xB883,   // 0x0660 (1632)
+0xF884, 0xF863, 0xF863, 0xF843, 0xF803, 0xF844, 0xF8E4, 0xF125, 0xE884, 0xE803, 0xF844, 0xF884, 0xA884, 0xF884, 0xF864, 0xB884,   // 0x0670 (1648)
+0x98A5, 0xD084, 0xF884, 0xF884, 0xF883, 0xF863, 0xF884, 0xF864, 0xF884, 0xF863, 0xF864, 0xF864, 0xE24E, 0x5A2D, 0x7432, 0x8DDB,   // 0x0680 (1664)
+0x85DC, 0x85DC, 0x8DDC, 0x8D7B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x8D9D, 0x8DDD, 0x8DBD, 0x8DDD, 0x8DDD,   // 0x06A0 (1696)
+0x6370, 0x9C16, 0xFACD, 0xF843, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xF064, 0xB083, 0xB083, 0xF064, 0xA883,   // 0x06B0 (1712)
+0xD884, 0xF884, 0xF823, 0xF0C4, 0xF348, 0xF5AB, 0xF6ED, 0xF70D, 0xEE8C, 0xCC88, 0xB1E5, 0x9023, 0xC864, 0xF864, 0xB084, 0x98A4,   // 0x06C0 (1728)
+0xF884, 0xF864, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF843, 0xE885, 0x8A2A, 0x7473, 0x8DDA, 0x85DA,   // 0x06D0 (1744)
+0x85BB, 0x85BC, 0x85BB, 0x8D5B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4AFD, 0x857C, 0x85DD, 0x85BC, 0x85BD, 0x85DD,   // 0x06F0 (1776)
+0x8559, 0x7106, 0xFA4B, 0xF8A5, 0xF884, 0xF884, 0xF863, 0xF883, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xB063, 0xA063, 0xF863,   // 0x0700 (1792)
+0xB063, 0xE003, 0xF247, 0xF6AC, 0xFFEE, 0xFFCE, 0xFF8E, 0xFFAE, 0xF76D, 0xF7AD, 0xEFAD, 0x94C9, 0x9084, 0xC024, 0xA8A5, 0xF863,   // 0x0710 (1808)
+0xF884, 0xF864, 0xF864, 0xF884, 0xF864, 0xF864, 0xF883, 0xF864, 0xF863, 0xE085, 0x7A2A, 0x6B4F, 0x8D99, 0x95DB, 0x85DB, 0x859B,   // 0x0720 (1824)
+0x859B, 0x7D9C, 0x859B, 0x853B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x857C, 0x85DC, 0x7D9C, 0x85DC, 0x85DD,   // 0x0740 (1856)
+0x85BE, 0x7C12, 0xB802, 0xF844, 0xF884, 0xF883, 0xF864, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF863, 0xF884, 0xD863, 0xA083,   // 0x0750 (1872)
+0xC003, 0x8AE7, 0xFF8E, 0xFFCE, 0xBD8A, 0xF72C, 0xFF8E, 0xFFEE, 0x8C09, 0x8C08, 0xFFEE, 0xFFEE, 0xADC9, 0x60C5, 0xF044, 0xF864,   // 0x0760 (1888)
+0xF883, 0xF884, 0xF064, 0xC084, 0xA0C5, 0x70C4, 0x60C5, 0x60C5, 0x58A4, 0x6B6E, 0x7D7A, 0x85BC, 0x85BB, 0x85BB, 0x7D9B, 0x859B,   // 0x0770 (1904)
+0x859B, 0x7D9C, 0x859B, 0x853B, 0x4A9D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D5C, 0x85BD, 0x7D9C, 0x7DBD, 0x7DBD,   // 0x0790 (1936)
+0x7DBD, 0x859C, 0x7C53, 0x7925, 0xD043, 0xF843, 0xF843, 0xF883, 0xF864, 0xF863, 0xF863, 0xF884, 0xF884, 0xF884, 0xF863, 0xB043,   // 0x07A0 (1952)
+0x89C6, 0xF76D, 0xFFEE, 0xC5AA, 0x3185, 0xEF2D, 0xFFAE, 0xFFCE, 0x9428, 0xAD09, 0xFFCE, 0xFF8D, 0xFFEE, 0x9CE9, 0x9844, 0xF863,   // 0x07B0 (1968)
+0xD884, 0x88C4, 0xB885, 0xA8A4, 0xD884, 0xE084, 0xE884, 0xE884, 0xE884, 0xA147, 0x91C9, 0x62ED, 0x6C11, 0x8D57, 0x8579, 0x857B,   // 0x07C0 (1984)
+0x7D7B, 0x7D7C, 0x7D7B, 0x853C, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D7C, 0x859D, 0x759D, 0x7DDD, 0x759D,   // 0x07E0 (2016)
+0x7DBC, 0x859B, 0x9577, 0x9532, 0x948E, 0x9BCB, 0xA247, 0xC0E4, 0xC0A3, 0xF083, 0xF864, 0xF863, 0xF864, 0xF863, 0xF864, 0xE043,   // 0x07F0 (2032)
+0xB56A, 0xFFEE, 0xFFAE, 0xD64B, 0xC5AA, 0xFFAE, 0xFF6E, 0xFF6D, 0xFF8D, 0xFFAE, 0xFF6D, 0xFF6D, 0xFF8E, 0xF78D, 0x61E5, 0x9864,   // 0x0800 (2048)
+0xA884, 0xE864, 0xF884, 0xF863, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xF863, 0xF064, 0xC8A4, 0x91E9, 0x6B91, 0x7D1C,   // 0x0810 (2064)
+0x755E, 0x6D5D, 0x7D7C, 0x7D1B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ADD, 0x755D, 0x7D9E, 0x7DBF, 0x7DBE, 0x759D,   // 0x0830 (2096)
+0x7D7C, 0x859A, 0x9576, 0x848F, 0x8C0B, 0x94AC, 0x8C0A, 0x6A65, 0x4984, 0x58A3, 0x68A3, 0x78A2, 0xB083, 0xF064, 0xF844, 0xC125,   // 0x0840 (2112)
+0xE70C, 0xFFAE, 0xFF8D, 0xFF8E, 0xFFCE, 0xFF6E, 0xFF8E, 0xFF8E, 0xFFEE, 0xE70C, 0xB52A, 0xFFAD, 0xFF6E, 0xFFCD, 0x7B66, 0xD044,   // 0x0850 (2128)
+0xF864, 0xF064, 0xE864, 0xE884, 0xF884, 0xF864, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xC063, 0x6392,   // 0x0860 (2144)
+0x6D7F, 0x655D, 0x7DBD, 0x74FB, 0x3A7C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x323C, 0x64BB, 0x6D5D, 0x6D7E, 0x75BE, 0x75DE,   // 0x0880 (2176)
+0x7D9C, 0x74B4, 0x6269, 0xA8A4, 0xE864, 0xE843, 0xE864, 0xE864, 0xE864, 0xE884, 0xE884, 0xB884, 0x9883, 0x9884, 0xB823, 0x8A26,   // 0x0890 (2192)
+0xF7AD, 0xFF8D, 0xFF6D, 0xFF8D, 0xFFCD, 0xFFAD, 0xFF6C, 0xEF4D, 0xCDCB, 0xB289, 0xBCAA, 0xFFCE, 0xFF6E, 0xFFEC, 0x83E6, 0xA824,   // 0x08A0 (2208)
+0x80C4, 0xB085, 0xB885, 0xB085, 0xE064, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xF864, 0xF863, 0xC063,   // 0x08B0 (2224)
+0x63B2, 0x5D7C, 0x655A, 0x6498, 0x321B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x323C, 0x547B, 0x5CFC, 0x5D1D, 0x6D5D, 0x6D9C,   // 0x08D0 (2256)
+0x6C95, 0x8083, 0xF063, 0xF864, 0xF884, 0xF884, 0xF863, 0xF884, 0xF864, 0xF884, 0xE084, 0xB083, 0xB863, 0xA083, 0x612A, 0x4228,   // 0x08E0 (2272)
+0xF74C, 0xFF8E, 0xF74C, 0xCCAA, 0xC4CB, 0xC64F, 0xCE72, 0x9CD1, 0xCA2C, 0xD1AC, 0xD60B, 0xFFCE, 0xFF6D, 0xF7CD, 0x9265, 0xB044,   // 0x08F0 (2288)
+0xE863, 0xF864, 0xF863, 0xF863, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF864, 0xF863, 0xF863, 0xF884, 0xF864, 0xF884, 0xF864,   // 0x0900 (2304)
+0x9863, 0x6D19, 0x5CF8, 0x5BD4, 0x29DB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x327C, 0x5C9B, 0x5CFC, 0x54DC, 0x54DC, 0x5C55,   // 0x0920 (2336)
+0x80A3, 0xF843, 0xF884, 0xF864, 0xF863, 0xF863, 0xF884, 0xF884, 0xF064, 0xA0A4, 0x90C4, 0x90A3, 0x90A3, 0x90A3, 0x6127, 0x20E6,   // 0x0930 (2352)
+0xCE2A, 0xFFCE, 0xFFCE, 0xEDCC, 0xD1AC, 0xBB0F, 0xB2EF, 0xAA0A, 0xD1EC, 0xA209, 0xDEEC, 0xFF8D, 0xFFEE, 0xEE6A, 0xF884, 0xF844,   // 0x0940 (2368)
+0xF884, 0xF864, 0xF884, 0xF863, 0xF864, 0xF884, 0xF863, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864,   // 0x0950 (2384)
+0xF023, 0x82AD, 0x5C97, 0x4BF7, 0x29DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DD, 0x5CFC, 0x5D1C, 0x54DB, 0x64FA, 0x5926,   // 0x0970 (2416)
+0xF843, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xE883, 0xF884, 0xF864, 0xF864, 0xF864, 0xF863, 0x9023,   // 0x0980 (2432)
+0x62E5, 0xFFED, 0xFF8E, 0xFFCD, 0xC3AB, 0xD16B, 0xBBCD, 0xE653, 0x8BAC, 0x6AC5, 0xFFED, 0xFF8D, 0xF7ED, 0xBB27, 0xD023, 0xE084,   // 0x0990 (2448)
+0xE864, 0xF084, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF883, 0xF864, 0xF863, 0xF883, 0xF864,   // 0x09A0 (2464)
+0xF863, 0xB107, 0x5C15, 0x5C16, 0x327C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x653C, 0x5D7B, 0x551A, 0x634F, 0xD023,   // 0x09C0 (2496)
+0xF864, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF883, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xD884, 0x90C5,   // 0x09D0 (2512)
+0x2908, 0x9CE9, 0xFFED, 0xFFCE, 0xE72C, 0x6286, 0x7B6B, 0x9C2E, 0x7328, 0xCE6A, 0xFFEE, 0xFFEE, 0xE488, 0xB064, 0xB0A4, 0xB084,   // 0x09E0 (2528)
+0xB884, 0x9883, 0xA0C4, 0xE883, 0xF863, 0xF864, 0xF884, 0xF883, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF864, 0xF863,   // 0x09F0 (2544)
+0xF864, 0xB0E5, 0x6391, 0x6CB8, 0x53B9, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B5E, 0x6D9D, 0x65BD, 0x5CFA, 0x8106, 0xF884,   // 0x0A10 (2576)
+0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF863, 0xF884, 0xF864, 0xE084, 0x98A4, 0x98A4, 0xB8C6,   // 0x0A20 (2592)
+0x61AC, 0x38A4, 0x9407, 0xEF8C, 0xFFEE, 0xFFED, 0xB569, 0xA528, 0xEF2C, 0xFFEE, 0xF76C, 0xAC28, 0xB064, 0xB863, 0xB083, 0xE863,   // 0x0A30 (2608)
+0xF863, 0xF864, 0xC883, 0x88A4, 0x9883, 0xE884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF864, 0xF884, 0xF883, 0xF884, 0xF864, 0xF864,   // 0x0A40 (2624)
+0xF864, 0x90E6, 0x63B3, 0x6CDA, 0x537B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B3D, 0x6DBD, 0x6DFF, 0x64B8, 0x8373, 0xF148,   // 0x0A60 (2656)
+0xF863, 0xF863, 0xF883, 0xF864, 0xF864, 0xF863, 0xF884, 0xF864, 0xF884, 0xF864, 0xF063, 0xA0E4, 0x88A4, 0xD083, 0xE084, 0x90A3,   // 0x0A70 (2672)
+0xB083, 0xF064, 0xD823, 0x81C4, 0x9C68, 0xC649, 0xDF2C, 0xE72C, 0xC68A, 0xC488, 0xE965, 0xE823, 0xE864, 0xA0A4, 0x90A3, 0xB0A4,   // 0x0A80 (2688)
+0x90A4, 0xE084, 0xF863, 0xF864, 0x98A3, 0x68A4, 0xB884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF863,   // 0x0A90 (2704)
+0xD065, 0x6229, 0x6458, 0x751B, 0x5BBB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x85DE, 0x75DE, 0x5457, 0x8436, 0xF1A9,   // 0x0AB0 (2736)
+0xF863, 0xF863, 0xF884, 0xF884, 0xF863, 0xF863, 0xF884, 0xF884, 0xF843, 0xB8A4, 0x838F, 0x6227, 0xE864, 0xE884, 0x80A3, 0xD883,   // 0x0AC0 (2752)
+0xF884, 0xF884, 0xF064, 0xD824, 0xD024, 0xA0A3, 0x8904, 0xA105, 0x80C3, 0x8043, 0xF043, 0xF863, 0xF884, 0xF864, 0xF864, 0xF864,   // 0x0AD0 (2768)
+0xE883, 0xF084, 0xF884, 0xF884, 0xF864, 0xF084, 0xA0A4, 0x90A4, 0xC0A4, 0xF864, 0xF064, 0xF844, 0xF844, 0xF844, 0xF863, 0xC884,   // 0x0AE0 (2784)
+0x5944, 0x6435, 0x64DC, 0x751A, 0x5B9B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B3D, 0x8DDD, 0x861E, 0x6CF9, 0x7435, 0xE331,   // 0x0B00 (2816)
+0xF843, 0xF863, 0xF864, 0xF884, 0xF863, 0xF884, 0xF863, 0xE023, 0x8AAC, 0xA61A, 0x8BCF, 0xE883, 0xF864, 0x98A4, 0xE884, 0xF884,   // 0x0B10 (2832)
+0xF884, 0xF884, 0xC084, 0xD084, 0xF863, 0xF863, 0xD063, 0xA863, 0xF844, 0xE084, 0x60A2, 0xB063, 0xF863, 0xF884, 0xF883, 0xF884,   // 0x0B20 (2848)
+0xF884, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xE864, 0x88A4, 0x6143, 0xA388, 0x8BCE, 0x8AEB, 0x8248, 0x7A6A, 0x6A8C,   // 0x0B30 (2864)
+0x6C35, 0x6D7D, 0x74FA, 0x74FB, 0x429C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85BD, 0x8DFE, 0x861E, 0x628B, 0xF928,   // 0x0B50 (2896)
+0xF884, 0xF884, 0xF864, 0xF863, 0xF884, 0xF843, 0xB0C5, 0x7BF2, 0xAEBC, 0xA513, 0xE043, 0xF863, 0xB083, 0xB8A3, 0xF864, 0xF864,   // 0x0B60 (2912)
+0xF884, 0xF884, 0x80A3, 0xD884, 0xF863, 0xF884, 0xF864, 0x90A4, 0xE084, 0xF863, 0xD883, 0x48A3, 0xB883, 0xF884, 0xF884, 0xF864,   // 0x0B70 (2928)
+0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0x9922, 0xAD0A, 0xAE37, 0x9E3B, 0x8D58, 0x8519, 0x757C,   // 0x0B80 (2944)
+0x75BE, 0x75DE, 0x75DC, 0x7D7B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533D, 0x8DBD, 0x8E1F, 0x8E1F, 0x7D18, 0x8862,   // 0x0BA0 (2976)
+0xF843, 0xF864, 0xF864, 0xF863, 0xE064, 0x7A27, 0x9599, 0xAEBD, 0xAE18, 0xC043, 0xF863, 0xF884, 0xD084, 0xF883, 0xF863, 0xF864,   // 0x0BB0 (2992)
+0xF864, 0xE064, 0x88A3, 0xF864, 0xF883, 0xF884, 0xF884, 0xC884, 0xD0A4, 0xF864, 0xF884, 0xE064, 0x58C3, 0xB084, 0xF863, 0xF864,   // 0x0BC0 (3008)
+0xF864, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF883, 0xF863, 0xF863, 0xF863, 0x80E5, 0x8D74, 0x967E, 0x963E, 0x8E3D, 0x861C,   // 0x0BD0 (3024)
+0x75FB, 0x75FC, 0x861C, 0x85BB, 0x4B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533C, 0x8DDD, 0x8E3F, 0x8E1F, 0x865F, 0x6C94,   // 0x0BF0 (3056)
+0x8146, 0x9905, 0xA105, 0x9167, 0x842F, 0xA659, 0xAEDE, 0xB6BD, 0x9229, 0xF843, 0xF884, 0xF863, 0xF864, 0xF884, 0xF863, 0xF884,   // 0x0C00 (3072)
+0xF864, 0xC063, 0x78A3, 0xF884, 0xF884, 0xF863, 0xF884, 0xB884, 0x80A3, 0xF863, 0xF884, 0xF864, 0xC083, 0x3985, 0xC0A4, 0xF863,   // 0x0C10 (3088)
+0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF864, 0xF884, 0xF863, 0x78E4, 0x6CD5, 0x967F, 0x965E, 0x863C,   // 0x0C20 (3104)
+0x861C, 0x861D, 0x8E3D, 0x8DFC, 0x535D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85FC, 0x8E5E, 0x8E1E, 0x8E3E, 0x861C,   // 0x0C40 (3136)
+0x7DBA, 0x7538, 0x8599, 0x95DA, 0x9E59, 0xA6BC, 0xAEBE, 0x9D34, 0xC843, 0xF884, 0xF864, 0xF884, 0xF863, 0xF863, 0xF864, 0xF884,   // 0x0C50 (3152)
+0xF884, 0xC863, 0x80A3, 0xF864, 0xF884, 0xF863, 0xF884, 0xD8A4, 0x88A4, 0xF864, 0xF884, 0xF884, 0xF863, 0x9125, 0x8B6A, 0xC0A4,   // 0x0C60 (3168)
+0xF863, 0xF864, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xD023, 0x7C73, 0x9E7D, 0x963D, 0x8E3E,   // 0x0C70 (3184)
+0x8E3F, 0x863F, 0x8E3E, 0x963D, 0x5B9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42FC, 0x7DDB, 0x863D, 0x85FD, 0x861D, 0x8E1C,   // 0x0C90 (3216)
+0x85DC, 0x863E, 0xA69F, 0x9E7D, 0x9E5A, 0x9E5C, 0xAE9C, 0x81A7, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864,   // 0x0CA0 (3232)
+0xF884, 0xC863, 0x80A3, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xE864, 0xF863, 0xF864, 0xF863, 0xF884, 0xC863, 0x94B1, 0x9D97,   // 0x0CB0 (3248)
+0xC906, 0xF843, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xF883, 0xF864, 0xF883, 0xF884, 0xF843, 0x8C31, 0x965D, 0x961D, 0x965F,   // 0x0CC0 (3264)
+0x963F, 0x8E1F, 0x965F, 0x9E5E, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x757B, 0x7DDC, 0x7DDD, 0x861D, 0x8E1D,   // 0x0CE0 (3296)
+0x8E5D, 0xA69F, 0xA6BF, 0xAEBD, 0xA65D, 0xAEBF, 0x8D77, 0xC864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884,   // 0x0CF0 (3312)
+0xF863, 0xC863, 0x80A3, 0xF864, 0xF863, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF884, 0xF863, 0x88E5, 0xBEBD,   // 0x0D00 (3328)
+0xA5FA, 0xAA4B, 0xF043, 0xF863, 0xF884, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF042, 0x8411, 0x969C, 0x969D, 0x967E,   // 0x0D10 (3344)
+0x965F, 0x963F, 0x9E7F, 0xA69F, 0x63FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x755B, 0x7DDC, 0x7DFE, 0x8E3E, 0x965E,   // 0x0D30 (3376)
+0x8E7D, 0xA6FF, 0xAF3F, 0xAEBE, 0xAEDF, 0xAEDF, 0x7B4E, 0xE843, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF883,   // 0x0D40 (3392)
+0xF884, 0xB883, 0x78A3, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF863, 0xB863, 0xA619,   // 0x0D50 (3408)
+0xA63A, 0x9DD9, 0xACD1, 0xC106, 0xF843, 0xF864, 0xF884, 0xF864, 0xF863, 0xF884, 0xF864, 0xA063, 0x8577, 0x96BD, 0x96BD, 0x969E,   // 0x0D60 (3424)
+0x9E7F, 0x9E9F, 0xA6BF, 0xAE9E, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x7D5C, 0x7DBC, 0x7DDD, 0x8E1D, 0x963D,   // 0x0D80 (3456)
+0x9E9E, 0x9EDD, 0xA6DD, 0xA6FD, 0xA6DE, 0xA6DE, 0x828A, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884,   // 0x0D90 (3472)
+0xF864, 0x60A3, 0x78A3, 0xF864, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF864, 0xF883, 0xF884, 0xF884, 0xF884, 0xE023, 0x8C31,   // 0x0DA0 (3488)
+0xA69C, 0xB6BC, 0xBEFD, 0x9D79, 0x8B0C, 0xC126, 0xF063, 0xF043, 0xE843, 0xE843, 0xE023, 0x7B6F, 0x969D, 0x96BE, 0x9EDE, 0x9E9E,   // 0x0DB0 (3504)
+0x9E9F, 0x9E9F, 0xA6BE, 0xB6BD, 0x6BFE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x859C, 0x85BC, 0x7DBC, 0x85FD, 0x8DFC,   // 0x0DD0 (3536)
+0x967D, 0x8E5B, 0x8E7A, 0x9EBB, 0xA6DD, 0x9E7C, 0x79C8, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF864, 0xF864,   // 0x0DE0 (3552)
+0xF863, 0x8185, 0x7A25, 0xF043, 0xF863, 0xF884, 0xF883, 0xF863, 0xF863, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF843, 0x8B4D,   // 0x0DF0 (3568)
+0xB6DE, 0xAEBD, 0xAEBE, 0xAEBE, 0xA69D, 0x9E1B, 0x8452, 0x7B8E, 0x7B6D, 0x7BCF, 0x7C52, 0x8E5B, 0x969D, 0xA6FF, 0x9EDE, 0xA6DF,   // 0x0E00 (3584)
+0x9E9E, 0x9E7F, 0xAEBE, 0xBEFE, 0x73FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x535D, 0x8DDC, 0x8DFD, 0x85DD, 0x95FD, 0x95FD,   // 0x0E20 (3616)
+0x8E1C, 0x967C, 0x969C, 0x9E9C, 0x9E7C, 0x963B, 0x7208, 0xF863, 0xF864, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF863, 0xF884,   // 0x0E30 (3632)
+0xF843, 0xA347, 0xB4A7, 0xD843, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xF863, 0xF863, 0xF884, 0xF884, 0xF864, 0xF864, 0x7A8B,   // 0x0E40 (3648)
+0xAE9D, 0xA6BE, 0xA69E, 0x9EBE, 0xA69D, 0xAEBE, 0xB6DE, 0xB6DE, 0xAE9D, 0xA69D, 0xA69E, 0x9E9E, 0x9EBE, 0xA6FF, 0xA6FF, 0xAEBE,   // 0x0E50 (3664)
+0x9E9E, 0x9E7E, 0xA6BE, 0xC71E, 0x741E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x63BD, 0x9E5E, 0x9E7E, 0x9E5E, 0xA65E, 0xA65E,   // 0x0E70 (3696)
+0xAEBF, 0xA69D, 0x9EBD, 0xA67E, 0x9E5D, 0xA69E, 0x7A8B, 0xF843, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884,   // 0x0E80 (3712)
+0xC823, 0xB4A7, 0xD587, 0xC843, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF863, 0xF863, 0xF864, 0xF884, 0xF863, 0x82CB,   // 0x0E90 (3728)
+0xAEBE, 0xAEBE, 0xA6BE, 0xA69E, 0xA69E, 0xAEDE, 0xA6DE, 0xA6BE, 0xA6BD, 0x9E9E, 0xAEBE, 0xAEFF, 0xA6DD, 0xA6FE, 0xAEDE, 0xA6BE,   // 0x0EA0 (3744)
+0xA6BE, 0x9E7E, 0x9E5E, 0xBEDE, 0x7C5E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xA6BE, 0xA6FF, 0xAEDF, 0xAEFF, 0xAEFF,   // 0x0EC0 (3776)
+0xA6DE, 0xAEFF, 0xAF1F, 0xA69E, 0xAEBF, 0xA69E, 0x84D4, 0xC023, 0xF8C5, 0xF8C5, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF843,   // 0x0ED0 (3792)
+0xA1A6, 0xD524, 0xB4A5, 0x6862, 0xF884, 0xF885, 0xF863, 0xF883, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF843, 0x938C,   // 0x0EE0 (3808)
+0xAEBD, 0xAEDE, 0xA69D, 0xA69E, 0xA6BF, 0x9E9E, 0x9E7D, 0xA6BE, 0xA69D, 0xAEDE, 0xAEDE, 0xBF1F, 0xAEDD, 0xAEDD, 0xB71E, 0xAEFE,   // 0x0EF0 (3824)
+0x9EBD, 0x967D, 0x9E7E, 0xBEDE, 0x8CBE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xAEDF, 0xAF1F, 0xAEDF, 0xAF3E, 0xAF1D,   // 0x0F10 (3856)
+0xAF1E, 0xA6FE, 0xAF3E, 0xA6DE, 0xA6DE, 0xAEFE, 0xAEFD, 0x7A4A, 0xF823, 0xF8A5, 0xF884, 0xF884, 0xF884, 0xF864, 0xF863, 0xB043,   // 0x0F20 (3872)
+0xA48A, 0xC505, 0xD5E8, 0x7C09, 0x9863, 0xF907, 0xF906, 0xF843, 0xF864, 0xF864, 0xF864, 0xF864, 0xF884, 0xF884, 0xD822, 0xA4D0,   // 0x0F30 (3888)
+0xB6BC, 0xB6FD, 0xAEDD, 0xAEDE, 0xA6BE, 0xA6BE, 0xA6BE, 0xA6BE, 0xAEBD, 0xB6DE, 0xBEDE, 0xB6DD, 0xB6FD, 0xAEFD, 0xAEFE, 0xAEDF,   // 0x0F40 (3904)
+0x9E7F, 0x969F, 0x9E9F, 0xBEDE, 0x8C9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x741E, 0xB6FD, 0xB73F, 0xAEFF, 0xAF3E, 0xAF3D,   // 0x0F60 (3936)
+0xAF3D, 0xAF3D, 0xAEFD, 0x9E7D, 0xAF1E, 0xA6FE, 0xAF1E, 0x95F7, 0x7187, 0xD843, 0xF843, 0xF884, 0xF883, 0xF843, 0xC063, 0xA4B2,   // 0x0F70 (3952)
+0xB5F1, 0xB58B, 0xD68D, 0xBE0C, 0x5AAA, 0x9883, 0xF9CA, 0xF1CA, 0xF8C5, 0xF843, 0xF884, 0xF884, 0xF884, 0xF843, 0x99A9, 0xB638,   // 0x0F80 (3968)
+0xA69C, 0xA6BE, 0xAEBF, 0xAEDF, 0xAEDE, 0xAEDE, 0xAEDD, 0xAEFE, 0xA6DE, 0xAEBD, 0xBEDD, 0xB6DC, 0xAEFD, 0xAEFE, 0xA6DF, 0x965D,   // 0x0F90 (3984)
+0x967E, 0x9E9F, 0xA69E, 0xBEFE, 0x7C3E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xC6DE, 0xBF1E, 0xAEDD, 0xAF1E, 0xAF3D,   // 0x0FB0 (4016)
+0xA71C, 0xAF5C, 0xA6BC, 0xA69D, 0x84F4, 0x8516, 0xAEFE, 0xA6FC, 0xA699, 0x73CF, 0x8166, 0xD884, 0xD884, 0x8988, 0x8D15, 0xB6DD,   // 0x0FC0 (4032)
+0xB6B9, 0xA5D0, 0xAE0D, 0xC68D, 0x9CC7, 0x52A7, 0xA063, 0xF989, 0xF28D, 0xF24C, 0xF927, 0xF864, 0xF843, 0x88E4, 0x95BA, 0xAEDE,   // 0x0FD0 (4048)
+0xAEBE, 0xAEDE, 0xAEBE, 0xB6FF, 0xB6DF, 0xB6DE, 0xB6FF, 0xA6BE, 0x9E9E, 0xAEBE, 0xB6BC, 0xB6FE, 0xAEFF, 0xA69E, 0x9E9E, 0x965E,   // 0x0FE0 (4064)
+0x9E7E, 0xA69E, 0xB6BD, 0xCF1E, 0x8CBF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B9D, 0xBE7C, 0xBEFD, 0xB71D, 0xB73E, 0xAF1D,   // 0x1000 (4096)
+0xAF3D, 0xB73D, 0xA67C, 0xAEBE, 0x6BAD, 0x7C63, 0x8D33, 0xAEBB, 0xAF5D, 0xB73D, 0xAEBB, 0x84F4, 0x84B4, 0xB69C, 0xB71E, 0xB6DE,   // 0x1010 (4112)
+0xBF1C, 0xA633, 0x7CE8, 0xB6AD, 0x8D26, 0x7464, 0x52C8, 0xA022, 0xE823, 0xE084, 0xE884, 0xE043, 0x9167, 0xA63B, 0xAEDF, 0xB6FF,   // 0x1020 (4128)
+0xB6DE, 0xAEFD, 0xA6DF, 0xAE9E, 0xA65C, 0x8D16, 0x9DD9, 0xA6BE, 0xA6BE, 0xAEFE, 0xAEFE, 0xA69E, 0x9E5D, 0x9E9D, 0x9E9E, 0xA6BF,   // 0x1030 (4144)
+0xAEBE, 0xBEFE, 0xC6FD, 0xD73D, 0x847E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1C, 0xB63C, 0xC73E, 0xBF5F, 0xAEFD, 0xB71E,   // 0x1050 (4176)
+0xB75E, 0xB73D, 0xA6DB, 0xA6DD, 0x844D, 0xBEA2, 0xAEA3, 0x8CEA, 0x9DD7, 0xB73E, 0xBF3F, 0xB71F, 0xB73E, 0xB73E, 0xBF3E, 0xB71D,   // 0x1060 (4192)
+0xBF1B, 0xB6D6, 0x754B, 0x8DEB, 0x7525, 0x64A3, 0x4307, 0x0326, 0x8C70, 0x9D55, 0x73F0, 0x8C93, 0xAEBD, 0xAEDE, 0xAEBE, 0xB6FF,   // 0x1070 (4208)
+0xB6DD, 0xA61A, 0x84D4, 0x740E, 0x6BA7, 0x31A3, 0x5B6E, 0xA67D, 0xAEDD, 0xA6BE, 0x9E7E, 0x9E7E, 0xAEBF, 0xA69E, 0xA6BE, 0xAEBE,   // 0x1080 (4224)
+0xB6DD, 0xBEBC, 0xD73E, 0xC6BD, 0x5B7D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31DB, 0xAE1C, 0xCF5D, 0xC73E, 0xB6FD, 0xBF3E,   // 0x10A0 (4256)
+0xBF5E, 0xBF3E, 0xB71D, 0xAF1C, 0x8C8D, 0xD6C2, 0xB6A4, 0xC744, 0xA5C3, 0x7C6E, 0xA61B, 0xBF1E, 0xC73E, 0xC75E, 0xBF3E, 0xBF1E,   // 0x10B0 (4272)
+0xB75C, 0xBF59, 0x8E2F, 0x6D48, 0x7DA8, 0x6CE7, 0x22C6, 0x04C7, 0xB6D9, 0xB73C, 0xB75E, 0xB75F, 0xB71E, 0xAEDE, 0xB71F, 0x9DB8,   // 0x10C0 (4288)
+0x740E, 0x7446, 0x9D83, 0x9583, 0x9DC3, 0x9563, 0x5B0D, 0xB6BD, 0xB6FD, 0xAEDD, 0xA6BE, 0xA6BE, 0xA6BE, 0xA6BD, 0xB6DE, 0xB6FE,   // 0x10D0 (4304)
+0xB6DE, 0xC71D, 0xD75D, 0xBE7D, 0x427D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085B, 0x951D, 0xCF3E, 0xC73E, 0xCF7F, 0xBF5E,   // 0x10F0 (4336)
+0xBF3E, 0xBF5E, 0xBF5E, 0xBF5D, 0x7C2C, 0xF7A7, 0xAE24, 0xBEE4, 0xC744, 0xBEE3, 0x7CA5, 0x8CB4, 0xCEFD, 0xC73F, 0xBF3F, 0xBF1F,   // 0x1100 (4352)
+0xC75D, 0xBF5B, 0xA6B3, 0x6D48, 0x964B, 0x6CC8, 0x2BA8, 0x350C, 0xCF1B, 0xB75C, 0xB75D, 0xB73E, 0xBF5E, 0xBEBD, 0x8CF2, 0x9528,   // 0x1110 (4368)
+0xBEC8, 0xB667, 0x9DA8, 0xA5E5, 0xCF65, 0x9DC3, 0x5B0D, 0xB6DD, 0xAEFD, 0xAEDE, 0xAEBF, 0xA69D, 0xAEBD, 0xAEDD, 0xC73E, 0xBF1E,   // 0x1120 (4384)
+0xCF3E, 0xD75F, 0xDF9F, 0xAD9E, 0x10BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBC, 0xCEFD, 0xD77F, 0xCF7F, 0xC75F,   // 0x1140 (4416)
+0xC75F, 0xC75F, 0xC77F, 0xC77E, 0x7C0B, 0xFFE7, 0xD6C5, 0xA644, 0xBF04, 0xBF04, 0xC744, 0xA602, 0x7C0B, 0xCF1E, 0xC75F, 0xCF5F,   // 0x1150 (4432)
+0xC75E, 0xC75C, 0xBF57, 0x8DEC, 0x8DEA, 0x5C27, 0x2C4A, 0x4D0E, 0xDF3D, 0xBF5D, 0xB71E, 0xBF1E, 0xBE17, 0x9CC7, 0xB686, 0xBF08,   // 0x1160 (4448)
+0xA589, 0x9D67, 0xBEAA, 0xBF05, 0xD789, 0x9DA5, 0x52EB, 0xAEBC, 0xAEFE, 0xA6BE, 0x9E9E, 0xAE9D, 0xBF1E, 0xCF9F, 0xCF3D, 0xCF5E,   // 0x1170 (4464)
+0xD77E, 0xDF9E, 0xE7BE, 0x847E, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FB, 0xB5FE, 0xE7BF, 0xD79F, 0xCF9F,   // 0x1190 (4496)
+0xD77F, 0xCF7F, 0xCF7E, 0xCF7F, 0x8C6D, 0xFFC7, 0xF7A6, 0xADE3, 0xB6A4, 0xBF04, 0xBEE4, 0xC744, 0xB6C3, 0x6BC8, 0xBE5A, 0xCF5F,   // 0x11A0 (4512)
+0xCF5E, 0xD79E, 0xCF99, 0xA66F, 0x8DCB, 0x42E6, 0x0C88, 0x85B3, 0xCF7E, 0xCF7E, 0xBF1E, 0xBF1E, 0xCE88, 0xBEA3, 0xA605, 0x8D04,   // 0x11B0 (4528)
+0xB664, 0xBF25, 0xBEE5, 0xBEE4, 0xDF8B, 0x9D84, 0x6BCF, 0xC77D, 0xB73E, 0xB6FE, 0xBF3E, 0xC75E, 0xC73D, 0xCF5D, 0xD77E, 0xD77E,   // 0x11C0 (4544)
+0xDF7E, 0xF7FF, 0xBE3E, 0x215E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x4A9C, 0xBE7E, 0xE7DF, 0xDFBF,   // 0x11E0 (4576)
+0xDFBF, 0xD7BF, 0xD7BF, 0xD79F, 0x7C0F, 0xC626, 0xFFE6, 0xDF01, 0x9DA4, 0xBF04, 0xB704, 0xBEE4, 0xC744, 0x9DE3, 0x5304, 0xADF9,   // 0x11F0 (4592)
+0xCF7F, 0xD79E, 0xD7BA, 0xB6F2, 0x95ED, 0x3266, 0x04A8, 0xCF3B, 0xD79F, 0xD79F, 0xBE75, 0xE768, 0xBE23, 0x8D24, 0x9D84, 0xBF04,   // 0x1200 (4608)
+0xBF24, 0xB704, 0xB703, 0xBF05, 0xE7AB, 0x8D03, 0x84B3, 0xCFBE, 0xCFBF, 0xCF9E, 0xCF7D, 0xD77E, 0xCF5D, 0xDF9E, 0xE7DF, 0xE7BE,   // 0x1210 (4624)
+0xF7FF, 0xD71E, 0x52DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x425B, 0xB61D, 0xEFDF,   // 0x1230 (4656)
+0xEFFF, 0xE7DF, 0xDFBF, 0xDFDF, 0x8C91, 0xADA5, 0xE727, 0xFFE0, 0xCE62, 0x9DC3, 0xC724, 0xBEE4, 0xBEE4, 0xBF04, 0x9543, 0x7C85,   // 0x1240 (4672)
+0xC71C, 0xCF7D, 0xCFBB, 0xB6F3, 0x8D2E, 0x1AA6, 0x1428, 0xD79D, 0xD77E, 0xADAB, 0xFFE0, 0xE722, 0x7C23, 0xAE44, 0xC724, 0xBF04,   // 0x1250 (4688)
+0xBF24, 0xBF04, 0xBF03, 0xD74A, 0xD788, 0x6C03, 0xADF7, 0xDFDF, 0xDFDF, 0xDFDF, 0xDFBE, 0xDFBE, 0xDF9E, 0xE7DF, 0xEFFF, 0xF7FF,   // 0x1260 (4704)
+0xC69E, 0x4A9D, 0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x31DD, 0x849C,   // 0x1280 (4736)
+0xC67D, 0xE7BF, 0xEFFE, 0xDF9F, 0x9D54, 0xAE63, 0xB606, 0xBE22, 0xE741, 0xB603, 0xAE44, 0xC724, 0xBF04, 0xBF04, 0x9DA4, 0xAE63,   // 0x1290 (4752)
+0x950D, 0xCF7B, 0xCF79, 0xBF35, 0x8CEE, 0x02C5, 0x4C6B, 0xD79C, 0xADCE, 0xFFC0, 0xE6E1, 0x9D23, 0xBEE5, 0xCF64, 0xC744, 0xB704,   // 0x12A0 (4768)
+0xAE64, 0x9DE3, 0xA5E6, 0xC64B, 0xADE2, 0x52A5, 0xDF7D, 0xEFDF, 0xE7DF, 0xE7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xE79E, 0xA55E,   // 0x12B0 (4784)
+0x39FE, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109D,   // 0x12D0 (4816)
+0x4A5C, 0x7C3A, 0xADDA, 0xD71D, 0xB5F8, 0x8D63, 0xC765, 0xAE44, 0x9D83, 0xADC3, 0x8CE4, 0xA604, 0xBF24, 0xC704, 0xAE44, 0xAE24,   // 0x12E0 (4832)
+0xAE23, 0xB637, 0xCF3B, 0xC719, 0x6BD0, 0x0324, 0x5C51, 0xCEB8, 0xE742, 0xDEC1, 0xA5A3, 0xBF24, 0xB685, 0x8D45, 0x7C64, 0x8443,   // 0x12F0 (4848)
+0x9CE2, 0xBDA3, 0xDECA, 0xFFA3, 0xC600, 0x8C30, 0xF7DF, 0xF7FE, 0xF7FF, 0xEFDF, 0xF7FF, 0xE77E, 0xC69C, 0xA55D, 0x5B3D, 0x18BE,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001E, 0x005C, 0x299C, 0x5B1E, 0x6B9E, 0x6B9F, 0x6BBF, 0x6B9F, 0x73DF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6B9F, 0x6B9F, 0x637E,   // 0x1330 (4912)
+0x6B9E, 0x6BBF, 0x5B1E, 0x5B1D, 0x217D, 0x001F, 0x109D, 0x635E, 0x5B1E, 0x637F, 0x6B7F, 0x739F, 0x6B7F, 0x637F, 0x635E, 0x6B7F,   // 0x1340 (4928)
+0x6B7F, 0x73BF, 0x73BF, 0x73DF, 0x739F, 0x6B9F, 0x6B9F, 0x739F, 0x739F, 0x73BF, 0x73BF, 0x52DE, 0x31DD, 0x10BD, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1460 (5216)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1470 (5232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14B0 (5296)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14C0 (5312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1510 (5392)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1520 (5408)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1530 (5424)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1550 (5456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1560 (5472)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1570 (5488)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1580 (5504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x109F, 0x085F,   // 0x15B0 (5552)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15C0 (5568)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15D0 (5584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15F0 (5616)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x1600 (5632)
+0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F,   // 0x1610 (5648)
+0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1620 (5664)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1640 (5696)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x211F, 0xFFFF, 0x001F, 0x001F,   // 0x1650 (5712)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x1660 (5728)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1670 (5744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1690 (5776)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x16A0 (5792)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x16B0 (5808)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16C0 (5824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16E0 (5856)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x213F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x16F0 (5872)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x1700 (5888)
+0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1710 (5904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x1740 (5952)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x1750 (5968)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1790 (6032)
+0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_718/fotos.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: fotos.jpg
+// Time generated: 24.03.2014 12:47:16
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short fotos[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00D0 (208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001E, 0x18FB, 0x52DA, 0x94DD, 0xBDFF, 0xB5DF, 0xADBF, 0xB5FE, 0xB5DF, 0xADBE, 0xADBE, 0xB5BF, 0xAD9E, 0xAD9E, 0xB5BF, 0xB5DF,   // 0x0110 (272)
+0xB5DF, 0xAD9E, 0xADBE, 0xA55D, 0xB5DF, 0xADBF, 0xADBF, 0xADBE, 0xA55E, 0xB5DF, 0xB5DF, 0xA57E, 0xA57E, 0xAD7E, 0xA55E, 0xA57E,   // 0x0120 (288)
+0xB5BF, 0xADDF, 0xADDF, 0xADBF, 0xADBE, 0xB5BE, 0xB5BE, 0xB5BF, 0xB5DF, 0xB5BE, 0xBDFF, 0xAD9E, 0x6BBC, 0x297C, 0x001E, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31DC,   // 0x0150 (336)
+0x94BD, 0xC65E, 0xCEBD, 0xC69C, 0xCEDD, 0xCEDD, 0xCEBD, 0xC6BC, 0xC6BC, 0xC6DB, 0xC6DC, 0xC6BC, 0xCEBC, 0xCEBC, 0xCEBC, 0xCEBC,   // 0x0160 (352)
+0xC69C, 0xCE9C, 0xCEBD, 0xC69C, 0xCEBD, 0xCEDD, 0xC69C, 0xCEDD, 0xC69C, 0xCEBC, 0xCEDC, 0xC69B, 0xCE9B, 0xCEBB, 0xCE9B, 0xCEBC,   // 0x0170 (368)
+0xCEBD, 0xC6DD, 0xC6BD, 0xC6BC, 0xCEBC, 0xCE9C, 0xCEBC, 0xCEBC, 0xC6DC, 0xCEDC, 0xD6FD, 0xD6FD, 0xD6DC, 0xBE3C, 0x9D3D, 0x425D,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x633C, 0xBE3D,   // 0x01A0 (416)
+0xCEBC, 0xCEBC, 0xCEDD, 0xC6BD, 0xC6BD, 0xBEBD, 0xC69D, 0xC6BD, 0xBEBC, 0xBEBA, 0xBEBB, 0xC6BB, 0xC6BC, 0xC69C, 0xC69C, 0xC69C,   // 0x01B0 (432)
+0xC69C, 0xC69C, 0xCEBD, 0xCEDD, 0xC69C, 0xC6BC, 0xBE5B, 0xC6BC, 0xC69C, 0xC6BB, 0xD6FB, 0xCEBB, 0xC69B, 0xCEBC, 0xCE9C, 0xC69C,   // 0x01C0 (448)
+0xC69D, 0xBEBD, 0xBEBC, 0xBEBC, 0xC69C, 0xCE9C, 0xC69C, 0xC6BC, 0xBEBD, 0xC6BD, 0xCEBD, 0xCEFD, 0xD71D, 0xD71E, 0xD71D, 0xC65D,   // 0x01D0 (464)
+0x6B5C, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087C, 0x73DC, 0xBE5D, 0xC69B,   // 0x01F0 (496)
+0xBE7C, 0xC69D, 0xBE9D, 0xBE7D, 0xBE9E, 0xBE9E, 0xBE9D, 0xBE9D, 0xBE9B, 0xBEBB, 0xB6BB, 0xBE9C, 0xC6BC, 0xC69C, 0xBE7B, 0xC6BB,   // 0x0200 (512)
+0xCEDB, 0xC6BB, 0xC69B, 0xC67C, 0xBE5B, 0xBE7B, 0xC67B, 0xC67B, 0xC69A, 0xD71B, 0xDF7C, 0xCEDB, 0xC69B, 0xCE9C, 0xC65B, 0xC67C,   // 0x0210 (528)
+0xBE7C, 0xBEBC, 0xBEBC, 0xBEBC, 0xC69C, 0xC69C, 0xC69D, 0xBEBD, 0xB6BE, 0xB69D, 0xBEBD, 0xBEBD, 0xC69D, 0xCEDD, 0xD71D, 0xD6FD,   // 0x0220 (544)
+0xC67D, 0x73DD, 0x003D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x635C, 0xB63C, 0xC6BC, 0xBE9C,   // 0x0240 (576)
+0xBE5C, 0xBE9D, 0xBE9E, 0xB69E, 0xB67D, 0xB65D, 0xB65C, 0xBE7C, 0xBE9C, 0xB6BB, 0xB69C, 0xB69D, 0xBE7C, 0xBE5B, 0xBE7A, 0xCEFA,   // 0x0250 (592)
+0xDF5B, 0xD73B, 0xC69A, 0xBE59, 0xC67A, 0xCE9A, 0xD6FC, 0xCE9A, 0xCE99, 0xDF5A, 0xEFDB, 0xD6FA, 0xC67A, 0xC65B, 0xC63A, 0xC67B,   // 0x0260 (608)
+0xC69B, 0xBE9B, 0xB69B, 0xB69C, 0xBE7C, 0xBE7C, 0xBE7D, 0xB67D, 0xAE7E, 0xB67E, 0xB6BE, 0xB6BD, 0xBE9D, 0xC6BD, 0xC6DD, 0xC6BC,   // 0x0270 (624)
+0xCEBC, 0xC67C, 0x6B7E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ABD, 0xADDC, 0xB67B, 0xBE9C, 0xBE7D,   // 0x0290 (656)
+0xBE7D, 0xB67D, 0xAE7D, 0xAE7D, 0xAE9D, 0xB69D, 0xB65C, 0xBE5B, 0xB67B, 0xB67B, 0xB67D, 0xB65E, 0xBE7E, 0xBE5B, 0xBE58, 0xD6F9,   // 0x02A0 (672)
+0xE7BA, 0xE79A, 0xDF19, 0xC657, 0xC637, 0xD6D9, 0xEF7B, 0xE719, 0xE718, 0xEF78, 0xEF79, 0xD71A, 0xC679, 0xBE58, 0xCEBA, 0xDEDB,   // 0x02B0 (688)
+0xD6FB, 0xC69B, 0xBE7B, 0xB65C, 0xB67C, 0xBE7D, 0xBE7E, 0xB65E, 0xAE7E, 0xAE7E, 0xAE7D, 0xAE7D, 0xAE7D, 0xB67D, 0xBE9C, 0xBE7C,   // 0x02C0 (704)
+0xBE7C, 0xC6BB, 0xADDC, 0x423D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x635C, 0xB61C, 0xBE9C, 0xB65D, 0xB65D,   // 0x02E0 (736)
+0xB65C, 0xB67D, 0xAE5D, 0xA65D, 0xAE7D, 0xAE9D, 0xAE7B, 0xB63A, 0xB65B, 0xB67C, 0xB65D, 0xB63E, 0xBE5D, 0xC69B, 0xCEB9, 0xDF38,   // 0x02F0 (752)
+0xEFD8, 0xEF98, 0xE757, 0xD6B6, 0xCE75, 0xE717, 0xF798, 0xEF57, 0xEF36, 0xEF36, 0xEF37, 0xDEF8, 0xC677, 0xCE78, 0xDF1A, 0xEF5A,   // 0x0300 (768)
+0xE75B, 0xCEBA, 0xBE9A, 0xB65B, 0xB63C, 0xB65D, 0xB65D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE5D, 0xB65D, 0xB67D, 0xB67D,   // 0x0310 (784)
+0xB65C, 0xBE7B, 0xB63C, 0x5B3C, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213B, 0x8CFB, 0xB67D, 0xB69E, 0xAE5D, 0xAE5C,   // 0x0330 (816)
+0xAE5D, 0xAE7D, 0xAE7E, 0xA67E, 0xA67D, 0xA65C, 0xAE5A, 0xB65A, 0xB659, 0xB63A, 0xB61B, 0xB61C, 0xC65C, 0xD6DB, 0xE779, 0xE775,   // 0x0340 (832)
+0xF7B6, 0xF795, 0xEF75, 0xEF36, 0xE6F5, 0xFF56, 0xFF56, 0xF734, 0xEF34, 0xEEF4, 0xEF15, 0xDEF6, 0xCE75, 0xDED6, 0xF779, 0xF778,   // 0x0350 (848)
+0xEF58, 0xDEF9, 0xCE9A, 0xBE5B, 0xB65D, 0xB65D, 0xB65D, 0xB67D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE5D, 0xAE5C,   // 0x0360 (864)
+0xAE5C, 0xB65C, 0xBE7B, 0x8CDB, 0x18DB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x3A1B, 0xA5BB, 0xAE7C, 0xA65D, 0xA65D, 0xAE5D,   // 0x0380 (896)
+0xA61C, 0xA63C, 0xA63D, 0x9E3D, 0xA65D, 0xA65B, 0xB69B, 0xCF1C, 0xCEFA, 0xBE78, 0xB638, 0xB5F9, 0xC638, 0xDED9, 0xFFB9, 0xF774,   // 0x0390 (912)
+0xF7B4, 0xF773, 0xF774, 0xFF75, 0xFF35, 0xFF75, 0xFF54, 0xF6F2, 0xF6F3, 0xF6D3, 0xF6D4, 0xE6D5, 0xDEB4, 0xEF35, 0xFF96, 0xF775,   // 0x03A0 (928)
+0xEF35, 0xEF38, 0xCE99, 0xBE3A, 0xB63B, 0xB63B, 0xAE3B, 0xB65C, 0xAE7C, 0xAE5D, 0xAE5D, 0xAE5D, 0xAE5D, 0xAE5D, 0xA63D, 0xAE5C,   // 0x03B0 (944)
+0xAE3C, 0xAE3C, 0xB65B, 0xA59B, 0x3A1C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ABC, 0xA5FC, 0xAE7D, 0x9E3D, 0xA63D, 0xA63D,   // 0x03D0 (976)
+0xA63D, 0xA65D, 0xA65D, 0x9E5D, 0xA65C, 0xA63B, 0xB67A, 0xD71C, 0xE77B, 0xD738, 0xCEB7, 0xC637, 0xC5F5, 0xD694, 0xFF96, 0xF773,   // 0x03E0 (992)
+0xFF93, 0xFF73, 0xFF54, 0xFF74, 0xFF54, 0xFF53, 0xFF33, 0xF6B2, 0xF6B2, 0xF6B2, 0xF6B3, 0xEED4, 0xEF14, 0xFF95, 0xFFB4, 0xF753,   // 0x03F0 (1008)
+0xF754, 0xEF57, 0xCE76, 0xBE17, 0xBE59, 0xBE7A, 0xB65A, 0xAE5A, 0xAE7C, 0xAE5C, 0xAE5D, 0xAE5D, 0xA65D, 0xAE5E, 0xA65D, 0xAE5D,   // 0x0400 (1024)
+0xAE5D, 0xAE3D, 0xB65C, 0xADFC, 0x5B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBD, 0xAE3D, 0xA67D, 0xA65E, 0xA65E, 0xA61C,   // 0x0420 (1056)
+0x9E1C, 0xA63C, 0x9E3D, 0x9E5D, 0xA65C, 0xA61A, 0xB639, 0xD6FB, 0xEF9A, 0xEF97, 0xE736, 0xDEB5, 0xD653, 0xDEB2, 0xFF94, 0xFF72,   // 0x0430 (1072)
+0xFF72, 0xFF33, 0xFF53, 0xFF33, 0xFF53, 0xFF32, 0xFF32, 0xF6B1, 0xF691, 0xFED2, 0xEE91, 0xF6D3, 0xFF54, 0xFF93, 0xFF92, 0xF731,   // 0x0440 (1088)
+0xFF73, 0xE715, 0xC654, 0xC676, 0xD6F9, 0xD75B, 0xC6B9, 0xAE5A, 0xAE5C, 0xAE3C, 0xAE3C, 0xA63C, 0xA63D, 0xA65D, 0xA65D, 0xA65D,   // 0x0450 (1104)
+0xA65D, 0xA63D, 0xAE5C, 0xAE3C, 0x5B5D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x73FE, 0xAE5C, 0xAE9E, 0xA69E, 0xA65E, 0xA61D,   // 0x0470 (1136)
+0xA61C, 0x9DFC, 0x961C, 0x9E3D, 0x9E3C, 0xA61A, 0xADF8, 0xC678, 0xE717, 0xEF75, 0xEF54, 0xEF35, 0xEEF3, 0xEEF2, 0xFF72, 0xFF51,   // 0x0480 (1152)
+0xFF32, 0xFF13, 0xFF13, 0xFF12, 0xFF31, 0xFF10, 0xFF31, 0xF6B1, 0xF671, 0xFED1, 0xEE6F, 0xF6D1, 0xFF33, 0xFF51, 0xFF51, 0xFF31,   // 0x0490 (1168)
+0xF752, 0xDED2, 0xCE73, 0xD715, 0xE798, 0xEFDA, 0xC6D8, 0xA619, 0x9DFB, 0x9DFB, 0xA61C, 0xA61C, 0xA61C, 0xA61D, 0x9E3D, 0xA63D,   // 0x04A0 (1184)
+0xA63D, 0xA63D, 0xA63C, 0xA5DB, 0x52FD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xA63D, 0xAEBE, 0xA67E, 0xA65E, 0xA65D,   // 0x04C0 (1216)
+0xA65D, 0x9DFC, 0x9E1D, 0x9E3D, 0x95FB, 0xA61B, 0xADF8, 0xBE16, 0xDED5, 0xEF53, 0xEF32, 0xF753, 0xFF53, 0xFF31, 0xFF31, 0xFF31,   // 0x04D0 (1232)
+0xFED1, 0xFED2, 0xFED2, 0xFF11, 0xFF10, 0xFF0F, 0xFF30, 0xFED1, 0xEE50, 0xFEB0, 0xF66E, 0xFED1, 0xFF12, 0xFF10, 0xFF10, 0xFF31,   // 0x04E0 (1248)
+0xF731, 0xE732, 0xDF33, 0xEFB6, 0xEFB6, 0xE797, 0xBE96, 0xA5D8, 0xA5FB, 0x9DFB, 0x9DFB, 0xA5FB, 0xA61C, 0x9E1C, 0x9E1D, 0x9E1D,   // 0x04F0 (1264)
+0x9E3E, 0x9E3D, 0xA61C, 0x9DBB, 0x5B3D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0xA5FD, 0xAE7E, 0xA67E, 0xA65D, 0xA67E,   // 0x0510 (1296)
+0xA65D, 0xA63D, 0xA61D, 0xA61D, 0x9DFC, 0xA5FB, 0xAE18, 0xBDF3, 0xDE93, 0xFF53, 0xF711, 0xF711, 0xF6F0, 0xFF10, 0xFF30, 0xFF31,   // 0x0520 (1312)
+0xFEB0, 0xFEB1, 0xF691, 0xFED1, 0xFED0, 0xFEEF, 0xFEEF, 0xFEAF, 0xF64F, 0xFEB0, 0xEE4E, 0xFEB0, 0xFED0, 0xFEF0, 0xFF10, 0xFF31,   // 0x0530 (1328)
+0xFF31, 0xF771, 0xF792, 0xF7B3, 0xF7D4, 0xD715, 0xB614, 0xADD6, 0xA5F8, 0xA618, 0xA618, 0x9DFA, 0x9E1C, 0x9DFD, 0x9DDD, 0x961D,   // 0x0540 (1344)
+0x961D, 0x961D, 0x9E1C, 0x9DDB, 0x5AFD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637E, 0xA5FD, 0xAE3E, 0xA65E, 0xA65E, 0x9E5D,   // 0x0560 (1376)
+0xA67E, 0xAE7E, 0xAE3E, 0xAE1D, 0xAE3C, 0xAE3A, 0xBE78, 0xD674, 0xEED3, 0xFF32, 0xFF10, 0xF6EF, 0xF6CE, 0xFEEE, 0xFEEF, 0xFEF0,   // 0x0570 (1392)
+0xFE8F, 0xF670, 0xFE91, 0xFE90, 0xFE8F, 0xFE8F, 0xFE8E, 0xFE90, 0xEE2E, 0xFE91, 0xEE2E, 0xFE8F, 0xFE8F, 0xFEEF, 0xFEEF, 0xF6D0,   // 0x0580 (1408)
+0xFF51, 0xFF70, 0xFF8F, 0xEF6F, 0xF772, 0xCE72, 0xBDF4, 0xC656, 0xC697, 0xC6F9, 0xB6DA, 0x9E1A, 0x95DB, 0x9DDC, 0x9DDD, 0x95FD,   // 0x0590 (1424)
+0x8DFD, 0x8DFD, 0x961C, 0x9DBB, 0x52FD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x635E, 0xA5DD, 0xA63E, 0xA63E, 0x9E5E, 0x9E5D,   // 0x05B0 (1456)
+0xA65D, 0xA63D, 0xAE5C, 0xAE3B, 0xAE39, 0xB637, 0xCEB5, 0xEF14, 0xFF31, 0xFF2F, 0xF6EE, 0xFF0E, 0xFEEE, 0xFEED, 0xFEAD, 0xFEAE,   // 0x05C0 (1472)
+0xF66E, 0xEDED, 0xFE90, 0xFE6F, 0xFE4F, 0xF64F, 0xF66F, 0xF670, 0xE5EE, 0xFE71, 0xEDCE, 0xF64E, 0xFE8E, 0xFE8D, 0xFEAD, 0xFF10,   // 0x05D0 (1488)
+0xFF0F, 0xFF2F, 0xFF4E, 0xF72E, 0xEF10, 0xD630, 0xDE73, 0xE715, 0xEF76, 0xE79A, 0xBEDA, 0x9E1B, 0x95BB, 0x95BC, 0x9DDC, 0x95DD,   // 0x05E0 (1504)
+0x8E1E, 0x8DFD, 0x961C, 0x95BB, 0x52DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0x9DBD, 0x9E1E, 0x9E1E, 0x9E3D, 0x963D,   // 0x0600 (1536)
+0x961C, 0x961B, 0xAE9B, 0xC6DA, 0xC6D7, 0xC693, 0xD6B2, 0xF731, 0xFF4F, 0xFF2D, 0xFF0D, 0xFEEE, 0xFECD, 0xFECD, 0xFEAD, 0xFE8D,   // 0x0610 (1552)
+0xF62C, 0xEDAC, 0xEDCD, 0xF62F, 0xEDEE, 0xEE2F, 0xF671, 0xDDEF, 0xDDF0, 0xDDAF, 0xDDAE, 0xEE4F, 0xF66E, 0xFEAE, 0xFECD, 0xFEEE,   // 0x0620 (1568)
+0xFECE, 0xFECE, 0xFF0E, 0xFF4F, 0xF70F, 0xE6B0, 0xF6F2, 0xF731, 0xF752, 0xD6D5, 0xA5F7, 0x95B9, 0x959B, 0x95BB, 0x95BB, 0x8DDC,   // 0x0630 (1584)
+0x85FD, 0x85FD, 0x8DFC, 0x8D9B, 0x52DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533D, 0x95BD, 0x95FD, 0x95FE, 0x961D, 0x8E1D,   // 0x0650 (1616)
+0x8E1C, 0x961B, 0xA679, 0xCF39, 0xDF77, 0xE753, 0xF750, 0xFF2F, 0xFF2D, 0xFF2C, 0xFF0D, 0xFEEE, 0xFE8D, 0xFE6D, 0xFE6D, 0xFE6C,   // 0x0660 (1632)
+0xFDEB, 0xE56B, 0xDD4C, 0xEDCF, 0xD54E, 0xCD2E, 0xD590, 0xA46C, 0xB4CF, 0x93EB, 0xA44C, 0xCD6E, 0xE5CE, 0xF66E, 0xFECE, 0xFE8D,   // 0x0670 (1648)
+0xFECD, 0xFECD, 0xFF2D, 0xFF2E, 0xFF2E, 0xF70F, 0xFF30, 0xFF0F, 0xF70F, 0xCE71, 0xA5D3, 0x9575, 0x9597, 0x95B8, 0x8DB8, 0x8DDB,   // 0x0680 (1664)
+0x85DC, 0x85DC, 0x8DDC, 0x8D5B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x8D9D, 0x8DDD, 0x8DBD, 0x8DDD, 0x8DDD,   // 0x06A0 (1696)
+0x8DFD, 0x8DFB, 0x95F7, 0xBE95, 0xDF34, 0xEF51, 0xFF4F, 0xFF2D, 0xFF0C, 0xFF0C, 0xFEED, 0xFECE, 0xFE6D, 0xFE2C, 0xFDEB, 0xFE2C,   // 0x06B0 (1712)
+0xFE0D, 0xE52C, 0xC48B, 0xBC6C, 0xA40B, 0x9BCB, 0x9BED, 0x7B2A, 0x7B4B, 0x62C9, 0x6AE8, 0x8B8A, 0x9BE9, 0xCD6B, 0xFE8E, 0xFE8D,   // 0x06C0 (1728)
+0xFECD, 0xFEED, 0xFF2D, 0xFEEC, 0xFF0C, 0xFF2E, 0xFF0E, 0xFF0D, 0xFF0D, 0xDEB0, 0xC652, 0xB653, 0xBEB6, 0xBEB8, 0xA659, 0x8DD9,   // 0x06D0 (1744)
+0x7DBB, 0x7DBC, 0x85BB, 0x8D5B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4AFD, 0x857C, 0x85DD, 0x85BC, 0x85BD, 0x85DD,   // 0x06F0 (1776)
+0x85DD, 0x85DC, 0x8DD7, 0xB634, 0xD6D2, 0xE6EF, 0xF6ED, 0xFF0C, 0xFF0B, 0xFECB, 0xFE8C, 0xFE8D, 0xFE4C, 0xFDEB, 0xF5AA, 0xFDEC,   // 0x0700 (1792)
+0xFDEE, 0xDD2E, 0x9B69, 0x7AA7, 0x7AA9, 0x72EA, 0x72EB, 0x6AEB, 0x62EB, 0x62CA, 0x62EA, 0x6AE9, 0x6265, 0x8BA7, 0xD56C, 0xF66E,   // 0x0710 (1808)
+0xFECD, 0xFECC, 0xFECB, 0xF6CB, 0xFEEB, 0xFF0C, 0xFEEB, 0xFEEC, 0xFF0C, 0xEEEE, 0xDEAF, 0xE733, 0xEFB7, 0xDF99, 0xB699, 0x8DB8,   // 0x0720 (1824)
+0x7D7A, 0x7D9C, 0x859B, 0x853B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4AFD, 0x857C, 0x85DC, 0x7D9C, 0x85BD, 0x7DBD,   // 0x0740 (1856)
+0x85BD, 0x8DDD, 0x95B9, 0xB636, 0xD6D3, 0xE6CF, 0xEEAB, 0xFEEB, 0xFEEC, 0xFECC, 0xFE6C, 0xF62B, 0xF5EA, 0xFDCA, 0xF58A, 0xED6B,   // 0x0750 (1872)
+0xDD0C, 0xB40B, 0x7A88, 0x6A69, 0x6A8B, 0x6AEB, 0x6B0C, 0x630C, 0x5AEC, 0x632D, 0x6B4C, 0x630B, 0x62A8, 0x6265, 0x8346, 0xCD6C,   // 0x0760 (1888)
+0xEE2D, 0xF64B, 0xF669, 0xFEC9, 0xFEE9, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEB, 0xFEEC, 0xF70D, 0xF72F, 0xE712, 0xC674, 0x9DB5, 0x8557,   // 0x0770 (1904)
+0x7D7A, 0x7D9C, 0x859B, 0x851B, 0x4A9D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D7C, 0x85BD, 0x7D9C, 0x7DBD, 0x7DBD,   // 0x0790 (1936)
+0x7DBD, 0x857C, 0x9578, 0xADB5, 0xCE73, 0xE6D0, 0xE68B, 0xF6A9, 0xFECB, 0xFECB, 0xFE8B, 0xFE0A, 0xEDA8, 0xED68, 0xE549, 0xDD4B,   // 0x07A0 (1952)
+0xBC4A, 0x82C8, 0x6248, 0x6ACB, 0x5A8B, 0x5AAB, 0x62EC, 0x5AEC, 0x5AEC, 0x6B6C, 0x630B, 0x6AEB, 0x6ACA, 0x5A46, 0x59E3, 0xAC4A,   // 0x07B0 (1968)
+0xDD6C, 0xEDEB, 0xF629, 0xFE89, 0xFEA8, 0xFEA8, 0xFEC8, 0xFEEA, 0xFEEB, 0xFF0A, 0xFF0B, 0xEECD, 0xD650, 0xADB2, 0x8D36, 0x857A,   // 0x07C0 (1984)
+0x7D5B, 0x7D7C, 0x7D7C, 0x853B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D7C, 0x7DBD, 0x7D9D, 0x7DDD, 0x759D,   // 0x07E0 (2016)
+0x7D9C, 0x859B, 0x9578, 0x9D53, 0xB5B0, 0xD68F, 0xEEAC, 0xF689, 0xFEC9, 0xFE89, 0xFEAA, 0xFE4A, 0xF5C8, 0xE547, 0xDD08, 0xD52B,   // 0x07F0 (2032)
+0xABEA, 0x5A05, 0x6269, 0x5A6A, 0x528B, 0x52AA, 0x52EB, 0x632D, 0x632C, 0x7BAD, 0x732B, 0x6B2B, 0x6AEA, 0x5A68, 0x5A05, 0x9BA9,   // 0x0800 (2048)
+0xD50C, 0xEDAB, 0xFDE9, 0xFE28, 0xFE47, 0xFE87, 0xFEA7, 0xFEC9, 0xFEE9, 0xFEEA, 0xF6CA, 0xDE2C, 0xC5EF, 0xA574, 0x8518, 0x7D3C,   // 0x0810 (2064)
+0x755E, 0x6D5D, 0x7D7C, 0x7D1B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DD, 0x755C, 0x7DBE, 0x7DBF, 0x7DDE, 0x759D,   // 0x0830 (2096)
+0x7D9C, 0x859A, 0x9596, 0xA572, 0xAD8E, 0xD64D, 0xF6ED, 0xF6A9, 0xFE88, 0xFE88, 0xFE68, 0xFE28, 0xF5C8, 0xED89, 0xDD2A, 0xBC49,   // 0x0840 (2112)
+0x82E7, 0x6268, 0x5229, 0x4A6A, 0x4ACB, 0x4ACA, 0x4ACB, 0x5B0C, 0x632D, 0x7B6D, 0x9450, 0x732C, 0x6AEB, 0x5A89, 0x5A47, 0x61E4,   // 0x0850 (2128)
+0xB429, 0xE54B, 0xFDA9, 0xFDC8, 0xFE27, 0xFE46, 0xFE87, 0xFEA8, 0xFEC8, 0xF6E9, 0xEEAA, 0xDE4C, 0xC610, 0x9D75, 0x7D1B, 0x757E,   // 0x0860 (2144)
+0x6D7E, 0x655D, 0x759C, 0x74FB, 0x427C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x323C, 0x64BC, 0x6D5D, 0x6D7E, 0x75BE, 0x75BE,   // 0x0880 (2176)
+0x7D9C, 0x8599, 0x9DF6, 0xBE54, 0xCE90, 0xE6EE, 0xF70C, 0xF6C8, 0xFE67, 0xFE67, 0xFE27, 0xFDE7, 0xF587, 0xF589, 0xE56C, 0xA3A8,   // 0x0890 (2192)
+0x6A45, 0x5A69, 0x4A29, 0x426A, 0x428A, 0x4289, 0x4249, 0x424A, 0x4A6B, 0x5A8B, 0x83EF, 0x8C30, 0x734C, 0x62EB, 0x5226, 0x59C3,   // 0x08A0 (2208)
+0xB42A, 0xDD0A, 0xED28, 0xFD67, 0xFDC7, 0xFE06, 0xFE67, 0xFE88, 0xF6A8, 0xEEA8, 0xEECA, 0xE6AE, 0xB5F0, 0x8D55, 0x755C, 0x657E,   // 0x08B0 (2224)
+0x5D7E, 0x5D7D, 0x6D7B, 0x6499, 0x321C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x2A1C, 0x547B, 0x5CFC, 0x5D1C, 0x655D, 0x6D7D,   // 0x08D0 (2256)
+0x7DBC, 0x961B, 0xBEF9, 0xDF57, 0xE731, 0xEEEC, 0xF6A9, 0xFEA7, 0xFE86, 0xFE46, 0xFE47, 0xFDC7, 0xF527, 0xE4E8, 0xDCCA, 0x9B27,   // 0x08E0 (2272)
+0x61E5, 0x49E7, 0x4209, 0x424A, 0x3A6A, 0x3A49, 0x3A29, 0x3A0A, 0x39E9, 0x39A8, 0x524A, 0x8410, 0x738D, 0x5ACA, 0x4A07, 0x5A05,   // 0x08F0 (2288)
+0x9B88, 0xCCC9, 0xE508, 0xF527, 0xFDA7, 0xFE07, 0xFE47, 0xFE88, 0xF6A8, 0xEEA7, 0xF70A, 0xD66B, 0xA58C, 0x8D54, 0x757C, 0x5D5E,   // 0x0900 (2304)
+0x557E, 0x555C, 0x54F9, 0x5438, 0x29DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x325C, 0x5C9B, 0x5CFC, 0x54DC, 0x5CFC, 0x5CFB,   // 0x0920 (2336)
+0x651A, 0x7D9A, 0xA657, 0xC692, 0xDEAD, 0xF6EA, 0xF686, 0xFE65, 0xFE45, 0xFE45, 0xFDE5, 0xFD86, 0xF527, 0xE4C8, 0xD469, 0x92C5,   // 0x0930 (2352)
+0x5163, 0x49C7, 0x41E9, 0x3A2A, 0x3A4A, 0x3229, 0x31E8, 0x31C8, 0x39C9, 0x41E9, 0x31A8, 0x6B4D, 0x738D, 0x4A49, 0x41C6, 0x4963,   // 0x0940 (2368)
+0x61C1, 0xBC47, 0xE4E7, 0xED06, 0xFD86, 0xFDE7, 0xFE27, 0xFE67, 0xF687, 0xEE86, 0xF6E8, 0xF74C, 0xD6CF, 0x95D3, 0x6539, 0x553C,   // 0x0950 (2384)
+0x44FB, 0x44DB, 0x4CB9, 0x4C18, 0x29BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DD, 0x64FC, 0x5D1C, 0x54DB, 0x54FB, 0x5CFB,   // 0x0970 (2416)
+0x5CFA, 0x5CD7, 0x74F2, 0x9D4D, 0xCE0A, 0xF687, 0xFE45, 0xFE24, 0xFE24, 0xFE24, 0xFDC4, 0xFD65, 0xF526, 0xECC6, 0xDCA8, 0xB3A7,   // 0x0980 (2432)
+0x6A24, 0x4985, 0x3987, 0x31E9, 0x3A2A, 0x3209, 0x31C8, 0x31C8, 0x39E9, 0x39A8, 0x39C7, 0x6B4C, 0x736C, 0x5249, 0x4145, 0x4122,   // 0x0990 (2448)
+0x7A64, 0xC467, 0xE506, 0xF526, 0xFDA6, 0xFDE6, 0xFE25, 0xFE65, 0xFE85, 0xFEA5, 0xFEC7, 0xF6E9, 0xEF4F, 0xAE54, 0x5C96, 0x449A,   // 0x09A0 (2464)
+0x44FB, 0x44BB, 0x4CBA, 0x5458, 0x325B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x431D, 0x653C, 0x5D7C, 0x551B, 0x5D1C, 0x5D1C,   // 0x09C0 (2496)
+0x5D1C, 0x64FA, 0x74F4, 0xA56F, 0xD5CA, 0xE5C4, 0xF603, 0xFE23, 0xFE43, 0xFE03, 0xFDC3, 0xFD85, 0xF504, 0xE484, 0xE4A6, 0xCC68,   // 0x09D0 (2512)
+0x8AC5, 0x49A4, 0x41A7, 0x31C9, 0x31EA, 0x31E9, 0x31C7, 0x31A6, 0x3185, 0x39E7, 0x4A28, 0x6309, 0x4A46, 0x49C7, 0x4945, 0x4902,   // 0x09E0 (2528)
+0x8265, 0xD468, 0xE4E6, 0xFD25, 0xFD84, 0xFDE4, 0xFE03, 0xFE22, 0xFE42, 0xFE84, 0xF644, 0xDDC4, 0xBD87, 0x8CEE, 0x5C95, 0x54DB,   // 0x09F0 (2544)
+0x4CDC, 0x44BC, 0x549C, 0x64FA, 0x53BA, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B5E, 0x6D9D, 0x65BD, 0x5D5C, 0x5D3C, 0x5D1B,   // 0x0A10 (2576)
+0x5D1C, 0x5D3B, 0x7556, 0xA5F2, 0xC5EB, 0xDDE5, 0xFE23, 0xFDC1, 0xF5A0, 0xF5C0, 0xF560, 0xFD42, 0xFD23, 0xF4E4, 0xEC85, 0xBB83,   // 0x0A20 (2592)
+0x6140, 0x40E2, 0x3925, 0x2967, 0x2988, 0x31A8, 0x3A08, 0x31C7, 0x3185, 0x3966, 0x5288, 0x5AE9, 0x39E5, 0x2903, 0x3103, 0x5921,   // 0x0A30 (2608)
+0xAB46, 0xD406, 0xE444, 0xF4A3, 0xFD23, 0xFDA1, 0xFDC0, 0xFDA0, 0xFDC0, 0xFE02, 0xF603, 0xCD23, 0x9C86, 0x7CCF, 0x64F7, 0x4CBA,   // 0x0A40 (2624)
+0x4CBC, 0x4CDD, 0x54BC, 0x6CDA, 0x537B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x6DBD, 0x6DDF, 0x659E, 0x655D, 0x651C,   // 0x0A60 (2656)
+0x653C, 0x5D3B, 0x6536, 0x7D51, 0xA5AB, 0xD626, 0xF623, 0xFE01, 0xFDE0, 0xFE00, 0xFDC0, 0xFD61, 0xFCE1, 0xFCA2, 0xE421, 0xC3A2,   // 0x0A70 (2672)
+0x79C0, 0x2800, 0x1000, 0x0843, 0x1084, 0x20C4, 0x2125, 0x10C3, 0x2145, 0x41A6, 0x3966, 0x18E3, 0x1081, 0x0000, 0x1000, 0x6180,   // 0x0A80 (2688)
+0xBB63, 0xCB42, 0xDB41, 0xEC21, 0xFD01, 0xFDC0, 0xFE00, 0xFDC0, 0xF560, 0xFDC1, 0xF624, 0xCD66, 0x948A, 0x7492, 0x6519, 0x5D1C,   // 0x0A90 (2704)
+0x54FD, 0x551D, 0x5CDD, 0x753B, 0x5BBB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7DBD, 0x75DE, 0x6D9F, 0x655D, 0x651B,   // 0x0AB0 (2736)
+0x653B, 0x6538, 0x7575, 0x95D1, 0xBE2C, 0xE647, 0xF603, 0xFE00, 0xFDE0, 0xFE00, 0xFE00, 0xFDA1, 0xFD41, 0xF4A0, 0xEC40, 0xDC02,   // 0x0AC0 (2752)
+0xAAC2, 0x4880, 0x1000, 0x0800, 0x0000, 0x0000, 0x1062, 0x0001, 0x10A3, 0x1861, 0x28A2, 0x0800, 0x0000, 0x0800, 0x2000, 0x8A40,   // 0x0AD0 (2768)
+0xCB60, 0xDB61, 0xEB81, 0xEC01, 0xF4A0, 0xF580, 0xFE00, 0xFDE0, 0xF560, 0xED60, 0xE5A3, 0xCD89, 0x9D30, 0x8536, 0x6D5B, 0x5D3D,   // 0x0AE0 (2784)
+0x551D, 0x5D3E, 0x651D, 0x753B, 0x5BBB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x85BD, 0x7DFE, 0x75DE, 0x6DBD, 0x6D9C,   // 0x0B00 (2816)
+0x7579, 0x8597, 0xA5D2, 0xC62F, 0xDE4B, 0xEE47, 0xF624, 0xF5E1, 0xF600, 0xFE41, 0xFDE0, 0xFD80, 0xFD80, 0xFD00, 0xFCA0, 0xE3E0,   // 0x0B10 (2832)
+0xAAA0, 0x6100, 0x3040, 0x1800, 0x1000, 0x0801, 0x0000, 0x0800, 0x0800, 0x1820, 0x2881, 0x1000, 0x1800, 0x3000, 0x6960, 0xC362,   // 0x0B20 (2848)
+0xEC21, 0xEBA0, 0xF3E0, 0xFC81, 0xF4E1, 0xF560, 0xF5E0, 0xFE00, 0xF600, 0xE5A1, 0xDDA3, 0xC5AB, 0xA572, 0x8D58, 0x755C, 0x655E,   // 0x0B30 (2864)
+0x657E, 0x659E, 0x6D7D, 0x751C, 0x429C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85BD, 0x8DFE, 0x861E, 0x7E1E, 0x7E1E,   // 0x0B50 (2896)
+0x7DFA, 0x95F8, 0xB634, 0xCE50, 0xD62C, 0xDE29, 0xE606, 0xEDE3, 0xEDC0, 0xEDE0, 0xFE01, 0xFDC1, 0xFDA0, 0xFD40, 0xFD00, 0xFC61,   // 0x0B60 (2912)
+0xD381, 0xAB02, 0x8242, 0x3820, 0x2820, 0x1800, 0x0800, 0x1000, 0x1820, 0x2000, 0x2800, 0x3020, 0x4060, 0x68E0, 0xAAC4, 0xE3E3,   // 0x0B70 (2928)
+0xF400, 0xEBC0, 0xF420, 0xFCC1, 0xFD41, 0xF5A0, 0xEDA0, 0xF5E0, 0xF642, 0xEE23, 0xE626, 0xC5EC, 0xA592, 0x8D77, 0x859C, 0x75BD,   // 0x0B80 (2944)
+0x75BE, 0x75DE, 0x7DDD, 0x7D5B, 0x42DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x531D, 0x8DBD, 0x8E1F, 0x8E1F, 0x863F, 0x865F,   // 0x0BA0 (2976)
+0x861C, 0x8DFA, 0xA5F8, 0xADF5, 0xB5F2, 0xB60E, 0xC5E9, 0xD605, 0xE602, 0xF5E0, 0xFE01, 0xFDE2, 0xFD80, 0xF540, 0xF520, 0xFCE2,   // 0x0BB0 (2992)
+0xFCA2, 0xE3E3, 0xD3C3, 0xAAC1, 0x81C0, 0x5100, 0x3020, 0x2820, 0x3840, 0x6100, 0x7180, 0x9221, 0xA282, 0xAA01, 0xBA81, 0xE381,   // 0x0BC0 (3008)
+0xFC61, 0xFC40, 0xFC60, 0xFCE0, 0xFD60, 0xFDC0, 0xFDE0, 0xF5E1, 0xEE03, 0xEE45, 0xDE88, 0xC64D, 0xA612, 0x95F6, 0x8DFA, 0x7E1C,   // 0x0BD0 (3024)
+0x7DFC, 0x75FC, 0x861C, 0x85BC, 0x4AFD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x531D, 0x8DDD, 0x963F, 0x8E1F, 0x863F, 0x863E,   // 0x0BF0 (3056)
+0x861D, 0x85DA, 0x8DB9, 0x9DD8, 0x9DF5, 0xA5F0, 0xB5EB, 0xD606, 0xF664, 0xFE43, 0xF5C2, 0xF583, 0xF582, 0xFD81, 0xF540, 0xFD00,   // 0x0C00 (3072)
+0xFCC1, 0xF440, 0xD340, 0xD360, 0xBAC0, 0xB365, 0x7A00, 0xA2E6, 0x8A02, 0xBB25, 0xC344, 0xC321, 0xD3A2, 0xD301, 0xC280, 0xDB60,   // 0x0C10 (3088)
+0xF420, 0xFC80, 0xFCA0, 0xFCE0, 0xFD40, 0xFDC0, 0xFE00, 0xEDE2, 0xE605, 0xD628, 0xCE6C, 0xBE51, 0xAE35, 0x9617, 0x8DFA, 0x861C,   // 0x0C20 (3104)
+0x861C, 0x861D, 0x8E3D, 0x8DFC, 0x535D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85FC, 0x8E5D, 0x8E1E, 0x861D, 0x861C,   // 0x0C40 (3136)
+0x85FC, 0x85FC, 0x8E1D, 0x961B, 0x9E36, 0xA650, 0xBE2B, 0xE627, 0xEE04, 0xEDC3, 0xEDC4, 0xEDA6, 0xF5C5, 0xFDC2, 0xFDA0, 0xFD80,   // 0x0C50 (3152)
+0xFD41, 0xF460, 0xF3C0, 0xE380, 0xE3E3, 0xD384, 0xBAE2, 0xD3E6, 0xBAE1, 0xE404, 0xE3C2, 0xDB80, 0xEBC1, 0xE380, 0xCAE0, 0xE3C0,   // 0x0C60 (3168)
+0xFCC0, 0xFCC0, 0xF4A0, 0xFCA0, 0xFCE0, 0xFD60, 0xF581, 0xDDC3, 0xD5E8, 0xC5EE, 0xB615, 0xAE38, 0xA63A, 0x961A, 0x8DFB, 0x8E1E,   // 0x0C70 (3184)
+0x8E3F, 0x863F, 0x8E3F, 0x963D, 0x5B9D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42FC, 0x7DDB, 0x863D, 0x85FD, 0x861D, 0x861C,   // 0x0C90 (3216)
+0x85DC, 0x8E3D, 0x9EBF, 0x9E9D, 0x9E57, 0xB651, 0xCE6D, 0xE629, 0xD5A5, 0xCD85, 0xDDC7, 0xDD87, 0xDD64, 0xED81, 0xFE02, 0xED80,   // 0x0CA0 (3232)
+0xF540, 0xFCC0, 0xFC60, 0xFC21, 0xE3A0, 0xDB81, 0xD321, 0xDB82, 0xCB00, 0xF463, 0xE3C0, 0xEBE0, 0xEC00, 0xF421, 0xEBE0, 0xE3E0,   // 0x0CB0 (3248)
+0xF4C0, 0xF4E0, 0xF4C0, 0xF4A0, 0xF4A0, 0xF500, 0xEDA3, 0xDDE8, 0xC60D, 0xB5F4, 0xADDA, 0xA61C, 0x9E5D, 0x963C, 0x8E1D, 0x965F,   // 0x0CC0 (3264)
+0x965F, 0x8E3F, 0x965F, 0x9E3E, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42BC, 0x757B, 0x7DDC, 0x7DDD, 0x861D, 0x8E3D,   // 0x0CE0 (3296)
+0x963E, 0x9E9F, 0xA6BF, 0xB6BD, 0xBE99, 0xB632, 0xCE2E, 0xCE2B, 0xB588, 0xA549, 0xAD67, 0xBD45, 0xE647, 0xEE03, 0xE5A2, 0xDD22,   // 0x0CF0 (3312)
+0xE502, 0xF502, 0xF4A1, 0xF4A1, 0xF461, 0xDBA0, 0xDB40, 0xEBC2, 0xDB40, 0xF481, 0xE460, 0xF480, 0xEC60, 0xF440, 0xEC20, 0xE440,   // 0x0D00 (3328)
+0xF4E0, 0xFD42, 0xF500, 0xF4A0, 0xECC0, 0xE4E1, 0xE5A5, 0xD60C, 0xBE32, 0xA618, 0x9E1C, 0x9E5D, 0x9E9D, 0x969C, 0x969D, 0x967E,   // 0x0D10 (3344)
+0x965F, 0x963F, 0x965F, 0xA69F, 0x63FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x755B, 0x7DDC, 0x7DFE, 0x8E1E, 0x965E,   // 0x0D30 (3376)
+0x8E7D, 0xA6FF, 0xAF3F, 0xAEBC, 0xB678, 0xC695, 0xBE71, 0xAE0C, 0x8507, 0x3B01, 0x3AC0, 0xAD85, 0xE688, 0xE626, 0xBC82, 0x8280,   // 0x0D40 (3392)
+0xD4A1, 0xED22, 0xECC1, 0xECC0, 0xFD01, 0xE3C0, 0xDB40, 0xE340, 0xD300, 0xF480, 0xECA0, 0xEC80, 0xFD01, 0xEC60, 0xE420, 0xF4C1,   // 0x0D50 (3408)
+0xECE1, 0xF542, 0xED22, 0xF523, 0xED23, 0xDCE2, 0xCD25, 0xCE2F, 0xBE56, 0xA63A, 0x9E7D, 0x9EBE, 0x96BE, 0x96BD, 0x96BD, 0x967E,   // 0x0D60 (3424)
+0x9E7F, 0x9E9F, 0xA6BF, 0xAE9D, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x7D5B, 0x7DBC, 0x7DDD, 0x861D, 0x963D,   // 0x0D80 (3456)
+0x9EBD, 0x9EDD, 0xA6DD, 0xAF1D, 0xAEDA, 0xAEB7, 0x9E93, 0x4CA7, 0x12C0, 0x12C0, 0x3B41, 0xC6A9, 0xCE6A, 0x6260, 0x40C0, 0x9B40,   // 0x0D90 (3472)
+0xE524, 0xDCE0, 0xF560, 0xFDA0, 0xF521, 0xD360, 0xD340, 0xE381, 0xCB00, 0xF4A0, 0xF500, 0xF4C0, 0xFD00, 0xEC80, 0xF4C0, 0xECA0,   // 0x0DA0 (3488)
+0xF543, 0xED44, 0xEDC6, 0xE565, 0xD4A3, 0xD503, 0xCD66, 0xC5CE, 0xBE17, 0xA65A, 0x9E7D, 0x96BE, 0x96BD, 0x96BE, 0x9EDE, 0xA6BF,   // 0x0DB0 (3504)
+0xA6BF, 0xA6BE, 0xAEDE, 0xB6BD, 0x6BFE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x857C, 0x85BC, 0x7DBC, 0x85DC, 0x8E1C,   // 0x0DD0 (3536)
+0x965D, 0x8E7B, 0x8E7A, 0x96BB, 0xA71B, 0x8636, 0x3409, 0x0300, 0x0320, 0x1B80, 0x6D45, 0xB66B, 0x6BC2, 0x2920, 0x3900, 0xBC22,   // 0x0DE0 (3552)
+0xF585, 0xED41, 0xED40, 0xFE01, 0xFDA2, 0xCB80, 0xBAC0, 0xDB80, 0xCB20, 0xE440, 0xFD62, 0xF4E0, 0xFD21, 0xFCC0, 0xFCE0, 0xECE0,   // 0x0DF0 (3568)
+0xF564, 0xE586, 0xDDC8, 0xE60B, 0xD58A, 0xCD27, 0xC548, 0xBD8E, 0xBE16, 0xB69B, 0x9E7C, 0x8E5C, 0x969D, 0x9EDF, 0xA6DF, 0xAEFF,   // 0x0E00 (3584)
+0xAEDF, 0xA6BD, 0xB6FD, 0xBEFD, 0x741E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x535D, 0x8DDC, 0x8DFD, 0x85DD, 0x95FD, 0x95FD,   // 0x0E20 (3616)
+0x8DFC, 0x965C, 0x96BC, 0x9F1C, 0x8698, 0x344C, 0x02C3, 0x0320, 0x02C0, 0x23C2, 0x8609, 0x74C8, 0x0940, 0x1100, 0x49A0, 0xC464,   // 0x0E30 (3632)
+0xE4E3, 0xE520, 0xFE23, 0xFE43, 0xED63, 0xBB20, 0xC340, 0xCB60, 0xC300, 0xE420, 0xFCE1, 0xFD02, 0xFD62, 0xF4E0, 0xFD41, 0xF520,   // 0x0E40 (3648)
+0xE543, 0xD587, 0xD60C, 0xE672, 0xDE53, 0xCDCF, 0xC5AD, 0xBDAF, 0xBE34, 0xBEBA, 0xAEDD, 0x9E9D, 0x9EBE, 0xA6FF, 0xA6DF, 0xAEDF,   // 0x0E50 (3664)
+0xB6FF, 0xAEDD, 0xBF1D, 0xC71D, 0x741E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x63BE, 0x9E5E, 0x9E7E, 0x9E5E, 0xA65E, 0xA65E,   // 0x0E70 (3696)
+0xAEBF, 0xA69E, 0x9EDD, 0xAF9D, 0x6DF3, 0x0B45, 0x02A0, 0x02C0, 0x02C0, 0x12E0, 0x4424, 0x43A4, 0x0120, 0x00E0, 0x3180, 0xBC45,   // 0x0E80 (3712)
+0xDCC3, 0xE541, 0xF603, 0xD582, 0xBC60, 0xBBA0, 0xBB20, 0xBB00, 0xD3A0, 0xDC00, 0xFD43, 0xE4A0, 0xF563, 0xF501, 0xDC80, 0xFDC4,   // 0x0E90 (3728)
+0xE564, 0xC567, 0xD670, 0xCE76, 0xCE99, 0xD6B8, 0xCE95, 0xBE13, 0xBE54, 0xBEBA, 0xBEFE, 0xAF1F, 0xA6DE, 0xA6FE, 0xAEFE, 0xAEBE,   // 0x0EA0 (3744)
+0xBF1F, 0xB6BD, 0xA65A, 0xCF1E, 0x845E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xA6BE, 0xA6FF, 0xA6DF, 0xAEFF, 0xAEFF,   // 0x0EC0 (3776)
+0xAEDE, 0xAEFF, 0xB75F, 0x96B9, 0x3C4A, 0x02C0, 0x0B20, 0x1B42, 0x1301, 0x12A1, 0x3366, 0x64EE, 0x8DB2, 0x9DD3, 0x94CC, 0xBC87,   // 0x0ED0 (3792)
+0xBC01, 0xDD23, 0xDDC4, 0xA4C3, 0x7B20, 0xBBE0, 0xC380, 0xC340, 0xC380, 0xDC20, 0xF563, 0xE503, 0xDD03, 0xE4E3, 0xDCA3, 0xED85,   // 0x0EE0 (3808)
+0xE5C8, 0xCDCB, 0xC671, 0xBEB8, 0xC71D, 0xC6FC, 0xBE99, 0xBEB9, 0xBEFA, 0xB69B, 0xB6DE, 0xBF1F, 0xAEDD, 0xAEDD, 0xB71E, 0xB6FE,   // 0x0EF0 (3824)
+0xAE7D, 0x9DDA, 0x9DD9, 0xD71E, 0x8C9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xAEDE, 0xAF1F, 0xAEDF, 0xAF1E, 0xAF1E,   // 0x0F10 (3856)
+0xAF1E, 0xA6FE, 0xB75E, 0x85F5, 0x1B66, 0x02C0, 0x1321, 0x1B02, 0x43E7, 0x756F, 0x9676, 0xAEFA, 0xB71B, 0xBF3A, 0xCED5, 0xCDAE,   // 0x0F20 (3872)
+0xB465, 0xC504, 0xD608, 0xADA9, 0x8C23, 0xAC00, 0xBBC0, 0xC3A2, 0xCC04, 0xD484, 0xD4C4, 0xE5A8, 0xCD06, 0xCCE6, 0xCCE6, 0xE5A9,   // 0x0F30 (3888)
+0xE60B, 0xE730, 0xD775, 0xC73B, 0xAEBD, 0xAEDD, 0xBF1D, 0xB6FD, 0xAEFD, 0xBEFE, 0xBEDE, 0xB6DD, 0xB6FD, 0xAEFC, 0xB71E, 0xCF7F,   // 0x0F40 (3904)
+0x8D79, 0x6413, 0xBEBD, 0xD73E, 0x8C7E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x741E, 0xB6DD, 0xB73F, 0xB6FF, 0xAF1E, 0xAF3D,   // 0x0F60 (3936)
+0xAF3D, 0xAF3D, 0xB75C, 0x64F1, 0x12C6, 0x12C4, 0x2346, 0x652E, 0x9E96, 0xAF19, 0xB75C, 0xB73D, 0xB71D, 0xBF1C, 0xCEFA, 0xCE55,   // 0x0F70 (3952)
+0xBDAE, 0xB58A, 0xD6AD, 0xC62C, 0x9C85, 0x9BE1, 0xBC84, 0xABC5, 0xBC48, 0xBCC9, 0xCDAC, 0xD5EE, 0xE691, 0xD60F, 0xCDAD, 0xC5AC,   // 0x0F80 (3968)
+0x7BA3, 0x4AC3, 0x53A7, 0x9DF5, 0xC75D, 0xC73F, 0xB6FE, 0xAEFE, 0xAEDE, 0xB6DE, 0xBEDD, 0xB6DC, 0xB6FC, 0xC73E, 0xCF7F, 0x7D16,   // 0x0F90 (3984)
+0x32CE, 0x8D58, 0xD75F, 0xD71D, 0x7C1E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xBEDD, 0xBF1E, 0xAEDD, 0xAF1E, 0xAF3D,   // 0x0FB0 (4016)
+0xA71C, 0xB75C, 0xAF1A, 0x544F, 0x2B09, 0x5CAF, 0x8614, 0xAF39, 0xB75B, 0xBF3C, 0xBF1E, 0xB71E, 0xB6FE, 0xBEFE, 0xC71C, 0xC6DA,   // 0x0FC0 (4032)
+0xB675, 0x9DAD, 0xAE0C, 0xC68D, 0x94C5, 0x9463, 0xACE7, 0x93E7, 0xD5F1, 0xCE33, 0xD6B5, 0xD695, 0xE718, 0xD6D6, 0xC673, 0xB631,   // 0x0FD0 (4048)
+0x63C6, 0x0960, 0x00E0, 0x1923, 0x430B, 0xA67B, 0xCF7F, 0xB6FE, 0xB71E, 0xBF1D, 0xBEDC, 0xC71D, 0xD7BF, 0x9E39, 0x32AC, 0x19C9,   // 0x0FE0 (4064)
+0x74D5, 0xC71E, 0xCF1D, 0xD73D, 0x8CBF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B9D, 0xB67C, 0xBEFD, 0xB71D, 0xB73E, 0xAF1D,   // 0x1000 (4096)
+0xAF5D, 0xB75D, 0x8E37, 0x6D32, 0x85D5, 0xA6D9, 0xB73A, 0xB77B, 0xB75D, 0xB73D, 0xB73E, 0xB71E, 0xB71E, 0xBF1E, 0xBF3D, 0xBF3C,   // 0x1010 (4112)
+0xBF19, 0xA631, 0x74E9, 0xB6AD, 0x8D26, 0x7C83, 0x8485, 0x94EB, 0xD6F7, 0xCEFA, 0xC6FA, 0xC6FB, 0xC6FC, 0xC71A, 0xCF3A, 0xB6B6,   // 0x1020 (4128)
+0x850D, 0x5C28, 0x1A02, 0x00A0, 0x0060, 0x21C6, 0x8D96, 0xCF7E, 0xC75E, 0xC75E, 0xD7BF, 0xBEFC, 0x6CB3, 0x1967, 0x08E5, 0x6C73,   // 0x1030 (4144)
+0xC71E, 0xCF5F, 0xCF1D, 0xD71D, 0x847E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1C, 0xB65C, 0xC73E, 0xBF5F, 0xAEFD, 0xB71E,   // 0x1050 (4176)
+0xB73E, 0xB73D, 0x9E99, 0x9E58, 0xB71B, 0xBF5C, 0xB75C, 0xB73C, 0xB71D, 0xB73E, 0xBF3F, 0xB73E, 0xB71E, 0xB73E, 0xB73D, 0xBF3D,   // 0x1060 (4192)
+0xBF5B, 0xAED5, 0x7D4B, 0x8DEA, 0x7D46, 0x64A3, 0x4B82, 0x958F, 0xBF19, 0xBF3C, 0xB6FD, 0xB71F, 0xB6DE, 0xB6FD, 0xC77D, 0xB6F9,   // 0x1070 (4208)
+0xA654, 0x74CD, 0x644A, 0x3B26, 0x11A2, 0x0101, 0x19E5, 0x6C8F, 0x95D6, 0x8514, 0x6431, 0x328A, 0x0882, 0x0083, 0x6432, 0xC75E,   // 0x1080 (4224)
+0xC75E, 0xC6DD, 0xD73E, 0xC6BD, 0x635D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31BA, 0xAE1C, 0xCF5D, 0xC73E, 0xB6FD, 0xBF3E,   // 0x10A0 (4256)
+0xBF7E, 0xBF3D, 0xB71C, 0xB71C, 0xBF5D, 0xB73D, 0xB71C, 0xB73D, 0xBF5E, 0xBF3F, 0xBF1F, 0xBF1E, 0xBF1E, 0xBF3E, 0xB73E, 0xBF1E,   // 0x10B0 (4272)
+0xBF3C, 0xBF59, 0x8E30, 0x6D47, 0x7DC8, 0x5CA4, 0x22A0, 0x9E33, 0xBF5A, 0xB75C, 0xB75E, 0xB75F, 0xB73F, 0xB73E, 0xBF3D, 0xBF3B,   // 0x10C0 (4288)
+0xBF39, 0x8DD1, 0x7D4E, 0x5C4A, 0x4346, 0x3B27, 0x2243, 0x2A85, 0x2A85, 0x11C5, 0x0924, 0x0020, 0x0062, 0x53B0, 0xBF1D, 0xCF5F,   // 0x10D0 (4304)
+0xC73E, 0xCF1E, 0xD75D, 0xBE7C, 0x427D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085B, 0x951D, 0xCF3E, 0xC73E, 0xCF7F, 0xBF5E,   // 0x10F0 (4336)
+0xBF3E, 0xBF5E, 0xBF5E, 0xC77E, 0xBF5E, 0xBF7E, 0xBF5E, 0xB73E, 0xBF3E, 0xBF1F, 0xBF1F, 0xBF1E, 0xC73F, 0xC73F, 0xBF3F, 0xC73F,   // 0x1100 (4352)
+0xBF5E, 0xBF7B, 0xA6B3, 0x6D48, 0x8E4A, 0x5465, 0x2AE3, 0xBF39, 0xC75C, 0xB75C, 0xBF9D, 0xBF5E, 0xBF5E, 0xBF5F, 0xBF5E, 0xC77E,   // 0x1110 (4368)
+0xC77C, 0xBF5A, 0x9E13, 0x648C, 0x53E9, 0x4366, 0x3305, 0x1201, 0x0100, 0x00A0, 0x0041, 0x19A7, 0x74B3, 0xBEFC, 0xD79F, 0xCF5E,   // 0x1120 (4384)
+0xCF5E, 0xD75E, 0xDF9E, 0xAD9E, 0x10BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x6BBC, 0xCF1D, 0xD77F, 0xCF7F, 0xC75E,   // 0x1140 (4416)
+0xC75F, 0xC75F, 0xC77F, 0xC75E, 0xC73E, 0xC77F, 0xC79F, 0xC77F, 0xC75F, 0xCF3F, 0xCF3F, 0xC73E, 0xCF3F, 0xCF5F, 0xCF5F, 0xCF5F,   // 0x1150 (4432)
+0xC75E, 0xC77C, 0xBF57, 0x85CB, 0x8DEA, 0x4BE5, 0x53E8, 0xCF9C, 0xC75D, 0xC77D, 0xC77D, 0xC75D, 0xBF3D, 0xC73F, 0xC73F, 0xC73F,   // 0x1160 (4448)
+0xC73E, 0xCF9E, 0xBF1B, 0xAEB8, 0x9E75, 0x8DB2, 0x8DB2, 0x8592, 0x7D11, 0x7D12, 0x7CF3, 0x95D7, 0xCF5D, 0xD7DF, 0xCF3D, 0xCF5E,   // 0x1170 (4464)
+0xD77E, 0xDF9E, 0xE7BE, 0x847E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FB, 0xB5FD, 0xE7BF, 0xD79F, 0xCF9F,   // 0x1190 (4496)
+0xD77F, 0xCF7F, 0xCF7F, 0xCF7F, 0xCF7F, 0xCF9F, 0xCF9F, 0xCF7F, 0xCF7F, 0xCF7F, 0xD77F, 0xD77F, 0xCF7F, 0xD77F, 0xD77F, 0xCF7F,   // 0x11A0 (4512)
+0xCF5E, 0xD79E, 0xCF99, 0x9E4E, 0x8DCB, 0x3B23, 0x5C2B, 0xD7BD, 0xCF5E, 0xCF9E, 0xCF5D, 0xCF7E, 0xC73D, 0xC73E, 0xC73F, 0xC71F,   // 0x11B0 (4528)
+0xCF5F, 0xCF7F, 0xCF7F, 0xD7DF, 0xCFDD, 0xCFDD, 0xCFDD, 0xCFDD, 0xCFDE, 0xD7FF, 0xDFFF, 0xD77E, 0xC73D, 0xCF5D, 0xD77F, 0xD77E,   // 0x11C0 (4544)
+0xDF7E, 0xF7FF, 0xBE5E, 0x215D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x4A9C, 0xBE5E, 0xE7DF, 0xDFBF,   // 0x11E0 (4576)
+0xDFBF, 0xDFBF, 0xD79F, 0xD79F, 0xDFBF, 0xDFBF, 0xD79F, 0xD7BF, 0xD7BF, 0xD7BF, 0xD7BF, 0xD79F, 0xD79F, 0xD79F, 0xCF7F, 0xCF7F,   // 0x11F0 (4592)
+0xCF7F, 0xD7BE, 0xD7BA, 0xB6D1, 0x95ED, 0x3B04, 0x5BEB, 0xDFBE, 0xD79F, 0xD7BF, 0xCF9E, 0xCFBE, 0xCF9E, 0xCF9E, 0xCF9E, 0xCF7E,   // 0x1200 (4608)
+0xCF9F, 0xCF9F, 0xCF9F, 0xCF9E, 0xCFBD, 0xD7DE, 0xCFDE, 0xCFBE, 0xD7BF, 0xD7BE, 0xCF7D, 0xD77E, 0xCF5D, 0xDF9E, 0xE7DF, 0xE7BF,   // 0x1210 (4624)
+0xEFFF, 0xD71E, 0x52DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x425B, 0xB61D, 0xEFDF,   // 0x1230 (4656)
+0xEFFF, 0xE7BF, 0xE7BF, 0xDFBF, 0xDFBF, 0xDFBF, 0xDFBF, 0xDFDF, 0xDFFF, 0xDFDE, 0xD7BF, 0xD7BF, 0xD7DF, 0xD7DF, 0xD7BF, 0xD7BF,   // 0x1240 (4672)
+0xD7BE, 0xCF7D, 0xCFBA, 0xB6F3, 0x8DCE, 0x4347, 0x53CC, 0xD79D, 0xD7BE, 0xD7BF, 0xCFDF, 0xD7DF, 0xD7FE, 0xD7FD, 0xD7DD, 0xD7DE,   // 0x1250 (4688)
+0xD7BE, 0xD7DF, 0xD7DF, 0xD7DE, 0xD7DE, 0xD7DD, 0xD7DE, 0xD7DF, 0xDFDF, 0xDFDF, 0xDFBE, 0xDFBE, 0xDF9E, 0xE7BF, 0xF7FF, 0xFFFF,   // 0x1260 (4704)
+0xC69E, 0x4A9D, 0x005E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x31BD, 0x849C,   // 0x1280 (4736)
+0xC69D, 0xE7BE, 0xEFFE, 0xDF9E, 0xDF9E, 0xE7BE, 0xEFFF, 0xE7DF, 0xE7FE, 0xE7FD, 0xDFDE, 0xDFBF, 0xDFDF, 0xDFDF, 0xDFDF, 0xDFDE,   // 0x1290 (4752)
+0xDFDE, 0xCF7B, 0xCF79, 0xBF35, 0x8DCE, 0x3B25, 0x644B, 0xD79C, 0xD77D, 0xD79F, 0xDFDF, 0xDFFF, 0xE7FF, 0xE7FE, 0xE7FD, 0xE7FE,   // 0x12A0 (4768)
+0xE7FF, 0xE7FF, 0xE7FF, 0xE7FF, 0xE7FE, 0xE7FE, 0xE7FF, 0xE7DF, 0xE7DF, 0xE7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xE7BE, 0xA55E,   // 0x12B0 (4784)
+0x39FE, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x089D,   // 0x12D0 (4816)
+0x4A5C, 0x7C3B, 0xADDA, 0xD71D, 0xE79E, 0xEFDF, 0xF7FF, 0xEFFE, 0xEFFE, 0xEFFD, 0xEFFE, 0xEFDF, 0xEFFF, 0xE7DF, 0xE7BF, 0xE7BE,   // 0x12E0 (4832)
+0xDFDD, 0xDFBD, 0xCF3B, 0xC718, 0x7473, 0x1990, 0x4B12, 0xD79C, 0xCF3D, 0xDF7F, 0xE7BF, 0xEFFF, 0xEFFF, 0xEFDE, 0xEFDE, 0xEFDF,   // 0x12F0 (4848)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DE, 0xF7DF, 0xF7FF, 0xF7FF, 0xEFDF, 0xF7FF, 0xE77E, 0xC67D, 0xA55D, 0x633D, 0x10BE,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001E, 0x005C, 0x299C, 0x5B1E, 0x6B9F, 0x6B9F, 0x6BBF, 0x6B9F, 0x73DF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6B9F, 0x6B9F, 0x637F,   // 0x1330 (4912)
+0x6B9F, 0x6BBF, 0x5B1E, 0x531D, 0x215C, 0x001F, 0x109D, 0x5B3E, 0x5B3E, 0x635F, 0x6B7F, 0x6B9F, 0x6B9F, 0x6B7F, 0x637E, 0x6B7F,   // 0x1340 (4928)
+0x6B7F, 0x73BF, 0x73BF, 0x73BF, 0x73BF, 0x6B9F, 0x6B9F, 0x6B9F, 0x73BF, 0x739F, 0x73BF, 0x52DE, 0x31DD, 0x10BD, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1460 (5216)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1470 (5232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14B0 (5296)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14C0 (5312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4A5F, 0x107F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x20FF, 0x4A5F, 0x4A7F, 0x52BF, 0x52BF, 0x421F, 0x001F, 0x001F, 0x001F,   // 0x1510 (5392)
+0x001F, 0x001F, 0x001F, 0x003F, 0x4A7F, 0x423F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x319F,   // 0x1520 (5408)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1530 (5424)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1550 (5456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B9F, 0xFFFF, 0xFFFF, 0xD69F, 0xD6BF, 0x9CDF, 0x001F, 0x001F, 0x001F,   // 0x1560 (5472)
+0x001F, 0x001F, 0x001F, 0x18DF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xF7DF, 0x317F,   // 0x1570 (5488)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1580 (5504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0x9CDF, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x41FF,   // 0x15B0 (5552)
+0x4A3F, 0x319F, 0x001F, 0x18BF, 0xFFFF, 0xF79F, 0x423F, 0x001F, 0x001F, 0x39FF, 0x423F, 0x39FF, 0x001F, 0x001F, 0xB5BF, 0x213F,   // 0x15C0 (5568)
+0x001F, 0x319F, 0x423F, 0x4A5F, 0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15D0 (5584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15F0 (5616)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xBDDF, 0x39FF, 0x39FF, 0x295F, 0x003F, 0x633F, 0xFFFF,   // 0x1600 (5632)
+0xE73F, 0xF7DF, 0x297F, 0x109F, 0xFFFF, 0xFFFF, 0xDEFF, 0x001F, 0x31BF, 0xFFFF, 0xE71F, 0xFFFF, 0x4A5F, 0x003F, 0x001F, 0x001F,   // 0x1610 (5648)
+0x295F, 0xEF5F, 0xEF7F, 0xE71F, 0x421F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1620 (5664)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1640 (5696)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xFFBF, 0xE75F, 0xEF3F, 0x9D1F, 0x295F, 0xFFFF, 0xC61F,   // 0x1650 (5712)
+0x001F, 0xFFFF, 0xF79F, 0x003F, 0xFFFF, 0xF79F, 0x001F, 0x003F, 0xFFFF, 0xFFFF, 0x001F, 0xE75F, 0xFFFF, 0x211F, 0x001F, 0x001F,   // 0x1660 (5728)
+0xE75F, 0xFFFF, 0x4A7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1670 (5744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1690 (5776)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xA4FF, 0x001F, 0x001F, 0x001F, 0x421F, 0xFFFF, 0xCE5F,   // 0x16A0 (5792)
+0x109F, 0xFFFF, 0xDEFF, 0x083F, 0xFFFF, 0xF79F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0xEF7F, 0xFFFF, 0x18FF, 0x001F, 0x001F,   // 0x16B0 (5808)
+0xAD7F, 0xF7DF, 0xFFFF, 0x6B5F, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16C0 (5824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16E0 (5856)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xA55F, 0x001F, 0x001F, 0x001F, 0x41FF, 0xFFFF, 0xCE5F,   // 0x16F0 (5872)
+0x087F, 0xFFFF, 0xE71F, 0x003F, 0xFFFF, 0xF79F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0xEF7F, 0xFFFF, 0x211F, 0x001F, 0x001F,   // 0x1700 (5888)
+0x001F, 0xA53F, 0xF7BF, 0xFFFF, 0x529F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1710 (5904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B3F, 0xFFFF, 0xAD5F, 0x001F, 0x001F, 0x001F, 0x39BF, 0xE75F, 0xD6BF,   // 0x1740 (5952)
+0x319F, 0xFFFF, 0xC61F, 0x003F, 0xE71F, 0xFFBF, 0x211F, 0x001F, 0xDEFF, 0xFFFF, 0x211F, 0xF79F, 0xE73F, 0x18DF, 0x001F, 0x001F,   // 0x1750 (5968)
+0x18DF, 0x109F, 0xC65F, 0xEF5F, 0x421F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1F, 0xEF3F, 0x94BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x211F, 0xEF5F,   // 0x1790 (6032)
+0xF7BF, 0xC63F, 0x001F, 0x001F, 0x001F, 0xE75F, 0xF79F, 0x001F, 0x001F, 0xE71F, 0xF7BF, 0xEF5F, 0x003F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0xCE5F, 0xFFDF, 0xEF7F, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_718/instellingen.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: instellingen.jpg
+// Time generated: 12.04.2014 22:15:03
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short instellingen[0x1900] ={
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x0010 (16)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0020 (32)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0030 (48)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010,   // 0x0040 (64)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0050 (80)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0060 (96)
+0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0070 (112)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0080 (128)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011,   // 0x0090 (144)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00A0 (160)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00B0 (176)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0011,   // 0x00C0 (192)
+0x0012, 0x0012, 0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012,   // 0x00D0 (208)
+0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00E0 (224)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00F0 (240)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0100 (256)
+0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0812, 0x0812, 0x0812, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012,   // 0x0110 (272)
+0x0012, 0x0812, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012,   // 0x0120 (288)
+0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0011, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x0130 (304)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0140 (320)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0150 (336)
+0x0011, 0x0012, 0x0812, 0x0012, 0x0012, 0x0812, 0x0813, 0x0812, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813,   // 0x0160 (352)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813,   // 0x0170 (368)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0812, 0x0812, 0x0812, 0x0812, 0x0012, 0x0012, 0x0011, 0x0811, 0x0011, 0x0011, 0x0011,   // 0x0180 (384)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0190 (400)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x01A0 (416)
+0x0012, 0x294F, 0x3991, 0x62D4, 0x7BB6, 0x8417, 0x9CB9, 0xA53A, 0xB57A, 0xBDDB, 0xC61C, 0xCE3C, 0xCE5C, 0xD67C, 0xD69D, 0xCE7C,   // 0x01B0 (432)
+0xCE5C, 0xCE3C, 0xCE5C, 0xCE7C, 0xCE5C, 0xCE3C, 0xCE5C, 0xCE5C, 0xCE3C, 0xCE3C, 0xCE3C, 0xCE5C, 0xCE5C, 0xCE3C, 0xCE5C, 0xCE7C,   // 0x01C0 (448)
+0xCE7C, 0xCE5C, 0xCE3C, 0xCE5C, 0xC61C, 0xBDBB, 0xB57A, 0xAD3A, 0x9478, 0x83F7, 0x6315, 0x5AB4, 0x39B1, 0x18EA, 0x0011, 0x0012,   // 0x01D0 (464)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x01E0 (480)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012,   // 0x01F0 (496)
+0x0812, 0x5293, 0x7BB6, 0x9CF9, 0xAD7B, 0xC61B, 0xCE5C, 0xD67C, 0xDEBD, 0xDEFD, 0xE73E, 0xEF5E, 0xEF5E, 0xEF5E, 0xEF7E, 0xF79F,   // 0x0200 (512)
+0xF79F, 0xEF9E, 0xF7BF, 0xFFDF, 0xF7BF, 0xF79E, 0xF79F, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7DF,   // 0x0210 (528)
+0xF79F, 0xF79F, 0xF79F, 0xF79F, 0xEF7E, 0xE73E, 0xE71E, 0xE71E, 0xD69D, 0xB5BB, 0xA4F9, 0x9478, 0x62F5, 0x3191, 0x0811, 0x0011,   // 0x0220 (544)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0230 (560)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012,   // 0x0240 (576)
+0x6B35, 0x9CB9, 0x6B56, 0x39B0, 0x294B, 0x292A, 0x2129, 0x292A, 0x292A, 0x292A, 0x294A, 0x294A, 0x292A, 0x292A, 0x292A, 0x292A,   // 0x0250 (592)
+0x292A, 0x292A, 0x294B, 0x294A, 0x292A, 0x292A, 0x294A, 0x294A, 0x294A, 0x292A, 0x292A, 0x294A, 0x292A, 0x292A, 0x292A, 0x294A,   // 0x0260 (608)
+0x292A, 0x292A, 0x294A, 0x294B, 0x292A, 0x292A, 0x292A, 0x2109, 0x20C8, 0x20E9, 0x18E8, 0x18E9, 0x292C, 0x39B1, 0x4A33, 0x210D,   // 0x0270 (624)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0280 (640)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0811, 0x0012, 0x0812, 0x83F7,   // 0x0290 (656)
+0x7396, 0x316D, 0x294B, 0x316C, 0x41F1, 0x4A33, 0x4A33, 0x4A32, 0x5A95, 0x5253, 0x5274, 0x4A53, 0x5274, 0x4A53, 0x4A53, 0x4A33,   // 0x02A0 (672)
+0x5275, 0x5275, 0x4A33, 0x4A32, 0x4A33, 0x5253, 0x5253, 0x4A33, 0x5254, 0x5254, 0x5253, 0x4A32, 0x5254, 0x5254, 0x4A33, 0x4A33,   // 0x02B0 (688)
+0x5254, 0x5295, 0x4A53, 0x4A33, 0x5254, 0x5274, 0x4A33, 0x4A33, 0x4A33, 0x4A33, 0x39B0, 0x398F, 0x292B, 0x18E8, 0x18E9, 0x3150,   // 0x02C0 (704)
+0x2950, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x02D0 (720)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0012, 0x0812, 0x9478, 0x5294,   // 0x02E0 (736)
+0x294C, 0x316D, 0x39B0, 0x62F6, 0x7BB7, 0x83D7, 0x7BD7, 0x83F7, 0x8C38, 0x9498, 0x7BD7, 0x83D8, 0x8C38, 0x8C78, 0x83F8, 0x83F8,   // 0x02F0 (752)
+0x8C38, 0x8C38, 0x7BB7, 0x7BD7, 0x8C78, 0x9479, 0x83D8, 0x83F7, 0x9498, 0x8C58, 0x83D8, 0x7BD7, 0x8418, 0x9479, 0x8C38, 0x83F8,   // 0x0300 (768)
+0x8C58, 0x8C38, 0x7BB7, 0x7BB7, 0x8C58, 0x9499, 0x83D7, 0x7377, 0x9478, 0x8C18, 0x7376, 0x5AD4, 0x5AD4, 0x39B1, 0x2109, 0x10A6,   // 0x0310 (784)
+0x210C, 0x292F, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0320 (800)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0812, 0x62F5, 0x9438, 0x294C,   // 0x0330 (816)
+0x39AF, 0x5AB5, 0x83F7, 0x9498, 0x9CB9, 0x9CDA, 0xA51A, 0xAD5A, 0x9CD9, 0x9CB9, 0x9CD9, 0x9CD9, 0xA4F9, 0xA51A, 0x9CB9, 0xA4F9,   // 0x0340 (832)
+0x9CB9, 0xA4F9, 0xAD5A, 0xA4FA, 0x9CD9, 0x9CD9, 0xA4F9, 0xA4FA, 0x9CD9, 0x9CD9, 0xA4F9, 0xA51A, 0x9CD9, 0xA4FA, 0xA4F9, 0x9CB9,   // 0x0350 (848)
+0x9CD9, 0xA4F9, 0xAD5A, 0xA51A, 0x9CD9, 0x9CB9, 0xA51A, 0xA4F9, 0x9CB9, 0x9CD9, 0x9CD9, 0x9479, 0x83F8, 0x7396, 0x5274, 0x296E,   // 0x0360 (864)
+0x18E9, 0x39D2, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0370 (880)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x5AD4, 0x8417, 0x6B15, 0x398F,   // 0x0380 (896)
+0x4A13, 0x7356, 0x9498, 0x9CD9, 0x8C18, 0x9CD9, 0x9CB9, 0x9CD9, 0x9479, 0x9CB9, 0xA51A, 0xA51A, 0x8C39, 0x8C58, 0xA4FA, 0xA53A,   // 0x0390 (912)
+0x8C38, 0x9479, 0x9CB9, 0xA51A, 0x9499, 0x9478, 0x9CDA, 0x9CB9, 0x9478, 0x9479, 0x9CD9, 0x9CD9, 0x9479, 0x8C38, 0xA4F9, 0xA51A,   // 0x03A0 (928)
+0x9479, 0x8418, 0x9CB9, 0xA4FA, 0x9CB9, 0x8418, 0x9CDA, 0xA4F9, 0x9499, 0x8C38, 0x9CB9, 0x9499, 0x9478, 0x6B56, 0x6B56, 0x4A33,   // 0x03B0 (944)
+0x292C, 0x296F, 0x3191, 0x0812, 0x0012, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x03C0 (960)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x7B97, 0xA519, 0x4A13, 0x41F1,   // 0x03D0 (976)
+0x7BB7, 0x9499, 0x9498, 0x9CB9, 0xA51A, 0x9478, 0xA4FA, 0x9CD9, 0x9CB9, 0x9CDA, 0x9CD9, 0x9CB9, 0x9CB9, 0x9CD9, 0x9CB9, 0x9499,   // 0x03E0 (992)
+0x9CD9, 0x9CD9, 0x9CD9, 0x9CB9, 0x9C99, 0x9CB9, 0x9CF9, 0x9CD9, 0xA4F9, 0x9CB9, 0x9499, 0x9499, 0xA4FA, 0x9CB9, 0x9479, 0x9CD9,   // 0x03F0 (1008)
+0x9CD9, 0xA4FA, 0x9CD9, 0x9CD9, 0x9499, 0x9CD9, 0x9CB9, 0x9CD9, 0x9499, 0x9CB9, 0x9CD9, 0x9CD9, 0x9498, 0x94B8, 0x8417, 0x7356,   // 0x0400 (1024)
+0x39B0, 0x292C, 0x5AB4, 0x292F, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0410 (1040)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x83D7, 0xBDBB, 0x39CF, 0x4A33,   // 0x0420 (1056)
+0x7BB7, 0x9458, 0x7B97, 0x83F8, 0x9CF9, 0x9CB9, 0x7BB7, 0x8C38, 0x9479, 0x9479, 0x7BB7, 0x8C38, 0x9CD9, 0x9CB9, 0x83D8, 0x8C18,   // 0x0430 (1072)
+0x9CD9, 0x9499, 0x83F8, 0x8C38, 0x9479, 0x9499, 0x8418, 0x83F8, 0x9479, 0x9499, 0x83F8, 0x7BB7, 0x9499, 0x9499, 0x83F8, 0x83F8,   // 0x0440 (1088)
+0x9479, 0x9458, 0x83D7, 0x7BB7, 0x9499, 0x9C99, 0x8C18, 0x7BB7, 0x9CD9, 0x9479, 0x83F8, 0x7397, 0x9478, 0x9499, 0x83F7, 0x62B5,   // 0x0450 (1104)
+0x4A13, 0x316E, 0x7376, 0x41D2, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0460 (1120)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x8C58, 0xCE5C, 0x4A12, 0x5274,   // 0x0470 (1136)
+0x8C58, 0x83F8, 0x9CB9, 0x9479, 0x8C38, 0x8C38, 0x9CB9, 0x9478, 0x9458, 0x9479, 0x9CB9, 0x9458, 0x8C38, 0x9459, 0x9479, 0x9478,   // 0x0480 (1152)
+0x8C58, 0x8C58, 0x8C59, 0x8418, 0x9499, 0x9CD9, 0x8C38, 0x8C58, 0x9479, 0x8C58, 0x9479, 0x9C99, 0x8C38, 0x9458, 0x9499, 0x9479,   // 0x0490 (1168)
+0x9458, 0x8C39, 0x9499, 0x9458, 0x8C58, 0x8C38, 0x9499, 0x9459, 0x8C18, 0x9479, 0x9499, 0x9479, 0x8C58, 0x8C18, 0x8C18, 0x7BF7,   // 0x04A0 (1184)
+0x5254, 0x31B0, 0x9478, 0x5273, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x04B0 (1200)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0xAD3A, 0xCE7D, 0x4A33, 0x62D5,   // 0x04C0 (1216)
+0x6315, 0x7BD7, 0x9478, 0x8C18, 0x7376, 0x7BD7, 0x8C38, 0x9458, 0x6B56, 0x7BB7, 0x8C38, 0x8C38, 0x7357, 0x83F8, 0x8C38, 0x7BD7,   // 0x04D0 (1232)
+0x7356, 0x7BB7, 0x8C38, 0x8417, 0xB5BB, 0xC63C, 0x9CB9, 0x8C38, 0x7377, 0x6B16, 0xB59B, 0xE71E, 0x9479, 0x6B36, 0x8418, 0x8C58,   // 0x04E0 (1248)
+0x7B97, 0x6B36, 0x8C38, 0x9479, 0x7BB7, 0x6B56, 0x8C38, 0x8C59, 0x83F8, 0x6B36, 0x8418, 0x8C38, 0x8418, 0x6B16, 0x83D7, 0x83F8,   // 0x04F0 (1264)
+0x5A94, 0x398F, 0xA559, 0x6B55, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0500 (1280)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0xAD3A, 0xDEFD, 0x4A33, 0x5A95,   // 0x0510 (1296)
+0x83D7, 0x8C58, 0x83F8, 0x8418, 0x8C58, 0x8C18, 0x83F8, 0x7BB7, 0x8418, 0x83F8, 0x7BD7, 0x8418, 0x83F8, 0x7BB7, 0xA51A, 0xC63C,   // 0x0520 (1312)
+0x9479, 0x7BB7, 0x8418, 0x7377, 0xC61C, 0xFFDF, 0xAD5A, 0x7377, 0x7BD7, 0x8C18, 0xD67C, 0xFFFF, 0xB59B, 0x7BB7, 0x83D7, 0x7BB7,   // 0x0530 (1328)
+0x8C38, 0xA4DA, 0x9C99, 0x83D7, 0x8C38, 0x8418, 0x8C38, 0x83F8, 0x83F8, 0x83F7, 0x7BD8, 0x83F7, 0x83F7, 0x8C38, 0x83F8, 0x7BD7,   // 0x0540 (1344)
+0x5274, 0x4A33, 0xB59B, 0x7BB7, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0550 (1360)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xBDBA, 0xDEFD, 0x39F0, 0x5295,   // 0x0560 (1376)
+0x7397, 0x7B97, 0x62D6, 0x7377, 0x7BD7, 0x7BB7, 0x62F6, 0x7397, 0x83F8, 0x83F8, 0x62D5, 0x6B36, 0x83F8, 0x6B36, 0xA4FA, 0xF7BF,   // 0x0570 (1392)
+0xCE3C, 0x7BB7, 0x5A95, 0x6316, 0xD67C, 0xFFFF, 0xBDDB, 0x7376, 0x6B16, 0xAD1A, 0xFFBF, 0xFFFF, 0xBDBB, 0x6B36, 0x6316, 0x5A75,   // 0x0580 (1408)
+0xB59B, 0xF7BF, 0x9CD9, 0x5A95, 0x83F7, 0x7BB7, 0x7356, 0x5A95, 0x83D7, 0x8418, 0x7357, 0x62D5, 0x83F8, 0x83D7, 0x6B16, 0x5A95,   // 0x0590 (1424)
+0x5AB5, 0x4A33, 0xC61C, 0x8C58, 0x0012, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x05A0 (1440)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0012, 0x0813, 0xC61C, 0xF7BF, 0x4A33, 0x5275,   // 0x05B0 (1456)
+0x7BB7, 0x7B97, 0x7377, 0x7B97, 0x7BB7, 0x7B97, 0x7377, 0x7B97, 0x7356, 0x7357, 0x7377, 0x7357, 0x7397, 0x6B36, 0x9CDA, 0xEF5E,   // 0x05C0 (1472)
+0xFFDF, 0xAD3A, 0x62F6, 0x7397, 0xD69D, 0xFFFF, 0xEF5E, 0x8418, 0x62F6, 0xC61C, 0xFFFF, 0xFFFF, 0xC61C, 0x62F5, 0x62F5, 0x9CD9,   // 0x05D0 (1488)
+0xF7BF, 0xEF5E, 0xA4FA, 0x6B37, 0x7377, 0x7B97, 0x7356, 0x7356, 0x7357, 0x7376, 0x7377, 0x7BB7, 0x6B36, 0x7397, 0x7B97, 0x7377,   // 0x05E0 (1504)
+0x5274, 0x41F1, 0xD69C, 0x9CD9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x05F0 (1520)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xBDDB, 0xE73E, 0x4A32, 0x5AB5,   // 0x0600 (1536)
+0x5274, 0x62D6, 0x7BB7, 0x7BB7, 0x5274, 0x6B16, 0x7376, 0x7377, 0x5274, 0xBDFB, 0xD6BC, 0x7377, 0x4A52, 0x5A95, 0x9479, 0xE71E,   // 0x0610 (1552)
+0xFFFF, 0xEF7F, 0x8C58, 0x83F8, 0xDEDD, 0xFFFF, 0xFFFF, 0xB5BB, 0xAD7A, 0xFFDF, 0xFFFF, 0xFFFF, 0xCE3C, 0x5274, 0x83D8, 0xF7BF,   // 0x0620 (1568)
+0xFFFF, 0xEF5E, 0x9498, 0x6B16, 0x5AB6, 0x5253, 0x8C18, 0xAD5A, 0x62D6, 0x5273, 0x7376, 0x7357, 0x6B36, 0x5274, 0x7397, 0x6B36,   // 0x0630 (1584)
+0x5253, 0x41D0, 0xD69C, 0xA4F9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0640 (1600)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0x0813, 0xD69D, 0xF7BF, 0x4211, 0x4A52,   // 0x0650 (1616)
+0x6B16, 0x62F6, 0x6B56, 0x6B56, 0x62F5, 0x6B16, 0x7357, 0x6B16, 0x5A95, 0xCE5C, 0xFFDF, 0xDEFD, 0x7B97, 0x5253, 0x9458, 0xEF5E,   // 0x0660 (1632)
+0xF7BF, 0xFFFF, 0xDEFE, 0xDEBD, 0xFFFF, 0xF79F, 0xF79F, 0xF79F, 0xF79F, 0xFFDF, 0xFFBF, 0xFFDF, 0xEF5E, 0xCE5C, 0xDEDD, 0xFFDF,   // 0x0670 (1648)
+0xFFFF, 0xD69D, 0x83D7, 0x5AB5, 0x62D5, 0x9CB9, 0xEF7E, 0xD67C, 0x5274, 0x6B36, 0x6B16, 0x6B36, 0x62F6, 0x6B57, 0x62F6, 0x6B16,   // 0x0680 (1664)
+0x4A33, 0x4211, 0xD69D, 0xA519, 0x0813, 0x0813, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0690 (1680)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0x0813, 0xD69D, 0xEF5F, 0x41CF, 0x4A31,   // 0x06A0 (1696)
+0x6B36, 0x62F5, 0x4A32, 0x5A95, 0x7356, 0x62F6, 0x4A31, 0x5294, 0x5AB5, 0x9CB9, 0xEF7E, 0xFFFF, 0xE73D, 0x9479, 0x83F8, 0xDEFD,   // 0x06B0 (1712)
+0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xEF7E, 0xF79F, 0xF7BF, 0xFFFF, 0xFFDF, 0xF7BF, 0xFFFF, 0xFFFF, 0xEF7E, 0xF7BF, 0xFFFF, 0xF7BF,   // 0x06C0 (1728)
+0xFFFF, 0xDEDD, 0x62D6, 0x5253, 0xBDBB, 0xF7BF, 0xF79F, 0xAD5A, 0x5274, 0x6B57, 0x5A95, 0x4A31, 0x62F5, 0x6B36, 0x5A95, 0x4A11,   // 0x06D0 (1744)
+0x5253, 0x5253, 0xD69D, 0xA4F9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x06E0 (1760)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0812, 0x0813, 0xCE7C, 0xF79E, 0x4A32, 0x4A31,   // 0x06F0 (1776)
+0x5A95, 0x5AB6, 0x5AD5, 0x5A95, 0x5AB5, 0x5273, 0x5A94, 0x5274, 0x5274, 0x7376, 0xDEBD, 0xFFFF, 0xF7BF, 0xE71E, 0xDEFE, 0xF79F,   // 0x0700 (1792)
+0xF79E, 0xF7BF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xEF7E, 0xF7BF,   // 0x0710 (1808)
+0xFFDF, 0xEF5E, 0xBDFC, 0xCE7C, 0xFFBF, 0xFFFF, 0xE71E, 0x7BB7, 0x5273, 0x5274, 0x5AB6, 0x5A94, 0x5274, 0x62D5, 0x62F6, 0x5274,   // 0x0720 (1824)
+0x4A32, 0x4211, 0xD69D, 0x9CF9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0730 (1840)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xDEDD, 0xF7BF, 0x4A11, 0x4A11,   // 0x0740 (1856)
+0x41F0, 0x5252, 0x5AB5, 0x5253, 0x9CD9, 0xBDFB, 0x9499, 0x5A94, 0x39CE, 0x41EF, 0xC61C, 0xF79F, 0xF77E, 0xFFDF, 0xF79F, 0xF79F,   // 0x0750 (1872)
+0xFFFF, 0xF7BF, 0xE71D, 0xC61C, 0x9C99, 0x8418, 0x83F8, 0x7397, 0x62D6, 0x6B36, 0x9479, 0xAD3A, 0xDEDD, 0xF79F, 0xF79F, 0xFFFF,   // 0x0760 (1888)
+0xF7BF, 0xEF7E, 0xF7BF, 0xF79F, 0xF79F, 0xFFFF, 0xC5FC, 0x5253, 0x4A32, 0x39CE, 0x5273, 0x6B36, 0x5AB5, 0x4A11, 0x5274, 0x62D5,   // 0x0770 (1904)
+0x41F0, 0x39AE, 0xD6BD, 0x9CD9, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0780 (1920)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0012, 0x0813, 0x0813, 0xD69D, 0xFFFF, 0x41F0, 0x41F0,   // 0x0790 (1936)
+0x5253, 0x5273, 0x5AB5, 0x4A31, 0x7B97, 0xE71D, 0xEF7E, 0xD67C, 0x9478, 0x4A32, 0xB57A, 0xF79F, 0xEF7E, 0xEF7F, 0xF7BF, 0xEF7E,   // 0x07A0 (1952)
+0xBDDC, 0x8C38, 0x62F6, 0x5A94, 0x5A94, 0x5253, 0x4A52, 0x4A11, 0x4A32, 0x5253, 0x41F0, 0x7357, 0xE73E, 0xF77F, 0xDEDD, 0xCE5C,   // 0x07B0 (1968)
+0xDEFD, 0xFFDF, 0xF77E, 0xEF5E, 0xEF5E, 0xEF5E, 0x8C58, 0x39AE, 0x5253, 0x8417, 0xCE3C, 0xC63C, 0x8C38, 0x4A52, 0x5273, 0x5A74,   // 0x07C0 (1984)
+0x41F0, 0x4A11, 0xC63C, 0x9CD9, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x07D0 (2000)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0833, 0xDEDD, 0xEF7F, 0x318C, 0x39CF,   // 0x07E0 (2016)
+0x5273, 0x5253, 0x39CE, 0x4A31, 0x4A32, 0xAD7B, 0xEF5E, 0xEF7F, 0xDF1E, 0xD69D, 0xDEBD, 0xEF5E, 0xF79F, 0xDEFD, 0xB59B, 0x7377,   // 0x07F0 (2032)
+0x5253, 0x4A52, 0x39CE, 0x39CE, 0x4A32, 0x4A32, 0x41EF, 0x41CF, 0x5253, 0x4A53, 0x39CE, 0x7B97, 0xF79E, 0xF7BF, 0x9CDA, 0x4A10,   // 0x0800 (2048)
+0x7B97, 0xBDFC, 0xE71D, 0xF7BF, 0xE73E, 0xDEFD, 0xC5FC, 0x9499, 0xCE5C, 0xE6FE, 0xF79E, 0xCE5C, 0x5A95, 0x5273, 0x4A31, 0x318D,   // 0x0810 (2064)
+0x4210, 0x41F0, 0xCE5C, 0x9478, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0820 (2080)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xD6BD, 0xF7BF, 0x41F0, 0x39CE,   // 0x0830 (2096)
+0x4A32, 0x4A31, 0x4A52, 0x4A31, 0x4210, 0x5274, 0xCE3C, 0xEF5E, 0xE73E, 0xEF5E, 0xEF7E, 0xEF7E, 0xCE7C, 0x8C38, 0x5274, 0x4A31,   // 0x0840 (2112)
+0x4210, 0x4A11, 0x4A31, 0x4A32, 0x4A32, 0x4A31, 0x4A11, 0x4A10, 0x4A32, 0x41F0, 0x5253, 0xAD1A, 0xEF5E, 0xDEDD, 0x83F8, 0x39CF,   // 0x0850 (2128)
+0x4210, 0x5253, 0x8C38, 0xD6BD, 0xEF5E, 0xDEDD, 0xEF5E, 0xE73E, 0xEF7F, 0xEF5E, 0xD69D, 0x7BB7, 0x41F0, 0x4A31, 0x4A31, 0x4A52,   // 0x0860 (2144)
+0x41F0, 0x41CF, 0xCE7C, 0x8C17, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0870 (2160)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xD69C, 0xF7BF, 0x41CF, 0x39AE,   // 0x0880 (2176)
+0x31AD, 0x41EF, 0x41F0, 0x41EF, 0x294A, 0x318C, 0x8418, 0xD67C, 0xDEDD, 0xDEDD, 0xE71E, 0xBDFC, 0x5273, 0x41EF, 0x41EF, 0x4210,   // 0x0890 (2192)
+0x318D, 0x39CE, 0x5252, 0x5252, 0x39AD, 0x39CE, 0x4A32, 0x4A32, 0x39CE, 0x318C, 0x6B56, 0xDEBD, 0xEF5E, 0xB59B, 0x5274, 0x4210,   // 0x08A0 (2208)
+0x39AD, 0x316C, 0x4A11, 0x6B16, 0xC5FC, 0xE73E, 0xD6BD, 0xDEDD, 0xD6BD, 0xDEFD, 0x9CD9, 0x41CF, 0x41F0, 0x398D, 0x4210, 0x4A32,   // 0x08B0 (2224)
+0x318D, 0x294B, 0xCE7C, 0x83D7, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x08C0 (2240)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xCE5C, 0xFFDF, 0x39AE, 0x318D,   // 0x08D0 (2256)
+0x5274, 0xB57B, 0xB57A, 0x9CB9, 0x7356, 0x5253, 0x7377, 0xC63C, 0xDEDD, 0xCE7C, 0xA4F9, 0x5274, 0x39CE, 0x39CF, 0x4A10, 0x41EF,   // 0x08E0 (2272)
+0x4A11, 0x4A11, 0x4210, 0x4210, 0x4A10, 0x4210, 0x4A10, 0x41F0, 0x41F0, 0x41F0, 0x83D8, 0xDEFD, 0xDEDD, 0x8C58, 0x39CE, 0x41CF,   // 0x08F0 (2288)
+0x4210, 0x4A11, 0x39CE, 0x39AE, 0x5A95, 0xAD7A, 0xDEBD, 0xD69C, 0xD6BD, 0xB59B, 0x4A11, 0x296B, 0x39AD, 0x41CE, 0x4A32, 0x4A32,   // 0x0900 (2304)
+0x39AE, 0x39AE, 0xBDDB, 0x7B96, 0x0813, 0x0812, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0910 (2320)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xD6BD, 0xFFFF, 0x18E6, 0x2108,   // 0x0920 (2336)
+0x39AD, 0x9CD9, 0xEF5E, 0xD69D, 0xD6BD, 0xC5FC, 0xC61C, 0xC63C, 0xC5FC, 0xDEFD, 0x9458, 0x39AD, 0x39CE, 0x41F0, 0x316B, 0x398D,   // 0x0930 (2352)
+0x4A11, 0x4A11, 0x318D, 0x318D, 0x4A11, 0x4A31, 0x318D, 0x318D, 0x41F0, 0x5273, 0xAD3A, 0xD69D, 0xBDBB, 0x62F6, 0x2929, 0x318C,   // 0x0940 (2368)
+0x4A11, 0x4A10, 0x39AD, 0x296A, 0x39CE, 0x5274, 0xB57A, 0xDEDD, 0xCE3C, 0xB59B, 0x83D7, 0x8C18, 0xA4FA, 0xAD5A, 0xBDDC, 0x9C99,   // 0x0950 (2384)
+0x296B, 0x318C, 0xB59B, 0x7356, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0960 (2400)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xD69D, 0xFFFF, 0x2109, 0x18C6,   // 0x0970 (2416)
+0x2109, 0x316B, 0x83F7, 0xCE7C, 0xD67C, 0xCE5C, 0xD67D, 0xC61C, 0xC63C, 0xCE7C, 0xB59B, 0x7BB7, 0x41CF, 0x39AE, 0x41CE, 0x41CF,   // 0x0980 (2432)
+0x41CF, 0x41CF, 0x41CF, 0x39CE, 0x39CE, 0x39AD, 0x318C, 0x318B, 0x294A, 0x5A95, 0xC63C, 0xD6BD, 0x9478, 0x39CF, 0x39AE, 0x41EF,   // 0x0990 (2448)
+0x41EF, 0x41F0, 0x39CE, 0x39CE, 0x39CE, 0x39AD, 0x5274, 0xB59B, 0xCE5C, 0xCE3C, 0xC61C, 0xCE7C, 0xDEFD, 0xDEBD, 0xC61B, 0x5253,   // 0x09A0 (2464)
+0x18E7, 0x2929, 0xB59A, 0x6B35, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x09B0 (2480)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xCE5D, 0xFFDF, 0x316B, 0x18C6,   // 0x09C0 (2496)
+0x1063, 0x10A4, 0x294A, 0x83D7, 0xB59B, 0xB57A, 0xB55A, 0xAD5A, 0xA51A, 0xB59B, 0xC61C, 0xC5FB, 0x8C38, 0x4A11, 0x39CE, 0x41F0,   // 0x09D0 (2512)
+0x316B, 0x318C, 0x39AE, 0x41CF, 0x4211, 0x5273, 0x7357, 0x83D8, 0x7397, 0x94B9, 0xC61C, 0xBDFB, 0x5274, 0x2107, 0x41EF, 0x4210,   // 0x09E0 (2528)
+0x318C, 0x296A, 0x4210, 0x4211, 0x318D, 0x2929, 0x39CE, 0x6B36, 0xBDBB, 0xBDBB, 0xB59B, 0xBD9B, 0xB5BB, 0x9479, 0x39AD, 0x20E8,   // 0x09F0 (2544)
+0x10A4, 0x10A5, 0xBDBB, 0x62D4, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0A00 (2560)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xCE5C, 0xFFFF, 0x294A, 0x18A5,   // 0x0A10 (2576)
+0x1085, 0x18A5, 0x1063, 0x18C5, 0x7377, 0xA53A, 0xBDDB, 0x7376, 0x31AD, 0x5253, 0xAD7A, 0xBDBB, 0xBDBB, 0x9458, 0x5252, 0x318D,   // 0x0A20 (2592)
+0x316B, 0x39AD, 0x4210, 0x7337, 0x9458, 0x9CB9, 0xAD5A, 0xC5FB, 0xBDDB, 0xB59B, 0xBDDC, 0xBDBB, 0x7356, 0x41F0, 0x39CF, 0x39AE,   // 0x0A30 (2608)
+0x39CE, 0x39AD, 0x41CF, 0x39AE, 0x318C, 0x316B, 0x2929, 0x39AD, 0x7357, 0xAD5A, 0xA51A, 0xA4FA, 0x8C38, 0x39CE, 0x18A5, 0x2109,   // 0x0A40 (2624)
+0x18A5, 0x2909, 0xAD5A, 0x5AB4, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0A50 (2640)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0x0813, 0xD6BD, 0xFFFF, 0x18E7, 0x2109,   // 0x0A60 (2656)
+0x318D, 0x41F0, 0x39CE, 0x4210, 0x8C38, 0x9CD9, 0x8C58, 0x39AE, 0x18C6, 0x2107, 0x39AD, 0x8C18, 0xA4FA, 0xAD3A, 0x9459, 0x5252,   // 0x0A70 (2672)
+0x39AD, 0x4210, 0x83F8, 0xA51A, 0xA4FA, 0xAD3A, 0xAD3A, 0x9CB9, 0x9CDA, 0xA4F9, 0xA4FA, 0xA4FA, 0xA4F9, 0x83D7, 0x4210, 0x2128,   // 0x0A80 (2688)
+0x314A, 0x39AD, 0x20E7, 0x1085, 0x316B, 0x316C, 0x10A5, 0x0842, 0x39CE, 0x9458, 0xA4F9, 0x9479, 0x4A11, 0x0041, 0x0863, 0x0021,   // 0x0A90 (2704)
+0x10A4, 0x2129, 0xA4FA, 0x5273, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0AA0 (2720)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0x0813, 0xD67C, 0xFFFF, 0x41F0, 0x6B36,   // 0x0AB0 (2736)
+0x8C38, 0x9478, 0x9479, 0x9CF9, 0x9499, 0x9CD9, 0x5AB5, 0x2929, 0x20E7, 0x18C6, 0x18A5, 0x316B, 0x7377, 0x9CD9, 0x9CB9, 0x83F7,   // 0x0AC0 (2752)
+0x62D5, 0x7357, 0x9CBA, 0x9499, 0x8C18, 0x8C58, 0x9479, 0x8C38, 0x9479, 0x9478, 0x8C18, 0x8C58, 0x9499, 0x9479, 0x7B97, 0x41F0,   // 0x0AD0 (2768)
+0x20E8, 0x18E7, 0x20E7, 0x20E7, 0x2129, 0x2909, 0x20E8, 0x18C6, 0x2108, 0x62B6, 0x9CB9, 0x8C38, 0x7B97, 0x5294, 0x4A52, 0x4210,   // 0x0AE0 (2784)
+0x318D, 0x294B, 0xA51A, 0x4A13, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0AF0 (2800)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0812, 0x0813, 0xD69C, 0xFFDF, 0x39AE, 0x5253,   // 0x0B00 (2816)
+0xA53A, 0x9C99, 0x9CD9, 0x9479, 0x83F8, 0x9479, 0x41CF, 0x2108, 0x0862, 0x10A5, 0x2929, 0x18E7, 0x18C7, 0x5274, 0x8C39, 0x8418,   // 0x0B10 (2832)
+0x8C58, 0x9479, 0x83F7, 0x7BD8, 0x8C38, 0x83F8, 0x83F8, 0x8C38, 0x8C38, 0x83F8, 0x8418, 0x8C58, 0x8C38, 0x8C38, 0x9479, 0x7BB7,   // 0x0B20 (2848)
+0x39CE, 0x18A5, 0x2929, 0x316C, 0x18C6, 0x0883, 0x294A, 0x2929, 0x18C6, 0x316C, 0x9479, 0x8418, 0x9CD9, 0xAD7A, 0xAD3A, 0xA4F9,   // 0x0B30 (2864)
+0x7377, 0x41F0, 0x9499, 0x5253, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0B40 (2880)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xDEBD, 0xFFDF, 0x2109, 0x18C6,   // 0x0B50 (2896)
+0x39CE, 0x5AB5, 0x7BB8, 0x7BB7, 0x8C38, 0x6B16, 0x314B, 0x2108, 0x18C6, 0x18E7, 0x2108, 0x2108, 0x1084, 0x18E7, 0x5253, 0x7BD7,   // 0x0B60 (2912)
+0x83D7, 0x83D7, 0x7BB7, 0x7B97, 0x7B97, 0x7BB7, 0x7BD7, 0x7BB7, 0x7BD7, 0x83F8, 0x7BB7, 0x83F7, 0x7BB8, 0x7BD7, 0x7BB7, 0x83F7,   // 0x0B70 (2928)
+0x5AB5, 0x2929, 0x2108, 0x2929, 0x20E7, 0x18E7, 0x2929, 0x2109, 0x18E7, 0x294A, 0x6B17, 0x83F7, 0x7BB7, 0x83D7, 0x9499, 0x7B97,   // 0x0B80 (2944)
+0x41F0, 0x316C, 0x8C58, 0x41F2, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0B90 (2960)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xD69C, 0xFFFF, 0x18C6, 0x10A5,   // 0x0BA0 (2976)
+0x18C7, 0x2949, 0x41F0, 0x7337, 0x7BB7, 0x5253, 0x18A5, 0x18C6, 0x296B, 0x2929, 0x18A5, 0x18C5, 0x292A, 0x18C5, 0x41EF, 0x7397,   // 0x0BB0 (2992)
+0x7397, 0x6B36, 0x7357, 0x7B97, 0x7377, 0x7377, 0x7377, 0x7B97, 0x7BB7, 0x7377, 0x7377, 0x7376, 0x7B97, 0x7377, 0x7397, 0x7BB7,   // 0x0BC0 (3008)
+0x7377, 0x4A32, 0x18C6, 0x1084, 0x294A, 0x314B, 0x18E7, 0x1084, 0x2108, 0x2929, 0x5253, 0x7B97, 0x7BB7, 0x6B36, 0x41EF, 0x2128,   // 0x0BD0 (3024)
+0x10A5, 0x2109, 0x94B8, 0x39B1, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0BE0 (3040)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xCE5C, 0xFFFF, 0x20E8, 0x0863,   // 0x0BF0 (3056)
+0x18A6, 0x0863, 0x39CE, 0x62F5, 0x7377, 0x39CF, 0x18C6, 0x20E7, 0x2929, 0x2928, 0x20E7, 0x2109, 0x20E7, 0x292A, 0x5274, 0x6B56,   // 0x0C00 (3072)
+0x62F6, 0x62F6, 0x62F6, 0x6B36, 0x6B36, 0x62F6, 0x5A94, 0x4A32, 0x5253, 0x5A95, 0x62F6, 0x6B36, 0x7357, 0x62F6, 0x6B36, 0x6B36,   // 0x0C10 (3088)
+0x6B56, 0x5A94, 0x2109, 0x18E7, 0x292A, 0x2929, 0x2108, 0x18E7, 0x2108, 0x2108, 0x39CE, 0x7357, 0x6B16, 0x4A10, 0x10A4, 0x0021,   // 0x0C20 (3104)
+0x10A5, 0x2109, 0x8C37, 0x41D2, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0C30 (3120)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xD69C, 0xFFBF, 0x314B, 0x2129,   // 0x0C40 (3136)
+0x41EF, 0x5A75, 0x6B56, 0x5AB5, 0x6B36, 0x318C, 0x294A, 0x294A, 0x1084, 0x18E7, 0x294A, 0x314B, 0x0863, 0x2929, 0x5A95, 0x6B16,   // 0x0C50 (3152)
+0x62D5, 0x62D5, 0x5AB5, 0x5AD5, 0x5A95, 0x5273, 0x4A52, 0x4A52, 0x5273, 0x5273, 0x5253, 0x5AB5, 0x62D6, 0x62D5, 0x5A95, 0x5AB5,   // 0x0C60 (3168)
+0x6316, 0x5A94, 0x318C, 0x2108, 0x18C5, 0x1083, 0x2929, 0x2929, 0x18C6, 0x0863, 0x316B, 0x6B16, 0x5AD5, 0x5294, 0x5273, 0x39CE,   // 0x0C70 (3184)
+0x20C7, 0x18A5, 0x8417, 0x3190, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0C80 (3200)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0813, 0x0813, 0xDEDD, 0xF7BF, 0x41F1, 0x5A94,   // 0x0C90 (3216)
+0x7BD7, 0x8C59, 0x6B56, 0x5A95, 0x5AD5, 0x314B, 0x2108, 0x2929, 0x18C7, 0x2108, 0x2129, 0x2129, 0x18C6, 0x318C, 0x5294, 0x5A95,   // 0x0CA0 (3232)
+0x5A94, 0x5A94, 0x5274, 0x5A94, 0x5274, 0x5273, 0x7BB8, 0xBDFB, 0xBDBB, 0x7BD7, 0x5A75, 0x5274, 0x5294, 0x5A95, 0x5A94, 0x5274,   // 0x0CB0 (3248)
+0x5A95, 0x5274, 0x4210, 0x318C, 0x2949, 0x2108, 0x398D, 0x296B, 0x294A, 0x18C6, 0x398D, 0x5AB5, 0x5274, 0x6B36, 0x9499, 0x6B56,   // 0x0CC0 (3264)
+0x4A32, 0x31AD, 0x83D7, 0x398F, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0CD0 (3280)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xCE7C, 0xEF5E, 0x4A12, 0x4A32,   // 0x0CE0 (3296)
+0x5274, 0x5273, 0x5274, 0x5274, 0x5294, 0x2928, 0x1084, 0x2107, 0x318C, 0x314A, 0x18C6, 0x18E7, 0x2929, 0x41EF, 0x5274, 0x5274,   // 0x0CF0 (3312)
+0x5253, 0x5273, 0x5253, 0x5253, 0x5A95, 0x7BB7, 0xA51A, 0xCE5C, 0xCE5C, 0xA51A, 0x83F7, 0x5A95, 0x4A32, 0x5273, 0x5274, 0x4A52,   // 0x0D00 (3328)
+0x5273, 0x5274, 0x5274, 0x5A95, 0x5252, 0x5253, 0x5274, 0x4A32, 0x4A31, 0x4A32, 0x4A32, 0x5253, 0x5273, 0x5253, 0x5254, 0x62D5,   // 0x0D10 (3344)
+0x5A95, 0x41F0, 0x83F7, 0x39B0, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0D20 (3360)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0x0813, 0xCE7C, 0xF79F, 0x294A, 0x18E7,   // 0x0D30 (3376)
+0x294B, 0x39AE, 0x41EF, 0x4A11, 0x5253, 0x2929, 0x18C6, 0x2108, 0x294A, 0x292A, 0x20E8, 0x2129, 0x18C6, 0x41CF, 0x5273, 0x4A32,   // 0x0D40 (3392)
+0x4A52, 0x4A32, 0x4A52, 0x4A31, 0x5A95, 0x9CDA, 0x8C58, 0x5A74, 0x5A95, 0x8418, 0x9478, 0x62D6, 0x4A11, 0x4A32, 0x4A31, 0x4A52,   // 0x0D50 (3408)
+0x4A32, 0x4A32, 0x5252, 0x5273, 0x4A53, 0x5274, 0x5252, 0x5253, 0x5253, 0x5253, 0x5273, 0x4A31, 0x4A52, 0x5253, 0x41CF, 0x398D,   // 0x0D60 (3424)
+0x2129, 0x18E7, 0x83F8, 0x398F, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0D70 (3440)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0xCE7C, 0xFFFF, 0x292A, 0x1084,   // 0x0D80 (3456)
+0x2929, 0x0884, 0x316B, 0x41CF, 0x4A31, 0x294A, 0x294A, 0x294A, 0x10A5, 0x2107, 0x316C, 0x314A, 0x1084, 0x294A, 0x4A11, 0x4210,   // 0x0D90 (3472)
+0x4210, 0x4210, 0x4210, 0x41F0, 0x5273, 0x8C58, 0x9499, 0x62D6, 0x62D5, 0x9479, 0x8C58, 0x5274, 0x4210, 0x4A11, 0x4210, 0x4A11,   // 0x0DA0 (3488)
+0x4A11, 0x41F0, 0x39AE, 0x316C, 0x318C, 0x316B, 0x39AD, 0x39AE, 0x39AD, 0x318C, 0x39CE, 0x4210, 0x39CE, 0x318C, 0x2108, 0x316B,   // 0x0DB0 (3504)
+0x0863, 0x18C6, 0x83F7, 0x318E, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0DC0 (3520)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xC61C, 0xFFDF, 0x2909, 0x1084,   // 0x0DD0 (3536)
+0x7BB7, 0x39CE, 0x39CF, 0x39CE, 0x83D7, 0x316C, 0x20E8, 0x2909, 0x18C6, 0x2108, 0x294A, 0x294A, 0x18C6, 0x2107, 0x39CF, 0x4A10,   // 0x0DE0 (3552)
+0x41EF, 0x41EF, 0x41EF, 0x41EF, 0x4210, 0x5AB5, 0x9478, 0xB5BB, 0xB59B, 0x9498, 0x62F6, 0x41EF, 0x41CF, 0x4210, 0x41CF, 0x41CF,   // 0x0DF0 (3568)
+0x41EF, 0x39CE, 0x2929, 0x10A5, 0x18C6, 0x18A5, 0x20E7, 0x18E7, 0x18C6, 0x18C6, 0x316C, 0x6B16, 0x39AD, 0x296A, 0x316D, 0x83D7,   // 0x0E00 (3584)
+0x0842, 0x18C5, 0x8C18, 0x39AE, 0x0813, 0x0812, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x0E10 (3600)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0xCE5C, 0xF7BF, 0x18E7, 0x2929,   // 0x0E20 (3616)
+0xCE7C, 0x7BB7, 0x318C, 0x62F6, 0xE73E, 0x41F0, 0x1083, 0x18C6, 0x7B77, 0x41EF, 0x18A5, 0x20E7, 0x294A, 0x294A, 0x39AD, 0x41CF,   // 0x0E30 (3632)
+0x39AE, 0x39CE, 0x39CE, 0x39AE, 0x39AD, 0x39CF, 0x5253, 0x6B16, 0x62D5, 0x5273, 0x41F0, 0x39AD, 0x39CE, 0x41CF, 0x39CE, 0x39CE,   // 0x0E40 (3648)
+0x39CF, 0x318C, 0x18E7, 0x10A4, 0x20E7, 0x2108, 0x18C7, 0x318C, 0x4A32, 0x0863, 0x39AD, 0xBDFB, 0x62D5, 0x398D, 0x7BB7, 0xCE7D,   // 0x0E50 (3664)
+0x0864, 0x20E8, 0x83F7, 0x318E, 0x0834, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0E60 (3680)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0xC63C, 0xEF7E, 0x2108, 0x5233,   // 0x0E70 (3696)
+0xE71E, 0x6B16, 0x296B, 0xAD7A, 0xFFFF, 0x4A11, 0x0020, 0x41F0, 0xF79F, 0x5252, 0x1084, 0x10A5, 0x2109, 0x318D, 0x39AE, 0x39AD,   // 0x0E80 (3712)
+0x318C, 0x318C, 0x39AE, 0x318D, 0x39AD, 0x39AD, 0x318C, 0x318B, 0x316C, 0x318C, 0x398D, 0x398D, 0x398D, 0x39AD, 0x39AC, 0x39AD,   // 0x0E90 (3728)
+0x39AD, 0x294A, 0x18E6, 0x2108, 0x294A, 0x18E7, 0x18C6, 0x5253, 0xD67C, 0x18C6, 0x294A, 0xDEBD, 0xA4FA, 0x292A, 0x9CD9, 0xC63C,   // 0x0EA0 (3744)
+0x398D, 0x292A, 0x8C58, 0x39D0, 0x0814, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0EB0 (3760)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0xBDBB, 0xD69C, 0x4A13, 0x8418,   // 0x0EC0 (3776)
+0xDEDD, 0xA51A, 0x8C38, 0xCE7C, 0xF79F, 0x5274, 0x41CF, 0xBDFB, 0xEF5E, 0x39AE, 0x10A5, 0x398D, 0x62F6, 0x4210, 0x294B, 0x318C,   // 0x0ED0 (3792)
+0x318C, 0x316C, 0x316C, 0x318C, 0x316C, 0x318C, 0x316C, 0x316C, 0x318C, 0x316B, 0x316B, 0x316C, 0x318B, 0x316B, 0x318C, 0x318D,   // 0x0EE0 (3808)
+0x2929, 0x18C5, 0x2108, 0x39AE, 0x5A95, 0x5253, 0x10A4, 0x4A11, 0xFFFF, 0x7B97, 0x39AD, 0xDEFE, 0xCE5C, 0x7357, 0xC61C, 0xCE5C,   // 0x0EF0 (3824)
+0x7BD7, 0x5253, 0x83F7, 0x41D1, 0x1034, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0F00 (3840)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0xA51A, 0xCE5C, 0x7BB6, 0xB57B,   // 0x0F10 (3856)
+0xD69D, 0xD6BD, 0xE71E, 0xDEFD, 0xDEDD, 0x9CB9, 0xC5FC, 0xDEFD, 0xCE5C, 0x318B, 0x294A, 0xA51A, 0xAD7A, 0x41EF, 0x2109, 0x20E7,   // 0x0F20 (3872)
+0x292A, 0x316B, 0x294B, 0x316C, 0x294A, 0x294A, 0x316B, 0x294B, 0x316B, 0x316B, 0x316B, 0x316B, 0x316B, 0x294A, 0x316B, 0x314A,   // 0x0F30 (3888)
+0x2108, 0x2109, 0x18E7, 0x18E7, 0x7BB7, 0xE73E, 0x39CF, 0x39CE, 0xF7BF, 0xD67D, 0xA4D9, 0xDEDD, 0xE6FE, 0xDEDD, 0xD69D, 0xD67D,   // 0x0F40 (3904)
+0xAD5A, 0x7B97, 0x8C18, 0x41D1, 0x0834, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x0F50 (3920)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0x9478, 0xC61C, 0x7357, 0xA4F9,   // 0x0F60 (3936)
+0xC61C, 0xCE5C, 0xCE5D, 0xD69D, 0xCE7C, 0xD6BD, 0xD69D, 0xD69C, 0xC61C, 0x5274, 0x9CD9, 0xF79F, 0x6B16, 0x18C6, 0x0862, 0x2128,   // 0x0F70 (3952)
+0x294A, 0x2929, 0x2129, 0x294A, 0x294A, 0x2929, 0x2929, 0x294A, 0x292A, 0x2929, 0x2129, 0x2929, 0x294A, 0x2929, 0x2109, 0x18E7,   // 0x0F80 (3968)
+0x316B, 0x5A74, 0x4A11, 0x18C6, 0x318D, 0xEF9E, 0xD69C, 0x8C38, 0xDEDD, 0xDEBD, 0xE71D, 0xD69C, 0xD69D, 0xD69D, 0xCE5C, 0xC61B,   // 0x0F90 (3984)
+0x9CF9, 0x6B36, 0x9478, 0x4A12, 0x0834, 0x0814, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x0FA0 (4000)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0812, 0x7BB6, 0xAD5A, 0x6B15, 0x9CD9,   // 0x0FB0 (4016)
+0xC61C, 0xD67D, 0xCE3C, 0xD69D, 0xC61C, 0xC61C, 0xC61B, 0xC5FB, 0xCE5C, 0xD6BD, 0xCE7C, 0xDEDD, 0x39CE, 0x18C5, 0x318C, 0x83F8,   // 0x0FC0 (4032)
+0x49F0, 0x18A6, 0x20E7, 0x2108, 0x2929, 0x2108, 0x2108, 0x2929, 0x2929, 0x2108, 0x2929, 0x2929, 0x20E8, 0x2108, 0x18E7, 0x18C6,   // 0x0FD0 (4048)
+0x2129, 0x7336, 0xDEFD, 0x5274, 0x4A31, 0xAD3A, 0xE73E, 0xEF5E, 0xD69D, 0xD6BD, 0xD67D, 0xCE5C, 0xCE5C, 0xCE7D, 0xCE5C, 0xC63C,   // 0x0FE0 (4064)
+0x9CF9, 0x62F5, 0x9CD9, 0x5AB5, 0x0814, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x0FF0 (4080)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x62F5, 0x9CB8, 0x5AB4, 0x7396,   // 0x1000 (4096)
+0x9CD9, 0xA4FA, 0xAD7A, 0xB5BB, 0xC61C, 0xC63C, 0xC61C, 0xBDDB, 0xBDBB, 0xBDFC, 0xBDDB, 0xBDFC, 0x5274, 0x62F6, 0xD6BD, 0xB57B,   // 0x1010 (4112)
+0x316B, 0x1084, 0x2108, 0x18C6, 0x18A6, 0x2108, 0x20E8, 0x20E7, 0x20E7, 0x20E7, 0x2929, 0x2109, 0x18A6, 0x18E6, 0x294B, 0x2929,   // 0x1020 (4128)
+0x0863, 0x316C, 0xBDDB, 0xE73E, 0xC61C, 0xBDBB, 0xCE7C, 0xCE5C, 0xCE5C, 0xD69D, 0xD6BD, 0xCE5C, 0xBDDB, 0xA53A, 0xA4FA, 0x9CB9,   // 0x1030 (4144)
+0x7BB7, 0x6B15, 0xA519, 0x62F5, 0x0835, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x1040 (4160)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0811, 0x0812, 0x4A33, 0x7BD7, 0x41D1, 0x39D0,   // 0x1050 (4176)
+0x5254, 0x5AB5, 0x62D5, 0x6B36, 0x83F7, 0x9499, 0xAD3A, 0xBDDB, 0xB57A, 0xAD5A, 0xB59B, 0xAD5A, 0xBDFB, 0xCE5C, 0xC61C, 0x4A10,   // 0x1060 (4192)
+0x0862, 0x2108, 0x318C, 0x2108, 0x18E7, 0x18C7, 0x18E7, 0x18C6, 0x18C6, 0x18E7, 0x18C6, 0x18C7, 0x18C5, 0x2107, 0x4A32, 0x5274,   // 0x1070 (4208)
+0x318B, 0x2108, 0x62B5, 0xE71E, 0xCE3C, 0xCE5C, 0xD67D, 0xC63C, 0xCE7C, 0xB59B, 0xA4FA, 0x8C38, 0x7377, 0x62F5, 0x5A95, 0x5274,   // 0x1080 (4224)
+0x4A32, 0x5A75, 0xC5FB, 0x7BD7, 0x0834, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x1090 (4240)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x39B1, 0x6315, 0x316E, 0x41F1,   // 0x10A0 (4256)
+0x4A54, 0x5295, 0x5295, 0x5A95, 0x4A32, 0x5253, 0x62D5, 0x83F8, 0xA4FA, 0xB5BB, 0xAD3A, 0xA51A, 0xAD5A, 0xA51A, 0x9499, 0x41EF,   // 0x10B0 (4272)
+0x39AD, 0x62D6, 0x5253, 0x316C, 0x316B, 0x2929, 0x20E7, 0x18C7, 0x18C6, 0x18A5, 0x18A5, 0x10A4, 0x2108, 0x2929, 0x4A32, 0xCE7D,   // 0x10C0 (4288)
+0xBDBB, 0x7376, 0x7377, 0xCE7C, 0xC61C, 0xC5FB, 0xC63C, 0xBDFB, 0x9CB9, 0x6B56, 0x5253, 0x5253, 0x5A95, 0x6B16, 0x62F6, 0x5A95,   // 0x10D0 (4304)
+0x4A32, 0x7356, 0xDEBD, 0xA4F9, 0x0814, 0x0833, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011,   // 0x10E0 (4320)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x210C, 0x5254, 0x4A13, 0x39AF,   // 0x10F0 (4336)
+0x5294, 0x6B56, 0x6B56, 0x7377, 0x7376, 0x6B16, 0x5273, 0x4210, 0x62F6, 0x8C58, 0xAD3A, 0x9CD9, 0x9CD9, 0xA4FA, 0x83F8, 0x7BB7,   // 0x1100 (4352)
+0xAD5A, 0xAD3A, 0x318D, 0x18C5, 0x2929, 0x292A, 0x2108, 0x2108, 0x18C6, 0x1084, 0x1084, 0x1063, 0x18C6, 0x18E7, 0x2108, 0x5253,   // 0x1110 (4368)
+0xBDFC, 0xCE5C, 0xC63C, 0xB57A, 0xBDBB, 0xBDFB, 0xA51A, 0x62F6, 0x5253, 0x5AB5, 0x6B36, 0x7B97, 0x7BB7, 0x7B97, 0x7376, 0x5AB5,   // 0x1120 (4384)
+0x5A95, 0xCE3C, 0xDEDD, 0xC61C, 0x0814, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1130 (4400)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0811, 0x294E, 0x5AB4, 0x316D,   // 0x1140 (4416)
+0x41F2, 0x5274, 0x6315, 0x6B15, 0x6B16, 0x6B36, 0x7397, 0x62F6, 0x4210, 0x4A11, 0x83D7, 0x9CB9, 0x9479, 0x9499, 0x9CD9, 0xA51A,   // 0x1150 (4432)
+0x9458, 0x39AE, 0x2108, 0x296B, 0x294A, 0x314B, 0x316B, 0x2929, 0x18C6, 0x1084, 0x0863, 0x18A5, 0x292A, 0x314B, 0x2128, 0x39CE,   // 0x1160 (4448)
+0x8C58, 0xAD5A, 0xAD3A, 0xAD5A, 0xB57B, 0xA4FA, 0x62D5, 0x4A31, 0x7377, 0x7B97, 0x7BB7, 0x7377, 0x6B36, 0x6B36, 0x5AB5, 0x5273,   // 0x1170 (4464)
+0x83F8, 0xFFFF, 0xEF7E, 0x83F7, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1180 (4480)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x3191, 0x3990,   // 0x1190 (4496)
+0x39B0, 0x39D0, 0x4A12, 0x62D5, 0x62D5, 0x62B6, 0x62D5, 0x62D5, 0x62D5, 0x4A11, 0x4211, 0x7B96, 0x9479, 0x83F8, 0x83F8, 0x9479,   // 0x11A0 (4512)
+0x5AB5, 0x318D, 0x41CF, 0x5253, 0x4210, 0x294A, 0x2129, 0x316B, 0x2108, 0x1084, 0x0020, 0x18A5, 0x5A95, 0x8C18, 0x5A95, 0x5274,   // 0x11B0 (4528)
+0x7BB7, 0xA519, 0xA4FA, 0xB57B, 0x9479, 0x5252, 0x4A11, 0x7397, 0x7376, 0x7376, 0x6B16, 0x62F6, 0x62F5, 0x5A95, 0x5A95, 0x7BD7,   // 0x11C0 (4544)
+0xDEFD, 0xFFFF, 0xC61B, 0x0814, 0x0813, 0x0812, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x11D0 (4560)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x3191,   // 0x11E0 (4576)
+0x41F2, 0x39B0, 0x41D1, 0x4A12, 0x4A33, 0x5274, 0x5274, 0x4A32, 0x5A95, 0x5274, 0x318D, 0x41EF, 0x6B36, 0x7377, 0x6B56, 0x7377,   // 0x11F0 (4592)
+0x7377, 0x83F7, 0x8C38, 0x5A95, 0x318C, 0x2108, 0x18E7, 0x20E7, 0x2929, 0x18C5, 0x0000, 0x0000, 0x18C6, 0x5A95, 0x8418, 0x8C58,   // 0x1200 (4608)
+0x8C38, 0x83F8, 0x9479, 0x83F8, 0x4A52, 0x41CF, 0x62F6, 0x6316, 0x5AB5, 0x5A74, 0x62D6, 0x5A95, 0x5AB5, 0x6B56, 0xA4FA, 0xFFFF,   // 0x1210 (4624)
+0xFFFF, 0xFFFF, 0x0834, 0x0813, 0x0813, 0x0012, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1220 (4640)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0812,   // 0x1230 (4656)
+0x0812, 0x4213, 0x4A53, 0x4A13, 0x5254, 0x5AD5, 0x5AD5, 0x6B36, 0x6B16, 0x62D5, 0x6B36, 0x4A33, 0x62F6, 0x8C58, 0x8C58, 0x83D7,   // 0x1240 (4672)
+0x8C18, 0x8C58, 0x6B36, 0x4211, 0x39AE, 0x41F0, 0x41F0, 0x41EF, 0x41CF, 0x41CF, 0x316C, 0x294A, 0x294A, 0x41F0, 0x8418, 0x8C58,   // 0x1250 (4688)
+0x9478, 0x9CB9, 0x9499, 0x7BB7, 0x5253, 0x7BB7, 0x83F7, 0x7BB7, 0x7397, 0x6B56, 0x7BB7, 0x8418, 0x9478, 0xD69D, 0xFFFF, 0xFFFF,   // 0x1260 (4704)
+0xFFFF, 0x0814, 0x0813, 0x0813, 0x0812, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1270 (4720)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012,   // 0x1280 (4736)
+0x0012, 0x0812, 0x41F2, 0x6B15, 0x8C37, 0xA519, 0xC5FB, 0xCE9C, 0xDEDD, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1290 (4752)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x12A0 (4768)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BF, 0xF7BF, 0xF79E, 0xE73E, 0xEF9E, 0xEF5E, 0xE6FE, 0xEF5E, 0x0814,   // 0x12B0 (4784)
+0x0813, 0x0813, 0x0012, 0x0812, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x12C0 (4800)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x12D0 (4816)
+0x0812, 0x0812, 0x0812, 0x0813, 0x5253, 0x7376, 0x8C37, 0xA4FA, 0xB55B, 0xBDDB, 0xBDDB, 0xD69D, 0xD69C, 0xD69D, 0xDEDD, 0xDEBD,   // 0x12E0 (4832)
+0xD67C, 0xCE5C, 0xD69D, 0xD69C, 0xCE5C, 0xD67D, 0xCE5C, 0xCE3C, 0xCE7C, 0xC63C, 0xC61C, 0xCE5C, 0xCE5C, 0xD69C, 0xCE3C, 0xC61B,   // 0x12F0 (4848)
+0xC61C, 0xCE5C, 0xC61C, 0xBDDB, 0xC63C, 0xC5FC, 0xBDDB, 0xC5FB, 0xBD9B, 0xB5BB, 0xB5BB, 0xBDDB, 0xAD5A, 0x1014, 0x0814, 0x0814,   // 0x1300 (4864)
+0x0813, 0x0813, 0x0812, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1310 (4880)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1320 (4896)
+0x0011, 0x0012, 0x0011, 0x0012, 0x0012, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0814, 0x0833, 0x0814, 0x0814, 0x0834, 0x0814,   // 0x1330 (4912)
+0x0834, 0x0814, 0x0814, 0x0815, 0x0834, 0x0814, 0x0834, 0x0834, 0x0834, 0x0814, 0x0814, 0x0834, 0x0814, 0x0815, 0x0814, 0x0814,   // 0x1340 (4928)
+0x0814, 0x1015, 0x1015, 0x0814, 0x1034, 0x0814, 0x1015, 0x0814, 0x0834, 0x0814, 0x0814, 0x0814, 0x0833, 0x0813, 0x0833, 0x0813,   // 0x1350 (4944)
+0x0812, 0x0012, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1360 (4960)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1370 (4976)
+0x0011, 0x0011, 0x0012, 0x0011, 0x0812, 0x0812, 0x0012, 0x0012, 0x0812, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813,   // 0x1380 (4992)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0814, 0x0813,   // 0x1390 (5008)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0812, 0x0812, 0x0012,   // 0x13A0 (5024)
+0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x13B0 (5040)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011,   // 0x13C0 (5056)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0812, 0x0812, 0x0812, 0x0812, 0x0812, 0x0812,   // 0x13D0 (5072)
+0x0012, 0x0012, 0x0012, 0x0812, 0x0012, 0x0012, 0x0012, 0x0813, 0x0812, 0x0813, 0x0813, 0x0012, 0x0813, 0x0812, 0x0812, 0x0813,   // 0x13E0 (5088)
+0x0812, 0x0813, 0x0812, 0x0812, 0x0812, 0x0813, 0x0812, 0x0812, 0x0012, 0x0812, 0x0812, 0x0812, 0x0812, 0x0012, 0x0012, 0x0011,   // 0x13F0 (5104)
+0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1400 (5120)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1410 (5136)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0012, 0x0011, 0x0012,   // 0x1420 (5152)
+0x0012, 0x0011, 0x0012, 0x0012, 0x0011, 0x0812, 0x0011, 0x0011, 0x0012, 0x0012, 0x0011, 0x0012, 0x0811, 0x0811, 0x0011, 0x0012,   // 0x1430 (5168)
+0x0011, 0x0012, 0x0011, 0x0011, 0x0012, 0x0811, 0x0012, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0011,   // 0x1440 (5184)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1450 (5200)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1460 (5216)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1470 (5232)
+0x0011, 0x0011, 0x0011, 0x0811, 0x0012, 0x0010, 0x0011, 0x0011, 0x0011, 0x0811, 0x0011, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011,   // 0x1480 (5248)
+0x0011, 0x0012, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1490 (5264)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14A0 (5280)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x14B0 (5296)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14C0 (5312)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0xCE5D, 0x0011, 0x0011, 0xCE5D, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14D0 (5328)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14E0 (5344)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14F0 (5360)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0xFFFF, 0x0010, 0x0010,   // 0x1500 (5376)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0xFFFF, 0x000D, 0x0011, 0x0011, 0x0011,   // 0x1510 (5392)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1520 (5408)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1530 (5424)
+0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1540 (5440)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0x0011,   // 0x1550 (5456)
+0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0xFFFF, 0x084D, 0x0010, 0x0010, 0x0011,   // 0x1560 (5472)
+0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010,   // 0x1570 (5488)
+0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011,   // 0x1580 (5504)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1590 (5520)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0010, 0x0010,   // 0x15A0 (5536)
+0xFFFF, 0xFFFF, 0xFFFF, 0x080E, 0x0011, 0x0011, 0x0010, 0xFFFF, 0xFFFF, 0x000F, 0x210F, 0xFFFF, 0xFFFF, 0x000E, 0x0010, 0x0011,   // 0x15B0 (5552)
+0xFFFF, 0xFFFF, 0x0010, 0x0010, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0xFFFF,   // 0x15C0 (5568)
+0xFFFF, 0x0011, 0x0011, 0x0011, 0x082D, 0xFFFF, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x080D, 0xFFFF, 0xFFFF, 0x0010, 0x0011, 0x0011,   // 0x15D0 (5584)
+0xFFFF, 0xFFFF, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x15E0 (5600)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0010, 0x0011,   // 0x15F0 (5616)
+0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0010, 0x0011, 0xFFFF,   // 0x1600 (5632)
+0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x1610 (5648)
+0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010,   // 0x1620 (5664)
+0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1630 (5680)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011,   // 0x1640 (5696)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0xFFFF, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011, 0xFFFF,   // 0x1650 (5712)
+0xFFFF, 0xFFFF, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011,   // 0x1660 (5728)
+0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0xF77E, 0x0010, 0x0010, 0x0011,   // 0x1670 (5744)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1680 (5760)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011,   // 0x1690 (5776)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0010, 0xFFFF,   // 0x16A0 (5792)
+0x080D, 0x0011, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x16B0 (5808)
+0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x16C0 (5824)
+0xFFFF, 0x0010, 0x0010, 0xFFFF, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x16D0 (5840)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x000F, 0x0011, 0x0010,   // 0x16E0 (5856)
+0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0x0011, 0xFFFF,   // 0x16F0 (5872)
+0x082D, 0x0010, 0x0010, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x1700 (5888)
+0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1710 (5904)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1720 (5920)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0xFFFF, 0xFFFF, 0xFFFF, 0x0010, 0x0011,   // 0x1730 (5936)
+0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0x000E, 0x0011, 0x0010, 0x0011, 0xFFFF, 0xFFFF, 0x0010, 0x0011,   // 0x1740 (5952)
+0xFFFF, 0xFFFF, 0xFFFF, 0x000F, 0x0010, 0xFFFF, 0x0010, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x1750 (5968)
+0x0011, 0xFFFF, 0x0011, 0x0010, 0x000E, 0xFFFF, 0xFFFF, 0xFFFF, 0x0011, 0x0010, 0x000F, 0xFFFF, 0xFFFF, 0xFFFF, 0x0011, 0x0011,   // 0x1760 (5984)
+0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1770 (6000)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1780 (6016)
+0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1790 (6032)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x17A0 (6048)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x000D, 0xC5FD, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010,   // 0x17B0 (6064)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x17C0 (6080)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x17D0 (6096)
+0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x17E0 (6112)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x17F0 (6128)
+0x0011, 0x0011, 0x0011, 0x0010, 0x002D, 0xFFFF, 0xFFFF, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1800 (6144)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1810 (6160)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x1820 (6176)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011,   // 0x1830 (6192)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x1840 (6208)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1850 (6224)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1860 (6240)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1870 (6256)
+0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x1880 (6272)
+0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1890 (6288)
+0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x18A0 (6304)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x18B0 (6320)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x18C0 (6336)
+0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x18D0 (6352)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x18E0 (6368)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x18F0 (6384)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1900 (6400)
+};

_718/internet.ino

@@ -0,0 +1,290 @@
+void internet()
+{ //Serial2.setTimeout(5000);
+  char* name;
+   char* name1;
+   boolean bad=0;
+   int i;
+//  esp8266();
+//doo:
+     myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(0,172,238);
+ myGLCD.setFont(BigFont);
+// myGLCD.fillScr(VGA_BLUE); 
+ 
+ digitalWrite(18, LOW);
+ delay(3000);
+ digitalWrite(18, HIGH);//reset WIFI
+ myGLCD.print(" openweather " ,280, 457);
+  delay(7000);
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+                            i=0;
+                             if (Serial2.find("IP"))
+                            {myGLCD.print("ip:" ,260, 457);
+                             int ip1=Serial2.parseInt();
+                              int ip2=Serial2.parseInt();
+                                int ip3=Serial2.parseInt();
+                                int ip4=Serial2.parseInt();
+                                String data1=  String(ip1)+"."+String(ip2)+"."+String(ip3)+"."+String(ip4)+"   ";
+                                        myGLCD.print(data1 ,280, 457);
+                                        i=1000;
+                                        delay(3000);
+                                        c = Serial2.read();
+                                        c = Serial2.read();
+                                        myGLCD.print("                   " ,240, 457);
+       
+                                }
+   
+                           } 
+      if(i>0)delay (10); 
+     }
+//**************************************
+ Serial2.print("7");//проверка подключения к точке доступа если ответ больше 0 то подключились
+delay(1000);
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+                            i=0;
+                              if (Serial2.find("7+"))
+                            {myGLCD.print("    read data      " ,280, 457);
+                             i=1000;
+                              }
+   
+                           } 
+      if(i>0)delay (10); 
+     }
+//**************************************
+ Serial2.print("1");//проверка подключения к точке доступа если ответ больше 0 то подключились
+delay(1000);
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+                           i=0;
+                              if (Serial2.find("1+"))
+                            {myGLCD.print("   read server    " ,280, 457);
+                             i=1000;
+                              }
+   
+                           } 
+      if(i>0)delay (10); 
+     }
+//**************************************
+  //****************************SD**********************
+  sd.chdir("/");
+  delay (100);
+  
+  sd.chdir("progn");
+   delay (100);
+   if (sd.exists("prognoz.txt"))
+     {name= "prognoz1.txt";
+       name1= "prognoz.txt";
+       }//установка раб директории 
+     else
+   {name= "prognoz.txt";
+     name1= "prognoz1.txt";
+   }  
+
+ //  myFile.remove();
+   delay (50);
+    myFile.open(name, O_RDWR | O_CREAT | O_AT_END);
+   delay (50);
+   
+//******************************************************   
+
+  i = 0; //счетчик времени
+  int n = 1; // счетчик символов
+  int st=0;
+  char c ;
+  //Serial2.setTimeout(2000);
+  i=0; 
+  myGLCD.print("   read inform 1      " ,280, 457);
+  while (i<60000) {
+    if(Serial2.available()) {
+  
+      c = Serial2.read();
+     
+       myFile.print(c);
+   
+      i=0;   
+    }//gotov
+    i++;
+     
+      
+  }//while
+
+delay (500); 
+myGLCD.print("   read inform 2      " ,280, 457);
+    i=0; 
+  while (i<600) {
+    if(Serial2.available()) {
+  
+      c = Serial2.read();
+     
+       myFile.print(c);
+     
+      i=0;   
+    }//gotov
+     if(i>0)delay (10);
+    i++;
+   
+  }//while
+  
+  delay (500); 
+myGLCD.print("   read inform 3      " ,280, 457);
+    i=0; 
+  while (i<600) {
+    if(Serial2.available()) {
+  
+      c = Serial2.read();
+     
+       myFile.print(c);
+     
+      i=0;   
+    }//gotov
+     if(i>0)delay (10);
+    i++;
+   
+  }//while
+  
+
+  
+  myGLCD.print("                         ",118, 457);
+ myGLCD.print("   end read inform     " ,280, 457);
+ int cardSize=myFile.fileSize();
+//myGLCD.printNumI(st ,150, 230);
+ // myGLCD.printNumI(i ,180, 230);
+   myFile.close();
+   delay (1000);
+   myGLCD.print("                         ",118, 457);
+ myGLCD.print("     verifying         " ,280, 457); 
+ delay (1000);
+ myGLCD.print("                         ",118, 457);
+myGLCD.print("file size=" ,280, 457); 
+ myGLCD.printNumI(cardSize,280+160, 457);
+//************proverka file **********************************************
+
+ sd.chdir("/");//установка раб директории 
+     delay (1000);
+  sd.chdir("progn");
+   delay (100);
+   myFile.open(name, O_READ);
+   char symbol;
+    i=0;
+   char token[] = "weatherdata"; 
+  n=1;
+   while(  n < 8000)//размер считанного с сайта файла проверяем на наличае в конце </weatherdata>
+   { symbol = myFile.read();
+    if(n>1000)
+      {if (symbol == token[i])
+       { i=i+1;
+       }
+       else
+       {
+         i=0;
+       }
+      }
+    if(i>9){break;}
+   n=n+1;   
+   }
+ if (cardSize>5000)//измерение размера файла если размер больше то считали  все 
+{ if(i>9){// если есть в конце </weatherdata>
+  wifi=0;
+  myGLCD.print("   good file W=  " ,280, 457);
+  myGLCD.printNumI(i,280+256, 457);
+  wifih=t.hour;// час обновления данных
+   wifim=t.min;// минуты 
+  }
+  else// // если нет в конце </weatherdata> то error
+ { myGLCD.print("    bad file  W=   " ,280, 457); 
+ myGLCD.printNumI(i,280+256, 457);
+   wifi=9;
+  bad=1;
+ }
+ 
+}
+ else//размер меньше то считали не все error
+ { myGLCD.print("     bad file        " ,280, 457); 
+   wifi=9;
+  bad=1;
+ }
+    myFile.close();
+   delay (1000);
+   sd.chdir("/");//установка раб директории 
+     delay (1000);
+  sd.chdir("progn");
+   delay (100);
+ if (bad==1)
+   { if (sd.exists("Err.txt"))
+     {myFile.open("Err.txt", O_RDWR | O_CREAT | O_AT_END);
+       delay (100);
+      myFile.remove();
+     }
+    delay (100);
+    sd.rename(name,"Err.txt");
+    delay (100);
+  
+   }
+   else{
+      myFile.open(name1, O_RDWR | O_CREAT | O_AT_END);
+       delay (100);
+      myFile.remove();
+   }
+  
+
+    sd.chdir("/");
+  delay (2000);
+  // myGLCD.print(" end read inform " ,260, 460);
+myGLCD.print("                         ",118, 457);  
+   clc();  
+digitalWrite(65, LOW); 
+/*   return;
+
+   
+   
+   
+   
+//****Для отладки***************************
+
+
+
+while(1)
+{ 
+  if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+     int x=myTouch.getX();
+     int y=myTouch.getY();
+      
+         if ((x>=0) && (x<=799))  // Upper row
+      {
+        
+        if ((y>=10) && (y<=479))  // яркость
+          {
+             menu();
+          }
+      }
+    }//touch
+ sec=rtc_clock.get_seconds();
+if (sec==0)
+{
+delay(800);
+clc();
+}    
+    
+}//while
+ // dbgSerial.println(json);
+  //***********************************************************************************
+  */
+}
+//***********************************************

_718/intime.ino

@@ -0,0 +1,292 @@
+void intime()
+{
+  char c7 ;
+int i=0; 
+int h1,m1,s1,day1,month1,year1;
+int cl1=0;
+int save=0;
+int x,y;
+int x1=170;
+int y1=200;
+//doo:
+     myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(0,172,238);
+ myGLCD.setFont(BigFont);
+// myGLCD.fillScr(VGA_BLUE); 
+ 
+ digitalWrite(18, LOW);
+ delay(3000);
+ digitalWrite(18, HIGH);//reset WIFI
+ myGLCD.print("     NTP      " ,280, 457);
+ delay(5000);
+ myGLCD.print("   connecting    " ,280, 457);
+delay(500);
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+                            i=0;
+                             if (Serial2.find("IP"))
+                            {myGLCD.print("ip:" ,260, 457);
+                             int ip1=Serial2.parseInt();
+                              int ip2=Serial2.parseInt();
+                                int ip3=Serial2.parseInt();
+                                int ip4=Serial2.parseInt();
+                                String data1=  String(ip1)+"."+String(ip2)+"."+String(ip3)+"."+String(ip4)+"   ";
+                                        myGLCD.print(data1 ,280, 457);
+                                        i=1000;
+                                        delay(3000);
+                                        c7 = Serial2.read();
+                                        c7 = Serial2.read();
+                                        myGLCD.print("                   " ,240, 457);
+       
+                                }
+   
+                           } 
+      if(i>0)delay (10); 
+     }
+//**************************************
+ Serial2.print("7");//проверка подключения к точке доступа если ответ больше 0 то подключились
+delay(1000);
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+                            i=0;
+                              if (Serial2.find("7+"))
+                            {myGLCD.print("    read data      " ,280, 457);
+                             i=1000;
+                              }
+   
+                           } 
+      if(i>0)delay (10); 
+     }
+//**************************************
+ Serial2.print("2");//проверка подключения к точке доступа если ответ больше 0 то подключились
+delay(1000);
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+                            i=0;
+                              if (Serial2.find("2+"))
+                            {myGLCD.print("    read NTP     " ,280, 457);
+                            delay(1000);
+                             cl1=1;  
+           
+                 myGLCD.print("   end read NTP    " ,280, 457);
+                   myGLCD.setColor(155, 155,155);
+                  myGLCD.fillRect(160,140,660,390);//тень
+                       myGLCD.setColor(0, 0,155);
+                  myGLCD.fillRect(150,130,650,380);//поле
+                  myGLCD.setColor(VGA_WHITE);
+                  myGLCD.drawRect(160,140,640,370);//обводка
+
+                  myGLCD.drawRect(190,320,370,360);//YES
+                  myGLCD.drawRect(430,320,610,360);//NO
+                 myGLCD.setBackColor(0, 0,155);//фон цифр
+                 myGLCD.print("YES" ,255, 335);
+                 myGLCD.print("NO" ,500, 335);
+                 myGLCD.print("Set NTP Time" ,300, 140);
+                 
+                    h1=Serial2.parseInt();
+                      m1=Serial2.parseInt();
+                       s1=Serial2.parseInt();
+                       day1=Serial2.parseInt(); 
+                       month1=Serial2.parseInt()*(-1); 
+                     year1=Serial2.parseInt()*(-1);
+                                          if( year1==1970)
+                                              {  Serial2.print("2");
+                                              myGLCD.setBackColor(0,172,238);
+                                               myGLCD.print("  end read NTP1   " ,280, 457);
+                                                 delay(2000);
+                                              
+                                             if (Serial2.find("2+"))
+                                               {myGLCD.print("    read NTP2    " ,280, 457);
+                                                     delay(1000);
+                                                     h1=Serial2.parseInt();
+                                                      m1=Serial2.parseInt();
+                                                    s1=Serial2.parseInt();
+                                                    day1=Serial2.parseInt();
+                                                      month1=Serial2.parseInt()*(-1); 
+                                                   year1=Serial2.parseInt()*(-1); 
+                                                   myGLCD.print("   end read NTP2    " ,280, 457);
+                                               }  
+                                                  i=1000; 
+                                                  }
+   
+                           } 
+      if(i>0)delay (10); 
+     }
+     }
+//**************************************
+ if (cl1==1 )
+  {myGLCD.setBackColor(0, 0,155);//фон цифр
+    //***********************************************************************************************************
+  while (1)
+     {t = rtc.getTime();
+      //***********  T  O  U  C  H  ********************   
+   if (myTouch.dataAvailable())
+    { //myGLCD.fillScr(0, 0, 0); 
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      // Serial.print("xt=");
+      // Serial.println(xt);
+     //  Serial.print("yt=");
+     //  Serial.println(yt);
+       myGLCD.drawPixel(x, y);
+     
+        if ((y>=320) && (y<=360)) 
+        { if ((x>=200) && (x<=350))  // Upper row
+           {myGLCD.setColor(100,255,100);
+                 myGLCD.drawRect(190,320,370,360);//YES
+                 myGLCD.setFont(BigFont);
+                 myGLCD.print("YES" ,255, 335);//The time is set
+                save=1;
+                  
+           }
+           if ((x>=450) && (x=600))  // Upper row
+           {myGLCD.setColor(255,50,0);
+             myGLCD.drawRect(430,320,610,360);//NO
+             myGLCD.setFont(BigFont);
+              myGLCD.print("NO" ,500, 335);//time is not set
+              save=2;
+           }
+        }
+           
+    }
+
+
+      
+    if (t.sec!=oldsec) 
+  { oldsec=t.sec;
+  myGLCD.setFont(BigFont);
+  String data=  String(day1)+"/"+String(month1)+"/"+String(year1);
+   myGLCD.print(data ,330, 175); 
+    myGLCD.setFont( SevenSegNumFont);
+  s1++;
+   if(s1>59){
+    s1=0;
+    m1++;
+    if(m1>59){
+      h1++;
+       m1=0;
+        if(h1>23)h1=0;
+    }
+     }
+    
+  int clockCenterX=270;
+  int clockCenterY=220;
+     if (h1<10)
+  {
+    myGLCD.printNumI(0,clockCenterX, clockCenterY-20);
+    myGLCD.printNumI(h1, clockCenterX+32, clockCenterY-20);
+  }
+  else
+  {
+    myGLCD.printNumI(h1,clockCenterX, clockCenterY-20);
+  }
+  myGLCD.print(":",clockCenterX+64, clockCenterY-20);
+  if (m1<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+96, clockCenterY-20);
+    myGLCD.printNumI(m1, clockCenterX+128, clockCenterY-20);
+  }
+  else
+  {
+    myGLCD.printNumI(m1, clockCenterX+96, clockCenterY-20);
+  }
+  myGLCD.print(":",clockCenterX+160, clockCenterY-20);
+   if (s1<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+96*2, clockCenterY-20);
+    myGLCD.printNumI(s1, clockCenterX+96*2+32, clockCenterY-20);
+  }
+  else
+  {
+    myGLCD.printNumI(s1, clockCenterX+96*2, clockCenterY-20);
+  }
+  if(save==2)
+    { myGLCD.setFont(BigFont);
+       myGLCD.setColor(0, 0,155);
+        myGLCD.fillRect(170,280,630,368);//поле
+        myGLCD.setColor(255,50,0);
+      myGLCD.print("The time is not set" ,250, 310);
+      delay(3000);
+      return;
+     }
+   if(save==1)
+    { myGLCD.setFont(BigFont);
+       rtc.setTime(h1, m1,s1);     // Set the time to 12:00:00 (24hr format)
+       rtc.setDate(day1,month1,year1);   // Set the date to January 1st, 2014
+       dow=calcDOW(day1,month1, year1);
+       rtc.setDOW(dow);
+         myGLCD.setColor(0, 0,155);
+        myGLCD.fillRect(170,280,630,368);//поле
+        myGLCD.setColor(100,255,100);
+      myGLCD.print("The time is set" ,280, 310);
+      delay(3000);
+      return;
+     }
+  } 
+ delay(500);
+}
+
+  }
+
+  }
+//****************************************************************     
+void vrem()     
+{//t19:05d29/0915/  
+// peredacha vremeni drugim ds1307   
+min1= t.min;
+hour1=t.hour;   
+  
+Serial.print("t");
+
+ 
+ 
+  if (hour1>9)
+  {
+   Serial.print(hour1);
+  }
+  else
+  { Serial.print("0");
+     Serial.print(hour1);
+  }
+Serial.print(":");  
+    if (min1>9)
+  {
+   Serial.print(min1);
+  }
+  else
+  { Serial.print("0");
+     Serial.print(min1);
+  }
+  Serial.print("d"); 
+ if (date>9) 
+   {  Serial.print(date);
+  }
+  else
+  { Serial.print("0");
+     Serial.print(date);
+  }
+   Serial.print("/"); 
+   if (mon>9) 
+   {  Serial.print(mon);
+  }
+  else
+  { Serial.print("0");
+     Serial.print(mon);
+  } 
+Serial.print(t.year-2000);
+ Serial.print("/"); 
+} 
+     

_718/ints.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: ints.jpg
+// Time generated: 14.09.2015 16:54:26
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short ints[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087F,   // 0x00C0 (192)
+0x295D, 0x315A, 0x3196, 0x20D1, 0x10AF, 0x090F, 0x0150, 0x0170, 0x0150, 0x0150, 0x090F, 0x08EF, 0x18B0, 0x2934, 0x2939, 0x211C,   // 0x00D0 (208)
+0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213D, 0x3177, 0x18D0,   // 0x0110 (272)
+0x008D, 0x0170, 0x0212, 0x0315, 0x03F8, 0x049A, 0x04FC, 0x053D, 0x053D, 0x04DB, 0x04BB, 0x045A, 0x0397, 0x02B4, 0x01D1, 0x00EE,   // 0x0120 (288)
+0x18EF, 0x3175, 0x39DB, 0x109F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x31BC, 0x2952, 0x006C, 0x012E, 0x0272,   // 0x0160 (352)
+0x0355, 0x03D7, 0x0418, 0x0439, 0x049A, 0x04DC, 0x053D, 0x05BE, 0x05DF, 0x051D, 0x04FC, 0x04DC, 0x04DB, 0x049A, 0x0479, 0x03D7,   // 0x0170 (368)
+0x0315, 0x01D1, 0x008D, 0x18D0, 0x39BA, 0x10DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01A0 (416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x319C, 0x2152, 0x004A, 0x014E, 0x0292, 0x02F4, 0x0334,   // 0x01B0 (432)
+0x0335, 0x0376, 0x03B7, 0x03D8, 0x057D, 0x063F, 0x0E3F, 0x0E5F, 0x0E3F, 0x0DBE, 0x04FC, 0x04BB, 0x049A, 0x0459, 0x0418, 0x1437,   // 0x01C0 (448)
+0x0BD6, 0x0396, 0x02F5, 0x01F2, 0x006E, 0x08AF, 0x31DA, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01D0 (464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x211F, 0x39D6, 0x002A, 0x00EC, 0x0210, 0x0272, 0x0292, 0x02B3, 0x02D4,   // 0x0200 (512)
+0x0315, 0x0356, 0x0397, 0x03B7, 0x049A, 0x05FE, 0x0E3F, 0x0E5F, 0x163F, 0x0E5F, 0x061F, 0x04DB, 0x045A, 0x0419, 0x2477, 0x7576,   // 0x0210 (528)
+0x8595, 0x95D5, 0x9DD1, 0xB5A8, 0x8C6C, 0x4A4C, 0x104B, 0x20F2, 0x31BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0220 (544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0240 (576)
+0x39BE, 0x6AB9, 0x001F, 0x001F, 0x001F, 0x001F, 0x39FE, 0x18AE, 0x002A, 0x016E, 0x01EF, 0x0210, 0x0231, 0x0251, 0x0293, 0x02B3,   // 0x0250 (592)
+0x02F4, 0x0335, 0x0376, 0x03B7, 0x03B8, 0x059E, 0x0E3F, 0x0E3F, 0x163F, 0x0E3F, 0x0DFF, 0x04BB, 0x0459, 0x0419, 0x03B7, 0x0376,   // 0x0260 (608)
+0x0356, 0x1395, 0x3BD2, 0x8CE7, 0xE662, 0xFFC4, 0xEE06, 0xB3C6, 0x7249, 0x5A59, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0270 (624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x107F,   // 0x0290 (656)
+0xD3A8, 0xD3EA, 0x211F, 0x001F, 0x001F, 0x423B, 0x000B, 0x008A, 0x016E, 0x018E, 0x01AF, 0x01D0, 0x0211, 0x0231, 0x0272, 0x0293,   // 0x02A0 (672)
+0x02B4, 0x02B4, 0x0316, 0x0377, 0x0397, 0x055D, 0x065F, 0x0E3F, 0x0E3F, 0x0E3F, 0x059E, 0x045A, 0x0419, 0x03F8, 0x03B7, 0x0376,   // 0x02B0 (688)
+0x0355, 0x0314, 0x02B3, 0x0212, 0x118A, 0xB444, 0xFEE5, 0xFF65, 0xFEE4, 0xF544, 0xC40E, 0x5ABD, 0x087F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x72F9,   // 0x02E0 (736)
+0xFB40, 0xFBC2, 0xDE7A, 0x73BF, 0x4239, 0x0008, 0x00AA, 0x012D, 0x012D, 0x016E, 0x018E, 0x01AF, 0x01F0, 0x0231, 0x0211, 0x0252,   // 0x02F0 (752)
+0x2333, 0x6495, 0xADB4, 0x33F5, 0x0357, 0x055D, 0x063F, 0x063F, 0x061F, 0x063F, 0x061F, 0x047A, 0x03D8, 0x03B7, 0x0397, 0x0356,   // 0x0300 (768)
+0x0335, 0x0B13, 0x12D1, 0x1270, 0x11EE, 0x59C7, 0xFC04, 0xFD25, 0xFEE6, 0xFF05, 0xFD83, 0xFC85, 0xBC96, 0x423F, 0x001F, 0x001F,   // 0x0310 (784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18DF, 0xE408,   // 0x0330 (816)
+0xFB80, 0xFB80, 0xF4EA, 0x6354, 0x0007, 0x008A, 0x00CC, 0x00EC, 0x010D, 0x012E, 0x016E, 0x018E, 0x01D0, 0x01B0, 0x3312, 0xADB4,   // 0x0340 (832)
+0xFF56, 0xFE91, 0x7B0A, 0x02B3, 0x0419, 0x05FF, 0x05FF, 0x05FF, 0x061F, 0x059E, 0x05FE, 0x04DB, 0x03D8, 0x0397, 0x0376, 0x0315,   // 0x0350 (848)
+0x02F4, 0x22F1, 0x6B2C, 0xB3E8, 0xF568, 0xFDA7, 0xFCA4, 0xFBA3, 0xFC26, 0xFEEF, 0xFF2E, 0xFD66, 0xFC43, 0xED71, 0x529F, 0x003F,   // 0x0360 (864)
+0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x83DD, 0xFBA0,   // 0x0380 (896)
+0xFBA0, 0xFBC0, 0xFBA0, 0x6963, 0x0029, 0x006B, 0x006B, 0x008B, 0x00CC, 0x010D, 0x010D, 0x012E, 0x016F, 0x7BF1, 0xFE92, 0xFE70,   // 0x0390 (912)
+0xFD4D, 0x41E9, 0x01CF, 0x02D3, 0x055C, 0x05BE, 0x05DF, 0x05DE, 0x057D, 0x049B, 0x051C, 0x049A, 0x03F7, 0x0355, 0x0335, 0x03F7,   // 0x03A0 (928)
+0x0375, 0x0293, 0x0272, 0x1251, 0x532E, 0xACCD, 0xFEAD, 0xFEEC, 0xFD45, 0xFBE4, 0xFECE, 0xFF96, 0xFDCB, 0xFC23, 0xF5D1, 0x94DF,   // 0x03B0 (944)
+0x9BB3, 0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xDD94, 0xFB60,   // 0x03D0 (976)
+0xFB60, 0xF320, 0xEAC0, 0xEA60, 0x5905, 0x212B, 0x5AAD, 0xA40D, 0xBC8D, 0xBC8E, 0xA44F, 0x736F, 0xB38A, 0xFD0A, 0xFC47, 0xFBC5,   // 0x03E0 (992)
+0xB225, 0x018D, 0x02B1, 0x03F6, 0x057C, 0x059D, 0x055C, 0x049A, 0x0439, 0x0439, 0x04BA, 0x0397, 0x0335, 0x0396, 0x0458, 0x053B,   // 0x03F0 (1008)
+0x051A, 0x0458, 0x02F3, 0x0251, 0x01D0, 0x014C, 0x31AA, 0xB44A, 0xFF6D, 0xFEEA, 0xFCC3, 0xFF49, 0xFFF7, 0xFDEE, 0xFC04, 0xEE77,   // 0x0400 (1024)
+0xC50F, 0xBCB4, 0x297F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x425F, 0xECEC, 0xF2C0,   // 0x0420 (1056)
+0xEAA0, 0xDA40, 0xD1C0, 0xDA01, 0xF385, 0xF4EB, 0xFD6B, 0xFDAC, 0xFDAD, 0xFDCD, 0xFE0E, 0xFD09, 0xFB84, 0xFB43, 0xFB42, 0xFAC1,   // 0x0430 (1072)
+0x4A09, 0x0372, 0x03F5, 0x04F9, 0x053B, 0x057D, 0x049A, 0x0459, 0x049A, 0x03F8, 0x04FB, 0x051B, 0x04BA, 0x053B, 0x055B, 0x051A,   // 0x0440 (1088)
+0x04F9, 0x051A, 0x03B6, 0x0210, 0x01EF, 0x01AE, 0x014C, 0x00C9, 0x59E6, 0xE5E8, 0xFF69, 0xFE23, 0xFF87, 0xFFD3, 0xFDAD, 0xFCA9,   // 0x0450 (1104)
+0xBDB3, 0xEE67, 0xCE1D, 0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x73BF, 0xDC0A, 0xD9E0,   // 0x0470 (1136)
+0xD1A0, 0xC960, 0xE200, 0xFB02, 0xFB42, 0xFB42, 0xFB84, 0xFBC5, 0xFC06, 0xFC67, 0xFC67, 0xFB43, 0xFB22, 0xFB22, 0xFB41, 0xD241,   // 0x0480 (1152)
+0x0A0B, 0x0392, 0x0456, 0x04D9, 0x053B, 0x055B, 0x055C, 0x055B, 0x04BA, 0x0499, 0x051B, 0x055B, 0x055B, 0x051A, 0x04FA, 0x04FA,   // 0x0490 (1168)
+0x04D9, 0x04D9, 0x0355, 0x0210, 0x01EF, 0x01AF, 0x018E, 0x012B, 0x00AA, 0x18A7, 0xBC65, 0xFF46, 0xFF22, 0xFF47, 0xFF4F, 0xFD4A,   // 0x04A0 (1184)
+0xDC8A, 0xDEA7, 0xF6B2, 0xB5BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x847F, 0xD329, 0xC0E0,   // 0x04C0 (1216)
+0xC120, 0xEA20, 0xFAC0, 0xFAC0, 0xFAA0, 0xFAC0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE1, 0xFB21, 0xFB01, 0xFB20, 0xB1A1,   // 0x04D0 (1232)
+0x022D, 0x03D4, 0x0477, 0x04FA, 0x051A, 0x051B, 0x053B, 0x053B, 0x053B, 0x053B, 0x053B, 0x051A, 0x051A, 0x04FA, 0x04D9, 0x04D9,   // 0x04E0 (1248)
+0x04B9, 0x0498, 0x0458, 0x03B5, 0x01CF, 0x018E, 0x018E, 0x01AE, 0x00EB, 0x00A9, 0x094B, 0xB427, 0xFEE4, 0xFEC2, 0xFF27, 0xFE6C,   // 0x04F0 (1264)
+0xFCA9, 0xEE65, 0xF6A9, 0xE6DC, 0x4A9F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA53F, 0xBAA9, 0xC0E0,   // 0x0510 (1296)
+0xE260, 0xF280, 0xEA60, 0xF2C0, 0xF2E0, 0xEAE0, 0xEAA0, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFAE0, 0xFAE0, 0xFB00, 0xB100,   // 0x0520 (1312)
+0x70A4, 0x0B92, 0x0498, 0x04D9, 0x04FA, 0x04FA, 0x04FA, 0x051A, 0x051A, 0x051A, 0x051A, 0x04FA, 0x04DA, 0x04D9, 0x04B9, 0x04B9,   // 0x0530 (1328)
+0x0498, 0x0478, 0x0478, 0x0458, 0x0355, 0x01CF, 0x01D0, 0x0375, 0x0251, 0x0250, 0x0291, 0x09ED, 0xD446, 0xFE63, 0xFE82, 0xFEC7,   // 0x0540 (1344)
+0xFD29, 0xFE27, 0xFE85, 0xDE16, 0xB5DE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xADBF, 0xCB49, 0xEA80,   // 0x0560 (1376)
+0xF2E0, 0xEAC0, 0xEA80, 0xEAA0, 0xF2E0, 0xF2E0, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2A0, 0xF2C0, 0xF2E0, 0xFAE0, 0xFAE0, 0xFAE0, 0xB120,   // 0x0570 (1392)
+0xA040, 0x9163, 0x1BD4, 0x04DA, 0x051A, 0x051A, 0x04FA, 0x04D9, 0x04D9, 0x04D9, 0x04D9, 0x04D9, 0x04B9, 0x04B9, 0x0498, 0x0478,   // 0x0580 (1408)
+0x0478, 0x0458, 0x0437, 0x0437, 0x0437, 0x0395, 0x0355, 0x03B6, 0x0396, 0x0355, 0x02F3, 0x0231, 0x3A4C, 0xFCE5, 0xFE22, 0xFE64,   // 0x0590 (1424)
+0xFDC5, 0xFE06, 0xFEA6, 0xDDB0, 0xDEFD, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA51B, 0xE322, 0xFB20,   // 0x05B0 (1456)
+0xF300, 0xF2E0, 0xEB00, 0xF300, 0xEAC0, 0xEAA0, 0xEAC0, 0xEAC0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2E0, 0xC1A0,   // 0x05C0 (1472)
+0xA8E0, 0xC120, 0xB1C2, 0x72CA, 0x22CF, 0x0330, 0x03B3, 0x04B9, 0x04B9, 0x04B9, 0x04B9, 0x04B9, 0x0498, 0x0498, 0x0478, 0x0478,   // 0x05D0 (1488)
+0x0478, 0x0438, 0x0438, 0x03F7, 0x03D6, 0x03B7, 0x03B6, 0x0375, 0x0375, 0x0335, 0x0314, 0x0292, 0x01EF, 0xAB68, 0xFD64, 0xFE03,   // 0x05E0 (1504)
+0xFDC3, 0xFE05, 0xFE46, 0xED2A, 0xCE9A, 0x7BDE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10DF, 0xDC2A, 0xFB60, 0xF340,   // 0x0600 (1536)
+0xEAC0, 0xEB40, 0xFBC1, 0xF320, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xF2A0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2E0, 0xDA20,   // 0x0610 (1552)
+0xB940, 0xC1C0, 0xD9E0, 0xEA40, 0xD1E0, 0x4860, 0x10E4, 0x0457, 0x0498, 0x0498, 0x0498, 0x0478, 0x0478, 0x0458, 0x0458, 0x0437,   // 0x0620 (1568)
+0x0395, 0x03D6, 0x0395, 0x03F6, 0x03D6, 0x03B6, 0x0375, 0x0375, 0x0355, 0x0314, 0x02F4, 0x32D0, 0x0211, 0x62AA, 0xFCE5, 0xFDA3,   // 0x0630 (1584)
+0xFD83, 0xFD84, 0xFDE6, 0xF4C8, 0xC638, 0xAD7D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7B18, 0xF380, 0xF360, 0xEA80,   // 0x0650 (1616)
+0xE2A0, 0xF401, 0xEB81, 0xE280, 0xEAA0, 0xEAA0, 0xEA80, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAC0, 0xFB00, 0xEA80,   // 0x0660 (1632)
+0xC9A0, 0xDA00, 0xE220, 0xEAA0, 0xFC48, 0xFDF0, 0x8CD1, 0x03B5, 0x0437, 0x0457, 0x0478, 0x0478, 0x0458, 0x0458, 0x0437, 0x03F6,   // 0x0670 (1648)
+0x0251, 0x0231, 0x0210, 0x02F4, 0x03B6, 0x0375, 0x0375, 0x0355, 0x0334, 0x02F4, 0x02D5, 0x4208, 0x9349, 0x3A2C, 0xFC46, 0xFDC4,   // 0x0680 (1664)
+0xFDC3, 0xFD04, 0xFD66, 0xFCA7, 0xC5B5, 0xDEFD, 0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xE406, 0xF361, 0xE280, 0xE240,   // 0x06A0 (1696)
+0xEB41, 0xF3E1, 0xE2A0, 0xEA80, 0xF2E0, 0xF2E0, 0xEAC0, 0xEAA0, 0xEAC0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB00, 0xFB40, 0xF300,   // 0x06B0 (1712)
+0xD200, 0xE2C2, 0xF4AB, 0xFEF5, 0xF779, 0x740E, 0x0A4D, 0x0373, 0x03D6, 0x0437, 0x0457, 0x0354, 0x02D3, 0x0375, 0x0417, 0x0418,   // 0x06C0 (1728)
+0x02F3, 0x01F0, 0x01F0, 0x01CF, 0x02B2, 0x0396, 0x0355, 0x0315, 0x0314, 0x02F4, 0x02D4, 0x0948, 0xE423, 0xC407, 0xEC07, 0xFDA5,   // 0x06D0 (1744)
+0xFEA4, 0xFCE5, 0xFD05, 0xFC86, 0xC553, 0xD6FC, 0x39FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6AB9, 0xEB80, 0xE2A0, 0xE260, 0xEAA0,   // 0x06F0 (1776)
+0xEBA1, 0xEB01, 0xEA80, 0xF300, 0xF320, 0xF2E0, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB00, 0xFB41, 0xFB61, 0xFB82,   // 0x0700 (1792)
+0xF3A5, 0xFDD2, 0xFF37, 0xCDD2, 0x29E8, 0x01AA, 0x02D0, 0x0352, 0x03B5, 0x03F7, 0x03F7, 0x0272, 0x0210, 0x0210, 0x02B3, 0x0355,   // 0x0710 (1808)
+0x02B2, 0x01AF, 0x01CF, 0x01AE, 0x01F0, 0x0355, 0x0335, 0x0314, 0x02F4, 0x02D4, 0x02B4, 0x010A, 0xB363, 0xFE26, 0xFC06, 0xFD26,   // 0x0720 (1824)
+0xFF85, 0xFD05, 0xFCA5, 0xFC65, 0xD50F, 0xD658, 0x6B3E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xAB6E, 0xE240, 0xDA20, 0xEAC0, 0xEB00,   // 0x0740 (1856)
+0xEB61, 0xEA80, 0xEB00, 0xFB60, 0xF300, 0xEAA0, 0xF2A0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB20, 0xFB40, 0xFB62, 0xFBA3, 0xFBC3,   // 0x0750 (1872)
+0xFC04, 0xFD0B, 0xAC8F, 0x0926, 0x01AA, 0x024E, 0x02D0, 0x0353, 0x03B6, 0x03D6, 0x03F7, 0x02F3, 0x01F0, 0x0210, 0x01CF, 0x01CF,   // 0x0760 (1888)
+0x01CF, 0x01AF, 0x018F, 0x018E, 0x0251, 0x02F4, 0x0314, 0x02F4, 0x02D4, 0x0293, 0x0272, 0x006A, 0x8263, 0xFF06, 0xFC67, 0xFD06,   // 0x0770 (1904)
+0xFFE5, 0xFD45, 0xFC46, 0xFC65, 0xDCCD, 0xD530, 0xBD7A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0xCB09, 0xA8A0, 0xDA00, 0xF340, 0xF320,   // 0x0790 (1936)
+0xEAC0, 0xE280, 0xF360, 0xFB60, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB20, 0xFB41, 0xFB82, 0xFBA3, 0xFBE4, 0xFC04,   // 0x07A0 (1952)
+0xFC25, 0xFC66, 0x4A07, 0x018B, 0x024D, 0x02B0, 0x0333, 0x0375, 0x0396, 0x03B6, 0x03D6, 0x02B3, 0x01AE, 0x01CF, 0x01AF, 0x01AE,   // 0x07B0 (1968)
+0x018F, 0x018E, 0x016E, 0x016E, 0x018E, 0x01F0, 0x02D4, 0x02D4, 0x02B4, 0x0190, 0x004C, 0x00CB, 0x7A23, 0xFF66, 0xFD06, 0xFD06,   // 0x07C0 (1984)
+0xFFE6, 0xFE46, 0xFC06, 0xFC46, 0xE4CA, 0xE4EA, 0xEE56, 0x631F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x215F, 0x7A6C, 0x6062, 0xFB20, 0xF360, 0xEAA0,   // 0x07E0 (2016)
+0xE280, 0xEAC0, 0xF3E1, 0xEB00, 0xEA80, 0xF2C0, 0xEAC0, 0xFAC0, 0xFB00, 0xFB20, 0xFB41, 0xFB82, 0xFBA3, 0xFBE4, 0xFC05, 0xFC26,   // 0x07F0 (2032)
+0xFC66, 0xFCC7, 0xA3A9, 0x01ED, 0x02B0, 0x0313, 0x0354, 0x0375, 0x0395, 0x0396, 0x0396, 0x0334, 0x01CF, 0x018E, 0x018E, 0x018E,   // 0x0800 (2048)
+0x016E, 0x016E, 0x014D, 0x012D, 0x014D, 0x0293, 0x02D4, 0x02B3, 0x0293, 0x0273, 0x014F, 0x012D, 0x7A43, 0xFF46, 0xFD67, 0xFD06,   // 0x0810 (2064)
+0xFFE6, 0xFEC6, 0xFBE6, 0xFC26, 0xF506, 0xFD45, 0xE5F4, 0xC65E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213F, 0x8457, 0xA982, 0xFBC0, 0xF300, 0xE280,   // 0x0830 (2096)
+0xEA80, 0xEB21, 0xF3C1, 0xE2A0, 0xEAA0, 0xF2C0, 0xFAC0, 0xFB00, 0xFB21, 0xFB61, 0xFBA3, 0xFBC3, 0xFC04, 0xFC25, 0xFC66, 0xFC86,   // 0x0840 (2112)
+0xFCC8, 0xFCE8, 0xE4A9, 0x126E, 0x02D2, 0x0334, 0x0355, 0x0375, 0x0375, 0x0375, 0x0355, 0x0376, 0x02F3, 0x018E, 0x014E, 0x014E,   // 0x0850 (2128)
+0x014D, 0x012D, 0x010D, 0x012D, 0x00EC, 0x016E, 0x02B3, 0x0293, 0x0232, 0x0211, 0x0232, 0x016E, 0x8AA4, 0xFF26, 0xFD86, 0xFD47,   // 0x0860 (2144)
+0xFFA6, 0xFF07, 0xFBE6, 0xFC07, 0xFD46, 0xFDA5, 0xD553, 0xD6BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39FF, 0x93D3, 0xDAA0, 0xF3C1, 0xE280, 0xEAC0,   // 0x0880 (2176)
+0xEA80, 0xEB81, 0xEB21, 0xEA80, 0xF2C0, 0xFAE0, 0xFB00, 0xFB21, 0xFB61, 0xF362, 0xEB22, 0xEB43, 0xE344, 0xF384, 0xEBE5, 0xD3C6,   // 0x0890 (2192)
+0xDC27, 0xFCE8, 0xFD8A, 0x32EF, 0x02B2, 0x0314, 0x0355, 0x0335, 0x0335, 0x0335, 0x0335, 0x0335, 0x0354, 0x02F4, 0x0272, 0x014E,   // 0x08A0 (2208)
+0x010C, 0x010C, 0x010C, 0x010C, 0x00EC, 0x00CB, 0x018E, 0x01AF, 0x010C, 0x216C, 0x01CF, 0x014E, 0xB3A5, 0xFEE6, 0xFD86, 0xFD67,   // 0x08B0 (2224)
+0xFF67, 0xFF27, 0xFC66, 0xFC27, 0xFDC6, 0xFDC6, 0xC511, 0xC63B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x3A1F, 0xA3B0, 0xEB60, 0xEB21, 0xE280, 0xF2E0,   // 0x08D0 (2256)
+0xEAC0, 0xEB61, 0xE2A0, 0xEAA0, 0xF2A0, 0xEAA0, 0xF2C0, 0xF2C0, 0xD200, 0xB120, 0xA900, 0xA900, 0xB120, 0x9920, 0x20E3, 0x00A5,   // 0x08E0 (2272)
+0x08E5, 0x3964, 0x9AA4, 0x326C, 0x0292, 0x02F4, 0x0314, 0x0314, 0x0315, 0x0314, 0x0315, 0x0314, 0x02F4, 0x0315, 0x01CF, 0x00EC,   // 0x08F0 (2288)
+0x00EC, 0x010C, 0x00EB, 0x00CB, 0x00CB, 0x00CB, 0x00AB, 0x008A, 0x006A, 0x5188, 0x3A2B, 0x014F, 0xD466, 0xFE67, 0xFD46, 0xFE07,   // 0x0900 (2304)
+0xFF27, 0xFF27, 0xFD07, 0xFC26, 0xFEC7, 0xFD85, 0xB4B1, 0xBE1A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4A5F, 0xBBCD, 0xEB60, 0xDA00, 0xE280, 0xF300,   // 0x0920 (2336)
+0xEAE0, 0xEAE1, 0xE280, 0xE280, 0xEA80, 0xEAA0, 0xF2C0, 0xD1E0, 0xA900, 0xA900, 0xA920, 0xA920, 0xC160, 0x5943, 0x0109, 0x014A,   // 0x0930 (2352)
+0x016A, 0x016A, 0x012A, 0x01CD, 0x0292, 0x02D3, 0x02D4, 0x02F4, 0x02F4, 0x02D4, 0x02F4, 0x02F4, 0x02D4, 0x02B3, 0x010C, 0x00EB,   // 0x0940 (2368)
+0x00CB, 0x00CB, 0x00CB, 0x00AB, 0x00AB, 0x00AB, 0x008A, 0x008A, 0x0069, 0x4988, 0x9329, 0x016E, 0xED06, 0xFDE6, 0xFD06, 0xFE67,   // 0x0950 (2384)
+0xFEC7, 0xFF07, 0xFD46, 0xFC67, 0xFFA6, 0xF526, 0xACB1, 0xBDFA, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1F, 0xD42C, 0xE280, 0xC0E0, 0xEAA0, 0xF320,   // 0x0970 (2416)
+0xF320, 0xE280, 0xE280, 0xEA80, 0xE2A0, 0xEAA0, 0xE260, 0xB120, 0xB940, 0xB140, 0xB140, 0xB960, 0xD1E0, 0x69E5, 0x014B, 0x01AC,   // 0x0980 (2432)
+0x01CD, 0x01CE, 0x020E, 0x022F, 0x0271, 0x02B3, 0x02B3, 0x02B3, 0x02B3, 0x02B3, 0x02B4, 0x02B3, 0x02B3, 0x0293, 0x00EC, 0x00AB,   // 0x0990 (2448)
+0x00CB, 0x00CB, 0x00AB, 0x00AA, 0x008A, 0x008A, 0x008A, 0x0069, 0x0029, 0x31AC, 0xDBE7, 0x628B, 0xFD46, 0xFD46, 0xFD06, 0xFEA7,   // 0x09A0 (2464)
+0xFEA7, 0xFEE7, 0xFD06, 0xFD26, 0xFFC7, 0xE446, 0x9C92, 0xC61A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBF, 0xD40B, 0xD160, 0xC100, 0xEAE0, 0xEAC0,   // 0x09C0 (2496)
+0xFB80, 0xE2A0, 0xE280, 0xEA80, 0xEA80, 0xEAC0, 0xC9E0, 0xB960, 0xB980, 0xB980, 0xB980, 0xC1A0, 0xDA00, 0xD2C2, 0x118C, 0x01CF,   // 0x09D0 (2512)
+0x0210, 0x0210, 0x0230, 0x0231, 0x0272, 0x0293, 0x0293, 0x0293, 0x0293, 0x0293, 0x0293, 0x0293, 0x0273, 0x0293, 0x0211, 0x018F,   // 0x09E0 (2528)
+0x008A, 0x008A, 0x008A, 0x008A, 0x0089, 0x0069, 0x0069, 0x0069, 0x008B, 0x21EE, 0xF4C6, 0xF486, 0xFCE6, 0xFCC6, 0xFD66, 0xFEA7,   // 0x09F0 (2544)
+0xFE87, 0xFEA7, 0xFC87, 0xFEA7, 0xFF86, 0xC3E8, 0x94F4, 0xC63A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x843F, 0xD3EC, 0xC8E0, 0xC960, 0xF300, 0xE260,   // 0x0A10 (2576)
+0xEB40, 0xEB41, 0xE260, 0xEA80, 0xEAA0, 0xEAA0, 0xC9E0, 0xC180, 0xC1A0, 0xC1A0, 0xC9C0, 0xC9C0, 0xDA20, 0xFB00, 0xBAA3, 0x11EF,   // 0x0A20 (2592)
+0x0212, 0x0212, 0x0232, 0x0252, 0x0252, 0x0252, 0x0252, 0x0253, 0x0253, 0x0254, 0x0253, 0x0233, 0x0233, 0x0253, 0x0273, 0x010C,   // 0x0A30 (2608)
+0x006A, 0x006A, 0x0089, 0x0069, 0x0069, 0x0049, 0x0049, 0x010D, 0x0191, 0x19AE, 0xF5A6, 0xFD46, 0xFC46, 0xFC66, 0xFDE7, 0xFE87,   // 0x0A40 (2624)
+0xFE87, 0xFE47, 0xFCC6, 0xFFC7, 0xFEE6, 0xBBCA, 0xA555, 0xCE5B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94FF, 0xC40D, 0xB820, 0xD1C0, 0xF320, 0xE280,   // 0x0A60 (2656)
+0xE2A0, 0xF381, 0xEAA0, 0xEA80, 0xE2A0, 0xEAA0, 0xD1E0, 0xC9C0, 0xC9E0, 0xD1E0, 0xD200, 0xD1E0, 0xDA40, 0xFAE0, 0xFB00, 0xCAE3,   // 0x0A70 (2672)
+0x2A0E, 0x0212, 0x0213, 0x0232, 0x0232, 0x0212, 0x0234, 0x1A50, 0x6ACB, 0x9B2A, 0xAB8A, 0x93AD, 0x530F, 0x01F1, 0x0233, 0x018F,   // 0x0A80 (2688)
+0x0089, 0x0069, 0x0049, 0x0049, 0x0048, 0x0048, 0x0028, 0x006A, 0x0150, 0x218D, 0xF5A5, 0xFE26, 0xFC06, 0xFCA6, 0xFE46, 0xFE67,   // 0x0A90 (2704)
+0xFE67, 0xFDA6, 0xFE07, 0xFFE7, 0xFDE5, 0xA3CB, 0xAD97, 0xD67C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94FF, 0xBC71, 0xA800, 0xD9E0, 0xF340, 0xE260,   // 0x0AB0 (2736)
+0xE260, 0xEB00, 0xEB21, 0xE280, 0xEAA0, 0xEAA0, 0xDA00, 0xD1E0, 0xD200, 0xDA20, 0xDA20, 0xDA20, 0xE240, 0xFAE0, 0xFB00, 0xFB00,   // 0x0AC0 (2752)
+0xF301, 0x7269, 0x1A10, 0x01F2, 0x0A11, 0x3A4E, 0x9AC8, 0xEB64, 0xFBC4, 0xFC06, 0xFC26, 0xFCEA, 0xFE0F, 0xBCCE, 0x216C, 0x008A,   // 0x0AD0 (2768)
+0x0069, 0x0049, 0x0048, 0x0048, 0x0048, 0x0028, 0x0027, 0x00AB, 0x0150, 0x318C, 0xFD85, 0xFF26, 0xFC26, 0xFD27, 0xFE27, 0xFE27,   // 0x0AE0 (2784)
+0xFE27, 0xFDA6, 0xFF87, 0xFFE7, 0xEC86, 0x83CE, 0xBDF8, 0xCE7D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94BF, 0xC575, 0xA800, 0xDA00, 0xEB00, 0xE240,   // 0x0B00 (2816)
+0xE280, 0xE280, 0xEB00, 0xEAC0, 0xEA80, 0xEAA0, 0xE260, 0xDA00, 0xDA20, 0xDA40, 0xE260, 0xE260, 0xE240, 0xFAE0, 0xFAE0, 0xFAE0,   // 0x0B10 (2832)
+0xFB00, 0xFB20, 0xEB01, 0xD303, 0xE303, 0xFB41, 0xFB61, 0xFB63, 0xFB62, 0xFB82, 0xFBA2, 0xFBC3, 0xFCEB, 0xFEF3, 0xC4AE, 0x0027,   // 0x0B20 (2848)
+0x0048, 0x0048, 0x0048, 0x0048, 0x0027, 0x0027, 0x0006, 0x00ED, 0x0110, 0x49CB, 0xFD85, 0xFF26, 0xFCA6, 0xFDA6, 0xFE07, 0xFDE7,   // 0x0B30 (2864)
+0xFDC7, 0xFEC7, 0xFFE7, 0xFF67, 0xD407, 0x8C71, 0xCE38, 0xB59D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7BDF, 0xCE18, 0xA821, 0xD1C0, 0xE2E0, 0xDA20,   // 0x0B50 (2896)
+0xEAA0, 0xE280, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xEAA0, 0xE240, 0xE240, 0xE260, 0xEA80, 0xEAA0, 0xEA80, 0xE240, 0xE260, 0xFB40,   // 0x0B60 (2912)
+0xFB00, 0xFB20, 0xFB20, 0xFB20, 0xFB41, 0xFB41, 0xFB41, 0xFB61, 0xFB81, 0xFB82, 0xFB01, 0xFAA0, 0xE384, 0xE468, 0x9B47, 0x0027,   // 0x0B70 (2928)
+0x0028, 0x0028, 0x0028, 0x0027, 0x0027, 0x0006, 0x0008, 0x010F, 0x00CF, 0x8A89, 0xFDA5, 0xFEE6, 0xFD66, 0xFDA6, 0xFE68, 0xFDC7,   // 0x0B80 (2944)
+0xFE67, 0xFFA7, 0xFFE6, 0xFE06, 0xB388, 0x94F4, 0xD69A, 0x841E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5AFF, 0xD6DB, 0x9904, 0xC920, 0xE2E1, 0xD9E0,   // 0x0BA0 (2976)
+0xEAE0, 0xE2A0, 0xEA80, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xEA80, 0xEA60, 0xEA80, 0xEAA0, 0xF2C0, 0xFAC0, 0xEAA0, 0xA0C0, 0xB980,   // 0x0BB0 (2992)
+0xEA80, 0xFAE0, 0xFB40, 0xFB41, 0xFB61, 0xFB81, 0xFB61, 0xF321, 0xEB01, 0xEA40, 0xD1C0, 0x6901, 0x1042, 0x0822, 0x0003, 0x0026,   // 0x0BC0 (3008)
+0x0027, 0x0027, 0x0027, 0x0007, 0x0028, 0x008C, 0x312B, 0x296D, 0x00CE, 0xDBA6, 0xFD85, 0xFEA6, 0xFDA6, 0xFE09, 0xFEEC, 0xFDC6,   // 0x0BD0 (3024)
+0xFF27, 0xFF46, 0xFF47, 0xF4A6, 0x836B, 0xAD76, 0xDEDB, 0x423F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0xDF1D, 0x9B0C, 0xB820, 0xD261, 0xC960,   // 0x0BF0 (3056)
+0xF300, 0xEAA0, 0xE280, 0xEA80, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xF2A0, 0xF2A0, 0xF2C0, 0xFAE0, 0xFAE0, 0xFB00, 0xC9E0, 0x8820,   // 0x0C00 (3072)
+0x9880, 0xA8E0, 0xC180, 0xC9E1, 0xD1E0, 0xD1E0, 0xC9A0, 0xC940, 0xD960, 0xA961, 0x30A2, 0x0003, 0x0004, 0x0004, 0x0005, 0x0006,   // 0x0C10 (3088)
+0x0006, 0x0006, 0x0027, 0x0006, 0x0028, 0x006A, 0xB348, 0x190C, 0x51CB, 0xFC65, 0xFDA5, 0xFE66, 0xFD65, 0xFF90, 0xFE6D, 0xFE66,   // 0x0C20 (3104)
+0xFEC7, 0xFEE6, 0xFE26, 0xE406, 0x8430, 0xBDD7, 0xD6DC, 0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xC65E, 0xACD3, 0xA800, 0xD201, 0xC0E0,   // 0x0C40 (3136)
+0xF320, 0xEAE0, 0xE280, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xEAA0, 0xEAC0, 0xF2C0, 0xFB00, 0xFB00, 0xFB20, 0xFB20, 0xFB40, 0xB960,   // 0x0C50 (3152)
+0x9880, 0xA8A0, 0xA8C0, 0xB0C0, 0xB8E0, 0xC100, 0xC920, 0xB160, 0x6901, 0x0885, 0x0025, 0x0004, 0x0024, 0x0005, 0x0005, 0x0006,   // 0x0C60 (3168)
+0x0006, 0x0006, 0x0006, 0x0027, 0x006E, 0x7A27, 0xDBC5, 0x18CC, 0xDBC6, 0xFCA5, 0xFDA6, 0xFDC6, 0xFEC9, 0xFFF8, 0xFE4A, 0xFE46,   // 0x0C70 (3184)
+0xFE46, 0xFEA6, 0xFD06, 0xAB47, 0x8C93, 0xCE59, 0xB57E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x9CFE, 0xC679, 0x9104, 0xC080, 0xB8C0,   // 0x0C90 (3216)
+0xE280, 0xF360, 0xE280, 0xEA80, 0xEA80, 0xEAA0, 0xEA80, 0xEAA0, 0xF2A0, 0xF2C0, 0xF2E0, 0xFB00, 0xFB20, 0xFB21, 0xFB41, 0xFB21,   // 0x0CA0 (3232)
+0xA9A1, 0x7040, 0x78A0, 0x80C0, 0x80E0, 0x58C1, 0x3081, 0x0864, 0x0066, 0x0088, 0x0005, 0x0004, 0x0005, 0x0006, 0x0006, 0x0006,   // 0x0CB0 (3248)
+0x0006, 0x0006, 0x0005, 0x002B, 0x498C, 0xFC64, 0x9266, 0x9287, 0xFC65, 0xFCC5, 0xFD05, 0xFE65, 0xFFF3, 0xFF96, 0xFDC6, 0xFDE7,   // 0x0CC0 (3264)
+0xFE26, 0xFDC7, 0xF425, 0x7B6C, 0xAD55, 0xD6BA, 0x633F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4A7F, 0xDF1C, 0x932D, 0xA800, 0xB8E0,   // 0x0CE0 (3296)
+0xC980, 0xF380, 0xE281, 0xEA80, 0xEAA0, 0xEA80, 0xEA80, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2E0, 0xFAE0, 0xFB21, 0xFB20, 0xFB40,   // 0x0CF0 (3312)
+0xF320, 0x79A2, 0x0004, 0x0004, 0x0004, 0x0005, 0x0006, 0x0068, 0x0089, 0x0048, 0x0004, 0x0004, 0x0005, 0x0006, 0x0006, 0x0006,   // 0x0D00 (3328)
+0x0006, 0x0005, 0x0006, 0x392A, 0xEBE5, 0xFC24, 0xC325, 0xFC25, 0xFC45, 0xFC45, 0xFD65, 0xFFCC, 0xFFFA, 0xFEAE, 0xFD45, 0xFDA7,   // 0x0D10 (3344)
+0xFDC7, 0xFCE6, 0xAB46, 0x7C11, 0xBDD6, 0xDEFC, 0x211F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087F, 0xD6BD, 0xAD96, 0x9062, 0xB8A0,   // 0x0D30 (3376)
+0xC180, 0xC9E1, 0xE341, 0xD1E0, 0xEB00, 0xE280, 0xEAA0, 0xEAC0, 0xEAA0, 0xF2C0, 0xF2C0, 0xFAC0, 0xF2E0, 0xFAE0, 0xFB00, 0xFB20,   // 0x0D40 (3392)
+0xFB41, 0xFB60, 0xBA63, 0x30A6, 0x0008, 0x0008, 0x0008, 0x0029, 0x008B, 0x008B, 0x006B, 0x004A, 0x0048, 0x0005, 0x0005, 0x0005,   // 0x0D50 (3408)
+0x0005, 0x0006, 0x5145, 0xEBC5, 0xFC04, 0xFC04, 0xFC24, 0xFC25, 0xFC05, 0xFCE5, 0xFF68, 0xFFF4, 0xFFF6, 0xFD88, 0xFD06, 0xFD46,   // 0x0D60 (3424)
+0xFD26, 0xEC05, 0x732B, 0x9CF4, 0xCE79, 0x9CDE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x8C5E, 0xD6DB, 0x8AAB, 0xA800,   // 0x0D80 (3456)
+0xC1C0, 0xB980, 0xC9C1, 0xD241, 0xD1E0, 0xEA80, 0xEAA0, 0xEAE0, 0xF2A0, 0xF2C0, 0xF2C0, 0xF2E0, 0xFAE0, 0xFAE0, 0xFAE0, 0xFB00,   // 0x0D90 (3472)
+0xFB00, 0xFB21, 0xFB60, 0xF341, 0x9204, 0x2889, 0x000B, 0x000C, 0x006D, 0x008D, 0x008E, 0x008F, 0x004A, 0x0007, 0x0006, 0x0005,   // 0x0DA0 (3488)
+0x1065, 0x8A44, 0xFC04, 0xFC04, 0xFBE4, 0xFC04, 0xFC05, 0xFBE5, 0xFCE4, 0xFF67, 0xFFD1, 0xFFF4, 0xFF0F, 0xFC65, 0xFCC6, 0xFCE6,   // 0x0DB0 (3504)
+0xFC86, 0x9307, 0x7C30, 0xB5B6, 0xDEFC, 0x41FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x297F, 0xE71C, 0xA576, 0x8882,   // 0x0DD0 (3536)
+0xB840, 0xCA60, 0xB8C0, 0xC140, 0xC180, 0xD1E0, 0xEAA0, 0xEB20, 0xF2E0, 0xF2A0, 0xF2E0, 0xF2E0, 0xFAC0, 0xFAE0, 0xFB00, 0xFB00,   // 0x0DE0 (3552)
+0xFB00, 0xFB00, 0xFB00, 0xFB21, 0xFB80, 0xF322, 0xAA64, 0x5948, 0x188C, 0x006E, 0x004E, 0x002E, 0x004D, 0x088D, 0x30EB, 0x8A25,   // 0x0DF0 (3568)
+0xE384, 0xFC24, 0xFC04, 0xFBC3, 0xFBE4, 0xFC05, 0xFC04, 0xFD65, 0xFF48, 0xFFAF, 0xFFD1, 0xFFF1, 0xFD47, 0xFC46, 0xFC86, 0xFCA7,   // 0x0E00 (3584)
+0xCBA5, 0x630C, 0xA514, 0xCE79, 0xA53E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x9CDE, 0xCEDA, 0x8B4D,   // 0x0E20 (3616)
+0xA800, 0xB880, 0xCA60, 0xB080, 0xC180, 0xC140, 0xE240, 0xEB00, 0xF360, 0xF2C0, 0xF2E0, 0xF2E0, 0xF2C0, 0xFAE0, 0xFB00, 0xFB00,   // 0x0E30 (3632)
+0xFB00, 0xFB00, 0xFB20, 0xFB21, 0xFB41, 0xFB61, 0xFB81, 0xFBA1, 0xF342, 0xDB04, 0xC2E4, 0xC2E5, 0xCAE5, 0xE344, 0xFBC3, 0xFC03,   // 0x0E40 (3648)
+0xFBE4, 0xFBC3, 0xFB62, 0xFB41, 0xFB42, 0xFC04, 0xFDE5, 0xFF49, 0xFF6D, 0xFF8E, 0xFFD0, 0xFEAA, 0xFC45, 0xFC46, 0xFC87, 0xEC25,   // 0x0E50 (3664)
+0x5A48, 0x8C72, 0xBDD7, 0xDEFB, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0xDEFC, 0xADD7,   // 0x0E70 (3696)
+0x7945, 0xB000, 0xB060, 0xB940, 0xB900, 0xC200, 0xC940, 0xE280, 0xD240, 0xEAC0, 0xF2C0, 0xFB00, 0xFAC0, 0xFAC0, 0xFB00, 0xFB00,   // 0x0E80 (3712)
+0xFB00, 0xFB00, 0xFB20, 0xFB20, 0xFB20, 0xFB41, 0xFB61, 0xFB61, 0xFB81, 0xFB81, 0xFBA2, 0xFBC1, 0xFBC2, 0xFBC3, 0xFBC3, 0xFB83,   // 0x0E90 (3728)
+0xFB01, 0xFAC0, 0xFAA0, 0xFB01, 0xFC63, 0xFE25, 0xFF08, 0xFF0B, 0xFF2C, 0xFF8D, 0xFF4C, 0xFCC6, 0xFC26, 0xFC66, 0xFC86, 0x7A65,   // 0x0EA0 (3744)
+0x6BAF, 0xAD55, 0xD699, 0x94BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94DE, 0xD6BA,   // 0x0EC0 (3776)
+0x9492, 0x8841, 0xB800, 0xB000, 0xB000, 0xC180, 0xC200, 0xC900, 0xD220, 0xC1C0, 0xC9A0, 0xE200, 0xFB00, 0xFAE0, 0xFAE0, 0xFB00,   // 0x0ED0 (3792)
+0xFB20, 0xFB00, 0xFB20, 0xFB20, 0xFB20, 0xFB20, 0xFB21, 0xFB41, 0xFB62, 0xFB61, 0xFB62, 0xFB82, 0xFB82, 0xFB21, 0xEA60, 0xEA20,   // 0x0EE0 (3808)
+0xF220, 0xFA80, 0xFB81, 0xFD22, 0xFE23, 0xFE65, 0xFEA8, 0xFEE9, 0xFF2B, 0xFF4A, 0xFD26, 0xFC25, 0xFC66, 0xFCA7, 0xA2E4, 0x52EC,   // 0x0EF0 (3824)
+0x9D13, 0xC618, 0xD6BD, 0x18FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BF, 0xD6BD,   // 0x0F10 (3856)
+0xC679, 0x7B8E, 0x9000, 0xB800, 0xB000, 0xB000, 0xC1C0, 0xB940, 0xC0E0, 0xCA20, 0xCA60, 0xC160, 0xC920, 0xF280, 0xFB00, 0xFAE0,   // 0x0F20 (3872)
+0xEA60, 0xF2E0, 0xFB20, 0xFB40, 0xFB61, 0xFB40, 0xFB40, 0xFB40, 0xFB21, 0xFB40, 0xFB40, 0xFB01, 0xEA40, 0xD9A0, 0xE1A0, 0xEA40,   // 0x0F30 (3888)
+0xF340, 0xFC60, 0xFD81, 0xFDC2, 0xFDE2, 0xFE23, 0xFE65, 0xFEA8, 0xFF08, 0xFD86, 0xFC05, 0xFC46, 0xFCA6, 0xBB44, 0x4A4A, 0x94B2,   // 0x0F40 (3904)
+0xBDD7, 0xDEFB, 0x527F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x52BF,   // 0x0F60 (3936)
+0xDEFB, 0xBE18, 0x6AAA, 0x9800, 0xB800, 0xB000, 0xB000, 0xB900, 0xB060, 0xB840, 0xB940, 0xCAC0, 0xC220, 0xB8C0, 0xC900, 0xE220,   // 0x0F70 (3952)
+0xE220, 0xD1A0, 0xC900, 0xC900, 0xD160, 0xE200, 0xEA80, 0xF2A1, 0xEA80, 0xE200, 0xD9A0, 0xD140, 0xD180, 0xE240, 0xEB20, 0xF400,   // 0x0F80 (3968)
+0xFCA0, 0xFCE0, 0xFD21, 0xFD81, 0xFDC2, 0xFDE3, 0xFE44, 0xFE85, 0xFD45, 0xFC05, 0xFC25, 0xFC86, 0xCB84, 0x4A08, 0x8451, 0xB576,   // 0x0F90 (3984)
+0xD6BA, 0x8C9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FB0 (4016)
+0x947E, 0xDEBA, 0xADD7, 0x6248, 0x9800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB040, 0xC1A0, 0xC240, 0xB100, 0xB020,   // 0x0FC0 (4032)
+0xB860, 0xC0C0, 0xC920, 0xC900, 0xB880, 0xB000, 0xB000, 0xB840, 0xB8A0, 0xB8E0, 0xC960, 0xD200, 0xDA80, 0xE320, 0xEB80, 0xF3E0,   // 0x0FD0 (4048)
+0xF440, 0xFCA0, 0xFD01, 0xFD41, 0xFD82, 0xFDE3, 0xFE04, 0xFCA3, 0xFC05, 0xFC25, 0xFC86, 0xCB84, 0x4A08, 0x7C11, 0xAD55, 0xD699,   // 0x0FE0 (4064)
+0xBDFE, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1000 (4096)
+0x085F, 0xB5DD, 0xD67A, 0xA576, 0x6228, 0x9800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB8C0, 0xB880,   // 0x1010 (4112)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB840, 0xB8A0, 0xC0E0, 0xC160, 0xC9C0, 0xDA40, 0xDAA0, 0xE320, 0xEB80,   // 0x1020 (4128)
+0xF400, 0xFC60, 0xFCC0, 0xFD21, 0xFD82, 0xFD42, 0xFBE2, 0xFB83, 0xFC04, 0xFC66, 0xCB64, 0x41E7, 0x7BF0, 0xA534, 0xCE59, 0xCE7D,   // 0x1030 (4144)
+0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1050 (4176)
+0x001F, 0x20FF, 0xC65D, 0xCE79, 0xA575, 0x628A, 0x8000, 0xB800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000,   // 0x1060 (4192)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB820, 0xB840, 0xB8A0, 0xC120, 0xC980, 0xD200, 0xDA80, 0xE2E0, 0xEB60,   // 0x1070 (4208)
+0xF3C0, 0xFC20, 0xFCC0, 0xFCE0, 0xFC21, 0xFB21, 0xFB62, 0xFBC3, 0xFC23, 0xAB04, 0x4A28, 0x7BF0, 0xA514, 0xC638, 0xDEDC, 0x39DF,   // 0x1080 (4224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10A0 (4256)
+0x001F, 0x001F, 0x317F, 0xD69C, 0xCE59, 0xA595, 0x6B6D, 0x68A2, 0xA800, 0xC000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000,   // 0x10B0 (4272)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB020, 0xB820, 0xB860, 0xC0C0, 0xC140, 0xD1A0, 0xD220, 0xDAA0, 0xEB20,   // 0x10C0 (4288)
+0xF3A0, 0xF3E0, 0xFB60, 0xFAC0, 0xFAA0, 0xFB01, 0xFB82, 0xEB62, 0x8223, 0x528A, 0x8431, 0xA514, 0xC639, 0xD6BC, 0x421F, 0x001F,   // 0x10D0 (4304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10F0 (4336)
+0x001F, 0x001F, 0x001F, 0x317F, 0xCE7D, 0xCE79, 0xB5B6, 0x7C51, 0x59C7, 0x7820, 0xB000, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000,   // 0x1100 (4352)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB020, 0xB040, 0xB880, 0xC0E0, 0xC960, 0xD1E0, 0xDA60, 0xE2A0,   // 0x1110 (4368)
+0xE260, 0xEA20, 0xF220, 0xFA60, 0xFAC0, 0xFB00, 0xBA81, 0x59E6, 0x5B0D, 0x8C71, 0xAD55, 0xCE39, 0xDEDC, 0x421F, 0x001F, 0x001F,   // 0x1120 (4384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1140 (4416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x211F, 0xB5BD, 0xD69A, 0xBDD7, 0x9D14, 0x6B8E, 0x5145, 0x7800, 0xA800, 0xC000, 0xB800, 0xB000,   // 0x1150 (4432)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB020, 0xB040, 0xB860, 0xB8A0, 0xC100, 0xC940, 0xD160, 0xD960,   // 0x1160 (4448)
+0xE180, 0xE9E0, 0xFA40, 0xFA60, 0xC220, 0x69C3, 0x528A, 0x73F0, 0x94B2, 0xB596, 0xCE79, 0xCE5D, 0x31BF, 0x001F, 0x001F, 0x001F,   // 0x1170 (4464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1190 (4496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x8C7E, 0xDEFB, 0xC638, 0xB576, 0x94D3, 0x636D, 0x51A6, 0x6881, 0x8800, 0xB000,   // 0x11A0 (4512)
+0xB800, 0xB800, 0xB800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB820, 0xB840, 0xB840, 0xC080, 0xC8C0, 0xD920, 0xE160,   // 0x11B0 (4528)
+0xE180, 0xD180, 0x9940, 0x61C4, 0x4A69, 0x6BAE, 0x8C72, 0xA514, 0xBDD7, 0xDEDB, 0xAD9D, 0x20FF, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11C0 (4544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11E0 (4576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5ADF, 0xCE7C, 0xD6BA, 0xBDF7, 0xAD55, 0x94D3, 0x6BCF, 0x526A, 0x4944,   // 0x11F0 (4592)
+0x6082, 0x7800, 0x8800, 0x9800, 0xA800, 0xB000, 0xB800, 0xB800, 0xB800, 0xB820, 0xB820, 0xB020, 0xA040, 0xA060, 0x90A0, 0x8102,   // 0x1200 (4608)
+0x5943, 0x49C7, 0x52EC, 0x6BCF, 0x8C71, 0x9CF3, 0xB596, 0xCE59, 0xDEFC, 0x841E, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1210 (4624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1230 (4656)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BF, 0x843F, 0xDEFC, 0xD69A, 0xC618, 0xAD75, 0x9D13, 0x8C92,   // 0x1240 (4672)
+0x73EF, 0x5B2C, 0x4A49, 0x39A7, 0x4145, 0x4104, 0x48A3, 0x5062, 0x4883, 0x48A3, 0x48E3, 0x3925, 0x39A7, 0x4208, 0x4AAB, 0x636E,   // 0x1250 (4688)
+0x73CF, 0x8450, 0x9492, 0x9D14, 0xB5B6, 0xCE38, 0xDEFB, 0xB5BD, 0x39DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1260 (4704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1280 (4736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0x841F, 0xCE5D, 0xDEDB, 0xCE59, 0xBDD7,   // 0x1290 (4752)
+0xAD75, 0xA535, 0x9CF3, 0x94B2, 0x8C92, 0x8450, 0x7C10, 0x73F0, 0x73CF, 0x7410, 0x7C30, 0x8451, 0x8C71, 0x9492, 0x9CD2, 0x9CF3,   // 0x12A0 (4768)
+0xA534, 0xB596, 0xC618, 0xCE79, 0xDEFB, 0xBE1E, 0x529F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12B0 (4784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12D0 (4816)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x089F, 0x52DF, 0xA51E, 0xCE7C,   // 0x12E0 (4832)
+0xDEFB, 0xD69A, 0xC659, 0xC618, 0xBDD7, 0xB5B6, 0xB595, 0xB576, 0xAD75, 0xAD75, 0xB596, 0xB596, 0xBDD7, 0xBDF8, 0xC618, 0xCE7A,   // 0x12F0 (4848)
+0xD6BA, 0xDEFC, 0xC61D, 0x9CDE, 0x421F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BF,   // 0x1330 (4912)
+0x529F, 0x7BDE, 0xA4FE, 0xC65D, 0xDEFC, 0xDEFC, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFC, 0xCE7D, 0xAD5E, 0x949E,   // 0x1340 (4928)
+0x6B7F, 0x39DF, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x18DF, 0x319F, 0x421F, 0x52BF, 0x62FF, 0x7BDF, 0x73BF, 0x527F, 0x41FF, 0x39DF, 0x18FF, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x001F, 0x001F, 0x001F, 0x41FF, 0x41FF, 0x089F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1460 (5216)
+0x001F, 0x001F, 0x001F, 0xFFDF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7BFF,   // 0x1470 (5232)
+0x6B9F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0x7BFF, 0x7BFF,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14B0 (5296)
+0x001F, 0x001F, 0x41FF, 0xFFFF, 0xCE7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xB57F, 0xFFFF,   // 0x14C0 (5312)
+0x4A7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xAD7F, 0xFFFF, 0x41FF,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x6B7F, 0xFFDF, 0xA4FF, 0x001F, 0x947F, 0xBDFF, 0xA4FF, 0xDEFE, 0xDEFF, 0x62FF, 0x001F, 0x947F, 0xEF7F, 0xFFFF,   // 0x1510 (5392)
+0xCE9F, 0x089F, 0x3A1F, 0xD67F, 0xFFDF, 0xCE7F, 0x4A7F, 0x001F, 0x001F, 0x9CFF, 0xBDFF, 0x527F, 0xF77F, 0x62FF, 0x947F, 0xBDFF,   // 0x1520 (5408)
+0xA4FF, 0xE6FF, 0xDEFF, 0x5AFF, 0x001F, 0x001F, 0x7C1F, 0xF77F, 0xFFFF, 0xA4FF, 0x299F, 0x001F, 0x947F, 0xEF7F, 0xFFFF, 0xCE7F,   // 0x1530 (5424)
+0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1550 (5456)
+0x001F, 0x001F, 0xB57F, 0xFFFF, 0x6B9F, 0x001F, 0xF77F, 0xFFFF, 0xDEFF, 0x8C7F, 0xFFDF, 0xDEFF, 0x001F, 0xB57F, 0xFFFF, 0xEF7F,   // 0x1560 (5472)
+0xC5FF, 0x20FF, 0xEF7F, 0xF77F, 0x9CFF, 0xE6FF, 0xFFFF, 0x089F, 0x109F, 0xFFDF, 0xFFFF, 0xFFDF, 0xBDFF, 0x109F, 0xEF7F, 0xFFFF,   // 0x1570 (5488)
+0xDEFF, 0x9D1F, 0xFFFF, 0xE6FF, 0x001F, 0x737F, 0xFFFF, 0xDEFF, 0x9CFF, 0xFFFF, 0xB57F, 0x001F, 0xBDFF, 0xFFFF, 0xEF7F, 0xBDFF,   // 0x1580 (5504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0xE6FF, 0xFFDF, 0x299F, 0x20FF, 0xFFDF, 0xFFFF, 0x191F, 0x20FF, 0xFFFF, 0xD67F, 0x001F, 0x421F, 0xFFFF, 0xAD7F,   // 0x15B0 (5552)
+0x001F, 0x631F, 0xFFDF, 0xB57F, 0x41FF, 0x9CFF, 0xFFDF, 0x62FF, 0x39FF, 0xFFFF, 0xEF7F, 0x317F, 0x001F, 0x191F, 0xFFDF, 0xF77F,   // 0x15C0 (5568)
+0x109F, 0x211F, 0xFFDF, 0xBDFF, 0x001F, 0xCE7F, 0xFFDF, 0x62FF, 0x41FF, 0xDEFF, 0xFFFF, 0x001F, 0x527F, 0xFFFF, 0xB57F, 0x001F,   // 0x15D0 (5584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15F0 (5616)
+0x001F, 0x109F, 0xFFFE, 0xFFFF, 0x001F, 0x529F, 0xFFFF, 0xAD7F, 0x001F, 0x4A7F, 0xFFDF, 0xB57F, 0x001F, 0x7BFF, 0xFFFF, 0x7BFF,   // 0x1600 (5632)
+0x001F, 0xAD7F, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFDF, 0xFFFF, 0x737F, 0x7BFF, 0xFFFF, 0xA4FF, 0x001F, 0x001F, 0x5AFF, 0xFFFF, 0xAD7F,   // 0x1610 (5648)
+0x001F, 0x62FF, 0xFFFF, 0x9CFF, 0x001F, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0x001F, 0x7BFF, 0xFFFF, 0x737F, 0x001F,   // 0x1620 (5664)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1640 (5696)
+0x001F, 0x41FF, 0xFFFF, 0xC5FF, 0x001F, 0x7BFF, 0xFFFF, 0x6B9F, 0x001F, 0x7BFF, 0xFFFF, 0x737F, 0x001F, 0xAD7F, 0xFFFF, 0x41FF,   // 0x1650 (5712)
+0x001F, 0x947F, 0xFFFF, 0x4A7F, 0x109F, 0x6B9F, 0x739F, 0x089F, 0xAD9F, 0xFFFF, 0x4A9F, 0x001F, 0x001F, 0x8C7F, 0xFFDF, 0x6B9F,   // 0x1660 (5728)
+0x001F, 0x8C7F, 0xFFFF, 0x737F, 0x001F, 0xE6FF, 0xEF7F, 0x001F, 0x297F, 0x83FF, 0x3A1F, 0x001F, 0xBDFF, 0xFFFF, 0x39FF, 0x001F,   // 0x1670 (5744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1690 (5776)
+0x001F, 0x83FF, 0xFFFF, 0x8C7F, 0x001F, 0xBDFF, 0xFFFF, 0x39FF, 0x001F, 0xBDFF, 0xFFFF, 0x39FF, 0x001F, 0xBDFF, 0xFFDF, 0xCE9F,   // 0x16A0 (5792)
+0x317F, 0x191F, 0xFFFF, 0xF77F, 0xDEFF, 0xFFDF, 0x9CFF, 0x001F, 0xE6FF, 0xFFFF, 0x109F, 0x001F, 0x001F, 0xBDFF, 0xFFFF, 0x297F,   // 0x16B0 (5808)
+0x001F, 0xBDFF, 0xFFFF, 0x299F, 0x001F, 0x7BFF, 0xFFFF, 0xE6FF, 0xFFFF, 0xFFFF, 0x5AFF, 0x001F, 0xBDFF, 0xFFFF, 0xCE7F, 0x317F,   // 0x16C0 (5824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16E0 (5856)
+0x001F, 0x7BFF, 0xBDFF, 0x4A9F, 0x001F, 0xAD7F, 0xC5FF, 0x001F, 0x001F, 0xBDFF, 0xC5FF, 0x001F, 0x001F, 0x41FF, 0xAD9F, 0xBDFF,   // 0x16F0 (5872)
+0x109F, 0x001F, 0x20FF, 0x8C7F, 0xBDFF, 0x737F, 0x109F, 0x001F, 0xBE1F, 0xB57F, 0x001F, 0x001F, 0x001F, 0xC5FF, 0xC5DF, 0x001F,   // 0x1700 (5888)
+0x001F, 0xBDFF, 0xBDFF, 0x001F, 0x001F, 0x001F, 0x4A7F, 0xB57F, 0x9CFF, 0x4A7F, 0x001F, 0x001F, 0x41FF, 0xB57F, 0xBDFF, 0x089F,   // 0x1710 (5904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1740 (5952)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1750 (5968)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1790 (6032)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_718/jar.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: jar.jpg
+// Time generated: 12.04.2014 23:41:47
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short jar[0x384] ={
+0x012E, 0x014F, 0x014E, 0x09EF, 0x0A10, 0x1A31, 0x2A31, 0x2231, 0x1A70, 0x1A53, 0x2230, 0x1A51, 0x1A71, 0x2252, 0x2252, 0x2251,   // 0x0010 (16)
+0x2251, 0x2252, 0x1A52, 0x1A50, 0x1A32, 0x2251, 0x2251, 0x2231, 0x2251, 0x2A92, 0x22B2, 0x3AB4, 0x3B13, 0x3AF4, 0x092D, 0x014D,   // 0x0020 (32)
+0x0150, 0x0150, 0x11F0, 0x19F0, 0x1A12, 0x1A51, 0x1A32, 0x21F3, 0x1A12, 0x1A31, 0x29F1, 0x2232, 0x1230, 0xFFDF, 0x2251, 0x19F0,   // 0x0030 (48)
+0x2211, 0x2230, 0x2211, 0x1A31, 0x1A11, 0x1A30, 0x29F2, 0x2273, 0x22D2, 0x3AF3, 0x42F3, 0x4353, 0x010B, 0x010C, 0x014E, 0x014F,   // 0x0040 (64)
+0x016F, 0x19D1, 0x11EF, 0x11F1, 0x19F0, 0x19F0, 0x19F1, 0x1211, 0x11EF, 0x1211, 0x11F1, 0xFFFF, 0x11D1, 0x1A12, 0x19B1, 0x21F2,   // 0x0050 (80)
+0x11F1, 0x11F1, 0x19F2, 0x11D2, 0x2231, 0x1A31, 0x3293, 0x3AB4, 0x42F3, 0x4354, 0x010A, 0x010B, 0x012C, 0x094F, 0xFFFF, 0x098F,   // 0x0060 (96)
+0x0991, 0x09B1, 0x09B0, 0x1190, 0x11B2, 0x01B0, 0x09CF, 0x11B1, 0x1190, 0xFFFF, 0x01B0, 0x11B0, 0x09D0, 0x01B0, 0x11B0, 0x09B0,   // 0x0070 (112)
+0x09D0, 0x11D0, 0x0A11, 0x1A0F, 0xFFFF, 0x32B3, 0x4334, 0x4B13, 0x00CA, 0x014C, 0x012C, 0x090E, 0xEFDE, 0xFFFF, 0x1190, 0x0170,   // 0x0080 (128)
+0x01B0, 0x01D0, 0x014F, 0x01B0, 0x0990, 0x0970, 0x0990, 0xF7FF, 0x0991, 0x0190, 0x01CF, 0x01CF, 0x0191, 0x0170, 0x0990, 0x018F,   // 0x0090 (144)
+0x09AF, 0xFFFF, 0xFFFF, 0x2A92, 0x3312, 0x4B33, 0x00EB, 0x00EB, 0x012D, 0x010E, 0x018D, 0xFFDF, 0xFFFF, 0x096E, 0x096F, 0x0150,   // 0x00A0 (160)
+0x098F, 0x0151, 0x0190, 0x0170, 0x01AF, 0x016E, 0x094F, 0x018F, 0x0150, 0x094E, 0x0150, 0x0170, 0x0151, 0x0170, 0xFFFF, 0xFFDF,   // 0x00B0 (176)
+0x2212, 0x32B3, 0x3AF2, 0x3B35, 0x00C9, 0x010B, 0x00CB, 0x012F, 0x016E, 0x016F, 0xFFFF, 0xFFFF, 0x0170, 0x0171, 0x016F, 0x014F,   // 0x00C0 (192)
+0xF7FF, 0xFFDF, 0xFFFF, 0xFFDF, 0xFFFF, 0xF7FF, 0x094E, 0x0190, 0x0150, 0x01AF, 0x016F, 0xFFFF, 0xFFDF, 0x11D1, 0x1210, 0x2A92,   // 0x00D0 (208)
+0x32B2, 0x4313, 0x010A, 0x00EA, 0x010C, 0x014D, 0x012D, 0x0170, 0x0150, 0xFFFE, 0xFFFF, 0x016F, 0x014E, 0xF7FF, 0xE77F, 0xFFFF,   // 0x00E0 (224)
+0xFFFF, 0xFFFF, 0xFFFF, 0xE7DF, 0xFFFF, 0xFFFF, 0x094E, 0x016F, 0x014E, 0xFFFF, 0x018F, 0x09B1, 0x1230, 0x2A73, 0x32F3, 0x4314,   // 0x00F0 (240)
+0x010A, 0x010A, 0x00ED, 0x014B, 0x014F, 0x0150, 0x014E, 0x0170, 0x016F, 0x014E, 0xFFDF, 0xE7DF, 0xFFFF, 0x014F, 0x0190, 0x0150,   // 0x0100 (256)
+0x018E, 0xFFBF, 0xFFFF, 0xE7BF, 0xFFFF, 0x0170, 0x016F, 0x0190, 0x098F, 0x01D1, 0x2212, 0x2272, 0x3B13, 0x42F3, 0x00EB, 0x00EA,   // 0x0110 (272)
+0x094D, 0x012C, 0x0150, 0x014F, 0x018F, 0x016F, 0x014F, 0xFFFF, 0xE7DF, 0xFFFF, 0x0970, 0x016F, 0x014E, 0x0150, 0x016F, 0x096F,   // 0x0120 (288)
+0x014E, 0xFFFF, 0xE7DF, 0xFFFF, 0x014F, 0x0910, 0x0990, 0x0991, 0x1A30, 0x2292, 0x32F2, 0x4333, 0x00EB, 0x00EB, 0x00EC, 0x012D,   // 0x0130 (304)
+0x014F, 0x016E, 0x0170, 0x0151, 0xF7FF, 0xEFFF, 0xF7FF, 0x014F, 0x014E, 0x016F, 0x016F, 0x016F, 0x012F, 0x0191, 0x0170, 0x018D,   // 0x0140 (320)
+0xFFFF, 0xE7DF, 0xFFFF, 0x018F, 0x016F, 0x09D1, 0x19F2, 0x2A92, 0x3AD3, 0x4314, 0x00CA, 0x010B, 0x010D, 0x012C, 0x014E, 0x016E,   // 0x0150 (336)
+0x016F, 0x096E, 0xFFFF, 0xFFFE, 0x016E, 0x016F, 0x018F, 0x0930, 0x0171, 0x016E, 0x094F, 0x014F, 0x0150, 0x012F, 0x016E, 0xFFFF,   // 0x0160 (352)
+0xFFFF, 0x0170, 0x01B1, 0x09AF, 0x1A30, 0x3294, 0x3AB3, 0x3B35, 0x08CA, 0x00EB, 0x010C, 0x016D, 0x014F, 0x0150, 0x014F, 0xFFFF,   // 0x0170 (368)
+0xEFBF, 0xFFFF, 0x0192, 0x014E, 0x014F, 0x0170, 0x0130, 0x014F, 0x016F, 0x014F, 0x0170, 0x0190, 0x0170, 0xF7DF, 0xEFDF, 0xFFFF,   // 0x0180 (384)
+0x098E, 0x09D0, 0x2212, 0x2253, 0x3B14, 0x4333, 0x00EA, 0x012B, 0x010C, 0x012B, 0x014D, 0x012F, 0x014F, 0xFFFF, 0xFFFF, 0x094E,   // 0x0190 (400)
+0x016E, 0x0151, 0x014F, 0x016E, 0x0151, 0x0170, 0x018E, 0x0150, 0x0150, 0x016F, 0x0131, 0x014F, 0xFFDF, 0xFFFE, 0x018F, 0x09D0,   // 0x01A0 (416)
+0x1A10, 0x2A70, 0x32D3, 0x3B53, 0x010A, 0x00AB, 0xC679, 0xDF1B, 0xF77D, 0xEFFE, 0x0950, 0xFFDF, 0xFFFF, 0x016F, 0x016F, 0x018F,   // 0x01B0 (432)
+0x014F, 0x0150, 0x012F, 0x016F, 0x016F, 0x1150, 0x014F, 0x014E, 0x018E, 0x014D, 0xFFFF, 0xFFDF, 0x0971, 0xF7FF, 0xE7FF, 0xFFFF,   // 0x01C0 (448)
+0xFFFF, 0x4312, 0x00CA, 0x010A, 0x010E, 0x012E, 0x014F, 0x0150, 0x0170, 0xFFFF, 0xFFFE, 0x016F, 0x0150, 0x0150, 0x014F, 0x016F,   // 0x01D0 (464)
+0x0190, 0x014F, 0x0150, 0x0150, 0x016F, 0x096F, 0x0152, 0x0190, 0xFFFF, 0xFFFF, 0x018F, 0x11B0, 0x21F0, 0x3252, 0x3AD3, 0x4352,   // 0x01E0 (480)
+0x0108, 0x00EC, 0x010D, 0x010E, 0x014E, 0x014F, 0x094F, 0xFFFF, 0xE7DE, 0x0170, 0x0170, 0x014E, 0x096F, 0x014F, 0x0170, 0x0150,   // 0x01F0 (496)
+0x018E, 0x0170, 0x0170, 0x096F, 0x014F, 0x016E, 0xE7DE, 0xFFFF, 0x0170, 0x09D1, 0x21D1, 0x2A93, 0x3AF4, 0x42F4, 0x00EA, 0x010B,   // 0x0200 (512)
+0x00ED, 0x012C, 0x016E, 0x016F, 0x014D, 0x0970, 0xE7DF, 0xFFDF, 0x0150, 0x0150, 0x012F, 0x098E, 0x014F, 0x0170, 0x0170, 0x0150,   // 0x0210 (528)
+0x0150, 0x016F, 0x0150, 0xFFFF, 0xEFBF, 0x0150, 0x018F, 0x01B1, 0x2211, 0x2A91, 0x32F2, 0x4334, 0x00CA, 0x010B, 0x012C, 0x010C,   // 0x0220 (544)
+0x012E, 0x0170, 0x018E, 0x0170, 0xFFFF, 0xEFBF, 0xF7FF, 0x01B1, 0x0130, 0x014F, 0x018E, 0x018F, 0x016E, 0x018E, 0x0150, 0x016F,   // 0x0230 (560)
+0xFFFF, 0xE7BF, 0xFFFF, 0x0150, 0x016F, 0x09F1, 0x1A31, 0x2A92, 0x32F4, 0x4334, 0x00CA, 0x00EA, 0x012B, 0x012E, 0x112F, 0x012F,   // 0x0240 (576)
+0x018F, 0x016E, 0x014E, 0xFFFF, 0xE7DF, 0xFFFF, 0x016E, 0x0191, 0x016F, 0x014F, 0x0152, 0x014F, 0x096E, 0xFFFE, 0xDFFF, 0xF7FF,   // 0x0250 (592)
+0x018F, 0x016F, 0x0970, 0x09B1, 0x2211, 0x2292, 0x32F3, 0x4B14, 0x00EA, 0x010A, 0x010C, 0x012D, 0x012E, 0x014E, 0x094F, 0x0150,   // 0x0260 (608)
+0x018E, 0x0131, 0xFFFF, 0xEFBF, 0xFFFF, 0xFFFF, 0x094F, 0x0151, 0x016F, 0xF7DF, 0xEFDF, 0xE7BF, 0xF7FF, 0x0970, 0x014F, 0x092F,   // 0x0270 (624)
+0x018F, 0x09B0, 0x19F1, 0x2AB1, 0x3312, 0x42F4, 0x00CA, 0x010B, 0x012C, 0x012D, 0x016E, 0x0150, 0x0151, 0x016E, 0xFFFF, 0x0931,   // 0x0280 (640)
+0x0150, 0xFFFF, 0xFFFF, 0xE7FF, 0xFFDF, 0xFFDF, 0xFFFF, 0xDFFF, 0xFFFD, 0x094F, 0x016F, 0x014D, 0xFFFF, 0xF7FF, 0x0190, 0x01D0,   // 0x0290 (656)
+0x2212, 0x2A73, 0x3AD4, 0x4B15, 0x00EA, 0x00EB, 0x012C, 0x012D, 0x012F, 0x0170, 0x014E, 0xF7FF, 0xFFFF, 0x092F, 0x016F, 0x0170,   // 0x02A0 (672)
+0x018E, 0xFFFF, 0xFFDF, 0xF7FE, 0xFFFF, 0xFFFE, 0x0150, 0x0190, 0x014F, 0x0170, 0x016E, 0xFFFF, 0x096F, 0x09D1, 0x1A10, 0x2A72,   // 0x02B0 (688)
+0x3AD3, 0x4333, 0x00EA, 0x012B, 0x010C, 0x014D, 0x012E, 0x094D, 0xF7FF, 0xFFFF, 0x016E, 0x0151, 0x014F, 0x018F, 0x014F, 0x014F,   // 0x02C0 (704)
+0x0150, 0x016F, 0x014F, 0x016F, 0x0170, 0x014F, 0x0950, 0x0170, 0x016F, 0x0150, 0xFFFF, 0x11B0, 0x1A30, 0x2A72, 0x3AD3, 0x3B33,   // 0x02D0 (720)
+0x010A, 0x00EA, 0x010C, 0x012C, 0xEF5D, 0xF7BF, 0x014F, 0x016F, 0x014F, 0x016F, 0x0170, 0x014F, 0x0170, 0x016E, 0x014E, 0xFFDF,   // 0x02E0 (736)
+0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0xFFFF, 0xFFFE, 0x1A11, 0x2270, 0x3AD4, 0x3B13, 0x0109, 0x00EA,   // 0x02F0 (752)
+0x010C, 0xD6DA, 0xE73D, 0x014F, 0x016F, 0x014F, 0x0150, 0x014E, 0x012E, 0x016F, 0x012F, 0x0150, 0x014E, 0xF7DD, 0x014F, 0x014F,   // 0x0300 (768)
+0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x016E, 0xFFFF, 0xF7DF, 0x2252, 0x32B1, 0x3AF3, 0x00CA, 0x00EB, 0x010C, 0x010D,   // 0x0310 (784)
+0x012D, 0x010D, 0x012F, 0x014D, 0x012D, 0x016F, 0x014F, 0x014D, 0x012D, 0x014F, 0x012D, 0xEF5C, 0x014E, 0x014E, 0x014E, 0x014E,   // 0x0320 (800)
+0x014E, 0x014E, 0x014E, 0x014E, 0x012E, 0x0930, 0xF7FF, 0x11F2, 0x2A52, 0x2AD4, 0x00CA, 0x00CB, 0x010B, 0x010B, 0x010C, 0x014C,   // 0x0330 (816)
+0x014D, 0x012E, 0x012E, 0x012D, 0x012C, 0x012B, 0x016E, 0x010E, 0x012E, 0xDEFC, 0x012D, 0x012D, 0x012D, 0x012D, 0x012D, 0x012D,   // 0x0340 (832)
+0x012D, 0x012D, 0x014D, 0x014D, 0x014F, 0x01AF, 0x1210, 0x2250, 0x00E9, 0x00EB, 0x010A, 0x010B, 0x010C, 0x012C, 0x012C, 0x010D,   // 0x0350 (848)
+0x010D, 0x012D, 0x012D, 0x012D, 0x010D, 0x012C, 0x012C, 0xCE9B, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C,   // 0x0360 (864)
+0x012D, 0x014D, 0x016D, 0x014F, 0x09D1, 0x1A11, 0x08C9, 0x010B, 0x00EB, 0x00EB, 0x010C, 0x00EC, 0x012D, 0x012C, 0x010D, 0x010B,   // 0x0370 (880)
+0x012D, 0x010B, 0x012B, 0x014B, 0x010F, 0x10CA, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010D, 0x012C,   // 0x0380 (896)
+0x10EB, 0x016E, 0x0130, 0x018F, };

_718/kalen.ino

@@ -0,0 +1,297 @@
+
+void kalendar(int days,  int mon, word years)
+//void kalen()
+{
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+   char* strw[] = {"MO","TU","WE","TH","FR","SA","SU"};
+ int mon1;
+//  int days;
+  int dmax;
+word years1;
+  byte dow;
+
+  
+//***************************************************************************************** 
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(80, 35, 632, 420);
+  myGLCD.setColor(255,114,0);
+ myGLCD.fillRoundRect(80, 35, 632, 87);
+ 
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+    myGLCD.setColor(255, 255, 255);
+ myGLCD.setFont( Ubuntubold);
+ myGLCD.print(strm[mon-1], 250, 50);
+ myGLCD.printNumI(years, 420, 50);
+ myGLCD.setColor(0, 0, 100);
+ dmax=validmax(days, mon, years);
+ for(int i=0;i<7;i++)//вывод дней недели
+ {
+  if (i>4)
+ {myGLCD.setColor(255, 0, 0); //вывод красным выходных дней
+ }
+   myGLCD.print(strw[i], 104+i*72, 89);
+ }
+  myGLCD.setBackColor( VGA_TRANSPARENT);
+    myGLCD.setColor(0, 0, 255);
+ days=1;
+ int yk=0;
+ dow=calcDOW1(days, mon, years);
+ 
+ for (days=1;days<dmax+1;days++)//вывод чисел календаря
+ {
+ 
+  if (mon==t.mon)// текущая дата
+  {
+   if ( years==t.year)
+   {
+     if ( days==t.date)
+   {
+    //   myGLCD.setColor(200, 200, 200);
+ // myGLCD.fillRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+  
+    if (dow>5)
+ {
+    myGLCD.setColor(250, 198, 239);
+  myGLCD.fillRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+   myGLCD.setColor(255, 0, 0);
+  myGLCD.drawRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+ 
+ }
+ else
+ {
+     myGLCD.setColor(182, 217, 252);
+  myGLCD.fillRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+   myGLCD.setColor(0, 0, 255); 
+     myGLCD.drawRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+ }
+
+  
+    //  myGLCD.printNumI(days, (dow-1)*72+104, yk*50+135);
+   }
+   }
+  }  
+   
+     
+  if (dow>5)
+ {myGLCD.setColor(255, 0, 0); 
+ }
+ else
+ {
+   myGLCD.setColor(0, 0, 255); 
+ }
+   myGLCD.printNumI(days, (dow-1)*72+104, yk*50+135);//вывод чисел календаря
+   
+ 
+
+
+
+  
+   if (dow>6)
+   {dow=0;
+   yk=yk+1;
+   }
+
+   dow=dow+1;
+ }  
+ 
+ 
+  days=1;
+  if (mon==12)
+  {mon1=1;
+    years1=years+1;
+  }
+  else
+  {
+  mon1=mon+1;
+   years1=years;
+  }
+ dow=calcDOW1(days, mon1, years1); 
+ myGLCD.setColor(100, 100, 100); //*********************************
+ for (days=1;dow<8;days++)
+ {
+ myGLCD.printNumI(days, (dow-1)*72+104, yk*50+135); 
+  dow=dow+1;
+ }
+
+if (mon==1)
+  {mon1=12;
+    years1=years-1;
+  }
+  else
+  {
+  mon1=mon-1;
+  years1=years;
+  }
+dmax=validmax(days, mon1, years1);
+days=dmax;
+ dow=calcDOW1(days, mon1, years1); 
+ if(dow<7)
+ {
+ myGLCD.setColor(100, 100, 100); //*************************
+ for (days=dmax;dow>0;days--)
+ {
+ myGLCD.printNumI(days, (dow-1)*72+104, 135); 
+  dow=dow-1;
+ }
+ }
+}
+
+//******************************kalendar*******************************************************************
+void  kalendarset()  
+{
+  
+
+
+ int  days=t.date;
+int  mon=t.mon;
+ word years=t.year;  
+  
+ kalendar(days, mon, years); 
+
+ 
+// myButtons.setButtonColors(VGA_WHITE,VGA_AQUA,VGA_WHITE,VGA_YELLOW,VGA_RED);
+//   myGLCD.setFont(BigFont);
+//    myButtons.setSymbolFont(Dingbats1_XL);
+ drawButkal();
+
+
+ while(1)
+ {
+ if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+     int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+      if ((y>=390) && (y<=390+30))  // Upper row
+      {
+        
+        if ((x>= 588) && (x<= 588+30))  //X
+             {waitForIt( 588, 390, 588+30, 390+30);
+             return;
+           }
+      } 
+        
+       if ((y>=40) && (y<=40+30))  // Upper row
+      {
+        
+        if ((x>= 588) && (x<= 588+30))  //+
+             {waitForIt( 588, 40, 588+30, 40+30);    
+              mon=mon+1;
+              if (mon>12)
+                 {mon=1;
+                 }
+                   kalendar(days, mon, years);
+                    drawButkal();
+             }
+              if ((x>= 90) && (x<= 90+30))  //-
+             {waitForIt( 90, 40, 90+30, 40+30);  
+              mon=mon-1;
+               if (mon<1)
+               {mon=12;
+                }
+               kalendar(days, mon, years); 
+                drawButkal();
+             }
+       if ((x>= 545) && (x<= 545+30))  //>
+             {waitForIt( 545, 40, 545+30, 40+30);         
+               years=years+1;
+            if (years>2099)
+                {years=2000;
+                }
+               kalendar(days, mon, years);
+               drawButkal();
+             }
+        if ((x>= 135) && (x<= 135+30))  //<
+             {waitForIt( 135, 40, 135+30, 40+30);  
+              years=years-1;
+            if (years<2000)
+              {years=2099;
+              }
+                 kalendar(days, mon, years);
+                      drawButkal();
+             }
+
+     
+      
+      }
+      } 
+   
+
+ sec=t.sec;
+if (sec==0)
+{
+delay(800);
+clc();
+} 
+ 
+ 
+ }
+
+}
+
+byte validmax(byte d, byte m, word y)
+{
+  byte mArr[12] = {31,0,31,30,31,30,31,31,30,31,30,31};
+  byte dmax;
+  
+  if (m==2)
+  {
+    if ((y % 4)==0)
+    {
+      dmax=29;
+    }
+    else
+    {
+      dmax=28;
+    }
+  }
+  else
+  {
+    dmax=mArr[m-1];
+  }
+  
+  return dmax;
+}
+
+
+
+
+byte calcDOW1(byte d, byte m, int y)
+{
+  int dow;
+  byte mArr[12] = {6,2,2,5,0,3,5,1,4,6,2,4};
+  
+  dow = (y % 100);
+  dow = dow*1.25;
+  dow += d;
+  dow += mArr[m-1];
+  if (((y % 4)==0) && (m<3))
+    dow -= 1;
+  while (dow>7)
+    dow -= 7;
+    
+  return dow;
+}
+
+
+
+void drawButkal()// календарь на месяц 
+{
+myGLCD.setColor(255, 255, 255);
+   myGLCD.drawBitmap (588, 390, 30, 30, xf);
+    myGLCD.drawRoundRect (588, 390, 588+30, 390+30);//X
+    
+ myGLCD.drawBitmap (588, 40, 30, 30, ad);
+     myGLCD.drawRoundRect ( 588, 40,  618, 70); //+   
+
+ myGLCD.drawBitmap (90, 40, 30, 30, mi); 
+     myGLCD.drawRoundRect (  90, 40,  120, 70); //-
+
+ myGLCD.drawBitmap (545, 40, 30, 30, pr);
+     myGLCD.drawRoundRect ( 545, 40, 545+30, 40+30);//>
+
+ myGLCD.drawBitmap (135, 40, 30, 30, le);
+     myGLCD.drawRoundRect (  135, 40,  135+30, 40+30);//<
+}    

_718/klok.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: klok.jpg
+// Time generated: 24.03.2014 12:02:06
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short klok[0x1900] ={
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0010 (16)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0020 (32)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0030 (48)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0040 (64)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0050 (80)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0060 (96)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0070 (112)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0080 (128)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0090 (144)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00A0 (160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00B0 (176)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00C0 (192)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00D0 (208)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00E0 (224)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00F0 (240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0100 (256)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0110 (272)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0120 (288)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0130 (304)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0140 (320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0150 (336)
+0x0861, 0x31A6, 0x632C, 0x9492, 0x9CF3, 0x9492, 0x94B2, 0x9CF3, 0x9CF3, 0x9CD3, 0x9CD3, 0x9CD3, 0x9CD3, 0x9CD4, 0xA4D4, 0x9CF4,   // 0x0160 (352)
+0x9CF4, 0x9CF4, 0x9D14, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA534, 0xA534, 0xA514, 0xA514,   // 0x0170 (368)
+0xA514, 0xA514, 0xA514, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x8C71, 0x632C, 0x39C7, 0x0861, 0x0000, 0x0000,   // 0x0180 (384)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0190 (400)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB,   // 0x01A0 (416)
+0x7BEF, 0x738E, 0x630C, 0x4A49, 0x4228, 0x4A69, 0x528A, 0x528A, 0x4A69, 0x526A, 0x528A, 0x5A8A, 0x5A8A, 0x5A8B, 0x5A8B, 0x52AB,   // 0x01B0 (432)
+0x52AB, 0x52AB, 0x52CB, 0x5ACB, 0x5ACB, 0x5AEB, 0x5AEB, 0x630C, 0x630B, 0x630C, 0x630C, 0x630C, 0x630C, 0x630C, 0x5AEB, 0x5AEB,   // 0x01C0 (448)
+0x5ACB, 0x5ACB, 0x52AA, 0x52AA, 0x52AA, 0x52AA, 0x528A, 0x528A, 0x528A, 0x528A, 0x52AA, 0x632C, 0x632C, 0x7BEF, 0x630C, 0x0000,   // 0x01D0 (464)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x01E0 (480)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x73AE, 0x632C,   // 0x01F0 (496)
+0x39E7, 0x39E7, 0x4208, 0x4228, 0x39E7, 0x4208, 0x4A49, 0x4A69, 0x4228, 0x4A49, 0x5229, 0x5229, 0x5229, 0x524A, 0x524B, 0x526A,   // 0x0200 (512)
+0x526A, 0x528B, 0x528A, 0x528A, 0x528A, 0x5AAA, 0x5ACA, 0x5ACA, 0x62EB, 0x5AEB, 0x5ACB, 0x5ACB, 0x5ACB, 0x5ACB, 0x52AA, 0x52AA,   // 0x0210 (528)
+0x528A, 0x528A, 0x52AA, 0x528A, 0x528A, 0x4A69, 0x4A69, 0x4A69, 0x4A69, 0x4A49, 0x4228, 0x4A69, 0x4A49, 0x528A, 0x632C, 0x73AE,   // 0x0220 (544)
+0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0230 (560)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x6B6D, 0x52AA, 0x3186,   // 0x0240 (576)
+0x4228, 0x4228, 0x39E7, 0x39E7, 0x4228, 0x4A49, 0x4A69, 0x4A49, 0x4A49, 0x5269, 0x5249, 0x5A49, 0x5249, 0x524A, 0x526A, 0x526A,   // 0x0250 (592)
+0x526A, 0x52AB, 0x52AB, 0x52AB, 0x5AAB, 0x5ACA, 0x5ACA, 0x62AA, 0x5ACA, 0x5ACA, 0x5ACB, 0x5ACB, 0x52AA, 0x52AA, 0x52AA, 0x52AA,   // 0x0260 (608)
+0x5ACB, 0x52AA, 0x528A, 0x528A, 0x528A, 0x4A69, 0x4A69, 0x4A49, 0x4A69, 0x4A69, 0x528A, 0x4208, 0x39E7, 0x4208, 0x4208, 0x5ACB,   // 0x0270 (624)
+0x6B6D, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0280 (640)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x5AEB, 0x4A69, 0x31A6, 0x4208,   // 0x0290 (656)
+0x39E7, 0x4208, 0x39E7, 0x4A49, 0x4A49, 0x4208, 0x4208, 0x4A49, 0x4A69, 0x5228, 0x5208, 0x5229, 0x5A8A, 0x5A6A, 0x4A2A, 0x528A,   // 0x02A0 (672)
+0x5A8B, 0x4A09, 0x4A4A, 0x526A, 0x5229, 0x5228, 0x5A48, 0x5A48, 0x5A48, 0x5A8A, 0x528A, 0x528B, 0x52AA, 0x5ACA, 0x5AEB, 0x52AB,   // 0x02B0 (688)
+0x52AA, 0x528A, 0x52AA, 0x528A, 0x528A, 0x528A, 0x4A69, 0x4A69, 0x4A69, 0x4A49, 0x4A49, 0x4228, 0x4A49, 0x4A69, 0x4228, 0x39E7,   // 0x02C0 (704)
+0x52AA, 0x630C, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x02D0 (720)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x4208, 0x39C7, 0x39E7, 0x3186,   // 0x02E0 (736)
+0x39E7, 0x4208, 0x4208, 0x4208, 0x39E7, 0x4208, 0x4A69, 0x4A69, 0x4A49, 0x5249, 0x5249, 0x5A6A, 0x4A08, 0x4A29, 0x526A, 0x4A29,   // 0x02F0 (752)
+0x62EC, 0x9473, 0xB537, 0xD619, 0xEEFC, 0xEF9D, 0xF79E, 0xEF9D, 0xF75C, 0xEEFB, 0xC658, 0xAD35, 0x8C71, 0x632C, 0x4A49, 0x4A69,   // 0x0300 (768)
+0x528A, 0x52AA, 0x52AA, 0x52AA, 0x4A69, 0x4228, 0x4A69, 0x4A49, 0x4A69, 0x528A, 0x4A49, 0x4228, 0x4228, 0x4208, 0x4208, 0x39E7,   // 0x0310 (784)
+0x4228, 0x52AA, 0x528A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0320 (800)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x5AEB, 0x39C7, 0x39E7, 0x3186, 0x4208,   // 0x0330 (816)
+0x39E7, 0x39E7, 0x4208, 0x4228, 0x4228, 0x4228, 0x4228, 0x4208, 0x4228, 0x5248, 0x5249, 0x49E7, 0x41C7, 0x5ACC, 0x9C93, 0xCE5A,   // 0x0340 (832)
+0xEF7D, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFBE, 0xFEFB, 0xFF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDE, 0xF79E, 0xEF7D, 0xCE79, 0x8C72,   // 0x0350 (848)
+0x5AEB, 0x4A49, 0x528A, 0x528A, 0x52AA, 0x528A, 0x4A69, 0x52AA, 0x4228, 0x4228, 0x4A69, 0x4228, 0x39E7, 0x4208, 0x4228, 0x4228,   // 0x0360 (864)
+0x4208, 0x4208, 0x630C, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0370 (880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39C7, 0x4228, 0x39C7, 0x39E7, 0x31A6, 0x39E7,   // 0x0380 (896)
+0x39E7, 0x39E7, 0x39E7, 0x4228, 0x4228, 0x39C7, 0x4208, 0x4A49, 0x4A49, 0x5269, 0x41E6, 0x62EB, 0xB555, 0xEF3D, 0xF7BE, 0xFFFF,   // 0x0390 (912)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF9D, 0xFEBA, 0xFF5C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE,   // 0x03A0 (928)
+0xE71C, 0xA514, 0x5AEB, 0x4208, 0x4A69, 0x4A69, 0x528A, 0x4228, 0x4A69, 0x52AA, 0x4A49, 0x4228, 0x4A49, 0x4228, 0x4208, 0x4A49,   // 0x03B0 (944)
+0x4228, 0x39E7, 0x4A49, 0x39C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x03C0 (960)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4A49, 0x39C7, 0x31A6, 0x4208, 0x39E7, 0x31A6,   // 0x03D0 (976)
+0x39E7, 0x4228, 0x4208, 0x4208, 0x4228, 0x4228, 0x4A69, 0x4A49, 0x3A07, 0x5289, 0xA4F3, 0xE71C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03E0 (992)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF7D, 0xF5D7, 0xFF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03F0 (1008)
+0xFFFF, 0xF7BE, 0xE71C, 0x9CF3, 0x52AA, 0x4208, 0x52AA, 0x5AEB, 0x4228, 0x4A69, 0x4A49, 0x4228, 0x4A49, 0x4A49, 0x39E7, 0x4208,   // 0x0400 (1024)
+0x4228, 0x4208, 0x4A69, 0x4A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0410 (1040)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0x31A6, 0x31A6, 0x39E7, 0x39C7, 0x39C7,   // 0x0420 (1056)
+0x39E7, 0x4208, 0x4228, 0x4208, 0x4228, 0x528A, 0x39E7, 0x31A6, 0x6B4D, 0xCE78, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0430 (1072)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA492, 0xA3CF, 0xEDB6, 0xBC0F, 0xCCD2, 0xFF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0440 (1088)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xCE79, 0x6B4D, 0x39C7, 0x4A49, 0x528A, 0x4A49, 0x4A49, 0x4228, 0x4228, 0x4228, 0x4208, 0x4208,   // 0x0450 (1104)
+0x4208, 0x4208, 0x4A49, 0x52AA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0460 (1120)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0x39C7, 0x39C7, 0x3186, 0x4208, 0x31A6,   // 0x0470 (1136)
+0x39E7, 0x4208, 0x4208, 0x39E7, 0x39E7, 0x39E7, 0x4228, 0x7BEF, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0480 (1152)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD5F8, 0xABEF, 0xDD34, 0xF77D, 0xB4D2, 0xBCD3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0490 (1168)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0x7BCF, 0x4A49, 0x4A49, 0x4A49, 0x4228, 0x4228, 0x4208, 0x4228, 0x4228, 0x4228,   // 0x04A0 (1184)
+0x4208, 0x39E7, 0x39C7, 0x632C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x04B0 (1200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x31A6, 0x39C7, 0x39C7, 0x39E7,   // 0x04C0 (1216)
+0x39E7, 0x4208, 0x39E7, 0x4A49, 0x4208, 0x4208, 0x8C71, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0xC618, 0xFFFF, 0x9CF4, 0xBDD8,   // 0x04D0 (1232)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF6FB, 0xC472, 0xE4F4, 0xFEBA, 0xE575, 0xE659, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6,   // 0x04E0 (1248)
+0xA534, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x8430, 0x4A49, 0x4A49, 0x4A49, 0x4A69, 0x4228, 0x4208, 0x4228, 0x4208,   // 0x04F0 (1264)
+0x39E7, 0x4208, 0x4228, 0x5AEB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0500 (1280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x4208, 0x39C7, 0x39C7, 0x39E7, 0x39C7,   // 0x0510 (1296)
+0x4208, 0x39E7, 0x39C7, 0x4228, 0x4228, 0x8430, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD639, 0xB515, 0xFFBF, 0x8C72, 0xACF6,   // 0x0520 (1312)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE679, 0xD452, 0xC38F, 0xA2EB, 0xD5D6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA514,   // 0x0530 (1328)
+0x73AE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x8C71, 0x4228, 0x4208, 0x4A49, 0x4A49, 0x4228, 0x4228, 0x4208,   // 0x0540 (1344)
+0x4A49, 0x39C7, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0550 (1360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x31A6, 0x31A6, 0x39C7, 0x39E7, 0x39C7,   // 0x0560 (1376)
+0x4228, 0x4208, 0x4228, 0x2945, 0x73AE, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF3D, 0xCDD8, 0xF77E, 0xC639, 0xCDDA,   // 0x0570 (1392)
+0xFFBF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xFD98, 0xC2AD, 0xAACC, 0xCD33, 0xEF3B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE38,   // 0x0580 (1408)
+0xA534, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x73AE, 0x4228, 0x4A49, 0x4A49, 0x4228, 0x39E7, 0x4228,   // 0x0590 (1424)
+0x39E7, 0x4228, 0x4208, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x05A0 (1440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39C7, 0x31A6, 0x31A6, 0x39E7, 0x39E7,   // 0x05B0 (1456)
+0x39E7, 0x39E7, 0x3186, 0x6B4D, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE6FC, 0xC5B7, 0xF79E, 0xC5F8, 0xC5B8,   // 0x05C0 (1472)
+0xFF9F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF5D, 0xF4B4, 0xF597, 0xFF7D, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDB6,   // 0x05D0 (1488)
+0x9492, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0x5AEB, 0x39E7, 0x4228, 0x4208, 0x4A69, 0x4A49,   // 0x05E0 (1504)
+0x39C7, 0x4208, 0x4208, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x05F0 (1520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x39E7, 0x31A6, 0x39C7, 0x39E7,   // 0x0600 (1536)
+0x39C7, 0x31A6, 0x52AA, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xD659, 0xF7BE, 0xCE7A, 0xDE7B,   // 0x0610 (1552)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF3D, 0xFCD5, 0xFE19, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB,   // 0x0620 (1568)
+0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0x528A, 0x4208, 0x4208, 0x4A49, 0x4208,   // 0x0630 (1584)
+0x4208, 0x39E7, 0x4228, 0x52AA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0640 (1600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39C7, 0x39E7, 0x39C7, 0x39C7, 0x39C7,   // 0x0650 (1616)
+0x4228, 0x31A6, 0x8430, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBE, 0xFFFF, 0xF7BF, 0xFFBF,   // 0x0660 (1632)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEFC, 0xFC74, 0xFE19, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0670 (1648)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x8410, 0x31A6, 0x4228, 0x39E7, 0x4208,   // 0x0680 (1664)
+0x4228, 0x4208, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0690 (1680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x31A6, 0x31A6, 0x39E7, 0x39C7,   // 0x06A0 (1696)
+0x3186, 0x528A, 0xD69A, 0xFFFF, 0xFFFF, 0xC638, 0xEF5D, 0xFFFF, 0xAD75, 0xD6DA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06B0 (1712)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEDC, 0xFC33, 0xFDF9, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06C0 (1728)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xBDF7, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0x5ACB, 0x4228, 0x4A49, 0x4228,   // 0x06D0 (1744)
+0x4208, 0x39E7, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x06E0 (1760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0x4208, 0x2965, 0x31A6, 0x4208, 0x39C7,   // 0x06F0 (1776)
+0x2965, 0x9CD3, 0xFFDF, 0xFFFF, 0xFFFF, 0x8430, 0xC618, 0xCE59, 0xBDD7, 0x9CF2, 0xDF1B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0700 (1792)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF1D, 0xFC74, 0xFDF8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0710 (1808)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xD69A, 0xB5B6, 0xEF5D, 0xFFFF, 0xFFFF, 0xF7BE, 0x8C71, 0x2965, 0x4228, 0x4208,   // 0x0720 (1824)
+0x4228, 0x39E7, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0730 (1840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x39C7, 0x31A6, 0x39C7, 0x31A6, 0x39C7,   // 0x0740 (1856)
+0x528A, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0xBDD7, 0xA534, 0xEF7D, 0x9D13, 0xD6BA, 0xFFFF, 0xFFFF, 0xEF5D, 0xFFFF, 0xFFFF,   // 0x0750 (1872)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEFC, 0xFC95, 0xFE39, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0760 (1888)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x9CF3, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0x528A, 0x4208, 0x4208,   // 0x0770 (1904)
+0x39E7, 0x4208, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0780 (1920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5AEB, 0x39C7, 0x2965, 0x4228, 0x3186, 0x2945,   // 0x0790 (1936)
+0x8430, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0xBDF7, 0x9492, 0xFFFF, 0x9D13, 0xCE58, 0xFFFF, 0xFFFF, 0x9CD2, 0x4A89, 0xCE9A,   // 0x07A0 (1952)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEDC, 0xF433, 0xF5F8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07B0 (1968)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0xBDF7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x8410, 0x3186, 0x4208,   // 0x07C0 (1984)
+0x39E7, 0x4228, 0x4228, 0x630C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x07D0 (2000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x39C7, 0x39E7, 0x31A6, 0x39C7,   // 0x07E0 (2016)
+0xBDD7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0xD6BA, 0xDEDB, 0x8451, 0x9492, 0xEF7D, 0xFFFF, 0xFFFF, 0xDEFB, 0x31E7, 0x2104,   // 0x07F0 (2032)
+0xA535, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEDC, 0xEC11, 0xEDF8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0800 (2048)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA534, 0x39E7, 0xCE79, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDF7, 0x39E7, 0x4A49,   // 0x0810 (2064)
+0x4228, 0x39E7, 0x4208, 0x5AEB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0820 (2080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x39E7, 0x31A6, 0x31A6, 0x39E7, 0x4A69,   // 0x0830 (2096)
+0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xFFDF, 0xFFFF, 0xCE79, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCEBA, 0x18E3,   // 0x0840 (2112)
+0x0882, 0x8CF3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFE7A, 0xF3F1, 0xF5F7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0850 (2128)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xB5B6, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x528A, 0x4208,   // 0x0860 (2144)
+0x4208, 0x4208, 0x4A49, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0870 (2160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39C7, 0x2965, 0x4208, 0x31A6, 0x39C7, 0x73AE,   // 0x0880 (2176)
+0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B7,   // 0x0890 (2192)
+0x18C3, 0x10A2, 0x4B0B, 0xD699, 0xFFFF, 0xFEDC, 0xFC11, 0xFDF8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08A0 (2208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x738E, 0x4208,   // 0x08B0 (2224)
+0x4208, 0x4208, 0x4A69, 0x528A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x08C0 (2240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0861, 0x10A2, 0x2124, 0x2945, 0x9CF3,   // 0x08D0 (2256)
+0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08E0 (2272)
+0x8C72, 0x0020, 0x0000, 0x39C5, 0xCD55, 0xFEDC, 0xFC73, 0xFE19, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08F0 (2288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x94B2, 0x39E7,   // 0x0900 (2304)
+0x4A49, 0x3186, 0x18E3, 0x31A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0910 (2320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0020, 0x0841, 0xAD55,   // 0x0920 (2336)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0930 (2352)
+0xEF7D, 0x52EB, 0x0020, 0x2881, 0x4904, 0x91A8, 0xF26C, 0xFD96, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0940 (2368)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xAD75, 0x1082,   // 0x0950 (2384)
+0x10A2, 0x0841, 0x0000, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0960 (2400)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0xB5B6,   // 0x0970 (2416)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA514, 0xBDF7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0980 (2432)
+0xFFFF, 0xCE79, 0x41E7, 0x4924, 0x79C7, 0xA926, 0xE928, 0xF2AC, 0xFCF4, 0xFEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0990 (2448)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xB596, 0xEF7D, 0xFFFF, 0xFFFF, 0xBDD7, 0x0000,   // 0x09A0 (2464)
+0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x09B0 (2480)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0xCE59,   // 0x09C0 (2496)
+0xFFFF, 0xFFFF, 0xFFFF, 0x9CD3, 0xAD55, 0xB596, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09D0 (2512)
+0xFFFF, 0xFFFF, 0xBD35, 0x69A6, 0xC32D, 0xFB0F, 0xC844, 0xEA6B, 0xEB8E, 0x89C7, 0x5AEA, 0x73EF, 0x7C30, 0x8470, 0x9D14, 0xBDF7,   // 0x09E0 (2528)
+0xD6BA, 0xE71C, 0xEF5D, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xA514, 0xA534, 0xFFFF, 0xFFFF, 0xC618, 0x0000,   // 0x09F0 (2544)
+0x0000, 0x0000, 0x0020, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0A00 (2560)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0xD69A,   // 0x0A10 (2576)
+0xFFFF, 0xFFFF, 0xFFFF, 0x8C51, 0xD6BA, 0x9492, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A20 (2592)
+0xFFFF, 0xFFFF, 0xFF9E, 0xC451, 0xE3F1, 0xDA4B, 0xB001, 0xD9A9, 0xFB6E, 0x7125, 0x0000, 0x10C3, 0x0000, 0x0000, 0x0040, 0x10C2,   // 0x0A30 (2608)
+0x2104, 0x2945, 0x2965, 0x31A6, 0x4208, 0x62EB, 0x9CF3, 0xE73C, 0xFFFF, 0xE73C, 0x8C71, 0xBDD7, 0xFFFF, 0xFFFF, 0xCE79, 0x0000,   // 0x0A40 (2624)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0A50 (2640)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x0020, 0x0000, 0x0000, 0x0000, 0xD6BA,   // 0x0A60 (2656)
+0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xDEDB, 0x528A, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A70 (2672)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFEBB, 0xE411, 0xB188, 0xA822, 0xD947, 0xEA2A, 0x6042, 0x0820, 0x1924, 0x10A2, 0x2925, 0x39C7, 0x4A69,   // 0x0A80 (2688)
+0x630C, 0x6B4D, 0x6B6D, 0x7BCF, 0x8430, 0x9CF3, 0xC618, 0xF79E, 0xFFFF, 0xF7BE, 0xAD75, 0x8430, 0xFFFF, 0xFFFF, 0xCE79, 0x0000,   // 0x0A90 (2704)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0AA0 (2720)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0xCE79,   // 0x0AB0 (2736)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDF7, 0xA534, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0AC0 (2752)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFBF, 0xED76, 0xBA6A, 0xB125, 0xD9E8, 0xE2AB, 0xBB4D, 0xAD13, 0xB5B6, 0xBDD7, 0xCE59, 0xD6BA, 0xE73D,   // 0x0AD0 (2768)
+0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xA534, 0xAD55, 0xFFFF, 0xFFFF, 0xC638, 0x0000,   // 0x0AE0 (2784)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0AF0 (2800)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0xBDF7,   // 0x0B00 (2816)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B10 (2832)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF9E, 0xEE17, 0xE535, 0xED75, 0xFE59, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B20 (2848)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0xCE59, 0xFFFF, 0xFFFF, 0xFFDF, 0xA534, 0x0000,   // 0x0B30 (2864)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0B40 (2880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0020, 0x0000, 0x0000, 0x0000, 0xA514,   // 0x0B50 (2896)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B60 (2912)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B70 (2928)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x9CD3, 0x0000,   // 0x0B80 (2944)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0B90 (2960)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x7BCF,   // 0x0BA0 (2976)
+0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0BB0 (2992)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0BC0 (3008)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x8410, 0x0000,   // 0x0BD0 (3024)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0BE0 (3040)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x4208,   // 0x0BF0 (3056)
+0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C00 (3072)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C10 (3088)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x39C7, 0x0000,   // 0x0C20 (3104)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0C30 (3120)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841,   // 0x0C40 (3136)
+0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xCE59, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C50 (3152)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C60 (3168)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC638, 0x0000, 0x0000,   // 0x0C70 (3184)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0C80 (3200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0C90 (3216)
+0xA534, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x9CF3, 0xBDF7, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CA0 (3232)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CB0 (3248)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0x9CF3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x9CD3, 0x0000, 0x0000,   // 0x0CC0 (3264)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0CD0 (3280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0CE0 (3296)
+0x528A, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x94B2, 0xBDD7, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CF0 (3312)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D00 (3328)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x630C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x528A, 0x0000, 0x0000,   // 0x0D10 (3344)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D20 (3360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D30 (3376)
+0x0841, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xBDF7, 0xB596, 0x94B2, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D40 (3392)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D50 (3408)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xD6BA, 0x9CF3, 0xA534, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0x1082, 0x0000, 0x0000,   // 0x0D60 (3424)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D70 (3440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D80 (3456)
+0x0000, 0x6B6D, 0xF7BE, 0xFFFF, 0xFFFF, 0xF79E, 0xC618, 0xC638, 0xAD55, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D90 (3472)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DA0 (3488)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xDEDB, 0x9CD3, 0x738E, 0xE73C, 0xFFFF, 0xFFFF, 0xF7BE, 0x6B6D, 0x0000, 0x0000, 0x0000,   // 0x0DB0 (3504)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0DC0 (3520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0DD0 (3536)
+0x0000, 0x10A2, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xC638, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DE0 (3552)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DF0 (3568)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0x9CF3, 0xF79E, 0xFFFF, 0xFFFF, 0xBDF7, 0x18C3, 0x0000, 0x0000, 0x0000,   // 0x0E00 (3584)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E10 (3600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E20 (3616)
+0x0000, 0x0000, 0x52AA, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xEF7D, 0xFFFF,   // 0x0E30 (3632)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0E40 (3648)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x4A69, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E50 (3664)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E60 (3680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E70 (3696)
+0x0000, 0x0000, 0x0000, 0xA514, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x9CF3, 0xD69A,   // 0x0E80 (3712)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C,   // 0x0E90 (3728)
+0xDEDB, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x94B2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EA0 (3744)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EB0 (3760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EC0 (3776)
+0x0000, 0x0000, 0x0000, 0x2124, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CD3, 0xBDF7,   // 0x0ED0 (3792)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xA514,   // 0x0EE0 (3808)
+0xB5B6, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EF0 (3824)
+0x0000, 0x0000, 0x0020, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F00 (3840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F10 (3856)
+0x0000, 0x0000, 0x0000, 0x0000, 0x39E7, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xDEDB, 0xEF7D,   // 0x0F20 (3872)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0xB596,   // 0x0F30 (3888)
+0xD6BA, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE59, 0x31A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F40 (3904)
+0x0000, 0x0000, 0x0020, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F50 (3920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F60 (3936)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4A69, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0xCE59, 0xFFFF,   // 0x0F70 (3952)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xE71C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0F80 (3968)
+0xB596, 0xA534, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0x4208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F90 (3984)
+0x0000, 0x0000, 0x0020, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FA0 (4000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FB0 (4016)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0xCE59, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0xD6BA, 0xFFFF,   // 0x0FC0 (4032)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x9492, 0xB596, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C,   // 0x0FD0 (4048)
+0xAD75, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC638, 0x39E7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FE0 (4064)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FF0 (4080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1000 (4096)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39C7, 0xBDD7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1010 (4112)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x7BEF, 0xC618, 0xD6BA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xCE79,   // 0x1020 (4128)
+0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x31A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1030 (4144)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1040 (4160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1050 (4176)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x94B2, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1060 (4192)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0xB5B6, 0xCE59, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1070 (4208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x94B2, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1080 (4224)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1090 (4240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10A0 (4256)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0xB5B6, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x10B0 (4272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xD6BA, 0xBDD7, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x10C0 (4288)
+0xFFFF, 0xEF7D, 0xB5B6, 0x528A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10D0 (4304)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10E0 (4320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10F0 (4336)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x6B4D, 0xBDD7, 0xE71C, 0xFFFF,   // 0x1100 (4352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB,   // 0x1110 (4368)
+0xB5B6, 0x6B4D, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1120 (4384)
+0x0000, 0x0000, 0x0020, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1130 (4400)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1140 (4416)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x52AA, 0x9CF3,   // 0x1150 (4432)
+0xC618, 0xDEDB, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xDEFB, 0xC618, 0x94B2, 0x4A69,   // 0x1160 (4448)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1170 (4464)
+0x0000, 0x0020, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1180 (4480)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0841, 0x0000, 0x0000, 0x0000,   // 0x1190 (4496)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11A0 (4512)
+0x0000, 0x39E7, 0x738E, 0x9CF3, 0xB596, 0xB5B6, 0xBDD7, 0xBDD7, 0xBDD7, 0xAD75, 0x9492, 0x738E, 0x4208, 0x0000, 0x0000, 0x0000,   // 0x11B0 (4528)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11C0 (4544)
+0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11D0 (4560)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0020, 0x0000, 0x0000,   // 0x11E0 (4576)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11F0 (4592)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1200 (4608)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1210 (4624)
+0x0000, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1220 (4640)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000,   // 0x1230 (4656)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1240 (4672)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1250 (4688)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x1260 (4704)
+0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1270 (4720)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0861,   // 0x1280 (4736)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1290 (4752)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12A0 (4768)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0861,   // 0x12B0 (4784)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12C0 (4800)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3,   // 0x12D0 (4816)
+0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12E0 (4832)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12F0 (4848)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x1082, 0x0020, 0x0000,   // 0x1300 (4864)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1310 (4880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1320 (4896)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1330 (4912)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1340 (4928)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x18E3, 0x0841, 0x0000, 0x0000, 0x0000,   // 0x1350 (4944)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1360 (4960)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1370 (4976)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1380 (4992)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1390 (5008)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13A0 (5024)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13B0 (5040)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13C0 (5056)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13D0 (5072)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13E0 (5088)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13F0 (5104)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1400 (5120)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1410 (5136)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1420 (5152)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1430 (5168)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1440 (5184)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1450 (5200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1460 (5216)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1470 (5232)
+0x0000, 0x0000, 0x10A2, 0x2945, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2945, 0x10A2, 0x0000, 0x0000,   // 0x1480 (5248)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1490 (5264)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14A0 (5280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14B0 (5296)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x2124, 0x0861, 0x0000, 0x10A2,   // 0x14C0 (5312)
+0x2945, 0x0861, 0x9CF3, 0xFFFF, 0x7BEF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7BEF, 0xFFFF, 0xA514, 0x0000, 0x0000,   // 0x14D0 (5328)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14E0 (5344)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14F0 (5360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1500 (5376)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xBDD7, 0xFFFF, 0x5ACB, 0x1082, 0xBDF7,   // 0x1510 (5392)
+0xFFFF, 0x4A49, 0x8410, 0xFFFF, 0x738E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x738E, 0xFFFF, 0x9492, 0x0000, 0x0000,   // 0x1520 (5408)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1530 (5424)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1540 (5440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1550 (5456)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0x52AA, 0xAD55, 0xF7BE,   // 0x1560 (5472)
+0x4A69, 0x0000, 0x94B2, 0xFFFF, 0x738E, 0x0000, 0x0861, 0x2104, 0x2104, 0x0861, 0x0000, 0x738E, 0xFFFF, 0x9492, 0x0020, 0x2104,   // 0x1570 (5488)
+0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1580 (5504)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1590 (5520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15A0 (5536)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD55, 0xFFFF, 0xFFFF, 0xF7BE, 0x4A49,   // 0x15B0 (5552)
+0x0000, 0x0000, 0x94B2, 0xFFFF, 0x6B6D, 0x0861, 0x9CF3, 0xFFFF, 0xFFFF, 0x9CF3, 0x0861, 0x738E, 0xFFFF, 0x8C71, 0x6B4D, 0xFFFF,   // 0x15C0 (5568)
+0x9CD3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15D0 (5584)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15E0 (5600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15F0 (5616)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0xFFFF, 0x528A, 0x0000,   // 0x1600 (5632)
+0x0000, 0x0000, 0x94B2, 0xFFFF, 0x52AA, 0x7BCF, 0xFFFF, 0x5ACB, 0x5ACB, 0xFFFF, 0x7BCF, 0x52AA, 0xFFFF, 0xFFFF, 0xFFFF, 0x8430,   // 0x1610 (5648)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1620 (5664)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1630 (5680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1640 (5696)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0xFFFF, 0x6B6D, 0x0020,   // 0x1650 (5712)
+0x0000, 0x0000, 0x94B2, 0xFFFF, 0x5ACB, 0x738E, 0xFFFF, 0x632C, 0x632C, 0xFFFF, 0x738E, 0x5ACB, 0xFFFF, 0xFFFF, 0x8C71, 0x0000,   // 0x1660 (5728)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1670 (5744)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1680 (5760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1690 (5776)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD55, 0xFFFF, 0xF79E, 0xFFFF, 0x738E,   // 0x16A0 (5792)
+0x0841, 0x0000, 0x94B2, 0xFFFF, 0x5ACB, 0x738E, 0xFFFF, 0x632C, 0x632C, 0xFFFF, 0x738E, 0x52AA, 0xFFFF, 0xFFFF, 0x9CF3, 0x0841,   // 0x16B0 (5808)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16C0 (5824)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16D0 (5840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16E0 (5856)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0x31A6, 0x8410, 0xFFFF,   // 0x16F0 (5872)
+0x73AE, 0x0020, 0x9492, 0xFFFF, 0x5ACB, 0x6B4D, 0xFFDF, 0x738E, 0x738E, 0xFFDF, 0x6B6D, 0x5ACB, 0xFFFF, 0xFFDF, 0xFFDF, 0xAD55,   // 0x1700 (5888)
+0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1710 (5904)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1720 (5920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1730 (5936)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xA514, 0xF79E, 0x52AA, 0x0000, 0x9492,   // 0x1740 (5952)
+0xFFDF, 0x4A69, 0x7BCF, 0xF79E, 0x6B6D, 0x0000, 0x73AE, 0xFFDF, 0xFFDF, 0x73AE, 0x0000, 0x6B6D, 0xF79E, 0x738E, 0x4208, 0xF7BE,   // 0x1750 (5968)
+0x9CF3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1760 (5984)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1770 (6000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1780 (6016)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1790 (6032)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17A0 (6048)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17B0 (6064)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17C0 (6080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17D0 (6096)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17E0 (6112)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17F0 (6128)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1800 (6144)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1810 (6160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1820 (6176)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1830 (6192)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1840 (6208)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1850 (6224)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1860 (6240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1870 (6256)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1880 (6272)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1890 (6288)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18A0 (6304)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18B0 (6320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18C0 (6336)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18D0 (6352)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18E0 (6368)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18F0 (6384)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1900 (6400)
+};

_718/l.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: l.jpg
+// Time generated: 12.04.2014 22:14:24
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short l[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x18FF, 0x213F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x191D, 0x291F, 0x211E, 0x20FF, 0x211F, 0x193F, 0x191F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x20FF,   // 0x0030 (48)
+0x10FF, 0x191F, 0x18FF, 0x18FF, 0x20DF, 0x20FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10DD, 0x10BF, 0x10DF,   // 0x0050 (80)
+0x10DF, 0x10BF, 0x10BF, 0x189F, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x085F, 0x087F, 0x087F, 0x105E, 0x087F, 0x107F, 0x087F, 0x007E, 0x087E,   // 0x0070 (112)
+0x087F, 0x109F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x083F, 0x085F, 0x085F, 0x083F, 0x103F, 0x001F, 0x081F, 0x105F, 0x001E, 0x103F, 0x083F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F, 0x005F, 0x003E, 0x101F, 0xF7DF, 0xF7DF, 0xF7FD, 0x081F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0xFFDF, 0xFFBF, 0xFFFF, 0xF79F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x003F, 0x18FF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFE, 0xF7DF, 0x081E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003E, 0x001F, 0x081F, 0x001F, 0x20FF, 0xFFBF,   // 0x0100 (256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7DD, 0x081F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0110 (272)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x083F, 0x001E, 0x001F, 0x001F, 0x001F, 0x293F, 0xF7DD, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0120 (288)
+0xF7FF, 0x081F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0130 (304)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39BF, 0xF7DE, 0xFFFF, 0xFFDF, 0xFF9F, 0xF7FF, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001E, 0x081E, 0xFFBF, 0xFFFE, 0xFFFF, 0xFFDF, 0xFFFF, 0x081F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001F, 0x003E, 0x001F, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0x081F, 0x001F, 0x001E, 0x001E, 0x001F, 0x003F, 0x003E, 0x001E,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFDF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x003F, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xFFFF, 0x081F, 0x001E, 0x001F, 0x001F, 0x001E, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xEFDF,   // 0x01D0 (464)
+0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x081E,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x081F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF, 0xF7FF, 0xFFFF, 0x001F, 0x001E,   // 0x0210 (528)
+0x001F, 0x003F, 0x001E, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0x001F, 0x003F, 0x001E,   // 0x0230 (560)
+0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E, 0x001F, 0xF7BD, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x001F, 0x003F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x083F, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001E, 0x001E, 0x001F, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFF9F, 0xFFDE, 0xFF9E, 0xFF9F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x001F, 0x003F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x001F, 0x081F, 0xF7DE, 0xFFDE, 0xFFBF, 0xFFBE, 0xFFBF, 0x003E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x081E, 0xFFDF, 0xFFDD, 0xF7BF, 0xFFBF, 0x081F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0xF7BF, 0xFFBE, 0xF79E, 0x001F, 0x003F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x001E,   // 0x0300 (768)
+0x003C, 0x001E, 0x003D, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x083D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001E, 0x001D, 0x001D, 0x001E, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001A, 0x001C, 0x001C, 0x001A, 0x001C,   // 0x0340 (832)
+0x001A, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x0019, 0x001B, 0x001A, 0x0018, 0x001A, 0x0019, 0x0019,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0018, 0x0039, 0x0018, 0x0019, 0x0019, 0x0019, 0x0018, 0x001A, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_718/left.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: l.jpg
+// Time generated: 12.04.2014 22:14:24
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short le[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x18FF, 0x213F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x191D, 0x291F, 0x211E, 0x20FF, 0x211F, 0x193F, 0x191F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x20FF,   // 0x0030 (48)
+0x10FF, 0x191F, 0x18FF, 0x18FF, 0x20DF, 0x20FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10DD, 0x10BF, 0x10DF,   // 0x0050 (80)
+0x10DF, 0x10BF, 0x10BF, 0x189F, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x085F, 0x087F, 0x087F, 0x105E, 0x087F, 0x107F, 0x087F, 0x007E, 0x087E,   // 0x0070 (112)
+0x087F, 0x109F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x083F, 0x085F, 0x085F, 0x083F, 0x103F, 0x001F, 0x081F, 0x105F, 0x001E, 0x103F, 0x083F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F, 0x005F, 0x003E, 0x101F, 0xF7DF, 0xF7DF, 0xF7FD, 0x081F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0xFFDF, 0xFFBF, 0xFFFF, 0xF79F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x003F, 0x18FF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFE, 0xF7DF, 0x081E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003E, 0x001F, 0x081F, 0x001F, 0x20FF, 0xFFBF,   // 0x0100 (256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7DD, 0x081F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0110 (272)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x083F, 0x001E, 0x001F, 0x001F, 0x001F, 0x293F, 0xF7DD, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0120 (288)
+0xF7FF, 0x081F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0130 (304)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39BF, 0xF7DE, 0xFFFF, 0xFFDF, 0xFF9F, 0xF7FF, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001E, 0x081E, 0xFFBF, 0xFFFE, 0xFFFF, 0xFFDF, 0xFFFF, 0x081F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001F, 0x003E, 0x001F, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0x081F, 0x001F, 0x001E, 0x001E, 0x001F, 0x003F, 0x003E, 0x001E,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFDF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x003F, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xFFFF, 0x081F, 0x001E, 0x001F, 0x001F, 0x001E, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xEFDF,   // 0x01D0 (464)
+0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x081E,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x081F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF, 0xF7FF, 0xFFFF, 0x001F, 0x001E,   // 0x0210 (528)
+0x001F, 0x003F, 0x001E, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0x001F, 0x003F, 0x001E,   // 0x0230 (560)
+0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E, 0x001F, 0xF7BD, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x001F, 0x003F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x083F, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001E, 0x001E, 0x001F, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFF9F, 0xFFDE, 0xFF9E, 0xFF9F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x001F, 0x003F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x001F, 0x081F, 0xF7DE, 0xFFDE, 0xFFBF, 0xFFBE, 0xFFBF, 0x003E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x081E, 0xFFDF, 0xFFDD, 0xF7BF, 0xFFBF, 0x081F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0xF7BF, 0xFFBE, 0xF79E, 0x001F, 0x003F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x001E,   // 0x0300 (768)
+0x003C, 0x001E, 0x003D, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x083D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001E, 0x001D, 0x001D, 0x001E, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001A, 0x001C, 0x001C, 0x001A, 0x001C,   // 0x0340 (832)
+0x001A, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x0019, 0x001B, 0x001A, 0x0018, 0x001A, 0x0019, 0x0019,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0018, 0x0039, 0x0018, 0x0019, 0x0019, 0x0019, 0x0018, 0x001A, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_718/m.c

@@ -0,0 +1 @@
+

_718/menu.ino

@@ -0,0 +1,419 @@
+//********************************************************************************
+void menu()
+{
+
+  
+    byte bait;
+byte bait1;
+byte bait2;
+byte bait3;
+//long address;
+int i;
+  int w;
+  int w1;
+  int w2;
+  int q=0;
+  int x,y;
+  if( t.hour<7 )
+{night=1;
+}
+else
+{night=0;
+}
+    myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+  delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("33.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (i =0 ; i < 96000; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>399){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, 2*m, 400, 1, pic1, 2);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+
+ 
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+ myGLCD.setFont(BigFont);
+
+
+ 
+  myGLCD.setColor(255, 255, 255);
+  
+     myGLCD.drawBitmap (100, 100, 80, 80, flr);
+    myGLCD.drawRoundRect (100, 100, 180, 180);// fl
+    
+     myGLCD.drawBitmap (100, 190, 80, 80, dom1);//******************************
+    myGLCD.drawRoundRect (100, 190, 180, 270);// dom1
+    
+   myGLCD.drawBitmap (10, 10, 80, 80, aandelen);
+    myGLCD.drawRoundRect (10, 10, 90, 90);// Aandelend
+    
+    myGLCD.drawBitmap (100, 10, 80, 80, clokk);
+    myGLCD.drawRoundRect (100, 10, 180, 90);// internet
+    
+    myGLCD.drawBitmap (10, 100, 80, 80,ints);
+    myGLCD.drawRoundRect (10, 100, 90, 180); //Radio
+    
+    myGLCD.drawBitmap (10, 190, 80, 80,wer);
+   myGLCD.drawRoundRect (10, 190, 90, 270); //Klok 
+   
+   
+    myGLCD.drawBitmap (10, 280, 80, 80, fotos);
+    myGLCD.drawRoundRect (10, 280, 90, 360); //Foto 
+    
+    myGLCD.drawBitmap (10, 370, 80, 80, instellingen);
+     myGLCD.drawRoundRect (10, 370, 90, 450); //Install 
+     
+      myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+     
+     myGLCD.drawBitmap (769, 449, 30, 30, jar);
+    myGLCD.drawRoundRect (769, 449, 769+30, 449+30);// яркость
+  kalend();
+clc();
+  c=0; 
+  
+    while(1)
+{ 
+  if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      
+         if ((x>=769) && (x<=799))  // Upper row
+      {
+        
+        if ((y>=449) && (y<=479))  // яркость
+          {
+            waitForIt1(769, 449, 799, 479);
+            bright();
+             menu();
+          }
+      } 
+      
+      if ((x>=100) && (x<=180))  // Upper row
+      {
+          if ((y>=10) && (y<=90))  // Aandelend
+        {waitForIt1(100, 10, 180, 90);
+        
+        intime();
+        menu();
+        // grafik();
+        //paint();
+        
+        }
+        
+        if ((y>=100) && (y<=180))  //Radio
+        {waitForIt1(100, 100, 180, 180);
+        //radio2();
+        flower();
+        menu();
+       
+        }
+        
+        if ((y>=190) && (y<=270))  //HOME
+        {waitForIt1(100, 190, 180, 270);
+        //radio2();
+        initial();
+        home1();
+        menu();
+       
+        }
+      }
+      
+      if ((x>=10) && (x<=90))  // Upper row
+      {
+        
+        if ((y>=10) && (y<=90))  // Aandelend
+        {waitForIt1(10, 10, 90, 90);
+        initial();
+         grafik();
+        //paint();
+        
+        }
+        
+         if ((y>=100) && (y<=180))  //Radio
+        {waitForIt1(10, 100, 90, 180);
+        //radio2();
+        internet();
+        menu();
+       
+        }
+        
+          if ((y>=190) && (y<=270))  //(10, 190, 90, 270); //Klok 
+        {waitForIt1(10, 190, 90, 270);
+        initial();
+        pogoda();
+        
+        }
+        
+          if ((y>=280) && (y<=360))  //(10, 280, 90, 360); //Foto 
+        {
+          waitForIt1(10, 280, 90, 360);
+          initial();
+        raw();
+        }
+        
+          if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Install 
+        {waitForIt1(10, 370, 90, 450);
+       sdlist();
+       menu();
+        }
+     }    
+    
+    
+    if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            menu();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+         vrem();
+          clok();
+        }
+      } 
+        
+    }
+
+ 
+ //***************************************** 
+  
+t = rtc.getTime();
+ // sec=t.sec;
+ if (raw1==0)
+ {raw1=1;
+ raw();
+ }
+if (t.sec==0)
+{
+delay(800);
+clc();
+}
+if ((t.sec==5) || (t.sec==20) || (t.sec==35)|| (t.sec==50))
+{  
+   priem();
+}
+ if ((t.sec==14) || (t.sec==42) )
+{
+dtu21();
+
+ bmp085();
+ 
+ uart();
+ }
+ 
+
+ 
+}
+
+
+
+}
+//*******************************************************************************
+void kalend()
+{
+byte bait;
+byte bait1;
+
+//long address;
+
+  int w;
+  int i;
+  int q=0;
+ // char* S1[]={"fam1.txt","fam.txt","fam2.txt","fam3.txt"};
+
+  
+
+
+ 
+ 
+myFile.open("Kalendar.raw", O_READ);
+  
+int n=0;
+int m=0;
+//160*160=25600
+   for (i =0 ; i < 25600; i = i++) {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>159){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (640, m, 160, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close();
+ }
+//************************************************************************************ 
+ 
+void clc() 
+{ char* strm[] = {" JAN","FEBR","MARCH","APRIL"," MAY","JUNE","JULY"," AUG","SEPT"," OCT"," NOV"," DEC"};
+  int cx=640;
+  int cy=383;
+  int month1;
+//**********CLOK*******************************************************************************
+ myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,38,92);
+myGLCD.setFont( SevenSegNumFont);
+ t = rtc.getTime();
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,cx, cy);
+    myGLCD.printNumI(t.hour, cx+32, cy);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,cx, cy);
+  }
+  myGLCD.print(":",cx+64, cy);
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,cx+96, cy);
+    myGLCD.printNumI(t.min, cx+128, cy);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, cx+96, cy);
+  }
+  myGLCD.setFont( Ubuntubold);
+  //myGLCD.setFont(BigFont);
+  
+  myGLCD.setColor(0,0,155);
+  myGLCD.setBackColor(255,114,0);
+  month1=t.mon;
+   myGLCD.print(strm[month1-1], 663, 18);
+   
+// **********WIFI work ********************************************************************
+if(t.hour>7)
+{
+ if (t.min==7)  
+  {if (fwifi==1)
+     {fwifi=0;
+      internet();
+     }
+  } 
+  if (wifi>0) //если была ошибка подключения
+  {if (t.min==23)
+     {
+          internet();
+         
+      } 
+  }
+}  
+
+ //**************************опрос всех датчиков каждый час и запись всех данных в massiv 23:00 ******************
+ if (t.min==0)
+ {
+
+  //  printmassiv();
+  if (fsec==1)
+  {uart();
+  bmp085();
+  uart();
+  savemastd();//запись данных датчиков в рабочий массив
+  
+   digitalWrite(53, LOW);//reset NRF
+ delay(100);
+ digitalWrite(53, HIGH);
+ 
+  fsec=0;  //delay (300);
+  if(t.hour==23)
+  {sdwrite();//запись данных в файлы по месяцам и дням  директориии улица и дом Temul i Temdom
+   savemasclok();//запись времени на sd 12:56 15/05/14 и массива rab
+     saveminmax();//запись макс  мин и средних значений датчиков за день
+  } 
+  
+   if((t.hour>=0)||(t.hour<23))
+  {
+   savemasclok();//запись времени на sd 12:56 15/05/14 и массива rab
+  } 
+
+  
+  }   
+  
+}
+
+ if (t.min>30)
+ {fsec=1;
+  fwifi=1;
+ }
+ //*****************************************************************    
+
+//  myGLCD.print(rtc.getDOWStr(FORMAT_SHORT), 256+450, 8);
+myGLCD.setFont( SevenSegNumFont);
+ myGLCD.setColor(0,0,155);
+  myGLCD.setBackColor(255,255,255);
+  if (t.date<10)
+    myGLCD.printNumI(t.date, 710, 56);
+  else
+    myGLCD.printNumI(t.date, 695, 56);
+   // myGLCD.setFont(BigFont);
+   // myGLCD.setBackColor(180,180,180);
+   myGLCD.setFont( Ubuntubold);
+   dow= t.dow;
+   myGLCD.print(str[dow-1], 690,110);
+ /// myGLCD.printNumI(rtc_clock.get_months(), 695, 122);
+ myGLCD.setFont(BigFont);
+  myGLCD.setBackColor(180,180,180);
+  myGLCD.printNumI(t.year, 694, 143);
+
+   
+myGLCD.setBackColor(0,0,55);
+
+}
+
+void waitForIt1(int x1, int y1, int x2, int y2)
+{
+  myGLCD.setColor(255, 232, 13);
+  myGLCD.drawRoundRect (x1, y1, x2, y2);
+  while (myTouch.dataAvailable())
+    myTouch.read();
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect (x1, y1, x2, y2);
+}

_718/mi.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: -.jpg
+// Time generated: 12.04.2014 22:13:44
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short mi[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF,   // 0x0030 (48)
+0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF,   // 0x0050 (80)
+0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F,   // 0x0070 (112)
+0x087F, 0x087F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0013, 0x0017, 0x0019, 0x0019, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0016, 0x0017,   // 0x0110 (272)
+0x0018, 0x001D, 0x001D, 0x001E, 0x001F, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0120 (288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0017, 0x0018, 0x001C,   // 0x0130 (304)
+0x001E, 0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0015, 0x0019, 0x001B, 0x001D, 0x001D,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001E, 0x005F, 0x001F, 0x081E,   // 0x0170 (368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0016, 0x0019, 0x001A, 0x001D, 0x001F, 0x001D, 0xF7FF, 0xFFFF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0018, 0x0018, 0x001C, 0x001F, 0x001E, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001D, 0x001F, 0x081F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01D0 (464)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0210 (528)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E,   // 0x0300 (768)
+0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B,   // 0x0340 (832)
+0x001B, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_718/nightgraf.ino

@@ -0,0 +1,233 @@
+void nightgraf()
+{
+  
+ mon1=t.mon;
+ years1=t.year;
+ days1=t.date;
+ 
+    myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(0, 0, 635, 475);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(0, 0, 635, 475);//прямоугольник с  обводкой
+  
+  pikgrafik();
+  colorgraf=0;
+  picgraftoday();
+  myGLCD.setFont( SevenSegNumFont);//myGLCD.setFont(BigFont);Ubuntubold
+  myGLCD.setBackColor( VGA_TRANSPARENT);
+  
+   myGLCD.setColor(255,242, 0);
+  myGLCD.printNumI(pressure,430,205);// myGLCD.print(":",cx+32+32, cy);
+    myGLCD.setFont( Ubuntubold); 
+    myGLCD.print("MM",430+103, 205+24);
+    
+    
+    //*********TEMPUL**************************************    
+    //  myGLCD.setColor(255,142,21);
+      myGLCD.setColor(VGA_WHITE);
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+ if (zn<2)
+ {myGLCD.print("-",420, 65+8);
+ }
+ else
+ {myGLCD.print("+",420, 65+8);
+ }
+ 
+ myGLCD.print(",",420+88, 65+24);
+ myGLCD.print("C",420+88+20+32+10, 68);
+ 
+  myGLCD.setFont( SevenSegNumFont);
+  if (tu<10)
+ { myGLCD.printNumI(tu,420+24+32,65);// myGLCD.print(":",cx+32+32, cy);
+ }
+ else
+ {myGLCD.printNumI(tu,420+24,65);
+ }
+ myGLCD.printNumI(tud,420+88+20,65);    
+//*********HUG**************************************     
+  myGLCD.setColor(129,239,255);
+  
+ myGLCD.setBackColor( VGA_TRANSPARENT);    
+  myGLCD.setFont( Ubuntubold);
+ myGLCD.print(",",420+88, 300+24); 
+ myGLCD.print("%",420+88+20+32+10, 300+24); 
+ myGLCD.setFont( SevenSegNumFont);
+ myGLCD.printNumI(hu,420+24,300);
+ myGLCD.printNumI(hud,420+88+20,300);
+//*************tdom*******************************    
+   myGLCD.setColor(5,252,46);
+ 
+  myGLCD.setFont( Ubuntubold);
+ myGLCD.print("+",420, 395+8); 
+myGLCD.print(",",420+88, 395+27);
+ myGLCD.print("C",420+88+20+32+10, 395); 
+  myGLCD.setFont( SevenSegNumFont);
+ myGLCD.printNumI(tdc,420+24,395);
+ //int tem = temperatur;
+ myGLCD.printNumI(tdd,420+88+20,395);
+ myGLCD.setBackColor( VGA_TRANSPARENT); 
+ //*********************min max************************************************
+ // myGLCD.setBackColor(8,101,192); 
+  myGLCD.setColor(255, 55, 55);
+  myGLCD.setFont(BigFont);
+  int px=430;
+  int py=80+50;
+   byte hh;
+  byte mm;
+  byte d;
+  byte m;
+  word y;
+  //*************max****************************************
+  d=time1[24]/1000;
+  m=(time1[24]%1000)/10;
+  y=((time1[24]%1000)%10)*10;
+  hh=time1[25]/1000;
+  mm=(time1[25]%1000)/10;
+   y=y+((time1[25]%1000)%10);
+      myGLCD.setBackColor(255,255,255); 
+  myGLCD.print("Tmax=+" ,px, py);
+   myGLCD.printNumI(temul[24]/10, px+16*6, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(temul[24]%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+     
+      myGLCD.setBackColor( VGA_TRANSPARENT); 
+      myGLCD.print(":" ,px-4+16*2, py+16);
+     if(hh<10)
+     { myGLCD.print("0" ,px, py+16);
+       myGLCD.printNumI(hh, px+16, py+16);
+     }
+    else 
+     {myGLCD.printNumI(hh, px, py+16);
+     }
+  //myGLCD.print(":" ,px+16*2, py+16);
+  
+   if(mm<10)
+     { myGLCD.print("0" ,px+16*3-8, py+16);
+       myGLCD.printNumI(mm, px+16*4-8, py+16);
+     }
+    else 
+     {myGLCD.printNumI(mm, px+16*3-8, py+16);
+     }
+ // myGLCD.print(" " ,px+16*5, py+16);
+  myGLCD.print("." ,px+16*7-4, py+16);
+  if(d<10)
+     { myGLCD.print("0" ,px+16*5, py+16);
+       myGLCD.printNumI(d, px+16*6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(d, px+16*5, py+16);
+     }
+  
+   myGLCD.print("." ,px+16*10-10, py+16);
+  if(m<10)
+     { myGLCD.print("0" ,px+16*8-6, py+16);
+       myGLCD.printNumI(m, px+16*9-6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(m, px+16*8-6, py+16);
+     }
+ // myGLCD.print("." ,px+16*11-12, py+16);
+  
+  myGLCD.printNumI(y, px+16*11-14, py+16);
+ 
+//*************min ***********************************************
+  myGLCD.setColor(55, 55, 255);
+  myGLCD.setBackColor(255,255,255); 
+ d=time1[26]/1000;
+  m=(time1[26]%1000)/10;
+  y=((time1[26]%1000)%10)*10;
+  hh=time1[27]/1000;
+  mm=(time1[27]%1000)/10;
+   y=y+((time1[27]%1000)%10);
+  int Tm; 
+  py=py+35;
+    if (temul[25]>1000)
+       {   Tm=temul[25]-1000;
+       
+        if(Tm<100)
+        {myGLCD.print("Tmin= -" ,px, py);
+        }
+        else
+        { myGLCD.print("Tmin=-" ,px, py);
+        }
+       }
+    else
+   {
+    Tm=temul[25];
+     if(Tm<100)
+        {myGLCD.print("Tmin= +" ,px, py);
+        }
+        else
+        { myGLCD.print("Tmin=+" ,px, py);
+        }
+   }
+  
+ if(Tm<100) 
+ { // myGLCD.print(" " ,px+16*6, py);
+   myGLCD.printNumI(Tm/10, px+16*7, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(Tm%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+ }  
+  else
+  { myGLCD.printNumI(Tm/10, px+16*6, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(Tm%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+  }
+     
+     
+      myGLCD.setBackColor( VGA_TRANSPARENT); 
+     myGLCD.print(":" ,px-4+16*2, py+16);
+     if(hh<10)
+     { myGLCD.print("0" ,px, py+16);
+       myGLCD.printNumI(hh, px+16, py+16);
+     }
+    else 
+     {myGLCD.printNumI(hh, px, py+16);
+     }
+ // myGLCD.print(":" ,px+16*2, py+16);
+  
+   if(mm<10)
+     { myGLCD.print("0" ,px+16*3-8, py+16);
+       myGLCD.printNumI(mm, px+16*4-8, py+16);
+     }
+    else 
+     {myGLCD.printNumI(mm, px+16*3-8, py+16);
+     }
+//  myGLCD.print(" " ,px+16*5, py+16);
+   myGLCD.print("." ,px+16*7-4, py+16);
+  if(d<10)
+     { myGLCD.print("0" ,px+16*5, py+16);
+       myGLCD.printNumI(d, px+16*6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(d, px+16*5, py+16);
+     }
+     
+   myGLCD.print("." ,px+16*10-10, py+16);
+  
+  if(m<10)
+     { myGLCD.print("0" ,px+16*8-6, py+16);
+       myGLCD.printNumI(m, px+16*9-6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(m, px+16*8-6, py+16);
+     }
+  
+  myGLCD.printNumI(y, px+16*11-14, py+16);
+ 
+ 
+ 
+    myGLCD.setColor(255, 255, 255);
+  myGLCD.setFont( Ubuntubold);
+  
+ 
+ 
+ 
+ 
+ 
+//delay(8000);
+  
+}

_718/open.c

@@ -0,0 +1,108 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: open.jpg
+// Time generated: 04.05.2014 19:24:37
+// Dimensions    : 40x40 pixels
+// Size          : 3 200 Bytes
+
+const unsigned short open[0x640] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x210A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x527B, 0x93F0, 0xD501, 0xCCC1, 0xD4E0, 0xC4C5,   // 0x0080 (128)
+0x5A9A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18C8, 0x2929, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0xAC4C, 0xD4C1, 0xDD00, 0xDD20, 0xDD40, 0xDD41, 0xDD20, 0xCCE1, 0x525B, 0x001F, 0x001F, 0x001F, 0x001F, 0x10C8, 0x39AE,   // 0x00B0 (176)
+0x0000, 0x2970, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39BD, 0xCCE1, 0xD540, 0xD540, 0xDD21, 0xDD20, 0xD501, 0xDD20,   // 0x00D0 (208)
+0xDD20, 0xC4C7, 0x001F, 0x001F, 0x3193, 0x1086, 0x296F, 0x2124, 0x1922, 0x10C7, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x8352, 0x93AE, 0xA3EB, 0xAC09, 0xB428, 0xB428, 0xB448, 0xB448, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x083F, 0xDD20, 0xDD20, 0xDD21, 0xDD40, 0xE561, 0xE560, 0xE580, 0xE540, 0xA401, 0x41EE, 0x212B, 0x3128, 0x18C3, 0x2965, 0x18E4,   // 0x0100 (256)
+0x3287, 0x10C7, 0x001F, 0x297D, 0x18FE, 0x39BD, 0x001F, 0xD5CE, 0xCD4C, 0xC509, 0xC4E8, 0xC4C6, 0xC4A6, 0xC4A6, 0xC4E6, 0xA3E9,   // 0x0110 (272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10DF, 0xD4E1, 0xDD40, 0xDD40, 0xD500, 0xAC21, 0xBC81, 0x8B60,   // 0x0120 (288)
+0x2901, 0x3164, 0x41E6, 0x39A4, 0x8BC9, 0x0822, 0x7266, 0xCBE5, 0x72C4, 0x08A3, 0x31EA, 0x63B0, 0xA599, 0xC69C, 0xE75E, 0xEF9F,   // 0x0130 (304)
+0xFFDF, 0xFFFE, 0xFFBE, 0xF77C, 0xF75A, 0xEF19, 0xEEF8, 0xEEB6, 0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0xB489, 0xE560, 0x9BC1, 0x2102, 0x10A3, 0x0841, 0x41E6, 0x10A3, 0x5246, 0x8C0A, 0x0841, 0x19E9, 0x73D3, 0xC46C, 0x5204,   // 0x0150 (336)
+0x61A3, 0x2082, 0x39E7, 0x636B, 0x7C51, 0x63F1, 0x6C12, 0xAD12, 0x7476, 0x7CF8, 0xD615, 0xBDD7, 0xADD8, 0xC617, 0xCE58, 0xCE99,   // 0x0160 (352)
+0x087F, 0x10BF, 0x085F, 0x083F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA42D, 0xED60, 0x7B00, 0x738A, 0xACCC, 0x0001, 0x8389,   // 0x0170 (368)
+0x2965, 0x08A2, 0x1903, 0x0000, 0x33F5, 0x7D1A, 0x938B, 0xA343, 0xA2C3, 0x1862, 0x39E2, 0x6B67, 0xEE6F, 0xD56D, 0x9C6D, 0xFE6E,   // 0x0180 (384)
+0xA4CE, 0x6B8E, 0xF5EC, 0xDDC5, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0x003F, 0x001F,   // 0x0190 (400)
+0x001F, 0x8394, 0xE560, 0x7B20, 0x39E6, 0x49E4, 0x0842, 0x3124, 0x7286, 0x4A68, 0x2A45, 0x0820, 0x1A2B, 0x6457, 0xE509, 0xEC03,   // 0x01A0 (416)
+0x6A03, 0x10A3, 0x3183, 0x5AC4, 0xC56A, 0xFEAF, 0xF630, 0xF60F, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5,   // 0x01B0 (432)
+0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5E5, 0xE5C4, 0x003F, 0x001F, 0x001F, 0x4A1C, 0xE540, 0x8B40, 0x0085, 0x2B72, 0x7AF0, 0xD48B,   // 0x01C0 (448)
+0xBBE6, 0xA343, 0x4A24, 0x0021, 0x1988, 0x5436, 0x8348, 0x82C2, 0x49E5, 0x1904, 0x5223, 0x8345, 0xBCC8, 0xF64B, 0xE5C5, 0xE5C4,   // 0x01D0 (464)
+0xE5C5, 0xE5E4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0x003F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x295E, 0xDD22, 0x8300, 0x1148, 0x565F, 0x8C34, 0x938C, 0x6266, 0x61C2, 0x5102, 0x0000, 0x2B31, 0x6CD5, 0x6AC8, 0x6285,   // 0x01F0 (496)
+0xA488, 0xACE9, 0xD588, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5E5, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5,   // 0x0200 (512)
+0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE62A, 0xE62A, 0x003F, 0x001F, 0x001F, 0x001F, 0xCCE8, 0x8300, 0x0947, 0x55FF, 0x6392, 0xD46B,   // 0x0210 (528)
+0xED44, 0xDC24, 0xB406, 0x83A6, 0xB52A, 0xDE0A, 0xE607, 0xEE27, 0xEE27, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4,   // 0x0220 (544)
+0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C4, 0xEDC5, 0xE5E4, 0xE62A, 0xE60A, 0xE62A, 0xE62B, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x9C12, 0x8300, 0x1127, 0x5DFF, 0x4B52, 0x8368, 0xF648, 0xEE47, 0xF624, 0xF625, 0xEDE3, 0xEDC3, 0xE5C4, 0xE5C4,   // 0x0240 (576)
+0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5E5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5,   // 0x0250 (592)
+0xE5C5, 0xE60A, 0xE60A, 0xE62A, 0xE62A, 0xE60A, 0x003F, 0x001F, 0x001F, 0x001F, 0x8BB4, 0x82E0, 0x0927, 0x55FF, 0x4B91, 0xB4E8,   // 0x0260 (608)
+0xF644, 0xEDA1, 0xE5C2, 0xE5A2, 0xE5A2, 0xE5C4, 0xE5C4, 0xEDC4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4,   // 0x0270 (624)
+0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5E9, 0xE609, 0xE60A, 0xE60A, 0xE62A, 0xEE2A, 0xE609, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x5ABA, 0x8300, 0x0927, 0x55BF, 0x6D99, 0xEE26, 0xEDC0, 0xE5C2, 0xE5C2, 0xE5A2, 0xE5C2, 0xE5C5, 0xE5C5, 0xE5C4,   // 0x0290 (656)
+0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xEDE5, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5E7, 0xE5E8, 0xE5E9,   // 0x02A0 (672)
+0xE60A, 0xE62A, 0xEE0B, 0xE60A, 0xE60A, 0xE609, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FF, 0x8300, 0x0927, 0x4DDF, 0x761C, 0xF605,   // 0x02B0 (688)
+0xEDA0, 0xE5C2, 0xEDC2, 0xE5A2, 0xE5A2, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5E5, 0xE5C4,   // 0x02C0 (704)
+0xE5C5, 0xE5C4, 0xE5C4, 0xE5E7, 0xE5E7, 0xE5E8, 0xE5E8, 0xE609, 0xE60A, 0xE60A, 0xE60A, 0xE609, 0xE60A, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x18DF, 0x82E0, 0x0928, 0x55BF, 0x75FC, 0xEE05, 0xEDA1, 0xE5C2, 0xE5C2, 0xEDA2, 0xEDA2, 0xFFFF, 0xFFFF, 0xE5A3,   // 0x02E0 (736)
+0xE5C3, 0xFFFF, 0xFFFE, 0xFFFF, 0xE5C4, 0xE5C5, 0xFFFF, 0xFFFF, 0xFFFF, 0xE5C6, 0xFFFF, 0xE5C7, 0xE5E8, 0xE5E8, 0xFFFF, 0xE60A,   // 0x02F0 (752)
+0xE60A, 0xEE0B, 0xE60A, 0xE609, 0xE5EA, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x72C7, 0x1127, 0x55BF, 0x75FD, 0xEE27,   // 0x0300 (768)
+0xE5A1, 0xE5C2, 0xE5A2, 0xEDA2, 0xFFFE, 0xE5C3, 0xEDA3, 0xFFFF, 0xE5C4, 0xFFFF, 0xE5C4, 0xE5C5, 0xFFFF, 0xE5E5, 0xFFFE, 0xE5E6,   // 0x0310 (784)
+0xE5C7, 0xE5E7, 0xFFFF, 0xFFFF, 0xE5E8, 0xE5E8, 0xFFFE, 0xE60A, 0xE60B, 0xE60A, 0xE5EA, 0xE5EA, 0xE5EA, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x62AF, 0x0926, 0x55DF, 0x95B6, 0xF606, 0xE5A1, 0xEDA2, 0xEDC3, 0xE5A2, 0xFFFF, 0xE5C3, 0xE5C3, 0xFFFF,   // 0x0330 (816)
+0xE5C4, 0xFFFF, 0xE5C5, 0xE5C5, 0xFFFF, 0xE5C5, 0xFFFF, 0xFFDF, 0xE5C7, 0xE5C7, 0xFFFF, 0xE5E7, 0xFFFF, 0xE5E9, 0xFFFF, 0xEDEA,   // 0x0340 (832)
+0xE60A, 0xE5EA, 0xE5EA, 0xE5EA, 0xE5EA, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x41D9, 0x0907, 0x5DDD, 0xAC05, 0xD480,   // 0x0350 (848)
+0xE5E2, 0xE5A2, 0xE5A3, 0xE5E3, 0xFFFE, 0xE5C3, 0xEDC3, 0xFFFF, 0xE5C4, 0xFFFE, 0xFFFF, 0xFFDF, 0xE5C5, 0xE5C5, 0xFFFF, 0xE5C6,   // 0x0360 (864)
+0xE5C6, 0xE5C7, 0xFFFF, 0xE5E8, 0xE5E8, 0xFFDF, 0xFFFF, 0xE5EA, 0xE5EA, 0xDDEA, 0xDDE9, 0xE5EB, 0xE5CA, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x319B, 0x0063, 0x8C8C, 0xC380, 0xCC80, 0xEDC2, 0xEDA2, 0xE5C3, 0xE5C3, 0xFFFF, 0xE5C4, 0xE5C4, 0xFFFF,   // 0x0380 (896)
+0xE5C4, 0xFFFF, 0xE5C5, 0xE5C5, 0xE5C6, 0xE5C5, 0xFFFE, 0xE5C7, 0xE5C7, 0xDDE7, 0xFFFF, 0xE5E8, 0xE5E9, 0xE5EA, 0xFFFF, 0xDDEA,   // 0x0390 (912)
+0xDDA8, 0xDDA7, 0xD5A7, 0xDDCA, 0xDDCA, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295D, 0x6A02, 0xBBA0, 0xBBA0, 0xCC80,   // 0x03A0 (928)
+0xEDC3, 0xE5C2, 0xEDC3, 0xE5C3, 0xE5C3, 0xFFFF, 0xFFFF, 0xE5C4, 0xE5C5, 0xFFFF, 0xE5C5, 0xE5A5, 0xE5C5, 0xE5C6, 0xFFFF, 0xFFFF,   // 0x03B0 (944)
+0xFFFF, 0xDDC7, 0xFFFF, 0xDDC8, 0xDDC8, 0xDDC8, 0xFFFF, 0xD586, 0xD566, 0xD567, 0xD567, 0xD5A9, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0xC3C3, 0xC3A0, 0xBB80, 0xCC81, 0xEDE3, 0xE5C3, 0xEDC3, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4,   // 0x03D0 (976)
+0xE5C5, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C6, 0xE5C7, 0xDDC7, 0xDDC7, 0xE5A7, 0xDDA7, 0xDD86, 0xDD87, 0xD587, 0xD586, 0xD566,   // 0x03E0 (992)
+0xD566, 0xD546, 0xCD47, 0xCD68, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x936F, 0xBB80, 0xBBA0, 0xD4A2,   // 0x03F0 (1008)
+0xEDE3, 0xE5C3, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5A5, 0xE5A5, 0xE5C6, 0xDDC6, 0xDDA6, 0xDD85,   // 0x0400 (1024)
+0xDD85, 0xD565, 0xD585, 0xD566, 0xD586, 0xD566, 0xCD45, 0xCD45, 0xC546, 0xCD26, 0xCD27, 0xBCE6, 0x003F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x6AD7, 0xBB80, 0xBB80, 0xD4A3, 0xEDE4, 0xE5C3, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5,   // 0x0420 (1056)
+0xE5A5, 0xE5A5, 0xE5A5, 0xE5A5, 0xDD84, 0xDD64, 0xDD64, 0xD564, 0xD564, 0xD565, 0xD565, 0xD566, 0xCD46, 0xCD25, 0xC524, 0xC505,   // 0x0430 (1072)
+0xC505, 0xC4E5, 0xA445, 0x5A95, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x293E, 0xBB81, 0xBBA0, 0xD4C4,   // 0x0440 (1088)
+0xEDE4, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5A5, 0xE5C5, 0xE5A5, 0xDD84, 0xDD83, 0xDD83, 0xD563, 0xD563, 0xD564, 0xD544,   // 0x0450 (1104)
+0xD545, 0xD545, 0xCD46, 0xCD46, 0xCD25, 0xC4E4, 0xC4C4, 0xB484, 0x9C06, 0x83AA, 0x39B9, 0x297D, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xB361, 0xBB80, 0xD4E4, 0xEE04, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5A4, 0xDD83, 0xDD83,   // 0x0470 (1136)
+0xDD63, 0xDD63, 0xDD63, 0xD563, 0xD544, 0xD544, 0xD524, 0xD525, 0xCD24, 0xC526, 0xCD26, 0xC504, 0xBCA3, 0xA425, 0x8BA7, 0x73AC,   // 0x0480 (1152)
+0x31BB, 0x215E, 0x089F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA388, 0xBB80, 0xDCE6,   // 0x0490 (1168)
+0xEE05, 0xE5C4, 0xE5C3, 0xE5A3, 0xDD82, 0xDD82, 0xDD63, 0xDD82, 0xD563, 0xD544, 0xD543, 0xD543, 0xCD24, 0xCD24, 0xCD24, 0xC504,   // 0x04A0 (1184)
+0xC525, 0xC4E5, 0xB464, 0x93C5, 0x7B89, 0x31B8, 0x29BD, 0x18FF, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x934E, 0xB360, 0xD507, 0xEE06, 0xE5C3, 0xE582, 0xDD82, 0xDD82, 0xDD62, 0xDD63, 0xD542,   // 0x04C0 (1216)
+0xD543, 0xD523, 0xD523, 0xCD23, 0xC504, 0xC504, 0xC4E4, 0xBCA4, 0xA405, 0x8387, 0x738C, 0x31DB, 0x295E, 0x10BF, 0x001F, 0x001F,   // 0x04D0 (1232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5A79, 0xBB40, 0xD4C7,   // 0x04E0 (1248)
+0xEE27, 0xE5A3, 0xE582, 0xDD62, 0xDD62, 0xDD62, 0xD543, 0xD543, 0xCD23, 0xCD03, 0xC503, 0xC503, 0xC4C4, 0xAC63, 0x8BC6, 0x7369,   // 0x04F0 (1264)
+0x7BD0, 0x29BC, 0x211E, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x317D, 0xB341, 0xCC66, 0xEE28, 0xE583, 0xDD82, 0xDD62, 0xDD42, 0xD542, 0xCD23, 0xCD03,   // 0x0510 (1296)
+0xC503, 0xC4E3, 0xB4A3, 0x9BE4, 0x7B47, 0x738C, 0x31DA, 0x297E, 0x10DF, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0520 (1312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xB363, 0xC405,   // 0x0530 (1328)
+0xEE28, 0xDDA3, 0xDD42, 0xD542, 0xD522, 0xCD03, 0xC502, 0xC4C2, 0xAC23, 0x8386, 0x6B49, 0x73D0, 0x31BC, 0x211E, 0x107F, 0x001F,   // 0x0540 (1344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA3CD, 0xD483, 0xEE09, 0xDD63, 0xD542, 0xD523, 0xCD02, 0xBC83, 0x9BC4, 0x7347,   // 0x0560 (1376)
+0x6B6D, 0x8453, 0x297D, 0x10DF, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0570 (1392)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5A7B, 0xD568,   // 0x0580 (1408)
+0xE609, 0xDD42, 0xD502, 0xAC43, 0x8385, 0x6B29, 0x73D0, 0x31BC, 0x213E, 0x109F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0590 (1424)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7B77, 0x93D0, 0xA403, 0x7B27, 0x6B6D, 0x7C53, 0x297D, 0x18DF, 0x085F,   // 0x05B0 (1456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05C0 (1472)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05D0 (1488)
+0x4217, 0x31F7, 0x31DC, 0x213E, 0x109F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05E0 (1504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0600 (1536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0610 (1552)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0620 (1568)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0630 (1584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+};

_718/paint.ino

@@ -0,0 +1,130 @@
+//***************************************************************************************************
+void paint()
+{
+
+  myGLCD.clrScr();
+    myGLCD.setColor(VGA_WHITE);
+  myGLCD.drawLine(32,0,32,myGLCD.getDisplayYSize()-1);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,0,myGLCD.getDisplayXSize()-32,myGLCD.getDisplayYSize()-1);
+  myGLCD.print("C", myGLCD.getDisplayXSize()-24, 8);
+  myGLCD.print("L", myGLCD.getDisplayXSize()-24, 24);
+  myGLCD.print("E", myGLCD.getDisplayXSize()-24, 40);
+  myGLCD.print("A", myGLCD.getDisplayXSize()-24, 56);
+  myGLCD.print("R", myGLCD.getDisplayXSize()-24, 72);
+  myGLCD.print("+", myGLCD.getDisplayXSize()-24, 136);
+  myGLCD.print("-", myGLCD.getDisplayXSize()-24, 200);
+ // myButtons.drawButton(but7);
+  myGLCD.fillRect(myGLCD.getDisplayXSize()-32,96,myGLCD.getDisplayXSize()-1,128);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,160,myGLCD.getDisplayXSize()-1,160);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,192,myGLCD.getDisplayXSize()-1,192);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,224,myGLCD.getDisplayXSize()-1,224);
+  for (int i=0; i<8; i++)
+  {
+    myGLCD.setColor(colorlist[i]);
+    myGLCD.fillRect(0, (i*30), 24, (((i+1)*30)-1));
+  }
+  drawColorMarkerAndBrushSize(color);
+    int x;
+int y;
+int a=0;
+ do
+  {
+  
+  
+ while (myTouch.dataAvailable() == true)
+ {
+    myTouch.read();
+    x = myTouch.getX();
+    y = myTouch.getY();
+// if ((x>300) and (y>230)) 
+//{a=1;
+//}
+ if ((x<700) and (y>400)) 
+{a=1;
+}
+    if ((x!=-1) and (y!=-1))
+    {
+      if (x>(31+bsize) and (x<myGLCD.getDisplayXSize()-(31+bsize)))
+      {
+        if (bsize==1)
+          myGLCD.drawPixel(x, y);
+        else
+          myGLCD.fillCircle(x, y, bsize);
+      }
+      else
+      {
+        if (x<(30+bsize))
+        {
+          if (y<240)
+          {
+            color = y / 30;
+            drawColorMarkerAndBrushSize(color);
+            while (myTouch.dataAvailable()) {};
+            delay(50);
+         }
+        }
+        else
+        {
+          if (y<96)
+          {
+            myGLCD.setColor(VGA_BLACK);
+            myGLCD.fillRect(33, 0, myGLCD.getDisplayXSize()-33, myGLCD.getDisplayYSize()-1);
+            myGLCD.setColor(colorlist[color]);
+          }
+          if ((y>128) and (y<160))
+          {
+            if (bsize<7)
+            {
+              bsize++;
+              drawColorMarkerAndBrushSize(color);
+              while (myTouch.dataAvailable()) {};
+              delay(50);
+            }
+          }
+          if ((y>160) and (y<192))
+          {
+              bsize=4;
+              drawColorMarkerAndBrushSize(color);
+              while (myTouch.dataAvailable()) {};
+              delay(50);
+          }
+          if ((y>192) and (y<224))
+          {
+            if (bsize>1)
+            {
+              bsize--;
+              drawColorMarkerAndBrushSize(color);
+              while (myTouch.dataAvailable()) {};
+              delay(50);
+            }
+          }
+        }
+        }
+      }
+  }
+  } while (a<1);
+menu();
+}
+
+void drawColorMarkerAndBrushSize(int col)
+
+{
+  myGLCD.setColor(VGA_BLACK);
+  myGLCD.fillRect(25, 0, 31, 239);
+  myGLCD.fillRect(myGLCD.getDisplayXSize()-31, 161, myGLCD.getDisplayXSize()-1, 191);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.drawPixel(25, (col*30)+15);
+  for (int i=1; i<7; i++)
+    myGLCD.drawLine(25+i, ((col*30)+15)-i, 25+i, ((col*30)+15)+i);
+  
+  if (color==1)
+    myGLCD.setColor(VGA_WHITE);
+  else
+    myGLCD.setColor(colorlist[col]);
+  if (bsize==1)
+    myGLCD.drawPixel(myGLCD.getDisplayXSize()-15, 177);
+  else
+    myGLCD.fillCircle(myGLCD.getDisplayXSize()-15, 177, bsize);
+    
+  myGLCD.setColor(colorlist[col]);
+}

_718/pict_radio.ino

@@ -0,0 +1,46 @@
+void pictrad()
+{
+    byte bait;
+byte bait1;
+
+//long address;
+long i;
+  int w;
+  int w1;
+  int w2;
+  int q=0;
+
+    myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+  
+  myFile.open("rad.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (i =0 ; i <  384000; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>799){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 800, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+}

_718/pogoda.ino

@@ -0,0 +1,393 @@
+void pogoda()
+{
+   
+ 
+   myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(VGA_BLUE);
+ myGLCD.setFont(BigFont);
+ myGLCD.fillScr(VGA_BLUE); 
+  kalend();
+
+ //*************************************************************************
+   myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok
+         
+  clc();
+  
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+ info(); 
+ 
+   myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+        myGLCD.setFont( Ubuntubold);
+
+
+//int pos=(10*temperature/90)+42; 
+
+//*****************************************************************************************
+int xtd=10;
+ termdom(xtd);
+int xb=140;
+barometr(xb);
+int xtu=270;
+ termul(xtu);
+
+
+
+
+
+
+//************************************************************************************************************************************************************
+  while(1)
+  {
+    
+    
+     sec=t.sec;
+  //   myGLCD.setColor(VGA_BLUE);
+  //    myGLCD.setBackColor(255,255,255);
+   //     myGLCD.setFont( Ubuntubold); 
+  //   myGLCD.printNumI(sec , 700, 160);
+     
+if ((sec==0) ||(sec==15) || (sec==30) || (sec==45))
+{
+//  myGLCD.setBackColor(0,0,255);
+//      myGLCD.drawBitmap (769, 339, 30, 30, jar);
+   
+    
+delay(800);
+
+clc();
+ bmp085();
+
+    myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+        myGLCD.setFont( Ubuntubold);
+ int tem = tdc*10+tdd;      
+int pos=(10*tem/50); 
+//bar(x,y, pos,l,h);
+barvert(xtd+58,42, pos,10,340);
+
+//bar(x,y, pos,l,h);
+ pos=(100*(pressure-730)/50);
+barbarom(xb+58,42, pos,10,340);  
+int tem1=tdc*10+tdd;
+pos=(10*(tem1+340)/85); 
+//bar(x,y, pos,l,h);
+
+int tempul=tu*10+tud; 
+ pos=(10*(tempul+340)/85); 
+//bar(x,y, pos,l,h);
+barult(xtu+58,42, pos,10,340); 
+//barvert(xtu+58,42, pos,10,340); 
+
+}
+
+ if ((sec==11) || (sec==42) )
+{
+
+ info(); 
+ }
+ 
+ if ((sec==55) || (sec==25) )
+{
+
+ info();  
+
+ } 
+
+
+ //*****************************************************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+     //      myGLCD.setColor(VGA_BLUE);
+   //   myGLCD.setBackColor(255,255,255);
+   //   myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("x=    " , 650, 32);
+  //    myGLCD.printNumI(x , 700, 32);  
+   //   myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("y=    " ,650 , 72);
+    //  myGLCD.printNumI(y , 700, 72); 
+      
+      
+      
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            pogoda();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+         prognoz();
+          menu();
+        }
+      } 
+    }
+
+
+}
+}
+//***************************************************************************************************************************************************
+void termdom(int xtd)// xtd- координата начала вывода term dom по х
+{
+   myFile.open("termd.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 58086; i = i++) {
+    n=n+1;
+byte  bait = myFile.read();
+ 
+byte  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+int w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>125){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (xtd, m+8, 126, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close(); 
+ int tem=tdc*10+tdd;
+int pos=(10*tem/50); 
+//bar(x,y, pos,l,h);
+barvert(xtd+58,42, pos,10,340); 
+ 
+ 
+}
+
+
+void barvert(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(150,150,150);
+    
+    myGLCD.fillRoundRect(x-2, y-2, l+x+2, h+y+2);//рисуем серый пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ if (tdc>27)
+ { myGLCD.setColor(255,50,50);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor( 255,0,0); 
+ }
+ else
+ {
+     myGLCD.setColor(7,120,34);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+     myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+     myGLCD.setBackColor( 7,120,34); 
+ }
+myGLCD.setColor(255,255,255);
+myGLCD.setFont( Ubuntubold);
+//myGLCD.setBackColor( VGA_TRANSPARENT);
+ myGLCD.print("+" , x-48 , 380+30);
+ myGLCD.print("." ,x-48+24+40, 380+30);
+myGLCD.printNumI(tdc, x-48+24, 380+30);
+
+//int tdes=temperatur;
+myGLCD.printNumI(tdd , x-48+24+40+20, 380+30);
+
+  
+}
+//**********************************************************************
+
+
+void barometr(int xb)// xb- координата начала вывода бар по х
+{
+ myFile.open("barometr.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 58086; i = i++) {
+    n=n+1;
+byte  bait = myFile.read();
+ 
+byte  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+int w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>125){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (xb, m+8, 126, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close();   
+//bar(x,y, pos,l,h);
+
+int pos=(100*(pressure-730)/50); 
+barbarom(xb+58,42, pos,10,340);  
+}
+
+
+void barbarom(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(150,150,150);
+    
+    myGLCD.fillRoundRect(x-2, y-2, l+x+2, h+y+2);//рисуем серый пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ if (pressure<743)
+ { myGLCD.setColor(0,70,167);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//син
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor(0,70,167); 
+ }
+      if ((pressure<755)&&(pressure>742))
+ { myGLCD.setColor(60,212,209);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//бир
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor(60,212,209); 
+ }
+       if ((pressure<768)&&(pressure>754))
+ { myGLCD.setColor(230,94,32);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//ор
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor(230,94,32); 
+ }
+
+ if (pressure>767)
+ {
+     myGLCD.setColor(250,221,8);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//ж
+     myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+     myGLCD.setBackColor(250,221,8); 
+ }
+myGLCD.setColor(255,255,255);
+myGLCD.setFont( Ubuntubold);
+myGLCD.printNumI(pressure , x-30,  380+30); 
+//myGLCD.setBackColor( VGA_TRANSPARENT);
+ //myGLCD.print("+" ,20+58 , 380+30);
+
+
+  
+}
+
+
+
+
+
+
+void termul(int xtu)// xtu- координата начала вывода term dom по х
+{
+   myFile.open("termu.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 58086; i = i++) {
+    n=n+1;
+byte  bait = myFile.read();
+ 
+byte  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+int w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>125){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (xtu, m+8, 126, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+
+ 
+
+  // close the file:
+ myFile.close(); 
+int tempul=tu*10+tud; 
+int pos=(10*(tempul+340)/85); 
+//bar(x,y, pos,l,h);
+barult(xtu+58,42, pos,10,340); 
+ 
+ 
+}
+
+//*******************************************************************************************
+void barult(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(150,150,150);
+    
+    myGLCD.fillRoundRect(x-2, y-2, l+x+2, h+y+2);//рисуем серый пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ if (tdc>27)
+ { myGLCD.setColor(255,50,50);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor( 255,0,0); 
+ }
+ else
+ {
+     myGLCD.setColor(7,120,34);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+     myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+     myGLCD.setBackColor( 7,120,34); 
+ }
+myGLCD.setColor(255,255,255);
+myGLCD.setFont( Ubuntubold);
+//myGLCD.setBackColor( VGA_TRANSPARENT);
+ myGLCD.print("+" , x-48 , 380+30);
+ myGLCD.print("." ,x-48+24+40, 380+30);
+myGLCD.printNumI(tu , x-48+24, 380+30);
+
+//int tempul=tu*10+tud; 
+//int tdes=tempul;
+myGLCD.printNumI(tud , x-48+24+40+20, 380+30);
+
+  
+}
+
+
+
+
+
+ //******************************DHT11***********************************
+ 

_718/pr.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: pr.jpg
+// Time generated: 12.04.2014 22:14:34
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short pr[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x211E, 0x211F, 0x18FF, 0x211F, 0x211F, 0x211D, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x10FF, 0x211F, 0x18BF, 0x10FF, 0x18FF, 0x20DF, 0x18DF, 0x18FF, 0x18FF,   // 0x0030 (48)
+0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x109F, 0x10BF, 0x18DF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF,   // 0x0050 (80)
+0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x107F, 0x105F, 0x005E, 0x089F, 0x105F, 0x107F, 0x007F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F,   // 0x0070 (112)
+0x087F, 0x087F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x003F, 0x003F, 0x105F, 0x081F, 0x083E, 0x003F, 0x081F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001E, 0xEFFE,   // 0x00A0 (160)
+0xFFFF, 0xF7FD, 0x081F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF,   // 0x00C0 (192)
+0xF7DF, 0x081F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0xF7FE, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x00E0 (224)
+0xF7FF, 0x20FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001E, 0xF7BF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF,   // 0x0100 (256)
+0x291E, 0x001E, 0x003F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0110 (272)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xF7FF, 0xFFDF, 0xFFFE, 0xFFFF, 0xF7BF, 0x213F,   // 0x0120 (288)
+0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x005F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0130 (304)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x005F, 0x001F, 0xFFFF, 0xFFBF, 0xFFFF, 0xFFFF, 0xF7DF, 0x319F, 0x001F,   // 0x0140 (320)
+0x001F, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xF7FE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFDF, 0x001F, 0x001E, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001E, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFBF, 0xFFFD, 0xF7FE, 0xFFFF, 0x001F, 0x001F, 0x003F, 0x001E,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001E, 0x001F, 0x001F, 0x001E, 0x001E, 0x001D, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01B0 (432)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01D0 (464)
+0x001F, 0x001F, 0x001E, 0xEFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7FF, 0x081F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x003F,   // 0x01F0 (496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F, 0x081F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFE,   // 0x0210 (528)
+0xFFDF, 0xF7FE, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0x085F,   // 0x0230 (560)
+0x001F, 0x001E, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7DE, 0x001E, 0x001F, 0x001F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x085F, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0xF79E, 0xFFDE, 0xFF9F, 0xFFBE, 0xF7DE, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFF9F, 0xFFBF,   // 0x02A0 (672)
+0xF7DF, 0xFFBF, 0xFFDF, 0x081F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0xF7DF, 0xFFDE, 0xFFBE, 0xFFFD, 0x001E,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0xEFBE, 0xFF9F, 0xF79F, 0x081F, 0x003F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001D, 0x003E, 0x001D, 0x001F, 0x003E, 0x001D, 0x001E, 0x001E,   // 0x0300 (768)
+0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001E, 0x001D, 0x001D, 0x001C, 0x001E, 0x001D, 0x081D, 0x001D, 0x001D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001C, 0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B,   // 0x0340 (832)
+0x001B, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x0019, 0x0019, 0x0019, 0x0019, 0x001B, 0x0019, 0x001A, 0x0019, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0039, 0x0019,   // 0x0370 (880)
+0x0019, 0x0018, 0x0038, 0x0019, 0x0019, 0x0819, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_718/radio.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: radio.jpg
+// Time generated: 24.03.2014 12:47:03
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short radio[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0020 (32)
+0x003F, 0x003F, 0x085F, 0x085F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x0030 (48)
+0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0040 (64)
+0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F,   // 0x0070 (112)
+0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x0080 (128)
+0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x083F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F,   // 0x0090 (144)
+0x005F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F,   // 0x00B0 (176)
+0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x00C0 (192)
+0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F,   // 0x00D0 (208)
+0x087F, 0x085F, 0x107F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x00E0 (224)
+0x003F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x003F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0110 (272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0120 (288)
+0x001F, 0x18D9, 0x4A0C, 0x39D3, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0130 (304)
+0x001F, 0x003F, 0x003F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F, 0x109F,   // 0x0150 (336)
+0x5ADF, 0x5AFF, 0x5AFF, 0x5AFF, 0x5AFF, 0x5AFF, 0x5AFF, 0x62FF, 0x5AFF, 0x5AFF, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F,   // 0x0160 (352)
+0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F,   // 0x0170 (368)
+0x6B5F, 0x4A50, 0x18A0, 0x2945, 0x633F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F, 0x631F,   // 0x0180 (384)
+0x4A7F, 0x085F, 0x003F, 0x003F, 0x005F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x211F,   // 0x01A0 (416)
+0xBDFF, 0xC61F, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x01B0 (432)
+0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x01C0 (448)
+0xC63F, 0xAD7B, 0x4208, 0x7BD3, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC65F,   // 0x01D0 (464)
+0x8C7F, 0x003F, 0x085F, 0x085F, 0x083F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x001F, 0x39DF,   // 0x01F0 (496)
+0xBDDF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF,   // 0x0200 (512)
+0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0210 (528)
+0xBDDF, 0xC5FF, 0x94B5, 0xAD7C, 0xBDDF, 0xBDDF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDFF,   // 0x0220 (544)
+0x947F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x841F,   // 0x0240 (576)
+0xBDFF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xB5BF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0250 (592)
+0xBDBF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0260 (608)
+0xBDDF, 0xBDFF, 0x7BD1, 0xA51B, 0xBDFF, 0xB5DF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDBF, 0xBDBF, 0xBDBF, 0xBDBF, 0xBDBF, 0xBDBF, 0xBDDF,   // 0x0270 (624)
+0xB57F, 0x213F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5AFF, 0xBDFF,   // 0x0290 (656)
+0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x02A0 (672)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x02B0 (688)
+0xBDDF, 0xBDFF, 0x7BF1, 0xA53B, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF,   // 0x02C0 (704)
+0xBDFF, 0x7BDF, 0x003F, 0x005F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x003F,   // 0x02D0 (720)
+0x001F, 0x003F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x085F, 0x39BF, 0x215F, 0x191F, 0x39DF, 0x843F, 0xBDDF, 0xB5BF,   // 0x02E0 (736)
+0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x02F0 (752)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0300 (768)
+0xBDDF, 0xC61F, 0x7BF1, 0xAD5B, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xB5BF, 0xB5BF,   // 0x0310 (784)
+0xBDBF, 0xBDFF, 0x73BF, 0x18DF, 0x003F, 0x001F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0320 (800)
+0x003F, 0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x087F, 0x9CFF, 0xBDDF, 0xB59F, 0xBDDF, 0xBDFF, 0xB5BF, 0xB5BF,   // 0x0330 (816)
+0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0340 (832)
+0xBDDF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0350 (848)
+0xBDFF, 0xC61F, 0x7BF1, 0xAD5B, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0360 (864)
+0xB5BF, 0xBDBF, 0xBDFF, 0xA55F, 0x73BF, 0x6B3F, 0x52BF, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0370 (880)
+0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x9CDF, 0xBDFF, 0xBDDF, 0xB5BF, 0xB5BF, 0xB5DF, 0xB5BF,   // 0x0380 (896)
+0xBDDF, 0xB5BF, 0xB5BF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF,   // 0x0390 (912)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x03A0 (928)
+0xBDFF, 0xC61F, 0x7BF1, 0xAD5B, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x03B0 (944)
+0xB5DF, 0xBDBF, 0xBDBF, 0xBDDF, 0xC61F, 0xC65F, 0x949F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x03C0 (960)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x087F, 0x9CDF, 0xBDDF, 0xB5BF, 0xBDBF, 0xBDBF, 0xB5BF, 0xBDBF,   // 0x03D0 (976)
+0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x03E0 (992)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x03F0 (1008)
+0xBDFF, 0xC61F, 0x7BF1, 0xAD7C, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0400 (1024)
+0xBDDF, 0xBDDF, 0xB5BF, 0xBDDF, 0xB5BF, 0xBE1F, 0x8C5F, 0x085F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F,   // 0x0410 (1040)
+0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x087F, 0x9CBF, 0xBDFF, 0xB5DF, 0xB5BF, 0xB5BF, 0xBDDF, 0xB5BF,   // 0x0420 (1056)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0430 (1072)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0440 (1088)
+0xBDFF, 0xC61F, 0x7BF1, 0xAD9C, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0450 (1104)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDBF, 0xBDBF, 0xBDFF, 0x8C7F, 0x085F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F,   // 0x0460 (1120)
+0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x9CDF, 0xBDDF, 0xB5BF, 0xBDBF, 0xB5BF, 0xB5BF, 0xBDDF,   // 0x0470 (1136)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0480 (1152)
+0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x0490 (1168)
+0xC61F, 0xC61F, 0x7C11, 0xB59C, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDDF,   // 0x04A0 (1184)
+0xBDDF, 0xBDDF, 0xB5DF, 0xBDDF, 0xBDDF, 0xBDFF, 0x8C7F, 0x085F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x04B0 (1200)
+0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x089F, 0x9CDF, 0xBDDF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x04C0 (1216)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F,   // 0x04D0 (1232)
+0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x04E0 (1248)
+0xC61F, 0xC63F, 0x7C11, 0xB5BC, 0xC61F, 0xBE1F, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x04F0 (1264)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xC61F, 0x8C7F, 0x085F, 0x089F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x0500 (1280)
+0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x109F, 0x9CFF, 0xBDFF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0510 (1296)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x0520 (1312)
+0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x0530 (1328)
+0xC61F, 0xC63F, 0x8411, 0xB5BC, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0540 (1344)
+0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xC61F, 0x8C7F, 0x087F, 0x109F, 0x109F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F,   // 0x0550 (1360)
+0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x109F, 0x9CFF, 0xBDFF, 0xB5BF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x0560 (1376)
+0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x0570 (1392)
+0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F,   // 0x0580 (1408)
+0xC63F, 0xCE3F, 0x8431, 0xBDDD, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0590 (1424)
+0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xC61F, 0x8C7F, 0x087F, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F,   // 0x05A0 (1440)
+0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x109F, 0x9CFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF,   // 0x05B0 (1456)
+0xBDFF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F,   // 0x05C0 (1472)
+0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F,   // 0x05D0 (1488)
+0xC63F, 0xCE5F, 0x8431, 0xBDDD, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x05E0 (1504)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xC61F, 0x8C7F, 0x109F, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x085F, 0x085F,   // 0x05F0 (1520)
+0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x10BF, 0x9CFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF,   // 0x0600 (1536)
+0xBDFF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F,   // 0x0610 (1552)
+0xC63F, 0xC63F, 0xC63F, 0xC65F, 0xC65F, 0xC63F, 0xC65F, 0xC65F, 0xCE3F, 0xCE3F, 0xCE3F, 0xCE3F, 0xCE3F, 0xCE3F, 0xCE3F, 0xCE3F,   // 0x0620 (1568)
+0xC65F, 0xCE5F, 0x8432, 0xBDFD, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF, 0xBDFF,   // 0x0630 (1584)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xC61F, 0x949F, 0x109F, 0x10BF, 0x109F, 0x109F, 0x109F, 0x087F, 0x087F, 0x085F, 0x085F,   // 0x0640 (1600)
+0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x107F, 0x087F, 0x10BF, 0x9CFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF,   // 0x0650 (1616)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC65F,   // 0x0660 (1632)
+0xCE3F, 0xCE3F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F,   // 0x0670 (1648)
+0xCE5F, 0xCE5F, 0x8C52, 0xBDFD, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF,   // 0x0680 (1664)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDDF, 0xC61F, 0x949F, 0x109F, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x109F, 0x087F, 0x087F, 0x085F,   // 0x0690 (1680)
+0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x107F, 0x109F, 0x109F, 0x10DF, 0x9CFF, 0xBDFF, 0xBDDF, 0xBDDF, 0xBDDF, 0xBDFF, 0xBDFF,   // 0x06A0 (1696)
+0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x06B0 (1712)
+0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F,   // 0x06C0 (1728)
+0xCE5F, 0xCE7F, 0x8C52, 0xC61D, 0xCE5F, 0xC65F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x06D0 (1744)
+0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0x949F, 0x10BF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F,   // 0x06E0 (1760)
+0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x109F, 0x109F, 0x109F, 0x18DF, 0x9CFF, 0xBDFF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x06F0 (1776)
+0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC65F, 0xC65F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F,   // 0x0700 (1792)
+0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F,   // 0x0710 (1808)
+0xCE5F, 0xCE7F, 0x8C52, 0xC63E, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x0720 (1824)
+0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0x949F, 0x10BF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x087F, 0x087F,   // 0x0730 (1840)
+0x085F, 0x085F, 0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x109F, 0x18DF, 0x9D1F, 0xBDFF, 0xBDFF, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF,   // 0x0740 (1856)
+0xBDFF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F,   // 0x0750 (1872)
+0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F,   // 0x0760 (1888)
+0xCE7F, 0xCE5F, 0x8C51, 0xC63E, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F,   // 0x0770 (1904)
+0xC61F, 0xC61F, 0xBE1F, 0xBDFF, 0xBDFF, 0xC63F, 0x94BF, 0x18DF, 0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x087F, 0x087F,   // 0x0780 (1920)
+0x085F, 0x087F, 0x087F, 0x107F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x18FF, 0xA51F, 0xC61F, 0xBDDF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F,   // 0x0790 (1936)
+0xC5FF, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xD67F,   // 0x07A0 (1952)
+0xCE7F, 0xCE7F, 0xCE7F, 0xCE9F, 0xCE9F, 0xD69F, 0xCE9F, 0xD69F, 0xD69F, 0xD69F, 0xD69F, 0xD69F, 0xD69F, 0xD69F, 0xCE9F, 0xD69F,   // 0x07B0 (1968)
+0xCE9F, 0xCE9F, 0x83F0, 0xC65E, 0xD69F, 0xD69F, 0xD69F, 0xD67F, 0xCE7F, 0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F,   // 0x07C0 (1984)
+0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF, 0xC63F, 0x94BF, 0x18DF, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x089F,   // 0x07D0 (2000)
+0x085F, 0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10BF, 0x18FF, 0xA51F, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F,   // 0x07E0 (2016)
+0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE9F, 0xCE7F,   // 0x07F0 (2032)
+0xD67F, 0xD69F, 0xD69F, 0xD69F, 0xD6BF, 0xD69F, 0xD6BF, 0xD6BF, 0xD6BF, 0xD6DF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEBF,   // 0x0800 (2048)
+0xDEDF, 0xD6BF, 0x73AF, 0xC5FC, 0xCE3D, 0xBDFB, 0xB5BA, 0xBDFC, 0xD67F, 0xD69F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F, 0xC63F, 0xC63F,   // 0x0810 (2064)
+0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xBDFF, 0xC63F, 0x94BF, 0x18FF, 0x18FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x109F, 0x109F, 0x087F,   // 0x0820 (2080)
+0x087F, 0x087F, 0x089F, 0x109F, 0x10BF, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0xA51F, 0xC61F, 0xBDFF, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F,   // 0x0830 (2096)
+0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE9F, 0xD69F, 0xD69F, 0xD6BF, 0xD6BF, 0xD6BF, 0xDEBF,   // 0x0840 (2112)
+0xD6BF, 0xD6BF, 0xD6BF, 0xD6BF, 0xD6BF, 0xCE9E, 0xCE9E, 0xC63D, 0xBDFB, 0xB5B9, 0xAD57, 0xA515, 0x9CD4, 0x9493, 0x9451, 0x8410,   // 0x0850 (2128)
+0x7B8D, 0x62EA, 0x41C5, 0x41E5, 0x39A4, 0x3143, 0x3144, 0x3985, 0x41E7, 0x8C34, 0xD69F, 0xCE5F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F,   // 0x0860 (2144)
+0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0x94BF, 0x18FF, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x089F,   // 0x0870 (2160)
+0x087F, 0x089F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18DF, 0x211F, 0xA51F, 0xC61F, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F,   // 0x0880 (2176)
+0xC63F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC65E, 0xC61C, 0xBDDC, 0xB59A, 0xAD78, 0xA4F6, 0xA4D5, 0x8C51,   // 0x0890 (2192)
+0x8C0F, 0x83EE, 0x838D, 0x732B, 0x6AC9, 0x5A47, 0x5206, 0x4184, 0x4122, 0x3921, 0x3901, 0x3901, 0x3902, 0x3102, 0x3122, 0x3123,   // 0x08A0 (2208)
+0x4185, 0x41A6, 0x41A5, 0x5A8B, 0x6B4F, 0x8411, 0x6B6E, 0x10A1, 0x1060, 0x5249, 0xD6BF, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xC63F,   // 0x08B0 (2224)
+0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0x9CBF, 0x20FF, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F,   // 0x08C0 (2240)
+0x087F, 0x089F, 0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18DF, 0x211F, 0xA51F, 0xC61F, 0xBDFF, 0xBDFF, 0xC61F, 0xC61F, 0xC61F,   // 0x08D0 (2256)
+0xC61F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xC65F, 0x6B4D, 0x5288, 0x5247, 0x41A4, 0x3963, 0x3122, 0x3101, 0x3941, 0x4142, 0x4983,   // 0x08E0 (2272)
+0x49A5, 0x51C5, 0x51C5, 0x51E6, 0x5227, 0x6269, 0x6B0C, 0x7B8F, 0x8C53, 0x9CD5, 0xAD37, 0xB578, 0xBDB9, 0xBDDB, 0xC61C, 0xCE5D,   // 0x08F0 (2288)
+0xD69F, 0xDEDF, 0x94B2, 0xDEBF, 0xDF1F, 0xE75F, 0xAD38, 0x10A2, 0x20A1, 0x524A, 0xD6BF, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F,   // 0x0900 (2304)
+0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0x9CDF, 0x211F, 0x211F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x109F,   // 0x0910 (2320)
+0x087F, 0x107F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18DF, 0x18FF, 0x213F, 0xA53F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F,   // 0x0920 (2336)
+0xC63F, 0xC63F, 0xC65F, 0xC65F, 0xCE7F, 0xC61D, 0x4207, 0x20C1, 0x41C7, 0x736E, 0x7BB0, 0x8C33, 0x9CD6, 0xAD58, 0xBDBA, 0xCE3C,   // 0x0930 (2352)
+0xCE5E, 0xD69E, 0xD6BF, 0xDEDF, 0xDEFF, 0xE71F, 0xE71F, 0xE73F, 0xE73F, 0xE71F, 0xE71F, 0xE71F, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF,   // 0x0940 (2368)
+0xDEFF, 0xDEDF, 0x9CB2, 0xD69E, 0xDEBF, 0xDEFF, 0xAD18, 0x18E2, 0x20C1, 0x5249, 0xD6BF, 0xCE7F, 0xCE5F, 0xCE5F, 0xC65F, 0xCE5F,   // 0x0950 (2384)
+0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0x9CDF, 0x211F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF, 0x10BF, 0x109F,   // 0x0960 (2400)
+0x087F, 0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x18FF, 0x213F, 0xA53F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F,   // 0x0970 (2416)
+0xC63F, 0xCE3F, 0xC65F, 0xCE5F, 0xCE7F, 0xC63E, 0x5268, 0x20C0, 0x83D1, 0xE73F, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEDF,   // 0x0980 (2432)
+0xDEFF, 0xDEDF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEDF, 0xDEDF, 0xDEFF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEFF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEDF,   // 0x0990 (2448)
+0xDEFF, 0xD67E, 0x9CB1, 0xD69E, 0xDEBF, 0xDEFF, 0xAD38, 0x18C2, 0x20A1, 0x5A69, 0xD6BF, 0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE3F,   // 0x09A0 (2464)
+0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xC63F, 0x9CDF, 0x213F, 0x213F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x109F,   // 0x09B0 (2480)
+0x087F, 0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x18FF, 0x18FF, 0x213F, 0xA53F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC61F, 0xC63F,   // 0x09C0 (2496)
+0xC65F, 0xCE3F, 0xC65F, 0xCE5F, 0xCE7F, 0xC63E, 0x5269, 0x20A0, 0x7B8F, 0xDEFF, 0xD6BF, 0xD6BF, 0xD6BF, 0xD6BF, 0xDEDF, 0xDEDF,   // 0x09D0 (2512)
+0xDEDF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF,   // 0x09E0 (2528)
+0xE71F, 0xC61B, 0x6AC7, 0xCE7D, 0xDEDF, 0xDF1F, 0xA538, 0x18C2, 0x20A0, 0x5A69, 0xD6BF, 0xD67F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE5F,   // 0x09F0 (2544)
+0xC65F, 0xC63F, 0xC63F, 0xC63F, 0xC61F, 0xC65F, 0x9CDF, 0x213F, 0x215F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x109F,   // 0x0A00 (2560)
+0x107F, 0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x20FF, 0x211F, 0x295F, 0xA53F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F,   // 0x0A10 (2576)
+0xC63F, 0xCE3F, 0xCE5F, 0xCE5F, 0xCE9F, 0xCE3E, 0x5A89, 0x28E1, 0x7B8F, 0xDF1F, 0xD6BF, 0xD6BF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEFF,   // 0x0A20 (2592)
+0xDEDF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDF1F, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEDF, 0xDEDF, 0xDEDF, 0xD6DE, 0xDEDE,   // 0x0A30 (2608)
+0xDEDD, 0xDE7B, 0x838B, 0xD67C, 0xDEFF, 0xE73F, 0xAD37, 0x10A0, 0x20A0, 0x5A69, 0xD6BF, 0xCE9F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE5F,   // 0x0A40 (2624)
+0xC65F, 0xC63F, 0xC63F, 0xC61F, 0xC61F, 0xCE5F, 0x9CDF, 0x215F, 0x293F, 0x213F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF,   // 0x0A50 (2640)
+0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x295F, 0xA53F, 0xC63F, 0xC61F, 0xC61F, 0xC61F, 0xC63F, 0xC63F,   // 0x0A60 (2656)
+0xCE5F, 0xC65F, 0xCE5F, 0xCE5F, 0xD67F, 0xCE7E, 0x5AA9, 0x28E0, 0x7B8F, 0xE71F, 0xD6DF, 0xD6BF, 0xD6DF, 0xDEDF, 0xDEDF, 0xDEDF,   // 0x0A70 (2672)
+0xDEDF, 0xD6DF, 0xD6BE, 0xDEBE, 0xDEDD, 0xDEDD, 0xDEFD, 0xDEDC, 0xDEDA, 0xDE99, 0xDE98, 0xE6B6, 0xE6B5, 0xEEB4, 0xEEB3, 0xEE92,   // 0x0A80 (2688)
+0xF691, 0xEE0F, 0xDD4C, 0xDDAE, 0xCD92, 0xCE39, 0x9CB5, 0x0000, 0x1040, 0x5A69, 0xD6DF, 0xD67F, 0xD67F, 0xCE7F, 0xCE7F, 0xCE5F,   // 0x0A90 (2704)
+0xCE5F, 0xCE3F, 0xC63F, 0xC63F, 0xC61F, 0xCE5F, 0x9CFF, 0x295F, 0x295F, 0x213F, 0x211F, 0x211F, 0x18FF, 0x18DF, 0x10BF, 0x10BF,   // 0x0AA0 (2720)
+0x109F, 0x109F, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x295F, 0xA55F, 0xC63F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC65F,   // 0x0AB0 (2736)
+0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE9F, 0x6AEB, 0x28E1, 0x732D, 0xDEFD, 0xD69C, 0xDEBB, 0xE6DB, 0xDEFA, 0xE6F9, 0xE6B7,   // 0x0AC0 (2752)
+0xE696, 0xE695, 0xE694, 0xEEB4, 0xEED3, 0xEED3, 0xEEB2, 0xEE91, 0xEE71, 0xEE50, 0xEE50, 0xEE50, 0xEE10, 0xEE0F, 0xEE0F, 0xE60F,   // 0x0AD0 (2768)
+0xE5EE, 0xDDAD, 0xDDAD, 0xDDAD, 0xDD8C, 0xDD8C, 0xCD2C, 0x8B88, 0x51A3, 0x5A69, 0xD6DF, 0xD69F, 0xD67F, 0xCE7F, 0xCE7F, 0xCE5F,   // 0x0AE0 (2784)
+0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x295F, 0x295F, 0x293F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF, 0x10BF,   // 0x0AF0 (2800)
+0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x20FF, 0x211F, 0x213F, 0x297F, 0xA53F, 0xC63F, 0xC61F, 0xC61F, 0xC63F, 0xC63F, 0xC65F,   // 0x0B00 (2816)
+0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xD6BF, 0xC61C, 0x6289, 0x2902, 0x7B08, 0xF713, 0xF6B2, 0xEE92, 0xEE91, 0xEE91, 0xEE51, 0xE650,   // 0x0B10 (2832)
+0xEE50, 0xEE50, 0xEE30, 0xEE30, 0xEE10, 0xEE30, 0xEE30, 0xEE50, 0xF671, 0xF691, 0xF691, 0xF6B1, 0xFEF2, 0xFF33, 0xFF53, 0xFF73,   // 0x0B20 (2848)
+0xFF94, 0xFF53, 0xFF53, 0xFF53, 0xFF73, 0xFF53, 0xFF32, 0xFF52, 0xFEAF, 0xDD6D, 0xDE77, 0xD6BF, 0xCE7F, 0xD69F, 0xCE7F, 0xCE7F,   // 0x0B30 (2864)
+0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x295F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF, 0x10BF,   // 0x0B40 (2880)
+0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x297F, 0xAD5F, 0xC63F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC65F,   // 0x0B50 (2896)
+0xCE5F, 0xCE5F, 0xCE7F, 0xD67F, 0xD6BF, 0xA4D4, 0x6266, 0x3123, 0x51A2, 0xB429, 0xDD8E, 0xE610, 0xE631, 0xEE51, 0xEE91, 0xF6B1,   // 0x0B60 (2912)
+0xFED2, 0xFF12, 0xFF33, 0xFF53, 0xFF94, 0xFF94, 0xFF94, 0xFF94, 0xFF74, 0xFF73, 0xFF53, 0xEEF3, 0xE671, 0xC5CF, 0xAD0D, 0x9C4B,   // 0x0B70 (2928)
+0x8BCA, 0xD5CE, 0xFE6E, 0xF62C, 0xF60C, 0xF5EC, 0xF5AA, 0xED89, 0xED89, 0xED27, 0xE506, 0xD5F3, 0xD6BF, 0xD67F, 0xD67F, 0xCE7F,   // 0x0B80 (2944)
+0xCE5F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF,   // 0x0B90 (2960)
+0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x213F, 0x297F, 0xAD5F, 0xC63F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F,   // 0x0BA0 (2976)
+0xCE5F, 0xCE7F, 0xCE7F, 0xD67F, 0xD69F, 0xBD54, 0x72E7, 0x3164, 0x38E0, 0xAB86, 0xED8B, 0xFEB0, 0xE671, 0xDDF0, 0xF713, 0xF713,   // 0x0BB0 (2992)
+0xE6D2, 0xDE92, 0xD651, 0xC58E, 0xB50D, 0x9C4A, 0x8368, 0x6AE7, 0x5A66, 0x5205, 0x49C4, 0x4183, 0x3902, 0x28C1, 0x2080, 0x1880,   // 0x0BC0 (3008)
+0x1040, 0x9B65, 0xED68, 0xE4E7, 0xE4E6, 0xE4E7, 0xDCC7, 0xE4E7, 0xDCE7, 0xE507, 0xDD07, 0xCD6E, 0xD69F, 0xD69F, 0xCE7F, 0xCE7F,   // 0x0BD0 (3024)
+0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10BF,   // 0x0BE0 (3040)
+0x109F, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x297F, 0xAD5F, 0xC63F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F,   // 0x0BF0 (3056)
+0xCE5F, 0xCE7F, 0xCE7F, 0xD69F, 0xD6BF, 0xBD75, 0x7B07, 0x3163, 0x4961, 0xD4EA, 0xF58C, 0xBC69, 0x6AC6, 0x5A25, 0x49A4, 0x41A3,   // 0x0C00 (3072)
+0x3963, 0x3122, 0x3102, 0x28C2, 0x20A1, 0x20A1, 0x2080, 0x20A0, 0x20A1, 0x20A1, 0x20A1, 0x18A1, 0x18A1, 0x18A1, 0x20C1, 0x18A0,   // 0x0C10 (3088)
+0x2081, 0x8304, 0xE4E7, 0xD486, 0xD466, 0xCC25, 0xB383, 0xB344, 0xBBA4, 0xCC86, 0xDCA7, 0xD56F, 0xCEBF, 0xD69F, 0xCE7F, 0xCE7F,   // 0x0C20 (3104)
+0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10BF,   // 0x0C30 (3120)
+0x109F, 0x10BF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x213F, 0x295F, 0x297F, 0xAD5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE3F, 0xCE5F,   // 0x0C40 (3136)
+0xCE5F, 0xCE5F, 0xCE7F, 0xCE9F, 0xD6BF, 0xBD75, 0x9BC9, 0x49A4, 0x4962, 0xDD6C, 0xCD6C, 0x20E2, 0x1081, 0x1881, 0x18A1, 0x18A1,   // 0x0C50 (3152)
+0x20A1, 0x18A1, 0x20C1, 0x18A0, 0x20C1, 0x1080, 0x20C2, 0x1080, 0x28C1, 0x1080, 0x18C1, 0x1080, 0x20C1, 0x18A1, 0x20C1, 0x18A1,   // 0x0C60 (3168)
+0x18A0, 0x72A4, 0xE4E7, 0xD466, 0xC404, 0x8A83, 0x7AC5, 0x9BA8, 0xAC07, 0xBC27, 0xCC66, 0xCD6F, 0xD6BF, 0xD69F, 0xCE7F, 0xCE7F,   // 0x0C70 (3184)
+0xCE5F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0C80 (3200)
+0x109F, 0x10BF, 0x18DF, 0x18FF, 0x20FF, 0x211F, 0x213F, 0x295F, 0x319F, 0xAD5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x0C90 (3216)
+0xCE5F, 0xCE7F, 0xCE7F, 0xCE9F, 0xD6BF, 0xC575, 0x9BC8, 0x3984, 0x4162, 0xE58C, 0xB48B, 0x18C1, 0x18C1, 0x1081, 0x18C1, 0x1080,   // 0x0CA0 (3232)
+0x10C1, 0x0881, 0x20C1, 0x18A1, 0x20C1, 0x20C0, 0x28E1, 0x20C1, 0x28C1, 0x20C1, 0x28C1, 0x28C1, 0x28C1, 0x20C1, 0x20C1, 0x1881,   // 0x0CB0 (3248)
+0x18A1, 0x6A63, 0xDCC7, 0xC405, 0x8262, 0x82E6, 0xEDEB, 0xFE0B, 0xF60C, 0xE5CC, 0xCCE8, 0xCD70, 0xD6BF, 0xD69F, 0xCE9F, 0xCE7F,   // 0x0CC0 (3264)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE5F, 0xA4FF, 0x297F, 0x297F, 0x297F, 0x215F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0CD0 (3280)
+0x109F, 0x10BF, 0x18DF, 0x18FF, 0x20FF, 0x211F, 0x213F, 0x295F, 0x319F, 0xAD5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x0CE0 (3296)
+0xCE7F, 0xCE7F, 0xD69F, 0xD69F, 0xD6BF, 0xBD75, 0xA42B, 0x3122, 0x6244, 0xE5CE, 0xB48B, 0x18A1, 0x18C1, 0x18C1, 0x20E1, 0x20C1,   // 0x0CF0 (3312)
+0x18E1, 0x18C1, 0x18C2, 0x18A1, 0x20C1, 0x18A1, 0x28C1, 0x1880, 0x28C1, 0x1080, 0x28C1, 0x1060, 0x28C1, 0x1880, 0x28E1, 0x18A0,   // 0x0D00 (3328)
+0x20A1, 0x5A03, 0xCC26, 0xA302, 0x51A2, 0xDD29, 0xDD48, 0xDD28, 0xE5AA, 0xE5AB, 0xDD6A, 0xD5D2, 0xD6BF, 0xD69F, 0xCE7F, 0xCE7F,   // 0x0D10 (3344)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE5F, 0xA4FF, 0x297F, 0x319F, 0x297F, 0x215F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF,   // 0x0D20 (3360)
+0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x20FF, 0x213F, 0x215F, 0x295F, 0x319F, 0xAD5F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x0D30 (3376)
+0xCE7F, 0xCE7F, 0xCE7F, 0xD69F, 0xD6BF, 0xB554, 0xE5F0, 0xC50D, 0xCD0C, 0xEDEF, 0xBCCC, 0x18C1, 0x18C1, 0x1080, 0x18C1, 0x1080,   // 0x0D40 (3392)
+0x18C1, 0x0880, 0x18C1, 0x1081, 0x18A1, 0x10A1, 0x20C1, 0x18C1, 0x20C1, 0x20C1, 0x28E1, 0x28C1, 0x30E0, 0x28E1, 0x30E1, 0x20C1,   // 0x0D50 (3408)
+0x28A1, 0x59E3, 0xCBE5, 0x7A21, 0x72C4, 0xDD29, 0xDD29, 0xDD49, 0xDD8A, 0xDD8A, 0xD54A, 0xD5D3, 0xD6BF, 0xCE9F, 0xD69F, 0xCE7F,   // 0x0D60 (3424)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xCE5F, 0xA4FF, 0x297F, 0x319F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF,   // 0x0D70 (3440)
+0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x295F, 0x319F, 0xAD5F, 0xCE5F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F,   // 0x0D80 (3456)
+0xCE5F, 0xCE7F, 0xCE9F, 0xD69F, 0xDEBF, 0xAD15, 0xE5F0, 0xE60F, 0xE5CE, 0xEE30, 0xBCCC, 0x18C1, 0x18C1, 0x18C1, 0x20C1, 0x20C1,   // 0x0D90 (3472)
+0x20C1, 0x18C1, 0x20C1, 0x18A1, 0x20C1, 0x18A1, 0x20C1, 0x18A1, 0x20C1, 0x1080, 0x18C1, 0x1080, 0x18C1, 0x10A0, 0x28C1, 0x18A1,   // 0x0DA0 (3488)
+0x28C0, 0x59E2, 0xC404, 0x7241, 0x8B25, 0xD508, 0xCCE8, 0xD54A, 0xDD8B, 0xDD6B, 0xD54A, 0xD5F4, 0xD6BF, 0xD69F, 0xD69F, 0xCE7F,   // 0x0DB0 (3504)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xCE5F, 0xA4FF, 0x319F, 0x319F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0DC0 (3520)
+0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x295F, 0x319F, 0xAD5F, 0xCE5F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F,   // 0x0DD0 (3536)
+0xCE7F, 0xD67F, 0xD67F, 0xD69F, 0xD6BF, 0xAD14, 0xE60F, 0xE62F, 0xE60E, 0xEE30, 0xBCED, 0x18E2, 0x18A2, 0x1081, 0x18E1, 0x1080,   // 0x0DE0 (3552)
+0x28C1, 0x1060, 0x20C1, 0x1081, 0x20A1, 0x1880, 0x20C1, 0x18A1, 0x20C0, 0x20A1, 0x20C1, 0x20C1, 0x28E1, 0x20C1, 0x20C1, 0x18C1,   // 0x0DF0 (3568)
+0x20A0, 0x51C2, 0xBBE5, 0x8A82, 0x7264, 0xD4C8, 0xCCE8, 0xD54A, 0xDD8C, 0xDD8C, 0xD52A, 0xD5F4, 0xD6BF, 0xD69F, 0xCE9F, 0xCE7F,   // 0x0E00 (3584)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xCE5F, 0xA4FF, 0x319F, 0x319F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0E10 (3600)
+0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x295F, 0x319F, 0xAD5F, 0xCE5F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F,   // 0x0E20 (3616)
+0xCE7F, 0xD67F, 0xD69F, 0xD69F, 0xD6DF, 0xAD15, 0xE5F0, 0xEE30, 0xE60E, 0xEE30, 0xC52E, 0x18E2, 0x18C1, 0x10A1, 0x18C1, 0x10A1,   // 0x0E30 (3632)
+0x18C1, 0x18C1, 0x20E1, 0x20C0, 0x28E1, 0x28C1, 0x28E1, 0x20A0, 0x20E1, 0x10A1, 0x20C1, 0x1080, 0x20C1, 0x1860, 0x18C1, 0x1881,   // 0x0E40 (3648)
+0x20C1, 0x51C2, 0xB384, 0xA303, 0x69C2, 0xB407, 0xD52A, 0xD56C, 0xDDCD, 0xD54B, 0xCCC8, 0xD5F4, 0xD6BF, 0xD69F, 0xCE9F, 0xCE7F,   // 0x0E50 (3664)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xCE5F, 0xA4FF, 0x297F, 0x319F, 0x297F, 0x215F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0E60 (3680)
+0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x295F, 0x319F, 0xAD5F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x0E70 (3696)
+0xCE7F, 0xCE7F, 0xCE7F, 0xD69F, 0xDEDF, 0xACF4, 0xE5F0, 0xE630, 0xE5EF, 0xF630, 0xC52D, 0x20E2, 0x18C1, 0x10A1, 0x18E1, 0x1081,   // 0x0E80 (3712)
+0x18C1, 0x0881, 0x10C1, 0x0881, 0x18A1, 0x1080, 0x20C1, 0x20C1, 0x28C1, 0x28C1, 0x30E1, 0x30C1, 0x28E0, 0x30E1, 0x28E1, 0x20C1,   // 0x0E90 (3728)
+0x20A1, 0x51A2, 0xB384, 0xAB43, 0x92C2, 0x7A83, 0xB407, 0xCD0B, 0xC488, 0xBC06, 0xD4C8, 0xD5F4, 0xD6BF, 0xD69F, 0xCE9F, 0xCE7F,   // 0x0EA0 (3744)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE5F, 0xA4FF, 0x297F, 0x297F, 0x297F, 0x215F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0EB0 (3760)
+0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x295F, 0x319F, 0xAD5F, 0xCE5F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F,   // 0x0EC0 (3776)
+0xCE7F, 0xCE7F, 0xCE9F, 0xD69F, 0xD6DF, 0xAD15, 0xDDCF, 0xEE30, 0xE60F, 0xEE30, 0xC54E, 0x2102, 0x18C1, 0x18A0, 0x20C1, 0x18C1,   // 0x0ED0 (3792)
+0x20E1, 0x18C1, 0x20C1, 0x18C1, 0x18C1, 0x10C1, 0x18C1, 0x18C1, 0x20C1, 0x18A1, 0x20C1, 0x1880, 0x28C1, 0x18A1, 0x30E1, 0x18A0,   // 0x0EE0 (3808)
+0x28A1, 0x59C2, 0xB3A4, 0xB363, 0xAB23, 0x9B02, 0x9281, 0x8AC2, 0xA323, 0xC3E5, 0xD508, 0xD5F5, 0xD6BF, 0xD69F, 0xD67F, 0xCE7F,   // 0x0EF0 (3824)
+0xCE7F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE5F, 0xA4FF, 0x297F, 0x297F, 0x295F, 0x213F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10BF,   // 0x0F00 (3840)
+0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x293F, 0x295F, 0x319F, 0xAD5F, 0xCE3F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F,   // 0x0F10 (3856)
+0xCE7F, 0xD67F, 0xCE7F, 0xD69F, 0xDEBF, 0xB556, 0xDDCF, 0xEE30, 0xEE0F, 0xEE30, 0xCD6E, 0x2102, 0x18C1, 0x20C1, 0x28E1, 0x18A1,   // 0x0F20 (3872)
+0x20C1, 0x1080, 0x28C1, 0x1081, 0x20C1, 0x1081, 0x18C1, 0x18A1, 0x18A1, 0x10A1, 0x18C2, 0x18C2, 0x20C1, 0x28C1, 0x3101, 0x28C1,   // 0x0F30 (3888)
+0x28C1, 0x59C2, 0xBBA4, 0xBB84, 0xAB42, 0x8261, 0x4941, 0x59A2, 0x8263, 0xABA6, 0xD4C8, 0xDDF6, 0xD6BF, 0xD69F, 0xD67F, 0xCE7F,   // 0x0F40 (3904)
+0xCE5F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE7F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x215F, 0x213F, 0x20FF, 0x18FF, 0x18DF, 0x10BF,   // 0x0F50 (3920)
+0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x295F, 0x319F, 0xAD5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x0F60 (3936)
+0xCE7F, 0xD67F, 0xCE7F, 0xD69F, 0xD6BF, 0xC5B9, 0xE5EF, 0xEE31, 0xEE0F, 0xEE30, 0xCD6F, 0x2902, 0x18C1, 0x18A1, 0x28E1, 0x20A1,   // 0x0F70 (3952)
+0x28E1, 0x20C1, 0x28E1, 0x28C1, 0x30E1, 0x28C1, 0x28E1, 0x20A1, 0x28C1, 0x10A1, 0x20C1, 0x1061, 0x10C2, 0x0881, 0x18A2, 0x1081,   // 0x0F80 (3968)
+0x10A1, 0x59E2, 0xC3C4, 0xB363, 0x8A61, 0x3901, 0x9324, 0xCC46, 0xC426, 0xC447, 0xD4E8, 0xD5F6, 0xD6BF, 0xD69F, 0xCE7F, 0xCE7F,   // 0x0F90 (3984)
+0xCE7F, 0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF,   // 0x0FA0 (4000)
+0x109F, 0x10BF, 0x18DF, 0x18FF, 0x20FF, 0x211F, 0x213F, 0x295F, 0x319F, 0xAD5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x0FB0 (4016)
+0xCE5F, 0xCE7F, 0xCE9F, 0xCE9F, 0xD6BF, 0xCDF9, 0xE5CF, 0xEE51, 0xEE10, 0xEE30, 0xCD8F, 0x2902, 0x20A1, 0x20A1, 0x20C1, 0x18A1,   // 0x0FC0 (4032)
+0x30E1, 0x1881, 0x28C1, 0x1081, 0x20A1, 0x1080, 0x20E1, 0x18A1, 0x20C1, 0x20C1, 0x28E1, 0x20C0, 0x28E1, 0x20C2, 0x20C1, 0x18C1,   // 0x0FD0 (4048)
+0x1081, 0x5A03, 0xBBC4, 0xAB02, 0x4141, 0x9B65, 0xE507, 0xDCC7, 0xD4C7, 0xE56A, 0xCCC8, 0xCD95, 0xD6BF, 0xD67F, 0xCE7F, 0xCE7F,   // 0x0FE0 (4064)
+0xCE5F, 0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF,   // 0x0FF0 (4080)
+0x109F, 0x10BF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x213F, 0x295F, 0x319F, 0xAD5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F,   // 0x1000 (4096)
+0xCE5F, 0xCE7F, 0xCE7F, 0xD67F, 0xD6BF, 0xCE19, 0xE5CF, 0xEE30, 0xEE0F, 0xEE30, 0xCD8E, 0x3142, 0x20C1, 0x1081, 0x20E2, 0x18A1,   // 0x1010 (4112)
+0x20C1, 0x18C1, 0x20E1, 0x20C1, 0x20C1, 0x20C1, 0x20C1, 0x20C1, 0x28E1, 0x20C1, 0x28C1, 0x1880, 0x28C1, 0x1881, 0x20C1, 0x1880,   // 0x1020 (4128)
+0x20A1, 0x6A43, 0xC405, 0x8A82, 0x4182, 0xDCE8, 0xDD08, 0xDD08, 0xDD29, 0xDD8B, 0xDD29, 0xCDD6, 0xD6BF, 0xD69F, 0xCE7F, 0xCE7F,   // 0x1030 (4144)
+0xCE5F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF,   // 0x1040 (4160)
+0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x297F, 0xAD5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE3F, 0xCE5F,   // 0x1050 (4176)
+0xCE5F, 0xCE7F, 0xCE7F, 0xD69F, 0xD69F, 0xCE1A, 0xE5CF, 0xEE30, 0xEE0F, 0xEE30, 0xD58F, 0x2922, 0x18C2, 0x18C2, 0x18C2, 0x18C1,   // 0x1060 (4192)
+0x20C1, 0x1881, 0x20E1, 0x1081, 0x18A1, 0x1061, 0x18A1, 0x1081, 0x18A1, 0x18A1, 0x20C1, 0x20C2, 0x28E1, 0x28E1, 0x30E1, 0x28C1,   // 0x1070 (4208)
+0x28C1, 0x7A84, 0xCC26, 0x8AC3, 0x5A03, 0xE529, 0xDD6A, 0xDD6A, 0xDD8B, 0xE5CD, 0xDD09, 0xD5F6, 0xD6BF, 0xCE7F, 0xCE7F, 0xCE5F,   // 0x1080 (4224)
+0xCE5F, 0xCE5F, 0xC65F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x295F, 0x297F, 0x293F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF, 0x10BF,   // 0x1090 (4240)
+0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x297F, 0xAD5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F,   // 0x10A0 (4256)
+0xCE5F, 0xCE7F, 0xCE7F, 0xCE7F, 0xD69F, 0xCE3B, 0xE5CF, 0xE610, 0xEE0F, 0xEE10, 0xD590, 0x2943, 0x18C2, 0x10A0, 0x18C1, 0x1081,   // 0x10B0 (4272)
+0x18C1, 0x10A1, 0x18C1, 0x18C1, 0x18C1, 0x18C1, 0x20C1, 0x18C1, 0x18C1, 0x18A1, 0x18C1, 0x10A1, 0x20C2, 0x1080, 0x20C1, 0x1081,   // 0x10C0 (4288)
+0x20A2, 0x7AC5, 0xD447, 0xA385, 0x5A03, 0xDD2A, 0xDD8B, 0xE5AC, 0xE5CC, 0xDD8B, 0xCCA8, 0xD5F7, 0xCEBF, 0xCE7F, 0xCE7F, 0xCE7F,   // 0x10D0 (4304)
+0xCE5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x295F, 0x295F, 0x215F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF,   // 0x10E0 (4320)
+0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x297F, 0xAD5F, 0xC63F, 0xC61F, 0xC63F, 0xC63F, 0xC63F, 0xC65F,   // 0x10F0 (4336)
+0xCE5F, 0xCE7F, 0xCE7F, 0xCE9F, 0xD69F, 0xCE3B, 0xD58F, 0xEE10, 0xE60F, 0xEE10, 0xD5AF, 0x3143, 0x20A1, 0x20C1, 0x20E2, 0x18A1,   // 0x1100 (4352)
+0x18C1, 0x1081, 0x18C1, 0x1081, 0x10C2, 0x1060, 0x18C2, 0x1081, 0x10A1, 0x10A1, 0x18C1, 0x18C2, 0x18A1, 0x18C1, 0x18E1, 0x20A1,   // 0x1110 (4368)
+0x20A1, 0x82E4, 0xCC47, 0xBBE6, 0x9B25, 0xABC7, 0xE5AB, 0xE5AC, 0xDD4B, 0xBC07, 0xC406, 0xD5F8, 0xD6BF, 0xCE7F, 0xCE7F, 0xCE7F,   // 0x1120 (4384)
+0xCE5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x215F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF, 0x109F,   // 0x1130 (4400)
+0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x297F, 0xAD5F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F,   // 0x1140 (4416)
+0xCE5F, 0xCE7F, 0xCE5F, 0xCE7F, 0xCE9F, 0xCE7E, 0xD5B1, 0xE5CE, 0xE5CF, 0xEE0F, 0xDDAF, 0x3163, 0x18A1, 0x1080, 0x18C2, 0x1081,   // 0x1150 (4432)
+0x18C1, 0x1081, 0x18C1, 0x10A1, 0x18C1, 0x18C1, 0x18C2, 0x10A1, 0x18C2, 0x1081, 0x18A2, 0x1080, 0x18C1, 0x1081, 0x18C2, 0x1081,   // 0x1160 (4448)
+0x18A1, 0x8B04, 0xCC26, 0xBBE6, 0xBC06, 0xB3E6, 0xBC46, 0xC488, 0xC448, 0xBC49, 0xC48A, 0xCE1A, 0xCE9F, 0xCE7F, 0xCE7F, 0xCE5F,   // 0x1170 (4464)
+0xCE5F, 0xCE3F, 0xC63F, 0xC63F, 0xC63F, 0xCE5F, 0x9CFF, 0x215F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x109F,   // 0x1180 (4480)
+0x109F, 0x109F, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x295F, 0xAD5F, 0xCE5F, 0xCE5F, 0xC63F, 0xC63F, 0xC63F, 0xC65F,   // 0x1190 (4496)
+0xCE5F, 0xCE5F, 0xCE5F, 0xCE7F, 0xD67F, 0xCE9F, 0xCE7D, 0xDDD1, 0xE5CE, 0xE5EF, 0xDDAF, 0x3144, 0x10C1, 0x18C1, 0x18C2, 0x10A1,   // 0x11A0 (4512)
+0x18C1, 0x10A1, 0x18C2, 0x0861, 0x10A2, 0x0881, 0x18C2, 0x1081, 0x10C2, 0x1081, 0x10C2, 0x10A2, 0x18A2, 0x18A1, 0x18C1, 0x18A1,   // 0x11B0 (4528)
+0x10A1, 0x9345, 0xCC66, 0xC446, 0xC447, 0xC447, 0xC448, 0xC48A, 0xC50E, 0xCD93, 0xCE18, 0xD67F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE5F,   // 0x11C0 (4544)
+0xCE3F, 0xC63F, 0xC63F, 0xCE5F, 0xCE5F, 0xD69F, 0x8C7F, 0x213F, 0x213F, 0x211F, 0x211F, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x109F,   // 0x11D0 (4560)
+0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x295F, 0x4A5F, 0x5B1F, 0x841F, 0xBDFF, 0xCE5F, 0xC63F, 0xC63F,   // 0x11E0 (4576)
+0xC65F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE9F, 0xD6BF, 0xC5D8, 0xCD6F, 0xE5EE, 0xDDAF, 0x3164, 0x18C1, 0x1081, 0x18C2, 0x1081,   // 0x11F0 (4592)
+0x18C2, 0x10A1, 0x18A2, 0x10A2, 0x10C2, 0x10A1, 0x10C2, 0x10A1, 0x10C2, 0x1081, 0x10A2, 0x1081, 0x10A2, 0x10A1, 0x10C2, 0x10A2,   // 0x1200 (4608)
+0x2123, 0xABC7, 0xBC07, 0xA3A7, 0x9B87, 0xA3CA, 0xAC6F, 0xB535, 0xC5FA, 0xD65E, 0xD69F, 0xCE9F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE3F,   // 0x1210 (4624)
+0xC63F, 0xCE7F, 0xC63F, 0x9CDF, 0x841F, 0x843F, 0x421F, 0x213F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF, 0x10BF, 0x109F,   // 0x1220 (4640)
+0x107F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x20FF, 0x211F, 0x213F, 0x213F, 0x213F, 0x213F, 0x52BF, 0xBDDF, 0xCE3F, 0xC63F,   // 0x1230 (4656)
+0xC63F, 0xC65F, 0xCE5F, 0xCE5F, 0xCE7F, 0xD67F, 0xD69F, 0xCE7E, 0xB535, 0xCD2F, 0xDDAF, 0x3164, 0x10A1, 0x18C2, 0x18C2, 0x10A2,   // 0x1240 (4672)
+0x18C2, 0x1081, 0x18C2, 0x0861, 0x10A1, 0x0881, 0x10C2, 0x1081, 0x18C2, 0x18C2, 0x1903, 0x2123, 0x2944, 0x2985, 0x39C6, 0x39E7,   // 0x1250 (4688)
+0x5A89, 0x838C, 0x7B6C, 0x7BAF, 0x9452, 0xAD37, 0xC61C, 0xCE7E, 0xD69F, 0xD69F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xC63F,   // 0x1260 (4704)
+0xCE5F, 0xB59F, 0x5AFF, 0x319F, 0x295F, 0x213F, 0x215F, 0x293F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x109F, 0x109F,   // 0x1270 (4720)
+0x087F, 0x109F, 0x109F, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x295F, 0x295F, 0x299F, 0x215F, 0x5ADF, 0xC61F, 0xC63F,   // 0x1280 (4736)
+0xC63F, 0xC65F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE7F, 0xD69F, 0xCE7E, 0xACF5, 0xBCEF, 0x41E6, 0x18C2, 0x18A1, 0x18E2, 0x18C1,   // 0x1290 (4752)
+0x18E2, 0x18E2, 0x18E3, 0x18E3, 0x2103, 0x2124, 0x3185, 0x39C6, 0x4228, 0x528A, 0x630C, 0x738E, 0x83F0, 0x9472, 0xA4F5, 0xAD57,   // 0x12A0 (4768)
+0xBDD9, 0xC61B, 0xCE7C, 0xD6BE, 0xD6BF, 0xDEDF, 0xD6BF, 0xD6BF, 0xD67F, 0xD67F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F,   // 0x12B0 (4784)
+0xBDFF, 0x529F, 0x297F, 0x31BF, 0x297F, 0x297F, 0x295F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x109F, 0x087F,   // 0x12C0 (4800)
+0x087F, 0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x295F, 0x317F, 0x297F, 0x297F, 0x9CFF, 0xCE5F,   // 0x12D0 (4816)
+0xC63F, 0xC65F, 0xC65F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xCE7F, 0xD69F, 0xCE7E, 0xB557, 0x736D, 0x4A29, 0x4208, 0x4208, 0x4A28,   // 0x12E0 (4832)
+0x5269, 0x5269, 0x5AAA, 0x62EB, 0x6B2C, 0x7BAF, 0x8C52, 0xA515, 0xB5B8, 0xC61A, 0xCE5C, 0xD69E, 0xDEBE, 0xDEDF, 0xDEDF, 0xDEFF,   // 0x12F0 (4848)
+0xDEFF, 0xDEDF, 0xDEBF, 0xD6BF, 0xD6BF, 0xD69F, 0xD69F, 0xD69F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE5F, 0xCE5F, 0xCE3F, 0xC63F, 0xCE7F,   // 0x1300 (4864)
+0x841F, 0x297F, 0x31BF, 0x319F, 0x297F, 0x295F, 0x213F, 0x213F, 0x211F, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x087F,   // 0x1310 (4880)
+0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x213F, 0x213F, 0x295F, 0x297F, 0x295F, 0x7BFF, 0xCE5F,   // 0x1320 (4896)
+0xC63F, 0xC63F, 0xC63F, 0xC65F, 0xCE5F, 0xCE5F, 0xCE7F, 0xCE7F, 0xD67F, 0xD69F, 0xD67F, 0xC61C, 0xAD58, 0xA4F6, 0xA4D6, 0xA537,   // 0x1330 (4912)
+0xAD58, 0xB599, 0xBDDA, 0xC63B, 0xCE7D, 0xD6BE, 0xDEDF, 0xDEFF, 0xDEDF, 0xDEFF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEDF, 0xD6DF, 0xD6BF,   // 0x1340 (4928)
+0xD6BF, 0xD6BF, 0xD6BF, 0xD6BF, 0xD69F, 0xD69F, 0xCE9F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE7F, 0xCE5F, 0xCE3F, 0xC63F, 0xC63F, 0xCE5F,   // 0x1350 (4944)
+0x631F, 0x317F, 0x319F, 0x297F, 0x295F, 0x215F, 0x213F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x109F, 0x089F, 0x087F,   // 0x1360 (4960)
+0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x20FF, 0x191F, 0x213F, 0x293F, 0x295F, 0x295F, 0x7C1F, 0xD6BF,   // 0x1370 (4976)
+0xCE7F, 0xCE7F, 0xCE7F, 0xCE9F, 0xCE9F, 0xD69F, 0xD6BF, 0xD6BF, 0xD6BF, 0xD6BF, 0xD6DF, 0xDEDF, 0xDEDF, 0xDEDF, 0xDEFF, 0xDEFF,   // 0x1380 (4992)
+0xE6FF, 0xDEFF, 0xE6FF, 0xE6FF, 0xE6FF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEFF, 0xDEDF, 0xDEDF,   // 0x1390 (5008)
+0xDEDF, 0xDEDF, 0xD6DF, 0xDEDF, 0xDEDF, 0xDEBF, 0xDEBF, 0xD6BF, 0xD6BF, 0xD69F, 0xD69F, 0xCE9F, 0xCE9F, 0xCE7F, 0xCE7F, 0xC63F,   // 0x13A0 (5024)
+0x529F, 0x297F, 0x317F, 0x297F, 0x295F, 0x293F, 0x191F, 0x191F, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x087F, 0x087F,   // 0x13B0 (5040)
+0x087F, 0x087F, 0x109F, 0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x213F, 0x213F, 0x295F, 0x295F, 0x5AFF, 0x7BFF,   // 0x13C0 (5056)
+0x7BFF, 0x7C1F, 0x83FF, 0x843F, 0x845F, 0x8C5F, 0x8C5F, 0x947F, 0x949F, 0x949F, 0x94BF, 0x9CBF, 0x9CDF, 0x9CFF, 0x9CFF, 0x9CFF,   // 0x13D0 (5072)
+0x9CFF, 0x9CFF, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0xA51F, 0x9CFF, 0x9CFF,   // 0x13E0 (5088)
+0x9CFF, 0x9CDF, 0x9CDF, 0x9CBF, 0x9CBF, 0x94BF, 0x949F, 0x949F, 0x8C7F, 0x8C5F, 0x8C5F, 0x843F, 0x841F, 0x841F, 0x7C1F, 0x5AFF,   // 0x13F0 (5104)
+0x319F, 0x297F, 0x297F, 0x295F, 0x213F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x087F, 0x087F,   // 0x1400 (5120)
+0x087F, 0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x213F, 0x215F, 0x295F, 0x295F, 0x295F,   // 0x1410 (5136)
+0x295F, 0x297F, 0x319F, 0x31BF, 0x31DF, 0x39FF, 0x421F, 0x423F, 0x4A5F, 0x4A7F, 0x4A9F, 0x529F, 0x52BF, 0x52DF, 0x5AFF, 0x5AFF,   // 0x1420 (5152)
+0x5AFF, 0x62FF, 0x631F, 0x631F, 0x633F, 0x631F, 0x633F, 0x633F, 0x633F, 0x633F, 0x633F, 0x631F, 0x631F, 0x631F, 0x62FF, 0x5B1F,   // 0x1430 (5168)
+0x5ADF, 0x5ADF, 0x52BF, 0x52BF, 0x529F, 0x4A9F, 0x4A7F, 0x4A3F, 0x4A3F, 0x421F, 0x39FF, 0x39DF, 0x31BF, 0x319F, 0x297F, 0x297F,   // 0x1440 (5184)
+0x319F, 0x297F, 0x295F, 0x213F, 0x213F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F,   // 0x1450 (5200)
+0x085F, 0x087F, 0x087F, 0x107F, 0x109F, 0x10BF, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x215F, 0x295F, 0x297F,   // 0x1460 (5216)
+0x421F, 0x423F, 0x4A5F, 0x4A7F, 0x529F, 0x52BF, 0x52BF, 0x5ADF, 0x62FF, 0x631F, 0x6B3F, 0x6B9F, 0x739F, 0x73BF, 0x7BBF, 0x7BDF,   // 0x1470 (5232)
+0x7BDF, 0x7C1F, 0x841F, 0x83FF, 0x83FF, 0x83FF, 0x841F, 0x841F, 0x841F, 0x841F, 0x841F, 0x843F, 0x7BFF, 0x7BFF, 0x7BDF, 0x7BDF,   // 0x1480 (5248)
+0x7BDF, 0x73BF, 0x739F, 0x6B5F, 0x6B5F, 0x6B5F, 0x635F, 0x631F, 0x5AFF, 0x5ADF, 0x52BF, 0x529F, 0x39FF, 0x39BF, 0x319F, 0x319F,   // 0x1490 (5264)
+0x297F, 0x295F, 0x295F, 0x213F, 0x211F, 0x20FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x087F, 0x087F, 0x085F,   // 0x14A0 (5280)
+0x085F, 0x085F, 0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x295F, 0x297F,   // 0x14B0 (5296)
+0x39FF, 0x3A1F, 0x423F, 0x4A3F, 0x4A7F, 0x52BF, 0x6B3F, 0x6B5F, 0x739F, 0x739F, 0x6B7F, 0x5AFF, 0x6B5F, 0x737F, 0x737F, 0x6B9F,   // 0x14C0 (5312)
+0x83FF, 0x73BF, 0x73DF, 0x7BDF, 0x843F, 0x8C5F, 0x8C7F, 0x8C9F, 0x841F, 0x739F, 0x7BDF, 0x7BDF, 0x7C1F, 0x843F, 0x8C3F, 0x73DF,   // 0x14D0 (5328)
+0x739F, 0x631F, 0x73BF, 0x9CDF, 0x8C5F, 0x5AFF, 0x5AFF, 0x5AFF, 0x5ADF, 0x52BF, 0x529F, 0x4A7F, 0x39BF, 0x31BF, 0x319F, 0x317F,   // 0x14E0 (5344)
+0x295F, 0x295F, 0x213F, 0x211F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x087F, 0x087F, 0x087F, 0x085F,   // 0x14F0 (5360)
+0x085F, 0x085F, 0x087F, 0x087F, 0x107F, 0x109F, 0x109F, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x211F, 0x213F, 0x295F,   // 0x1500 (5376)
+0x39DF, 0x39FF, 0x39FF, 0x423F, 0x39FF, 0x8C9F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC5FF, 0x631F, 0x6B3F, 0x5AFF, 0xC63F,   // 0x1510 (5392)
+0xFFFF, 0x83FF, 0x6B7F, 0x6B5F, 0xF79F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5F, 0x7BDF, 0x633F, 0xDEDF, 0xFFFF, 0xFFFF, 0x841F,   // 0x1520 (5408)
+0x5AFF, 0xC61F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBF, 0x633F, 0x529F, 0x52BF, 0x529F, 0x4A7F, 0x423F, 0x31BF, 0x319F, 0x297F, 0x295F,   // 0x1530 (5424)
+0x295F, 0x213F, 0x211F, 0x211F, 0x18FF, 0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x085F, 0x085F,   // 0x1540 (5440)
+0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x211F, 0x213F,   // 0x1550 (5456)
+0x31BF, 0x39DF, 0x39FF, 0x39FF, 0x41FF, 0x52BF, 0xFFFF, 0xFFFF, 0x6B7F, 0x9CDF, 0xFFFF, 0xFFFF, 0x73BF, 0x52BF, 0x739F, 0xFFFF,   // 0x1560 (5472)
+0xFFFF, 0xB57F, 0x5AFF, 0x5AFF, 0xD6BF, 0xFFFF, 0xE71F, 0x73DF, 0xEF7F, 0xFFFF, 0xFFFF, 0x5ABF, 0xBDDF, 0xFFFF, 0xCE7F, 0x4A7F,   // 0x1570 (5488)
+0xD69F, 0xFFFF, 0xD67F, 0x4A7F, 0x949F, 0xFFFF, 0xF7BF, 0x4A3F, 0x4A7F, 0x4A5F, 0x423F, 0x421F, 0x319F, 0x297F, 0x295F, 0x213F,   // 0x1580 (5504)
+0x213F, 0x211F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x085F, 0x085F,   // 0x1590 (5520)
+0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x107F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x18FF, 0x211F, 0x211F,   // 0x15A0 (5536)
+0x319F, 0x319F, 0x31BF, 0x39FF, 0x31DF, 0x5B1F, 0xFFFF, 0xFFFF, 0x297F, 0x5ADF, 0xFFFF, 0xFFFF, 0x633F, 0x423F, 0xCE5F, 0xFFFF,   // 0x15B0 (5552)
+0xFFFF, 0xEF7F, 0x52BF, 0x52BF, 0xE71F, 0xFFFF, 0x9CFF, 0x529F, 0x6B5F, 0xFFFF, 0xFFFF, 0x6B7F, 0xBDFF, 0xFFFF, 0x94DF, 0x73BF,   // 0x15C0 (5568)
+0xFFFF, 0xFFFF, 0x529F, 0x529F, 0x4A7F, 0xFFFF, 0xFFFF, 0x739F, 0x421F, 0x423F, 0x421F, 0x39FF, 0x297F, 0x295F, 0x215F, 0x213F,   // 0x15D0 (5584)
+0x211F, 0x211F, 0x18FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F,   // 0x15E0 (5600)
+0x003F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x109F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10DF, 0x18DF, 0x18FF, 0x18FF, 0x211F,   // 0x15F0 (5616)
+0x297F, 0x317F, 0x31BF, 0x39BF, 0x297F, 0x843F, 0xFFFF, 0xDEFF, 0x5AFF, 0xEF7F, 0xFFFF, 0x9CBF, 0x421F, 0x6B7F, 0xFFFF, 0x6B5F,   // 0x1600 (5632)
+0xFFFF, 0xFFFF, 0x5ADF, 0x527F, 0xF7BF, 0xFFFF, 0x7BDF, 0x5ABF, 0x5ADF, 0xFFFF, 0xFFFF, 0x7BFF, 0xCE9F, 0xFFFF, 0x7BBF, 0xC63F,   // 0x1610 (5648)
+0xFFFF, 0xAD7F, 0x421F, 0x527F, 0x3A1F, 0xF7DF, 0xFFFF, 0x8C7F, 0x31BF, 0x421F, 0x39FF, 0x39DF, 0x295F, 0x293F, 0x211F, 0x211F,   // 0x1620 (5664)
+0x20FF, 0x18FF, 0x18FF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F,   // 0x1630 (5680)
+0x003F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x109F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x18DF, 0x18DF, 0x18FF, 0x18FF,   // 0x1640 (5696)
+0x295F, 0x297F, 0x299F, 0x319F, 0x213F, 0xAD5F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD5F, 0x31BF, 0x39DF, 0xCE9F, 0xEF5F, 0x529F,   // 0x1650 (5712)
+0xFFFF, 0xFFFF, 0x631F, 0x423F, 0xFFFF, 0xFFFF, 0x631F, 0x529F, 0x52BF, 0xFFFF, 0xFFFF, 0x6B7F, 0xF7BF, 0xFFFF, 0x6B5F, 0xFFFF,   // 0x1660 (5728)
+0xFFFF, 0x8C9F, 0x421F, 0x4A5F, 0x41FF, 0xFFFF, 0xFFFF, 0x83FF, 0x319F, 0x39FF, 0x39BF, 0x31BF, 0x213F, 0x213F, 0x211F, 0x18FF,   // 0x1670 (5744)
+0x18FF, 0x18DF, 0x18DF, 0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F,   // 0x1680 (5760)
+0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x089F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10DF, 0x18DF, 0x18FF,   // 0x1690 (5776)
+0x215F, 0x295F, 0x295F, 0x297F, 0x211F, 0xCE5F, 0xFFFF, 0x9CFF, 0xB5BF, 0xFFFF, 0xE75F, 0x319F, 0x4A9F, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x16A0 (5792)
+0xFFFF, 0xFFFF, 0x843F, 0x423F, 0xFFFF, 0xFFFF, 0x529F, 0x423F, 0x5AFF, 0xFFFF, 0xFFFF, 0x52BF, 0xFFFF, 0xFFFF, 0x52BF, 0xFFFF,   // 0x16B0 (5808)
+0xFFFF, 0x7BFF, 0x39FF, 0x39FF, 0x52BF, 0xFFFF, 0xFFFF, 0x4A3F, 0x31BF, 0x31BF, 0x31BF, 0x297F, 0x211F, 0x211F, 0x20FF, 0x18FF,   // 0x16C0 (5824)
+0x18DF, 0x18DF, 0x10BF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x089F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F,   // 0x16D0 (5840)
+0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x089F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10DF, 0x18DF,   // 0x16E0 (5856)
+0x211F, 0x213F, 0x295F, 0x295F, 0x18FF, 0xE71F, 0xFFFF, 0x5ADF, 0x527F, 0xFFFF, 0xFFFF, 0x421F, 0x9CFF, 0xE75F, 0x4A5F, 0x4A7F,   // 0x16F0 (5872)
+0xB5BF, 0xFFFF, 0xBDFF, 0x527F, 0xFFFF, 0xFFFF, 0x39FF, 0x319F, 0xC63F, 0xFFFF, 0xCE5F, 0x4A9F, 0xFFFF, 0xFFFF, 0x31BF, 0xE6FF,   // 0x1700 (5888)
+0xFFFF, 0x8C5F, 0x297F, 0x295F, 0x947F, 0xFFFF, 0xB59F, 0x213F, 0x31BF, 0x319F, 0x297F, 0x297F, 0x211F, 0x18FF, 0x18FF, 0x18DF,   // 0x1710 (5904)
+0x10DF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x109F, 0x089F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F,   // 0x1720 (5920)
+0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x089F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10DF,   // 0x1730 (5936)
+0x211F, 0x211F, 0x213F, 0x213F, 0x213F, 0xFFFF, 0xFFFF, 0x5ADF, 0x213F, 0xFFFF, 0xFFFF, 0x73BF, 0xFFFF, 0x8C7F, 0x295F, 0x295F,   // 0x1740 (5952)
+0x8C5F, 0xFFFF, 0xE71F, 0x843F, 0xFFFF, 0xFFFF, 0x529F, 0xBE1F, 0xFFFF, 0xFFFF, 0x41FF, 0x7BFF, 0xFFFF, 0xFFFF, 0x295F, 0x6B7F,   // 0x1750 (5968)
+0xFFFF, 0xEF5F, 0x31BF, 0x6B5F, 0xFFFF, 0xFFDF, 0x319F, 0x297F, 0x297F, 0x297F, 0x295F, 0x295F, 0x18FF, 0x18DF, 0x18DF, 0x10DF,   // 0x1760 (5984)
+0x10BF, 0x10BF, 0x109F, 0x109F, 0x109F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F,   // 0x1770 (6000)
+0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x089F, 0x109F, 0x109F, 0x109F, 0x10BF,   // 0x1780 (6016)
+0x18FF, 0x20FF, 0x191F, 0x18BF, 0x6B7F, 0xFFFF, 0xFFFF, 0x739F, 0x5AFF, 0xFFFF, 0xFFFF, 0xF7BF, 0xFFFF, 0xA53F, 0x295F, 0x319F,   // 0x1790 (6032)
+0xCE7F, 0xFFFF, 0xF79F, 0xE71F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE7F, 0x4A5F, 0x297F, 0xD67F, 0xFFFF, 0xFFFF, 0x4A7F, 0x295F,   // 0x17A0 (6048)
+0x94BF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69F, 0x39BF, 0x293F, 0x297F, 0x295F, 0x295F, 0x213F, 0x213F, 0x18DF, 0x18DF, 0x10BF, 0x10BF,   // 0x17B0 (6064)
+0x10BF, 0x109F, 0x109F, 0x109F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x17C0 (6080)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x087F, 0x109F, 0x109F, 0x109F,   // 0x17D0 (6096)
+0x18DF, 0x18FF, 0x18FF, 0x20FF, 0x213F, 0x295F, 0x297F, 0x295F, 0x297F, 0x319F, 0x319F, 0x31BF, 0x31BF, 0x319F, 0x29BF, 0x319F,   // 0x17E0 (6112)
+0x39DF, 0x39DF, 0x39DF, 0x39DF, 0x39DF, 0x39FF, 0x421F, 0x39BF, 0x215F, 0x319F, 0x31BF, 0x39DF, 0x39DF, 0x39DF, 0x319F, 0x319F,   // 0x17F0 (6128)
+0x213F, 0x31BF, 0x4A7F, 0x39FF, 0x18FF, 0x293F, 0x217F, 0x295F, 0x213F, 0x213F, 0x211F, 0x211F, 0x10BF, 0x10BF, 0x10BF, 0x109F,   // 0x1800 (6144)
+0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x085F, 0x003F, 0x003F, 0x001F,   // 0x1810 (6160)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x087F, 0x109F, 0x109F,   // 0x1820 (6176)
+0x10DF, 0x18DF, 0x18DF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x213F, 0x213F, 0x211F, 0x213F, 0x213F, 0x213F, 0x295F, 0x295F, 0x297F,   // 0x1830 (6192)
+0x295F, 0x297F, 0x297F, 0x297F, 0x297F, 0x317F, 0x297F, 0x299F, 0x317F, 0x319F, 0x317F, 0x297F, 0x297F, 0x297F, 0x317F, 0x297F,   // 0x1840 (6208)
+0x297F, 0x295F, 0x213F, 0x293F, 0x213F, 0x213F, 0x293F, 0x211F, 0x211F, 0x211F, 0x20FF, 0x18FF, 0x10BF, 0x10BF, 0x109F, 0x109F,   // 0x1850 (6224)
+0x109F, 0x087F, 0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F, 0x107F,   // 0x1870 (6256)
+0x089F, 0x109F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x18BF, 0x18DF, 0x18DF, 0x18DF, 0x18DF, 0x18FF, 0x18FF, 0x20FF, 0x18FF, 0x18FF,   // 0x1880 (6272)
+0x20FF, 0x211F, 0x211F, 0x211F, 0x191F, 0x211F, 0x211F, 0x211F, 0x211F, 0x191F, 0x191F, 0x211F, 0x191F, 0x20FF, 0x18FF, 0x18FF,   // 0x1890 (6288)
+0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18DF, 0x18DF, 0x10DF, 0x10DF, 0x10BF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x109F, 0x087F,   // 0x18A0 (6304)
+0x087F, 0x087F, 0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x003F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x087F, 0x087F, 0x087F,   // 0x18C0 (6336)
+0x089F, 0x089F, 0x089F, 0x109F, 0x109F, 0x109F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10DF, 0x18DF, 0x18DF, 0x18DF, 0x18FF,   // 0x18D0 (6352)
+0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18DF,   // 0x18E0 (6368)
+0x18DF, 0x18DF, 0x18DF, 0x18DF, 0x18BF, 0x18BF, 0x10BF, 0x10BF, 0x10BF, 0x109F, 0x109F, 0x109F, 0x107F, 0x087F, 0x087F, 0x087F,   // 0x18F0 (6384)
+0x087F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x085F, 0x003F, 0x003F, 0x003F, 0x001F, 0x003F, 0x003F, 0x001F,   // 0x1900 (6400)
+};

_718/radio.ino

@@ -0,0 +1,611 @@
+//***********************************************
+
+void radio2() 
+{
+   int STATION_1=1059;
+  int STATION_2=1000;
+ int STATION_3=1004;
+  int STATION_4=1010;
+  int STATION_5=1039;
+    int STATION_6=1025;
+      int STATION_7=1068;
+       int STATION_8=1052;
+        int STATION_9=1075;
+      
+  int x,y,f;
+  boolean mem=0;
+  myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(VGA_BLUE);
+ myGLCD.setFont(BigFont);
+ myGLCD.fillScr(66,32,7); //(66,32,7)
+   //******************************************************************************************************
+
+if (rad==0)
+{
+   StationFrequency=STATION_5*100;
+  MP1090S:: InitI2C (19);
+MP1090S:: SetBand (MHz87_5_108);
+MP1090S::SetSpace (kHz50);
+MP1090S::SetVolume (volume);
+MP1090S::SetStation (StationFrequency);  
+
+//***************
+
+   //myGLCD.setFont(  Dingbats1_XL);
+//myButtons.drawButton(but7);
+ //  but7 = myButtons.addButton(270, 80, 35,  35, "w", BUTTON_SYMBOL); 
+    // myGLCD.setFont(  BigFont);
+  
+//  volume=5;
+ // MP1090S::SetVolume (volume);
+  rad=1;
+}
+   pictrad();
+   c=1;
+//int a=0;
+//  drawButtons();
+
+ // myGLCD.setFont(  Dingbats1_XL);
+  // pictradio();
+  
+  myGLCD.setFont( BigFont);
+drawButt();
+strelka();
+
+
+myGLCD.setBackColor(0,104,39);//goluboy
+myGLCD.setColor(255,255,255);
+ myGLCD.setFont( BigFont);
+ myGLCD.print("   ", 160, 95);
+
+ int pos=100*volume/15; 
+myGLCD.printNumI(abs(pos) , 160, 95); 
+//bar(x,y, pos,l,h);
+barrad(65,135, pos,270-25,10);
+
+  // myGLCD.setColor(255,255,255);
+   myGLCD.setColor(29,124,221);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+          myGLCD.printNumI(STATION_1 , 70, 370);        
+          myGLCD.printNumI(STATION_2 ,119, 420); 
+          myGLCD.printNumI(STATION_3 , 230, 370); 
+          myGLCD.printNumI(STATION_4, 280, 420); 
+          myGLCD.printNumI(STATION_5 , 388, 370);
+         myGLCD.printNumI(STATION_6 ,440, 420); 
+          myGLCD.printNumI(STATION_7 , 540, 370);
+           myGLCD.printNumI(STATION_8 ,595, 420); 
+          myGLCD.printNumI(STATION_9 , 695, 370);  
+
+ // myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+   //  myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+     clcrad();
+  while(1)
+  {
+     sec=t.sec;
+if (sec==0)
+{
+delay(800);
+ //kalend();
+clcrad();
+}
+ 
+  // digitalClockDisplay();
+//{  
+   if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      
+     myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+       // myGLCD.setFont( Ubuntubold);
+     //   myGLCD.print("x=    " , 650, 32);
+//myGLCD.printNumI(x , 700, 32);  
+ // myGLCD.setFont( Ubuntubold);
+      //  myGLCD.print("y=    " ,650 , 72);
+//myGLCD.printNumI(y , 700, 72); 
+//**************************************************
+ if ((y>=405) && (y<=450))  // Upper row
+      {
+        if ((x>=62) && (x<=112))// 2
+        {waitForIt(62, 405, 112, 450); 
+        if (mem==1)
+         {STATION_2= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 119, 420);
+          myGLCD.printNumI(STATION_2 ,119, 420); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_2*100;
+         strelka();
+         }
+        }
+        
+        if ((x>=224) && (x<=274))// 4
+        {waitForIt(224, 405, 274, 450); 
+        if (mem==1)
+         {STATION_4= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 280, 420);
+          myGLCD.printNumI(STATION_4, 280, 420); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_4*100;
+         strelka();
+         }
+        }
+        
+                if ((x>=383) && (x<=433))// 6
+        {waitForIt(383, 405, 433, 450); 
+        if (mem==1)
+         {STATION_6= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 440, 420);
+          myGLCD.printNumI(STATION_6 ,440, 420); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_6*100;
+         strelka();
+         }
+        }
+                  if ((x>=540) && (x<=590))// 8
+        {waitForIt(540, 405, 590, 450); 
+        if (mem==1)
+         {STATION_8= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 595, 420);
+          myGLCD.printNumI(STATION_8 ,595, 420); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_8*100;
+         strelka();
+         }
+        }
+//******************************
+      }
+if ((y>=5) && (y<=50))  // Upper row
+      {
+        
+        if ((x>=230) && (x<=280))  // Button: x
+        { waitcirForIt(260+3,30+10,22);
+          mem=1;
+        } 
+        if ((x>=480) && (x<=520))  // Button:_
+        {
+          waitForIt(482, 3, 532, 48);
+          rad=1;
+         //clok();
+          return ;
+        } 
+       
+       if ((x>=540) && (x<=580))  // Button: x
+        {
+          waitForIt(540, 3, 590, 48);
+          rad=0;
+          volume=0;
+          MP1090S::SetVolume (volume);
+          //clok();
+          return ;
+          
+        }   
+      }
+      //**********************************************************************************
+if ((y>=290) && (y<=330))  // Upper row
+      {
+         if ((x>=20) && (x<=55))  // Button:<<
+        {
+          waitForIt(10, 284, 62, 329);
+         
+         // do
+         //{ 
+           StationFrequency=StationFrequency-1000;
+           if (StationFrequency<90000)
+          {StationFrequency=108000;
+          }
+         strelka();
+                 //myGLCD.printNumI(ust , CENTER, 350);
+                
+       //  } while(ust>0);
+          }
+          if ((x>=75) && (x<=120))  // Button:-
+        {
+          waitForIt(70, 284, 120, 329);
+         
+          StationFrequency=StationFrequency-50; 
+              if (StationFrequency<90000)
+          {StationFrequency=108000;
+          }
+         strelka();
+
+        }  
+     if ((x>=675) && (x<=725))  // Button:+
+        {
+          waitForIt(677, 284, 727, 329);  
+       
+        StationFrequency=StationFrequency+50;
+         if (StationFrequency>108000)
+          {StationFrequency=90000;
+          }
+     strelka();
+
+        }
+       if ((x>=735) && (x<=775))  // Button:>>
+        {
+          waitForIt(739, 284, 792, 329);  
+       
+     //   do
+    //  {  
+        StationFrequency=StationFrequency+1000; 
+     
+      if (StationFrequency>107000)
+          {StationFrequency=90000;
+          }
+          strelka();
+               // myGLCD.printNumI(ust , CENTER, 350);
+   //   } while(ust>0);     
+                
+        }    
+        
+        
+      } 
+    if ((y>=120) && (y<=150))  // Upper row
+      {
+         if ((x>=28) && (x<=48))  // Button:- volume
+        {
+          waitcirForIt(32-3,138+4,18); 
+           if (volume<1)
+          {volume=1;
+          }
+          volume=volume-1;
+          MP1090S::SetVolume (volume);
+         myGLCD.setColor(255,255,255);
+          myGLCD.setBackColor(0,104,39);
+          myGLCD.setFont( BigFont);
+          myGLCD.print("   ", 160, 95); 
+         // myGLCD.printNumI(volume , 168, 90); 
+          int pos=100*volume/15; 
+          myGLCD.printNumI(abs(pos) ,160, 95);  
+
+           barrad(65,135, pos,270-25,10); 
+        }
+        
+        if ((x>=316) && (x<=356))  // Button:+ volume
+        {
+         waitcirForIt(338+3,138+4,18);
+          if (volume>14)
+          {volume=14;
+          }
+         volume=volume+1; 
+          MP1090S::SetVolume (volume);
+          myGLCD.setColor(255,255,255);
+          myGLCD.setBackColor(0,104,39);
+          myGLCD.setFont( BigFont);
+          myGLCD.print("   ", 160, 95); 
+         // myGLCD.printNumI(volume , 168, 90); 
+          int pos=100*volume/15; 
+          myGLCD.printNumI(abs(pos) , 160, 95); 
+
+           barrad(65,135, pos,270-25,10); 
+        }
+        
+      } 
+      
+   if ((y>=70) && (y<=100))  // Upper row
+      { 
+    if ((x>=17) && (x<=47))  // Button:mute
+        {  waitcirForIt(32-3,85+6,18);
+          volume=0;
+     MP1090S::SetVolume (volume); 
+     myGLCD.setColor(255,255,255);
+          myGLCD.setBackColor(0,104,39);
+          myGLCD.setFont( BigFont);
+          myGLCD.print("   ", 160, 95); 
+         // myGLCD.printNumI(volume , 168, 90); 
+          int pos=100*volume/15; 
+          myGLCD.printNumI(abs(pos) , 160, 95);  
+
+           barrad(65,135, pos,270-25,10); 
+        }
+      } 
+      
+      if ((y>=355) && (y<=405))  // Upper row
+      {
+        if ((x>=16) && (x<=56))// 1
+        {waitForIt(6, 355, 56, 400); 
+        if (mem==1)
+         {STATION_1= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 70, 370);
+          myGLCD.printNumI(STATION_1 , 70, 370); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_1*100;
+         strelka();
+         }
+        }
+         
+          if ((x>=175) && (x<=215))// 3
+          {waitForIt(170, 355, 220, 400); 
+        if (mem==1)
+         {STATION_3= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 230, 370);
+          myGLCD.printNumI(STATION_3 , 230, 370); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_3*100;
+          strelka();
+         }
+          }
+           if ((x>=330) && (x<=380))// 5
+          {waitForIt(330, 355, 380, 400); 
+        if (mem==1)
+         {STATION_5= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 388, 370);
+          myGLCD.printNumI(STATION_5 , 388, 370); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_5*100;
+          strelka();
+         }
+          }
+               if ((x>=484) && (x<=530))// 7
+          {waitForIt(484, 355, 534, 400); 
+        if (mem==1)
+         {STATION_7= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 540, 370);
+          myGLCD.printNumI(STATION_7 , 540, 370); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_7*100;
+          strelka();
+         }
+          }
+           if ((x>=640) && (x<=690))// 9
+          {waitForIt(640, 355, 690, 400); 
+        if (mem==1)
+         {STATION_9= StationFrequency/100;
+           myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(66,32,7);
+        myGLCD.setFont( Ubuntubold);
+           myGLCD.print("    ", 695, 370);
+          myGLCD.printNumI(STATION_9 , 695, 370); 
+          mem=0;
+         }
+         else
+         { StationFrequency=STATION_9*100;
+          strelka();
+         }
+          }
+      }
+//**********-----------------------------------------------------------------------------------------------------      
+      if ((y>=210) && (y<=270))  // Upper row
+      {f=x*10/44+900;
+       myGLCD.setFont( BigFont);
+   myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+       // myGLCD.print("f=    " , 650, 132);
+       // myGLCD.printNumI(f , 700, 132);
+       StationFrequency=f*100;
+      strelka(); 
+      }
+}
+
+
+  
+
+
+
+delay(100);
+      }      
+    }
+    
+
+
+//  Рисуем кнопки  
+void drawButt()
+{
+// Draw the upper row of buttons
+
+  
+    myGLCD.setColor(255, 232, 13);
+    myGLCD.drawRoundRect (482, 3, 532, 48);// _ 50x45
+    myGLCD.drawRoundRect (540, 3, 590, 48); //x
+    
+    
+    myGLCD.drawRoundRect (10, 284, 62, 329);//<< 
+    myGLCD.drawRoundRect (70, 284, 120, 329);//- 50x45
+    myGLCD.drawRoundRect (677, 284, 727, 329);//+
+    myGLCD.drawRoundRect (739, 284, 792, 329);//>>
+    
+     myGLCD.drawCircle (32-3,85+6,18);//mute
+     myGLCD.drawCircle (32-3,138+4,18);//-
+      myGLCD.drawCircle (338+3,138+4,18);//+
+       myGLCD.drawCircle (260+3,30+10,22);//glass
+       
+           myGLCD.drawRoundRect (6, 355, 56, 400);//1
+      myGLCD.drawRoundRect (170, 355, 220, 400);//3
+        myGLCD.drawRoundRect (330, 355, 380, 400);//5
+          myGLCD.drawRoundRect (484, 355, 534, 400);//7
+            myGLCD.drawRoundRect (640, 355, 690, 400);//9
+            
+                       myGLCD.drawRoundRect (62, 405, 112, 450);//2
+      myGLCD.drawRoundRect (224, 405, 274, 450);//4
+        myGLCD.drawRoundRect (383, 405, 433, 450);//6
+          myGLCD.drawRoundRect (540, 405, 590, 450);//8
+}
+        
+    
+    
+    
+
+
+
+// Draw a red frame while a button is touched
+void waitForIt(int x1, int y1, int x2, int y2)
+{
+  myGLCD.setColor(0, 217, 48);
+  myGLCD.drawRoundRect (x1, y1, x2, y2);
+  while (myTouch.dataAvailable())
+    myTouch.read();
+  myGLCD.setColor(255, 232, 13);
+  myGLCD.drawRoundRect (x1, y1, x2, y2);
+}
+
+void waitcirForIt(int x1, int y1, int x2)
+{
+  myGLCD.setColor(0, 217, 48);
+ myGLCD.drawCircle (x1,y1,x2);//glass
+  while (myTouch.dataAvailable())
+    myTouch.read();
+  myGLCD.setColor(255, 232, 13);
+ myGLCD.drawCircle (x1,y1,x2);//glass
+}
+
+
+
+//****************************strelka***********************************
+void strelka()
+{
+  int xstr;
+    xstr=(StationFrequency/100-900)*44/10;
+   xstr=abs(xstr);
+  
+
+  
+   myGLCD.setColor(0,104,39);
+  myGLCD.fillRoundRect (306, 279, 500, 333); //clear 
+ myGLCD.setColor(255,255,255);
+      myGLCD.setBackColor(0,104,39);
+      myGLCD.setFont( SevenSegNumFont);
+myGLCD.printNumI(StationFrequency/100 , CENTER, 280);
+MP1090S::SetStation ( StationFrequency);
+
+
+
+  myGLCD.setColor(63,33, 9);
+  myGLCD.fillRoundRect (0, 246, 800, 266);
+  myGLCD.setColor(255,0, 0);
+  myGLCD.fillRoundRect (xstr-2, 246, xstr+3, 266);
+}
+
+//************************************************************************************ 
+ 
+void clcrad() 
+{ char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  int cx=70;
+  int cy=30;
+  int month1;
+//**********CLOK*******************************************************************************
+ myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,38,92);
+myGLCD.setFont( SevenSegNumFont);
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,cx, cy);
+    myGLCD.printNumI(t.hour, cx+32, cy);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,cx, cy);
+  }
+  myGLCD.print(":",cx+64, cy);
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,cx+96, cy);
+    myGLCD.printNumI(t.min, cx+128, cy);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, cx+96, cy);
+  }
+  
+// kalendar  
+  myGLCD.setFont( Ubuntubold);
+  //myGLCD.setFont(BigFont);
+  myGLCD.setBackColor( VGA_TRANSPARENT);
+  myGLCD.setColor(245,61,6);
+ // myGLCD.setBackColor(255,114,0);
+  month1=t.mon;
+   myGLCD.print(strm[month1-1], 663-15, 18+8);
+
+//  myGLCD.print(rtc.getDOWStr(FORMAT_SHORT), 256+450, 8);
+myGLCD.setFont( SevenSegNumFont);
+myGLCD.setBackColor( VGA_TRANSPARENT);
+//  myGLCD.setBackColor(255,255,255);
+myGLCD.setColor(29,124,221);//goluboy
+  if (t.date<10)
+    myGLCD.printNumI(t.date, 710-30, 56+5);
+  else
+    myGLCD.printNumI(t.date, 695-30, 56+5);
+   // myGLCD.setFont(BigFont);
+   // myGLCD.setBackColor(180,180,180);
+   myGLCD.setFont( Ubuntubold);
+   myGLCD.setColor(13,124,30);//zelen
+   dow= t.dow;
+   myGLCD.print(str[dow-1], 690-20,110+5);
+ /// myGLCD.printNumI(rtc_clock.get_months(), 695, 122);
+ myGLCD.setFont(BigFont);
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+  //myGLCD.setBackColor(180,180,180);
+  myGLCD.printNumI(t.year, 694-20, 143+5);
+
+   
+//myGLCD.setBackColor(0,0,55);
+
+}
+
+void barrad(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(0,104,39);//цвет фоновый пр-к
+   // myGLCD.setColor(0,0,255);
+    myGLCD.fillRoundRect(x-5, y-5, l+x+5, h+y+5);//рисуем фоновый пр-к
+     myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(x, y, l+x, h+y);//прямоугольник с  обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ myGLCD.setColor(29,124,221);// цвет прямоуг уровня
+  myGLCD.fillRoundRect(x+1, y+1, (pos*l/100+x)-1, h+y-1);//рисуем прямоуг уровня
+//  myGLCD.setFont(BigFont);
+//  myGLCD.setColor(VGA_WHITE);
+//   myGLCD.setBackColor(0,104,39);
+ // myGLCD.setBackColor(0,0,255);
+ // myGLCD.print("BRIGHT", x-48+(l/2), y-25);
+ // myGLCD.printNumI(abs(pos), x-10+(l/2), y+2);// уровень в процентах
+  
+  
+  
+  
+}

_718/raw.ino

@@ -0,0 +1,767 @@
+//*******************************************************************************
+void raw()//sd.begin(chipSelect, SPI_HALF_SPEED ); 
+       //myGLCD.setFont( Ubuntubold); 
+    //myGLCD.setFont(BigFont); 
+{  
+
+  boolean pause=0;
+  byte p=0;
+   if (t.hour<7 || t.hour>22)
+    {myGLCD.fillScr(22,18,70);
+        myGLCD.setColor(255, 255, 255);
+    myGLCD.setBackColor(22,18,70);
+         myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+    }
+    else
+    {  
+    myGLCD.setBackColor(VGA_AQUA);
+    }
+ //  myGLCD.setColor(VGA_WHITE);
+   
+  myGLCD.setColor(255, 255, 255);
+    
+  //  myGLCD.drawBitmap (679, 280, 80, 80, instellingen);
+ //    myGLCD.drawRoundRect (679, 280, 759, 360); //Install 
+
+      myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+     
+       myGLCD.drawBitmap (769, 449, 30, 30, jar);
+    myGLCD.drawRoundRect (769, 449, 769+30, 449+30);// яркость
+    
+    //myGLCD.setColor(255,255,255);
+   myGLCD.setBackColor(0,38,92);
+     myGLCD.setFont( BigFont);
+     
+      myGLCD.setColor(0,38,92);
+    
+    myGLCD.fillRoundRect (769-31, 449, 769-1, 449+30);
+     myGLCD.setColor(255, 255, 255);
+     myGLCD.setColor(0,250,0);
+               myGLCD.fillCircle (769-31+7+8,449+7+8,12);
+                myGLCD.setColor(255, 255, 255);
+     myGLCD.drawRoundRect (769-31, 449, 769-1, 449+30);// pause
+     
+     myGLCD.setColor(0,38,92);
+      myGLCD.fillRoundRect (769-61, 449, 769-31, 449+30);
+     //myGLCD.setColor(255, 255, 255);
+     myGLCD.setColor(0,174,235);
+               myGLCD.fillCircle (769-61+7+8,449+7+8,12);
+                //myGLCD.setColor(255,0,0);
+              // myGLCD.fillCircle (769-61+7+8,449+7+8,5);
+                myGLCD.setColor(255, 255, 255);
+     myGLCD.drawRoundRect (769-61, 449, 769-31, 449+30);// flower
+     
+      myGLCD.setColor(0,38,92);
+      myGLCD.fillRoundRect (769-91, 449, 769-61, 449+30);
+     myGLCD.setColor(255, 255, 255);
+     myGLCD.setColor(255,216,0);
+               myGLCD.fillCircle (769-91+7+8,449+7+8,12);
+                myGLCD.setColor(255,0,0);
+               myGLCD.fillCircle (769-61+7+8,449+7+8,5);
+                myGLCD.setColor(255, 255, 255);
+     myGLCD.drawRoundRect (769-91, 449, 769-61, 449+30);// datchik
+     
+     
+     
+     sd.chdir("/");
+  delay (100);
+   
+  if (!sd.chdir("/"))
+  {sd.begin(chipSelect, SPI_HALF_SPEED );
+  delay (100);
+  
+    sd.chdir("/");
+  delay (100);
+  }//установка раб директории 
+  
+    int i;
+   int data; 
+    kalend();
+  clc();
+    //myGLCD.print("   ", 710, 90);
+     // myGLCD.printNumI(brightness, 710, 90);
+
+byte bait;
+byte bait1;
+byte k=2;
+byte k1=0;
+byte k2=0;
+
+//long address;
+
+  int w;
+
+  int q=0;
+  char* S1[]={"fam4.raw","1.raw","2.raw","3.raw","4.raw","5.raw","6.raw","7.raw","8.raw","9.raw","10.raw","11.raw","12.raw","15.raw","16.raw","17.raw","18.raw","19.raw","20.raw","21.raw","22.raw","23.raw","24.raw","25.raw","26.raw","27.raw","28.raw","29.raw","30.raw","31.raw","32.raw","35.raw","36.raw","37.raw","38.raw","39.raw","39.raw"};//36
+  //********************Foto*************************************************
+myFile.open(S1[19], O_READ);
+  
+int n=0;
+int m=0;
+  for (i =0 ; i < 76800; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>319)
+   {
+    n=0;  
+          // myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+      myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+      m=m+1;
+   }
+  }
+ 
+
+  // close the file:
+       myFile.close();
+ //********************************************************
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+ info();  
+
+  myGLCD.setFont(BigFont);
+
+    while(1)
+{ 
+ //  currentMillis = millis();
+ 
+
+    // save the last time you blinked the LED 
+ //   previousMillis = currentMillis; 
+ t = rtc.getTime();
+ sec=t.sec;
+ //*****************************************************************************
+ if (pause==0)
+{
+
+  
+if (t.hour>6 && t.hour<22)  
+{
+  if (p==0) 
+  { if (sec==25 )
+    {
+      int  days=t.date;
+      int  mon=t.mon;
+      word years=t.year;  
+  
+     kalendar(days, mon, years); 
+//drawButkal();
+     delay(5000);
+ 
+ }
+}
+}
+
+if ((sec==5) || (sec==20) || (sec==35)|| (sec==50))
+{  p=0;
+   priem();
+   q = random(0, 36);
+k2=k2+1;  
+k=k+1;
+k1=k1+1;
+
+if (p==0)
+{
+    if (k2==5)
+      {
+
+        nightgraf();
+  
+        p=1;
+        
+      } 
+}
+//******************************
+if (p==0)
+{
+  if (k2>9)
+  {//rawp=1;
+    k2=0;
+    rawp=1;
+    readprognoz();
+  //  delay(2000);
+    p=1;
+   }
+}
+//***************
+if (p==0)
+{
+  if (k1==3)
+  {//rawp=1;
+    
+    rawp=1;
+   // flower();
+    home1();
+    //delay(2000);
+    p=1;
+   }
+}
+
+if (p==0)
+{
+       if  (k>7)
+          {k=0;
+
+            bmp085();
+             win();
+                p=1;
+               // delay(4000); 
+            }
+}
+
+ 
+
+ 
+
+if (p==0)
+{
+  if (k1>8)
+  {rawp=1;
+   k1=0;
+
+   prognoz();
+   p=1;
+   }
+} 
+
+ 
+  
+if (p==0)
+{
+  //********************Foto*************************************************
+myFile.open(S1[q], O_READ);
+  
+int n=0;
+int m=0;
+  for (i =0 ; i < 76800; i = i++) {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>319){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close();
+}
+ //********************************************************
+ }
+ //*****************************************************************
+}//pause
+else
+{  
+ myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(0,172,238);
+ myGLCD.setFont(BigFont);
+if(zn9==0) 
+{ myGLCD.print("T=+" ,80, 457);
+}
+else
+{myGLCD.print("T=-" ,80, 457);
+}
+myGLCD.printNumI(t9/10,80+48,457);
+myGLCD.print("," ,80+48+32, 457);
+myGLCD.printNumI(t9%10,80+48+32+16,457);
+myGLCD.print("C H=" ,80+48+32+16+16, 457);
+myGLCD.printNumI(h9/10,80+48+32+16+16+64,457);
+myGLCD.print("," ,80+48+32+16+16+64+32, 457);
+myGLCD.printNumI(h9%10 ,80+48+32+16+16+64+48,457);
+myGLCD.print("% S=" ,80+48+32+16+16+64+48+16, 457);
+myGLCD.printNumI(osv9,80+48+32+16+16+64+48+16+64,457);
+
+myGLCD.printNumI(hour9,80+48+32+16+16+64+48+16+64+64,457);
+myGLCD.print(":" ,80+48+32+16+16+64+48+16+64+64+32, 457);
+if(min9>9){
+myGLCD.printNumI(min9,80+48+32+16+16+64+48+16+64+64+32+16,457);
+}
+else
+{myGLCD.print("0" ,80+48+32+16+16+64+48+16+64+64+32+16, 457);
+myGLCD.printNumI(min9,80+48+32+16+16+64+48+16+64+64+32+16+16,457);
+}
+}
+
+
+//**********************************************************************
+
+
+
+ if ((sec==14) || (sec==42) )
+{
+ //******DHT read********
+info();
+
+ 
+ }
+
+ 
+ 
+//delay(5000);
+ if (myTouch.dataAvailable())
+ 
+{  
+  
+      myTouch.read();
+     int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+
+      if ((x>=640) && (x<=799)) // Upper row
+      {  
+        if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+         rawp=0;
+          menu();
+        }
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+               {
+                   kalendarset();
+            //pogoda();
+                }
+          if ((y>=160) && (y<=360))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(645, 155, 797, 367);//(645, 190, 795, 328)
+        rawp=1;
+          readprognoz();
+          
+          k1=5;
+        }
+        
+        
+      }
+      
+      //*********
+           if ((y>=451) && (y<=479))  // Upper row    (y>=449) && (y<=479)
+      {
+        
+       if ((x>=769) && (x<=799))  // яркость
+          {
+            waitForIt1(769, 449, 799, 479);
+            bright();
+            
+          }
+          
+          if ((x>=769-61) && (x<=799-61))  // яркость
+          {
+            waitForIt1(769-61, 449, 799-61, 479);
+            rawp=1;
+            //flower();
+            home1();
+            delay (2000);
+            }
+            
+            if ((x>=769-91) && (x<=799-91))  // датчик
+          {
+            waitForIt1(769-91, 449, 799-91, 479);
+            printdat();
+            delay (3000);
+            }
+           
+          if ((x>=769-31) && (x<=768))  // pause
+          {
+            waitForIt1(769-31, 449, 768, 479);
+            myGLCD.setColor(255,0,0);
+            myGLCD.setBackColor(0,38,92);
+              myGLCD.setFont( BigFont);
+             if(pause==1) 
+               {myGLCD.setColor(0,250,0);
+               myGLCD.fillCircle (769-31+7+8,449+7+8,12);
+                pause=0;
+               }
+               else
+               {myGLCD.setColor(255,60,50);
+               myGLCD.fillCircle (769-31+7+8,449+7+8,12);
+                pause=1;
+               }
+            
+          } 
+      }
+    if ((y>=50) && (y<=420))
+   {  if ((x>=50) && (x<=768))  // pause
+          {
+            waitForIt1(769-31, 449, 768, 479);
+            
+            myGLCD.setBackColor(0,38,92);
+              myGLCD.setFont( BigFont);
+             if(pause==1) 
+               {//myGLCD.print("P",769-31+7, 449+7);
+               myGLCD.setColor(0,250,0);
+               myGLCD.fillCircle (769-31+7+8,449+7+8,12);
+                pause=0;
+               }
+               else
+               {//myGLCD.print(">",769-31+7, 449+7);
+               myGLCD.setColor(255,60,50);
+               myGLCD.fillCircle (769-31+7+8,449+7+8,12);
+                pause=1;
+               }
+            
+          }
+     }
+     
+     
+         
+   delay(500);   
+ //  myGLCD.setColor(255,255,255);
+  //        if(pause==0)
+ //    myGLCD.print("P",769-31+7, 449+7);
+ //  else     
+ //    myGLCD.print(">",769-31+7, 449+7);     
+      
+
+  } 
+//*********************************************************
+ // sec=rtc_clock.get_seconds();
+t = rtc.getTime();  
+//*********************************************************
+ // sec=rtc_clock.get_seconds();
+  
+// sec=rtc_clock.get_seconds();
+if ((sec==0)||(sec==23)||(sec==40))
+{
+delay(800);
+clc();
+
+  if(t.hour<6 )
+{night=1;
+brightness=0;
+constbr=20;
+       br=constbr+brightness;
+       analogWrite(12, br);
+       rawp=1;
+clok();
+}
+else
+{night=0;
+}
+   if (t.hour<7 || t.hour>21)
+   {constbr=20;
+        br=constbr+brightness;
+        if (br>255)
+           {br=255;
+  
+              }
+      analogWrite(12, br);
+   }
+      else
+      {constbr=250;
+        br=constbr+brightness;
+        if (br>255)
+             br=255;
+               
+       analogWrite(12, br);
+      }
+
+  myGLCD.setFont(BigFont);
+
+
+
+ }
+ 
+}//wile
+}
+
+//***************************************************
+
+//**************  INFO *************************************
+void info()
+{
+  
+     myGLCD.setColor(255,255,255);
+   myGLCD.setBackColor(0,38,92);
+     myGLCD.setFont( BigFont);
+      myGLCD.print("|||" ,660+83, 200-25);
+  //******DHT read********
+dtu21();
+
+ bmp085();
+ 
+ uart();
+//******DHT read********
+ //*****************VOLT ************************
+
+if (volt/100<3)
+{myGLCD.setColor(255,0,0);//низкое напр батареи красным цветом
+   myGLCD.setBackColor(0,38,92);
+}
+else
+{
+       myGLCD.setColor(255,255,255);
+   myGLCD.setBackColor(0,38,92);
+}
+  
+  
+        //myGLCD.print("V=" ,650 , 290);
+        myGLCD.print("." ,712-48, 200-30);
+myGLCD.printNumI(volt/100 , 700-48, 200-30);
+
+if (volt%100<10)
+{
+ myGLCD.print("0" ,724-48, 200-30);
+ myGLCD.printNumI(volt%100, 724+16-48, 200-30); 
+}
+else
+{
+myGLCD.printNumI(volt%100, 724-48, 200-30); 
+}
+delay(1000);  
+  myGLCD.setColor(255,255,255);
+   myGLCD.setBackColor(0,38,92);
+   //********************************* 
+    myGLCD.print("  " ,660+16+83, 200-30); 
+  myGLCD.setFont( Ubuntubold);   
+  
+//********************** P ************************************    
+myGLCD.setBackColor( VGA_TRANSPARENT); 
+ myGLCD.setBackColor(0,38,92);
+     if (ptoday==0)//погода сегодня 0-солн 1-перемен обл 2-пасмурно 3-дождь 4- снег 5- туман 6-гроза
+  { myGLCD.setColor(255,250,50);
+    if (t.hour<6 || t.hour>20)//ночь
+    {myGLCD.print("[]" ,650, 200-5);//луна
+    }
+    else
+    {myGLCD.print("{}" ,650, 200-5);
+    }
+  }
+    if (ptoday==1)
+   {
+     if (t.hour<6 || t.hour>20)//ночь
+    {myGLCD.setColor(255,250,50);
+      myGLCD.print("[]" ,650, 200-9);//луна
+     myGLCD.setColor(210,210,220);
+     myGLCD.setBackColor( VGA_TRANSPARENT); 
+     myGLCD.print("|~" ,650, 200-5);//туча
+    }
+    else
+    {myGLCD.setColor(255,250,50);
+    myGLCD.print("{}" ,650, 200-9);// солнце
+    myGLCD.setColor(220,230,255);
+    myGLCD.setBackColor( VGA_TRANSPARENT); 
+    myGLCD.print("|~" ,650, 200-5);//туча
+    }
+  }
+  if ((ptoday==2)||(ptoday==5))
+   {
+     if (t.hour<6 || t.hour>20)//ночь
+    {
+     myGLCD.setColor(81,120,180);
+     myGLCD.print("|~" ,650, 200-8);//туча
+    }
+    else
+    {myGLCD.setColor(74,126,200);
+    myGLCD.print("|~" ,650, 200-8);//туча
+    }
+    
+  } 
+  
+  if ((ptoday==3)||(ptoday==6))
+   {
+     if (t.hour<6 || t.hour>20)//ночь
+    {
+     myGLCD.setColor(81,120,180);
+     myGLCD.print("^_" ,650, 200-7);//rain
+    }
+    else
+    {myGLCD.setColor(74,126,200);
+     myGLCD.print("^_" ,650, 200-7);
+    }
+  } 
+   if (ptoday==4)
+   {
+     if (t.hour<6 || t.hour>20)//ночь
+    {
+     myGLCD.setColor(250,250,250);
+     myGLCD.print("()" ,650, 200-7);//snow
+    }
+    else
+    {myGLCD.setColor(255,255,255);
+     myGLCD.print("()" ,650, 200-7);
+    }
+  }
+   myGLCD.setBackColor(0,38,92);
+     if (pressure>759)
+  { myGLCD.setColor(255,250,50);
+   //myGLCD.print("{}" ,650, 200-5);
+  }
+    if (pressure<746)
+   {myGLCD.setColor(0,0,255);
+   // myGLCD.print("|~" ,650, 200-5);
+  }  
+    if ((pressure>745)&&(pressure<760))
+ {
+ myGLCD.setColor(255,250,50);
+ // myGLCD.print("{}" ,650, 200-5);
+  myGLCD.setColor(7,255,34);
+  }
+   myGLCD.printNumI(pressure,698,200-5);  
+   word pr=pressure;
+     if (pr>pres[4]+1)
+  myGLCD.print("&",690+83,200-8);
+  
+     if (pr==pres[0])
+  myGLCD.print(" ",690+83,200-8);  
+  
+    if (pr<pres[4]-1)
+  myGLCD.print("'",690+83, 200-8);
+//********************** tu ************************************ 
+myGLCD.setColor(5,252,46);
+   myGLCD.print("#" ,650, 200+30);
+   
+   if (zn<2)
+ { myGLCD.setColor(129,239,255);
+   myGLCD.print("-",650+20, 200+30);
+
+ }
+ else
+ { myGLCD.setColor(255,150,150);
+  myGLCD.print("+",650+20, 200+30);
+ }
+ 
+  if (tu<10)
+ {myGLCD.print(" ",650+20+24+16+18+24, 230);
+  myGLCD.print(".",650+20+24+16, 230);
+  myGLCD.printNumI(tud,650+20+24+16+18 ,230); 
+   myGLCD.printNumI(tu,650+20+24,230);// myGLCD.print(":",cx+32+32, cy);
+ }
+ else
+ {myGLCD.print(".",650+20+24+24+16, 230);
+   myGLCD.printNumI(tu,650+20+24,230);
+   myGLCD.printNumI(tud,650+20+24+24+16+18 ,230); 
+ }
+//**********************T up  or doun ***************************** 
+int Tm;
+int Tm1;
+ if (zn<2)
+ {Tm1=-1*tu;
+ }
+ else
+ {Tm1=tu;
+ }
+
+
+if (temul[1]>1000)
+    {   Tm=-1*(temul[1]-1000);
+      
+    }
+    else
+   {
+    Tm=temul[1];
+   }
+   //myGLCD.setFont( Ubuntubold);
+if (Tm/10>Tm1)
+   myGLCD.print("'",690+83, 232-5); 
+   
+   if (Tm/10==Tm1)
+   myGLCD.print(" ",690+83, 232-5);
+  
+    if (Tm/10<Tm1)
+ myGLCD.print("&",690+83,232-5);
+  
+//***************************Hul**********************************************
+myGLCD.setColor(129,200,255);
+  // myGLCD.print("0" ,650, 270-5);
+ //  myGLCD.setColor(200,200,255);
+   myGLCD.print(".",650+20+24+24+16, 270-5);
+   myGLCD.printNumI(hu,650+20+24,270-5);
+  myGLCD.printNumI(hud,650+20+24+24+16+18,270-5);
+ 
+ if (hug[0]/10>hug[1]/10)
+ myGLCD.print("&",690+83,267-5);
+
+ if (hug[0]/10==hug[1]/10)
+ myGLCD.print(" ",690+83,267-5);  
+  
+    if (hug[0]/10<hug[1]/10)
+ myGLCD.print("'",690+83, 267-5);   
+//*************************** T dom **************************************************
+myGLCD.setColor(255,255,255);
+   myGLCD.print("!" ,650, 270+35-5);
+  int tem =tdc*10+tdd; 
+ 
+   myGLCD.setColor(5,252,46);
+    myGLCD.print("+" ,650+24, 270+35-5);
+   myGLCD.print(".",650+20+24+24+16, 270+35-5);
+   myGLCD.printNumI(tem/10,650+20+24,270+35-5);
+  myGLCD.printNumI(tem%10,650+20+24+24+16+18,270+35-5);
+
+if (temdom[0]/10>temdom[1]/10)
+ myGLCD.print("&",690+83,270+32-5);
+ 
+ if (temdom[0]/10==temdom[1]/10)
+ myGLCD.print(" ",690+83,270+32-5); 
+  
+    if (temdom[0]/10<temdom[1]/10)
+ myGLCD.print("'",690+83, 270+32-5);
+ 
+ //******************** H dom ***************************
+ myGLCD.setColor(129,200,255);
+ //  myGLCD.print("0" ,650, 270+70-5);
+   myGLCD.setColor(200,200,255);
+  
+   
+   //int humidity=35;
+   //myGLCD.printNumI(DHT.humidity,650+20+24,270+70-5);
+   
+    //myGLCD.printNumI(hdc,650+20+24,270+70-5);
+    //myGLCD.print(",",650+20+24+24+24, 270+70-5);
+   // myGLCD.printNumI(hdd,650+20+24+24+24+24,270+70-5);
+   // myGLCD.print("%",650+20+24+24+24+24, 270+70-5);
+ 
+  myGLCD.print(".",650+20+24+24+16, 270+70-5);
+   myGLCD.printNumI(hdc,650+20+24,270+70-5);
+  myGLCD.printNumI(hdd,650+20+24+24+16+18,270+70-5);
+ 
+ if (h[0]/10>h[1]/10)
+ myGLCD.print("&",690+83,270+70-3-5); 
+   if (h[0]/10==h[1]/10)
+ myGLCD.print(" ",690+83,270+70-3-5); 
+    if (h[0]/10<h[1]/10)
+ myGLCD.print("'",690+83, 270+70-3-5);   
+//*****************************************************************
+}
+
+void initial()
+{
+   myGLCD.setFont( Ubuntubold);  
+myGLCD.setBackColor( VGA_TRANSPARENT); 
+  myGLCD.setColor(10, 50, 255);
+  myGLCD.print("LOADING ..." ,400-120, 200-5);
+  
+   sd.chdir("/");
+  delay (100);
+   
+  if (!sd.chdir("/"))
+  {sd.begin(chipSelect, SPI_HALF_SPEED );
+  delay (100);
+  
+    sd.chdir("/");
+  delay (100);
+  }//установка раб директории 
+  else
+  {delay(500);
+  }
+}

_718/savedat.ino

@@ -0,0 +1,344 @@
+void savetdat()
+{  // myFile.print(c);//t1+103c375v299h9
+//byte ntdat;номер датчика
+//byte zndat;знак температуры 0+
+//int tdat;температура
+//int hdat;влажность
+//int vdat;напряж батареи датчика
+int hourd;//время прихода данных час
+  int mind;//мин
+   int tdatc;
+  int tdatd;
+  int hdatc;
+  int hdatd;
+  int vdat;
+if(ntdat==1)
+{ hourd1=t.hour;
+  mind1=t.min;
+  hourd=t.hour;
+  mind=t.min;
+  tdatc=t11/10;
+  tdatd=t11%10;
+  hdatc=h11/10;
+  hdatd=h11%10;
+  vdat=bat[0];
+}
+if(ntdat==2)
+{ hourd2=t.hour;
+  mind2=t.min;
+  hourd=t.hour;
+  mind=t.min;
+  tdatc=t12/10;
+  tdatd=t12%10;
+   hdatc=h12/10;
+  hdatd=h12%10;
+  vdat=bat[1];
+}
+if(ntdat==3)
+{ hourd3=t.hour;
+  mind3=t.min;
+  hourd=t.hour;
+  mind=t.min;
+  tdatc=t13/10;
+  tdatd=t13%10;
+   hdatc=h13/10;
+  hdatd=h13%10;
+  vdat=bat[2];
+}
+if(ntdat==4)
+{ hourd4=t.hour;
+  mind4=t.min;
+  hourd=t.hour;
+  mind=t.min;
+  tdatc=t14/10;
+  tdatd=t14%10;
+   hdatc=h14/10;
+  hdatd=h14%10;
+  vdat=bat[3];
+}
+if(ntdat==5)
+{ hourd5=t.hour;
+  mind5=t.min;
+  hourd=t.hour;
+  mind=t.min;
+  tdatc=t15/10;
+  tdatd=t15%10;
+   hdatc=h15/10;
+  hdatd=h15%10;
+  vdat=bat[4];
+}
+ myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(0,172,238);
+ myGLCD.setFont(BigFont);
+ 
+ myGLCD.print("                    " ,80, 457);//20
+   myGLCD.printNumI(ntdat ,80, 457);
+  myGLCD.print("t_T=" ,80+16, 457);//*16
+  if (zndat==0) 
+  {myGLCD.print("+" ,80+90, 457);
+  }
+  else
+  {myGLCD.print("-" ,80+90, 457);//pos*16
+  }
+ 
+ if (tdatc<10) 
+  {myGLCD.printNumI(tdatc ,80+90+16+16, 457);
+  }
+  else
+  {myGLCD.printNumI(tdatc ,80+90+16, 457);//pos*16
+  } 
+  myGLCD.print("," ,80+90+16+16+16, 457);
+  myGLCD.printNumI(tdatd ,80+90+16+16+16+16, 457);
+  myGLCD.print("C_H=" ,80+90+16+16+16+16+16+16, 457);//498
+  
+  
+ if (hdatc<10) 
+  {myGLCD.printNumI(hdatc ,314+16+16, 457);
+  }
+  else
+  {myGLCD.printNumI(hdatc ,314+16, 457);//pos*16
+  } 
+  myGLCD.print("," ,314+16+16+16, 457);
+  myGLCD.printNumI(hdatd ,314+16+16+16+16, 457);
+  
+  myGLCD.print("%_U=" ,314+16+16+16+16+16, 457);//610
+  myGLCD.printNumI(vdat/100 ,458-16, 457);
+   myGLCD.print("," ,458, 457);
+    myGLCD.printNumI(vdat%100 ,458+16, 457);
+    myGLCD.print("v " ,458+64-16, 457);
+    
+     if (hourd<10)
+  {myGLCD.print("0" ,474+64, 457);
+  myGLCD.printNumI(hourd,474+64+16, 457);
+  }
+  else
+ { myGLCD.printNumI(hourd,474+64, 457);
+ }
+ myGLCD.print(":",474+64+32, 457);
+  if (mind<10)
+  {myGLCD.print("0",474+64+32+16, 457);
+  myGLCD.printNumI(mind,474+64+32+32, 457);
+  }
+  else
+ { myGLCD.printNumI(mind,474+64+32+16, 457);
+ }
+ 
+ if(fh==0)
+ {   //запись на флешку
+    char* strd[] = {"01","02","03","04","05","06","07","08","09","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31"};
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  char* stry[] = {"2014","2015","2016","2017","D-2018","D-2019","D-2020","D-2021","D-2022","D-2023","D-2024","D-2025","D-2026","D-2027","D-2028","D-2029","D-2030","D-2031","D-2032","D-2033","D-2034","D-2035"};
+    char* strdat[] = {"T1.txt","T2.txt","T3.txt","T4.txt","T5.txt","T6.txt","T7.txt","T8.txt","T9.txt","T10.txt"};
+   char* name; 
+   sd.chdir("/");//корневая директория
+  delay (100);
+ //   if (!sd.chdir("tdat"))//если поддериктория не создана , то создаем
+ // {sd.mkdir("tdat");
+//  }
+ //  delay (100);
+//sd.chdir("tdat");
+//------------------------------------------------------------------------------------------------------
+ t = rtc.getTime();
+   name= stry[t.year-2014];
+   if (!sd.chdir(name))
+  {sd.mkdir(name);
+  }
+  sd.chdir(name);//установка раб директории
+  delay (100);
+  
+    name= strm[t.mon-1];
+  
+  if (!sd.chdir(name))
+  {sd.mkdir(name);
+  }
+   sd.chdir(name);//установка раб директории
+  delay (100);
+ 
+  name= strd[t.date-1];
+  
+  if (!sd.chdir(name))
+  {sd.mkdir(name);
+  }
+   sd.chdir(name);//установка раб директории
+  delay (100);
+//-----------------------------------------------------------------------------------------------------------------------------------
+//delay (100);
+  name= strdat[ntdat-1];// имя файла
+myFile.open(name, O_RDWR | O_CREAT | O_AT_END);//15:22 T=+25,2C H=45,6% U=2,7v
+ if (hourd<10)
+  {myFile.print("0");
+  myFile.print(hourd);
+  }
+  else
+ { myFile.print(hourd);
+ }
+ myFile.print(":");
+  if (mind<10)
+  {myFile.print("0");
+  myFile.print(mind);
+  }
+  else
+ { myFile.print(mind);
+ }
+ 
+ if (zndat==0) 
+  {myFile.print("T=+");
+  }
+  else
+  {myFile.print("T=-");
+  }
+  
+if (tdatc<10) 
+  {myFile.print("0");
+  myFile.print(tdatc);
+  }
+  else
+  {myFile.print(tdatc);
+  } 
+ myFile.print(",");
+ 
+  myFile.print(tdatd);
+
+  myFile.print("C H=");
+if (hdatc<10) 
+  {myFile.print("0");
+  myFile.print(hdatc);
+  }
+  else
+  {myFile.print(hdatc);
+  } 
+ myFile.print(",");
+  myFile.print(hdatd);
+  
+  myFile.print("% U=");
+   myFile.print(vdat/100);
+   myFile.print(",");
+   
+   if (vdat%100<10) 
+  {myFile.print("0");
+  myFile.print(vdat%100);
+  }
+  else
+  { myFile.print(vdat%100);
+  }
+   myFile.println("v");
+  
+ myFile.close();
+   sd.chdir("/");
+   
+
+}
+}
+
+//******************************************************************************************
+void printdat ()
+{
+   myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(0,172,238);
+ myGLCD.setFont(BigFont);
+ myGLCD.print("                    " ,80, 457);//20
+   myGLCD.printNumI(ntdat ,80, 457);
+  myGLCD.print("t_T=" ,80+16, 457);//*16
+  if (zndat==0) 
+  {myGLCD.print("+" ,80+90, 457);
+  }
+  else
+  {myGLCD.print("-" ,80+90, 457);//pos*16
+  }
+  
+  int hourd;//время прихода данных час
+  int mind;//мин
+   int tdatc;
+  int tdatd;
+  int hdatc;
+  int hdatd;
+  int vdat;
+if(ntdat==1)
+{
+  hourd=hourd1;
+  mind=mind1;
+  tdatc=t11/10;
+  tdatd=t11%10;
+  hdatc=h11/10;
+  hdatd=h11%10;
+  vdat=bat[0];
+}
+if(ntdat==2)
+{ hourd=hourd2;
+  mind=mind2;
+  tdatc=t12/10;
+  tdatd=t12%10;
+   hdatc=h12/10;
+  hdatd=h12%10;
+  vdat=bat[1];
+}
+if(ntdat==3)
+{ hourd=hourd3;
+  mind=mind3;
+  tdatc=t13/10;
+  tdatd=t13%10;
+   hdatc=h13/10;
+  hdatd=h13%10;
+  vdat=bat[2];
+}
+if(ntdat==4)
+{ hourd=hourd4;
+  mind=mind4;
+  tdatc=t14/10;
+  tdatd=t14%10;
+   hdatc=h14/10;
+  hdatd=h14%10;
+  vdat=bat[3];
+}
+if(ntdat==5)
+{ hourd=hourd5;
+  mind=mind5;
+  tdatc=t15/10;
+  tdatd=t15%10;
+   hdatc=h15/10;
+  hdatd=h15%10;
+  vdat=bat[4];
+}
+
+ if (tdatc<10) 
+  {myGLCD.printNumI(tdatc ,80+90+16+16, 457);
+  }
+  else
+  {myGLCD.printNumI(tdatc ,80+90+16, 457);//pos*16
+  } 
+  myGLCD.print("," ,80+90+16+16+16, 457);
+  myGLCD.printNumI(tdatd ,80+90+16+16+16+16, 457);
+  myGLCD.print("C_H=" ,80+90+16+16+16+16+16+16, 457);//498
+  
+ if (hdatc<10) 
+  {myGLCD.printNumI(hdatc ,314+16+16, 457);
+  }
+  else
+  {myGLCD.printNumI(hdatc ,314+16, 457);//pos*16
+  } 
+  myGLCD.print("," ,314+16+16+16, 457);
+  myGLCD.printNumI(hdatd ,314+16+16+16+16, 457);
+  
+  myGLCD.print("%_U=" ,314+16+16+16+16+16, 457);//610
+  myGLCD.printNumI(vdat/100 ,458-16, 457);
+   myGLCD.print("," ,458, 457);
+    myGLCD.printNumI(vdat%100 ,458+16, 457);
+    myGLCD.print("v " ,458+64-16, 457);
+    
+     if (hourd<10)
+  {myGLCD.print("0" ,474+64, 457);
+  myGLCD.printNumI(hourd,474+64+16, 457);
+  }
+  else
+ { myGLCD.printNumI(hourd,474+64, 457);
+ }
+ myGLCD.print(":",474+64+32, 457);
+  if (mind<10)
+  {myGLCD.print("0",474+64+32+16, 457);
+  myGLCD.printNumI(mind,474+64+32+32, 457);
+  }
+  else
+ { myGLCD.printNumI(mind,474+64+32+16, 457);
+ }
+ delay (1000);
+}

_718/saveminmax.ino

@@ -0,0 +1,314 @@
+void saveminmax()
+{ 
+  char* strd[] = {"01.txt","02.txt","03.txt","04.txt","05.txt","06.txt","07.txt","08.txt","09.txt","10.txt","11.txt","12.txt","13.txt","14.txt","15.txt","16.txt","17.txt","18.txt","19.txt","20.txt","21.txt","22.txt","23.txt","24.txt","25.txt","26.txt","27.txt","28.txt","29.txt","30.txt","31.txt"};
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  char* stry[] = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};
+
+ 
+   //*******************************************
+ //вычисление минимального и масимального значеия массива work2[n]
+ //************************************************ 
+ 
+ word Tmax;
+ 
+  word Tmin;
+ int Tcr=500;// значение нуля для средней темп
+  word td=0;
+  boolean znmin;//0-+ 1-- min max Знак начальной мин и макс температуры для сравнение
+  boolean znmax;//0-+ 1-- min max Знак начальной мин и макс температуры для сравнение
+  boolean zn;//0-+ 1-- tsr знак средней температуры
+  byte i;
+  if (temul[0]>999)
+  {Tmax=temul[0]-1000;
+   Tmin=Tmax;
+   znmin=1;//-
+   znmax=1;//-
+  }
+  else
+  {Tmax=temul[0];
+   Tmin=Tmax;
+  znmin=0;//+
+   znmax=0;//+
+  }
+  
+  for ( byte i=0; i<24; i++)//Tu
+   {
+     if (temul[i]>999)
+     { td=temul[i]-1000;
+       zn=1;//-
+     }
+     else
+     {td=temul[i];
+       zn=0;//+
+     }
+     
+     
+     if (zn==0)
+     {Tcr=Tcr+td;
+     }
+     else
+     {Tcr=Tcr-td;
+     }
+   //****************** + + ****************
+  if((zn==0)&&(znmax==0))  
+    { if (td>Tmax)
+     {Tmax=td;
+      znmax=0;
+     }
+    }
+      //****************** + - ******
+  if((zn==0)&&(znmax==1))  
+    { 
+     Tmax=td;
+     znmax=0;
+    }
+     //****************** - - ******
+ if((zn==1)&&(znmax==1))  
+    { if (td<Tmax)
+     {Tmax=td;
+      znmax=1;
+     }
+    } 
+       //****************** - + ******
+ if((zn==1)&&(znmax==0))  
+    { 
+     //Tmax=Tmax;
+      znmax=0;
+     
+    } 
+    
+  
+   //****************** + + ****************
+  if((zn==0)&&(znmin==0))  
+    { if (td<Tmin)
+     {Tmin=td;
+      znmin=0;
+     }
+    } 
+    //****************** - - ****************
+  if((zn==1)&&(znmin==1))  
+    { if (td>Tmin)
+     {Tmin=td;
+      znmin=1;
+     }
+    } 
+       //****************** - + ****************
+  if((zn==1)&&(znmin==0))  
+    { 
+     Tmin=td;
+      znmin=1;
+     
+    } 
+      //****************** + - ****************
+  if((zn==0)&&(znmin==1))  
+    { 
+     //Tmin=Tmin;
+      znmin=1;
+     
+    } 
+  
+  
+     
+    }
+ //******************************  
+   
+   if (Tcr<500)
+   { Tcr=(500-Tcr)/24;
+   zn=1;
+   }
+   else
+    {Tcr=(Tcr-500)/24;
+    zn=0;
+    }
+//********************************************** 
+ int Hcr=0;
+    for ( byte i=0; i<24; i++)//Tu
+   {
+    Hcr=Hcr+hug[i];
+   }
+ Hcr=Hcr/24;
+//*************************************************** 
+  word Pcr=0;
+ 
+  for ( byte i=0; i<24; i++)//Tu
+   {
+    Pcr=Pcr+pres[i]-700;
+     }
+    Pcr=700+Pcr/24;
+ //**************************************************
+ word Thcr=0;
+    for ( byte i=0; i<24; i++)//Tu
+   {
+   Thcr=Thcr+temdom[i];
+   }
+ Thcr=Thcr/24;
+ //**************************************************
+ 
+ t = rtc.getTime();
+  char* name;
+  sd.chdir("/");
+  delay (100);
+  
+  sd.chdir("tempul");
+   delay (100);
+   
+   name= stry[t.year-2014];
+   if (!sd.chdir(name))
+  {sd.mkdir(name);
+  }
+  sd.chdir(name);//установка раб директории
+  delay (100);
+  
+    name= strm[t.mon-1];
+  
+  if (!sd.chdir(name))
+  {sd.mkdir(name);
+  }
+   sd.chdir(name);//установка раб директории
+  delay (100);
+  byte m=t.mon;//  месяц
+  word yea=t.year;
+  byte d=t.date;
+  delay (100);
+if(dd==1)
+{if (t.date>1)
+{ d=t.date-1;
+}
+else
+{m=t.mon-1;
+d=31;//****************************
+}
+}
+else
+{d=t.date;
+}
+   myFile.open("minmax.txt", O_RDWR | O_CREAT | O_AT_END);
+   delay (50);
+   //****запись данных в файл в формате:   01.09.14 Tmax=30.4C Tmin=15.5C Tucr=22,5C Hucr=62,8% Pmm=756 Thcr=26,2C
+     if (d<10)
+  {myFile.print("0");
+  myFile.print(d);
+  }
+  else
+ { myFile.print(d);
+ }
+  myFile.print(".");
+  
+   if (m<10)
+  {myFile.print("0");
+  myFile.print(m);
+  }
+  else
+ { myFile.print(m);
+ }
+  myFile.print(".");
+  myFile.print(yea-2000);
+  if (znmax==0)
+ { myFile.print(" Tma=+");
+ }
+ else
+ { myFile.print(" Tma=-");
+ }
+ 
+  
+     if ((Tmax<100)&&(Tmax>9))
+     {myFile.print("0");
+     myFile.print(Tmax/10);
+     myFile.print(",");
+     myFile.print(Tmax%10);
+     }
+  if (Tmax<10)
+     {myFile.print("00,");
+      myFile.print(Tmax);
+     }
+ 
+ if (Tmax>99)
+ { myFile.print(Tmax/10);
+  myFile.print(",");
+    myFile.print(Tmax%10);
+ }
+  
+  
+    myFile.print(" Tmi=");
+  if (znmin==1)
+    { myFile.print("-");
+    }
+    else
+    {myFile.print("+");
+    }
+    
+     if ((Tmin<100)&&(Tmin>9))
+     {myFile.print("0");
+     myFile.print(Tmin/10);
+     myFile.print(",");
+     myFile.print(Tmin%10);
+     }
+  if (Tmin<10)
+     {myFile.print("00,");
+      myFile.print(Tmin);
+     }
+   if (Tmin>99)   
+ { myFile.print(Tmin/10);
+     myFile.print(",");
+     myFile.print(Tmin%10);
+ }    
+  myFile.print(" Tsr=");   
+    if (zn==1)
+    { myFile.print("-");
+   
+    }
+    else
+    {myFile.print("+");
+    }
+    
+     if ((Tcr<100)&&(Tcr>9))
+     {myFile.print("0");
+     myFile.print(Tcr/10);
+     myFile.print(",");
+     myFile.print(Tcr%10);
+     }
+  if (Tcr<10)
+     {myFile.print("00,");
+      myFile.print(Tcr);
+     }
+   if (Tcr>99)   
+ { myFile.print(Tcr/10);
+     myFile.print(",");
+     myFile.print(Tcr%10);
+ }  
+     
+     myFile.print("C Hcr=");
+     if (Hcr/10<10)
+        {myFile.print("0");
+         myFile.print(Hcr/10);
+         myFile.print(",");
+         myFile.print(Hcr%10);
+        }
+     else
+      {
+        myFile.print(Hcr/10);
+        myFile.print(",");
+        myFile.print(Hcr%10);
+     }
+     
+     myFile.print("% Pcr=");
+     myFile.print (Pcr);
+     
+      myFile.print(" Thcr=");
+     myFile.print(Thcr/10);
+    myFile.print(",");
+     myFile.println(Thcr%10);
+ //myFile.println("%");
+     
+     
+ myFile.close();   
+ 
+ delay (100);
+   sd.chdir("/");
+  delay (100);
+  
+  
+  
+  //********************
+  
+}

_718/setTimeDate.ino

@@ -0,0 +1,613 @@
+void drawUpButton(int x, int y)
+{
+  myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(x, y, 32*2+x, 25*2+y);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(x, y, 32*2+x, 25*2+y);
+  myGLCD.setColor(128, 128, 255);
+  for (int i=0; i<2*15; i++)
+    myGLCD.drawLine(6*2+x+(i/1.5), 20*2+y-i, 27*2+x-(i/1.5), 20*2+y-i);
+}
+
+void drawDownButton(int x, int y)
+{
+  myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(x, y,32*2+x, 25*2+y);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(x, y,32*2+x, 25*2+y);
+  myGLCD.setColor(128, 128, 255);
+  for (int i=0; i<15*2; i++)
+    myGLCD.drawLine(6*2+x+(i/1.5), y+10+i, 27*2+x-(i/1.5), y+10+i);
+}
+
+void showDOW(byte dow)
+{
+  myGLCD.setFont( Ubuntubold);
+  char* str[] = {"MON","TUE","WED","THU","FRI","SAT","SUN"};
+  
+  myGLCD.setColor(128, 128, 255);
+  myGLCD.setBackColor(0, 0, 0);
+  myGLCD.print(str[dow-1], 2*26, 2*167);
+}
+
+
+
+byte validateDate(byte d, byte m, word y)
+{
+  byte mArr[12] = {31,0,31,30,31,30,31,31,30,31,30,31};
+  byte od;
+  
+  if (m==2)
+  {
+    if ((y % 4)==0)
+    {
+      if (d==30)
+        od=1;
+      else if (d==0)
+        od=29;
+      else
+        od=d;
+    }
+    else
+    {
+      if (d==29)
+        od=1;
+      else if (d==0)
+        od=28;
+      else
+        od=d;
+    }
+  }
+  else
+  {
+    if (d==0)
+      od=mArr[m-1];
+    else if (d==(mArr[m-1]+1))
+      od=1;
+    else
+      od=d;
+  }
+  
+  return od;
+}
+
+byte validateDateForMonth(byte d, byte m, word y)
+{
+  myGLCD.setFont( Ubuntubold);
+  byte mArr[12] = {31,0,31,30,31,30,31,31,30,31,30,31};
+  byte od;
+  boolean dc=false;
+  
+  if (m==2)
+  {
+    if ((y % 4)==0)
+    {
+      if (d>29)
+      {
+        d=29;
+        dc=true;
+      }
+    }
+    else
+    {  
+      if (d>28)
+      {
+        d=28;
+        dc=true;
+      }
+    }
+  }
+  else
+  {
+    if (d>mArr[m-1])
+    {
+      d=mArr[m-1];
+      dc=true;
+    }
+  }
+  
+  if (dc)
+  {
+    if (d<10)
+    {
+      myGLCD.printNumI(0, 122*2, 140*2);
+      myGLCD.printNumI(d, 138*2-8, 140*2);
+    }
+    else
+    {
+      myGLCD.printNumI(d, 122*2, 140*2);
+    }
+  }
+  
+  return d;
+}
+
+void setClock()
+{
+//  Time t_temp;
+  int x, y;
+  int res = 0;
+  boolean ct=false;
+  boolean cd=false;
+  
+  waitForTouchRelease();    
+  
+  myGLCD.clrScr();
+ // myGLCD.setFont(BigFont);
+  
+  // Draw Save button
+  myGLCD.setFont( Ubuntubold);
+  myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(2*165, 2*200, 2*319, 2*239);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(2*165, 2*200, 2*319, 2*239);
+  myGLCD.setBackColor(64, 64, 128);
+  myGLCD.print("SAVE", 2*210, 2*212);
+  myGLCD.setBackColor(0, 0, 0);
+  // Draw Cancel button
+  myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(0, 2*200, 2*154, 2*239);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(0, 2*200, 2*154, 2*239);
+  myGLCD.setBackColor(64, 64, 128);
+  myGLCD.print("CANCEL", 2*29, 2*212);
+  myGLCD.setBackColor(0, 0, 0);
+  
+  // Draw frames
+  myGLCD.setColor(0, 0, 255);
+  myGLCD.drawRoundRect(0, 0, 319*2, 96*2);
+  myGLCD.drawRoundRect(0, 100*2, 319*2, 196*2);
+  myGLCD.print("TIME:", 10*2, 40*2);
+  myGLCD.print(":", 154*2, 40*2);
+  myGLCD.print(":", 202*2, 40*2);
+  myGLCD.print("DATE:", 10*2, 140*2);
+  myGLCD.print(".", 154*2, 140*2);
+  myGLCD.print(".", 202*2, 140*2);
+  
+  // Draw Buttons
+  drawUpButton(122*2, 10*2);
+  drawUpButton(170*2, 10*2);
+  drawUpButton(218*2, 10*2);
+  drawDownButton(122*2, 61*2);
+  drawDownButton(170*2, 61*2);
+  drawDownButton(218*2, 61*2);
+  drawUpButton(122*2, 110*2);
+  drawUpButton(170*2, 110*2);
+  drawUpButton(234*2, 110*2);
+  drawDownButton(122*2, 161*2);
+  drawDownButton(170*2, 161*2);
+  drawDownButton(234*2, 161*2);
+  
+  // Print current time and date
+  myGLCD.setColor(255, 255, 255);
+ // t_temp = rtc.getTime();
+  if (t.date==0)
+  {
+    rtc.setTime(15, 11, 0);
+ rtc.setDate(28, 12, 2015);
+  }
+  
+  if (t.hour<10)
+  {
+    myGLCD.printNumI(0, 122*2, 40*2);
+    myGLCD.printNumI(t.hour, 138*2-8, 40*2);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour, 122*2, 40*2);
+  }
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0, 170*2, 40*2);
+    myGLCD.printNumI(t.min, 186*2-8, 40*2);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, 170*2, 40*2);
+  }
+  if (t.sec<10)
+  {
+    myGLCD.printNumI(0, 218*2, 40*2);
+    myGLCD.printNumI(t.sec, 234*2-8, 40*2);
+  }
+  else
+  {
+    myGLCD.printNumI(t.sec, 218*2, 40*2);
+  }
+  if (t.date<10)
+  {
+    myGLCD.printNumI(0, 122*2, 140*2);
+    myGLCD.printNumI(t.date, 138*2-8, 140*2);
+  }
+  else
+  {
+    myGLCD.printNumI(t.date, 122*2, 140*2);
+  }
+  if (t.mon<10)
+  {
+    myGLCD.printNumI(0, 170*2, 140*2);
+    myGLCD.printNumI(t.mon, 186*2-8, 140*2);
+  }
+  else
+  {
+    myGLCD.printNumI(t.mon, 170*2, 140*2);
+  }
+  myGLCD.printNumI(t.year, 218*2, 140*2);
+ // showDOW(t_temp.dow);
+ hour1=t.hour;
+ min1=t.min;
+sec= t.sec;
+date=t.date;
+mon= t.mon;
+year1 =t.year;
+dow= t.dow;  
+  while (res==0)
+  {
+
+    if (myTouch.dataAvailable())
+    {
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      if ((y>=10*2) && (y<=35*2)) // Buttons: Time UP
+      {
+        if ((x>=122*2) && (x<=154*2))
+        {
+          buttonWait(122*2, 10*2);
+          hour1+=1;
+          if (hour1==24)
+            hour1=0;
+          if (hour1<10)
+          {
+            myGLCD.printNumI(0, 122*2, 40*2);
+            myGLCD.printNumI(hour1, 138*2-8, 40*2);
+          }
+          else
+          {
+            myGLCD.printNumI(hour1, 122*2, 40*2);
+          }
+          if (ct==false)
+          {
+            ct=true;
+            myGLCD.setColor(64, 64, 128);
+           // myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 10*2);
+            myGLCD.setColor(255, 255, 255);
+            //myGLCD.setFont(BigFont);
+            myGLCD.setFont( Ubuntubold);
+          }
+        }
+        else if ((x>=170*2) && (x<=202*2))
+        {
+          buttonWait(170*2, 10*2);
+          min1+=1;
+          if (min1==60)
+            min1=0;
+          if (min1<10)
+          {
+            myGLCD.printNumI(0, 170*2, 40*2);
+            myGLCD.printNumI(min1, 186*2-8, 40*2);
+          }
+          else
+          {
+            myGLCD.printNumI(min1, 170*2, 40*2);
+          }
+          if (ct==false)
+          {
+            ct=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 10*2);
+            myGLCD.setColor(255, 255, 255);
+            //myGLCD.setFont(BigFont);
+            myGLCD.setFont( Ubuntubold);
+          }
+        }
+        else if ((x>=218*2) && (x<=250*2))
+        {
+          buttonWait(218*2, 10*2);
+          sec+=1;
+          if (sec==60)
+            sec=0;
+          if (sec<10)
+          {
+            myGLCD.printNumI(0, 218*2, 40*2);
+            myGLCD.printNumI(sec, 234*2-8, 40*2);
+          }
+          else
+          {
+            myGLCD.printNumI(sec, 218*2, 40*2);
+          }
+          if (ct==false)
+          {
+            ct=true;
+            myGLCD.setColor(64, 64, 128);
+           // myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 10*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont( Ubuntubold);
+           // myGLCD.setFont(BigFont);
+          }
+        }
+      }
+      else if ((y>=61*2) && (y<=86*2)) // Buttons: Time DOWN
+      {
+        if ((x>=122*2) && (x<=154*2))
+        {
+          buttonWait(122*2, 61*2);
+          hour1-=1;
+          if (hour1==255)
+            hour1=23;
+          if (hour1<10)
+          {
+            myGLCD.printNumI(0, 122*2, 40*2);
+            myGLCD.printNumI(hour1, 138*2-8, 40*2);
+          }
+          else
+          {
+            myGLCD.printNumI(hour1, 122*2, 40*2);
+          }
+          if (ct==false)
+          {
+            ct=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 10*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont( Ubuntubold);
+           // myGLCD.setFont(BigFont);
+          }
+        }
+        else if ((x>=170*2) && (x<=202*2))
+        {
+          buttonWait(170*2, 61*2);
+          min1-=1;
+          if (min1==255)
+            min1=59;
+          if (min1<10)
+          {
+            myGLCD.printNumI(0, 170*2, 40*2);
+            myGLCD.printNumI(min1, 186*2-8, 40*2);
+          }
+          else
+          {
+            myGLCD.printNumI(min1, 170*2, 40*2);
+          }
+          if (ct==false)
+          {
+            ct=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 10*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont( Ubuntubold);
+           // myGLCD.setFont(BigFont);
+          }
+        }
+        else if ((x>=218*2) && (x<=250*2))
+        {
+          buttonWait(218*2, 61*2);
+          sec-=1;
+          if (sec==255)
+            sec=59;
+          if (sec<10)
+          {
+            myGLCD.printNumI(0, 218*2, 40*2);
+            myGLCD.printNumI(sec, 234*2-8, 40*2);
+          }
+          else
+          {
+            myGLCD.printNumI(sec, 218*2, 40*2);
+          }
+          if (ct==false)
+          {
+            ct=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 10*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont( Ubuntubold);
+            //myGLCD.setFont(BigFont);
+          }
+        }
+      }
+      if ((y>=110*2) && (y<=135*2)) // Buttons: Date UP
+      {
+        if ((x>=122*2) && (x<=154*2))
+        {
+          buttonWait(122*2, 110*2);
+          date+=1;
+          date=validateDate(date, mon, year1);
+          if (date<10)
+          {
+            myGLCD.printNumI(0, 122*2, 140*2);
+            myGLCD.printNumI(date, 138*2-8, 140*2);
+          }
+          else
+          {
+            myGLCD.printNumI(date, 122*2, 140*2);
+          }
+          if (cd==false)
+          {
+            cd=true;
+            myGLCD.setColor(64, 64, 128);
+           // myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 110*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont( Ubuntubold);
+           // myGLCD.setFont(BigFont);
+          }
+        }
+        else if ((x>=170*2) && (x<=202*2))
+        {
+          buttonWait(170*2, 110*2);
+          mon+=1;
+          if (mon==13)
+            mon=1;
+          if (mon<10)
+          {
+            myGLCD.printNumI(0, 170*2, 140*2);
+            myGLCD.printNumI(mon, 186*2-8, 140*2);
+          }
+          else
+          {
+            myGLCD.printNumI(mon, 170*2, 140*2);
+          }
+         date=validateDateForMonth(date, mon, year1);
+         //  rtc_clock.set_date(date, mon, year);
+          if (cd==false)
+          {
+            cd=true;
+            myGLCD.setColor(64, 64, 128);
+          //  myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 110*2);
+            myGLCD.setColor(255, 255, 255);
+            //myGLCD.setFont(BigFont);
+            myGLCD.setFont( Ubuntubold);
+          }
+        }
+        else if ((x>=218*2) && (x<=250*2))
+        {
+          buttonWait(234*2, 110*2);
+          year1+=1;
+          if (year1==2100)
+            year1=2000;
+          myGLCD.printNumI(year1, 218*2, 140*2);
+         date=validateDateForMonth(date, mon, year1);
+        //  rtc_clock.set_date(date, mon, year);
+          if (cd==false)
+          {
+            cd=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 110*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont( Ubuntubold);
+            //myGLCD.setFont(BigFont);
+          }
+        }
+        dow=calcDOW(date, mon, year1);
+        showDOW(dow);
+      }
+      else if ((y>=161*2) && (y<=186*2)) // Buttons: Date DOWN
+      {
+        if ((x>=122*2) && (x<=154*2))
+        {
+          buttonWait(122*2, 161*2);
+          date-=1;
+          date=validateDate(date, mon, year1);
+          if (date<10)
+          {
+            myGLCD.printNumI(0, 122*2, 140*2);
+            myGLCD.printNumI(date, 138*2-8, 140*2);
+          }
+          else
+          {
+            myGLCD.printNumI(date, 122*2, 140*2);
+          }
+          if (cd==false)
+          {
+            cd=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 110*2);
+            myGLCD.setColor(255, 255, 255);
+            //myGLCD.setFont(BigFont);
+            myGLCD.setFont( Ubuntubold);
+          }
+        }
+        else if ((x>=170*2) && (x<=202*2))
+        {
+          buttonWait(170*2, 161*2);
+          mon-=1;
+          if (mon==0)
+            mon=12;
+          if (mon<10)
+          {
+            myGLCD.printNumI(0, 170*2, 140*2);
+            myGLCD.printNumI(mon, 186*2-8, 140*2);
+          }
+          else
+          {
+            myGLCD.printNumI(mon, 170*2, 140*2);
+          }
+          date=validateDateForMonth(date, mon, year1);
+          if (cd==false)
+          {
+            cd=true;
+            myGLCD.setColor(64, 64, 128);
+            //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 110*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont(BigFont);
+          }
+        }
+        else if ((x>=218*2) && (x<=250*2))
+        {
+          buttonWait(234*2, 161*2);
+          year1-=1;
+          if (year1==1999)
+            year1=2099;
+          myGLCD.printNumI(year1, 218*2, 140*2);
+          date=validateDateForMonth(date, mon, year1);
+          if (cd==false)
+          {
+            cd=true;
+            myGLCD.setColor(64, 64, 128);
+           //myGLCD.setFont(SmallFont);
+            myGLCD.print("Changed!", 10*2, 110*2);
+            myGLCD.setColor(255, 255, 255);
+            myGLCD.setFont(BigFont);
+          }
+        }
+        dow=calcDOW(date, mon, year1);
+        showDOW(dow);
+      }
+      else if ((y>=200*2) && (y<=239*2)) // Buttons: CANCEL / SAVE
+      {
+        if ((x>=165*2) && (x<=319*2))
+        {
+          res=1;
+          myGLCD.setColor (255, 0, 0);
+          myGLCD.drawRoundRect(165*2, 200*2, 319*2, 239*2);
+        }
+        else if ((x>=0) && (x<=154*2))
+        {
+          res=2;
+          myGLCD.setColor (255, 0, 0);
+          myGLCD.drawRoundRect(0, 200*2, 154*2, 239*2);
+        }
+      }
+    }
+  }
+//************************************************************************************
+
+
+  waitForTouchRelease();
+
+  if (res==1)
+  {
+    if (ct)
+      //rtc.setTime(t_temp.hour, t_temp.min, t_temp.sec);
+      rtc.setTime(hour1, min1 , sec);
+  //  if (cd)
+  //  {
+      //rtc.setDate(t_temp.date, t_temp.mon, t_temp.year1);
+      rtc.setDate(date, mon, year1);
+      dow=calcDOW(date, mon, year1);
+      rtc.setDOW(dow);
+      //rtc.setDOW(t_temp.dow);
+   // }
+  }
+  if( t.hour<7 )
+{night=1;
+}
+else
+{night=0;
+}
+  q=1;
+  clok();
+  myGLCD.setFont(BigFont);
+ // drawDisplay();
+ // printDate();
+}

_718/uart.ino

@@ -0,0 +1,6 @@
+
+void uart()
+{
+peredat();
+delay(100);
+}

_718/utils.ino

@@ -0,0 +1,40 @@
+char uCase(char c)
+{
+  if ((c>='a') && (c<='z'))
+    return (c-0x20);
+  else
+    return c;
+}
+
+void buttonWait(int x, int y)
+{
+  myGLCD.setColor(255, 0, 0);
+  myGLCD.drawRoundRect(x, y,32*2+x, 25*2+y);
+  waitForTouchRelease();
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(x, y, 32*2+x, 25*2+y);
+}
+
+byte calcDOW(byte d, byte m, int y)
+{
+  int dow;
+  byte mArr[12] = {6,2,2,5,0,3,5,1,4,6,2,4};
+  
+  dow = (y % 100);
+  dow = dow*1.25;
+  dow += d;
+  dow += mArr[m-1];
+  if (((y % 4)==0) && (m<3))
+    dow -= 1;
+  while (dow>7)
+    dow -= 7;
+    
+  return dow;
+}
+
+void waitForTouchRelease()
+{
+  // Wait for release
+  while (myTouch.dataAvailable()==true)
+    myTouch.read();
+}

_718/wer.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: w.jpg
+// Time generated: 13.04.2014 18:06:28
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short wer[0x1900] ={
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0010 (16)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0020 (32)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0030 (48)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0040 (64)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0050 (80)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0060 (96)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0070 (112)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0080 (128)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0090 (144)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00A0 (160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00B0 (176)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00C0 (192)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00D0 (208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00E0 (224)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00F0 (240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF79E,   // 0x0100 (256)
+0xEF5D, 0xE73C, 0xE71C, 0xDEDB, 0xD6BA, 0xD6BA, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x0110 (272)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x0120 (288)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE79, 0xCE79, 0xCE79, 0xD69A, 0xD6BA, 0xDEDB, 0xE71C, 0xE73C,   // 0x0130 (304)
+0xEF7D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0140 (320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E, 0xEF7D, 0xE73C,   // 0x0150 (336)
+0xDEFB, 0xD6BA, 0xCE79, 0xC638, 0xBDF7, 0xBDF7, 0xB5B6, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xAD75, 0xAD75, 0xAD75,   // 0x0160 (352)
+0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD76, 0xAD76, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75,   // 0x0170 (368)
+0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD76, 0xAD76, 0xB596, 0xB596, 0xB5B6, 0xBDD7, 0xBDF8, 0xC638, 0xCE79, 0xD6BA,   // 0x0180 (384)
+0xDEFB, 0xE73C, 0xEF7D, 0xF79E, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E, 0xEF5D, 0xE71C, 0xD6BA,   // 0x01A0 (416)
+0xCE59, 0xC618, 0xB5B6, 0xAD75, 0xA534, 0x9CF3, 0x9CD3, 0x94B2, 0x9492, 0x9492, 0x9492, 0x8C92, 0x9492, 0x9492, 0x9492, 0x9492,   // 0x01B0 (432)
+0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x9492,   // 0x01C0 (448)
+0x9492, 0x9492, 0x9492, 0x9492, 0x9492, 0x8C92, 0x8C92, 0x9492, 0x9492, 0x9492, 0x94B3, 0x9CD3, 0xA514, 0xAD55, 0xB5B7, 0xC618,   // 0x01D0 (464)
+0xCE79, 0xDEDB, 0xE71C, 0xEF5D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01E0 (480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xF79E, 0xEF5D, 0xDEFB, 0xD69A, 0xC638,   // 0x01F0 (496)
+0xB5B7, 0xA555, 0xB5D7, 0xC639, 0xDEFC, 0xEF5E, 0xEF5E, 0xEF7E, 0xEF9E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF5E, 0xEF7E,   // 0x0200 (512)
+0xEF5E, 0xEF5E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E,   // 0x0210 (528)
+0xEF5E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xEF7E, 0xF7BF, 0xEF7E, 0xDEDC, 0xCE7A, 0xB5B7, 0xAD55,   // 0x0220 (544)
+0xB5B7, 0xC638, 0xD6BA, 0xE71C, 0xEF5D, 0xF79E, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0230 (560)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xEF5D, 0xDEFB, 0xCE79, 0xBDF7, 0xAD75,   // 0x0240 (576)
+0xA535, 0xDEFC, 0xE75D, 0xE73D, 0xDF1D, 0xD6DC, 0xD6BC, 0xD6DC, 0xD6DC, 0xCEBC, 0xCEBC, 0xCEBC, 0xD6BC, 0xCEBC, 0xD6BC, 0xD6BC,   // 0x0250 (592)
+0xD6BC, 0xD6BC, 0xCEBC, 0xCEBC, 0xCEBC, 0xCEBB, 0xCEBB, 0xCEBB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xCEBB,   // 0x0260 (608)
+0xCEBB, 0xCEBB, 0xCEDC, 0xCEDC, 0xD6DC, 0xCEDC, 0xCEDC, 0xCEDC, 0xD6DC, 0xD6DC, 0xCEBB, 0xD6DC, 0xD6FC, 0xE73D, 0xE75E, 0xD6DC,   // 0x0270 (624)
+0xAD55, 0xB576, 0xC618, 0xD69A, 0xDEFB, 0xEF5D, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0280 (640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xDEFB, 0xCE79, 0xBDF7, 0xAD55, 0xBDF8,   // 0x0290 (656)
+0xE73D, 0xDF3D, 0xD6FD, 0xCEBC, 0xCE9C, 0xCE9C, 0xCE9C, 0xC65B, 0xC67B, 0xC69C, 0xC69C, 0xC67C, 0xC67B, 0xC67B, 0xC67B, 0xC67B,   // 0x02A0 (672)
+0xC65B, 0xC67B, 0xC67B, 0xC67B, 0xC67B, 0xC67B, 0xC67A, 0xC65A, 0xCE5A, 0xCE7A, 0xCE7A, 0xCE7A, 0xCE7A, 0xCE7A, 0xC67A, 0xC67A,   // 0x02B0 (688)
+0xC67B, 0xC67B, 0xC67B, 0xC67B, 0xC69B, 0xC69B, 0xC69B, 0xC69B, 0xC69B, 0xC69C, 0xCEBC, 0xCEBB, 0xCEDC, 0xCEDC, 0xD6DC, 0xD6FD,   // 0x02C0 (704)
+0xEF7E, 0xB5D7, 0xAD76, 0xBDF8, 0xD69A, 0xE6FC, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x02D0 (720)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xD6BA, 0xBDF8, 0xAD55, 0xC639, 0xE73E,   // 0x02E0 (736)
+0xD6FC, 0xCEBC, 0xC6BC, 0xBE7C, 0xBE5B, 0xBE7C, 0xBE7C, 0xBE5C, 0xB65B, 0xBE5B, 0xBE5B, 0xBE3A, 0xBE3A, 0xBE3A, 0xBE3A, 0xBE3A,   // 0x02F0 (752)
+0xBE3A, 0xBE3A, 0xBE3A, 0xBE3A, 0xBE1A, 0xBE1A, 0xBDF9, 0xBE19, 0xC5F9, 0xC5F9, 0xC619, 0xC619, 0xC619, 0xBE19, 0xBE19, 0xBE19,   // 0x0300 (768)
+0xBE3A, 0xBE3A, 0xBE3A, 0xB63A, 0xB63A, 0xBE5B, 0xBE5B, 0xBE5B, 0xB65B, 0xBE3B, 0xBE3B, 0xBE3A, 0xBE5B, 0xC67C, 0xC69C, 0xDF1E,   // 0x0310 (784)
+0xCE9B, 0xE75E, 0xBDF8, 0xB596, 0xC618, 0xD6BA, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0320 (800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xC638, 0xB596, 0xB5B7, 0xDF1D, 0xCEDC,   // 0x0330 (816)
+0xBE7B, 0xBE7C, 0xB63B, 0xB65C, 0xB65C, 0xAE1B, 0xADFB, 0xAE1B, 0xB63B, 0xADFB, 0xB61B, 0xAE1A, 0xB619, 0xB61A, 0xB5F9, 0xB5F9,   // 0x0340 (832)
+0xB5F9, 0xB5F9, 0xB5F9, 0xB5F9, 0xB5D9, 0xB5B9, 0xBDB8, 0xBDB8, 0xBD97, 0xBDB7, 0xBDB7, 0xBDD7, 0xBDD7, 0xBDB7, 0xB5B8, 0xB5D8,   // 0x0350 (848)
+0xB5D9, 0xB5F9, 0xB5D9, 0xB5FA, 0xADFA, 0xAE1A, 0xAE1A, 0xAE1A, 0xAE1B, 0xADFA, 0xB61B, 0xBE5C, 0xB61B, 0xB63C, 0xBE7C, 0xB63B,   // 0x0360 (864)
+0xCEBC, 0xCEBC, 0xE75E, 0xAD97, 0xB596, 0xCE59, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0370 (880)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0xBDD7, 0xA514, 0xD6FC, 0xCEBC, 0xC67B,   // 0x0380 (896)
+0xBE7C, 0xB65C, 0xAE1C, 0xADFB, 0xA5FB, 0xA5FB, 0xA5FB, 0xA5DB, 0xA5FB, 0xA5DA, 0xADFA, 0xA5D9, 0xA5B8, 0xADD9, 0xADD9, 0xADD8,   // 0x0390 (912)
+0xADB8, 0xB5B8, 0xB597, 0xB5B8, 0xB597, 0xB577, 0xB576, 0xBD76, 0xBD75, 0xBD55, 0xBD75, 0xB575, 0xB575, 0xB576, 0xB597, 0xB597,   // 0x03A0 (928)
+0xAD97, 0xADB8, 0xADB8, 0xADB9, 0xADD9, 0xADDA, 0xADDA, 0xADDA, 0xADDA, 0xADFB, 0xADFA, 0xADFB, 0xADFB, 0xAE1B, 0xAE1C, 0xB63C,   // 0x03B0 (944)
+0xBE5C, 0xC67C, 0xCEDC, 0xD6DC, 0xA515, 0xBDF7, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03C0 (960)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC638, 0xAD76, 0xAD96, 0xCEBB, 0xC69C, 0xB67C,   // 0x03D0 (976)
+0xAE1C, 0xAE1C, 0xA5DB, 0xA5DB, 0x9DDB, 0x9DDB, 0x9DDA, 0x9DDA, 0x9DBA, 0x9DBA, 0x9DB9, 0xA599, 0xA598, 0xA598, 0xA597, 0xA576,   // 0x03E0 (992)
+0xAD76, 0xAD55, 0xB576, 0xB576, 0xB575, 0xB554, 0xB533, 0xB533, 0xBD33, 0xBD54, 0xBD54, 0xBD55, 0xB554, 0xB534, 0xAD34, 0xAD34,   // 0x03F0 (1008)
+0xAD55, 0xAD76, 0xAD77, 0xAD77, 0xAD98, 0xA598, 0xA599, 0xA599, 0xA59A, 0xA59A, 0xA5BA, 0xA5BA, 0xA5DB, 0xA5FB, 0xA5FB, 0xA61B,   // 0x0400 (1024)
+0xAE3C, 0xBE5C, 0xC67B, 0xD6DC, 0xB597, 0xB596, 0xCE59, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0410 (1040)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0xA535, 0xC639, 0xC69B, 0xB67B, 0xAE3C,   // 0x0420 (1056)
+0xA5DB, 0x9DDC, 0x9DBB, 0x959B, 0x959A, 0x959A, 0x959A, 0x959A, 0x9D9A, 0x9D79, 0x9D79, 0x9D99, 0xA579, 0xA558, 0xA557, 0xAD56,   // 0x0430 (1072)
+0xAD35, 0xAD34, 0xAD13, 0xB513, 0xB533, 0xB532, 0xB511, 0xB4F0, 0xB4F0, 0xB4D0, 0xBD32, 0xB512, 0xACF2, 0xACF2, 0xB533, 0xB554,   // 0x0440 (1088)
+0xB534, 0xAD35, 0xAD35, 0xAD56, 0xA557, 0xA558, 0xA578, 0x9D59, 0x9D79, 0x9D79, 0x9D7A, 0x9D9A, 0x9D9B, 0x95BB, 0x9DBB, 0x9DDC,   // 0x0450 (1104)
+0xA5FB, 0xAE1B, 0xBE5B, 0xCEBC, 0xC639, 0xA555, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0460 (1120)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x9CF4, 0xC65A, 0xBE7B, 0xAE3B, 0xA5FB,   // 0x0470 (1136)
+0x9DBC, 0x959B, 0x959B, 0x957B, 0x957A, 0x957A, 0x9579, 0x9579, 0x9559, 0x9559, 0x9D59, 0x9D58, 0x9D37, 0x9D16, 0xA515, 0xAD34,   // 0x0480 (1152)
+0xAD34, 0xAD13, 0xBD53, 0xB511, 0xACD0, 0xB4F0, 0xBD10, 0xBD0F, 0xB4EF, 0xB4EF, 0xB4F0, 0xB511, 0xB511, 0xB4F1, 0xB4F1, 0xACD1,   // 0x0490 (1168)
+0xACB1, 0xA4D2, 0xAD13, 0xAD15, 0xA535, 0xA536, 0x9D58, 0x9D58, 0x9D59, 0x9559, 0x9559, 0x957A, 0x957A, 0x959B, 0x959B, 0x95BB,   // 0x04A0 (1184)
+0x9DBB, 0xA5FB, 0xB63B, 0xBE5B, 0xC65A, 0x9D14, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x04B0 (1200)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B7, 0x94D4, 0xC67A, 0xBE5B, 0xA61B, 0x9DDB,   // 0x04C0 (1216)
+0x959B, 0x8D7B, 0x8D5B, 0x8D5A, 0x8D5A, 0x8D59, 0x8D59, 0x8D58, 0x9559, 0x9538, 0x9518, 0x9D37, 0x9D16, 0x9D15, 0xA4F4, 0xACF3,   // 0x04D0 (1232)
+0xACF2, 0xACD1, 0xACAF, 0xB4CF, 0xB4EF, 0xB4EF, 0xACAD, 0xAC8D, 0xB4CD, 0xBCEF, 0xB4CE, 0xB4CF, 0xACAE, 0xACAE, 0xB4CF, 0xB4F0,   // 0x04E0 (1248)
+0xB4D0, 0xACD1, 0xACD2, 0xA4F3, 0xA514, 0x9D15, 0x9D16, 0x9537, 0x9518, 0x9538, 0x8D39, 0x8D59, 0x8D5A, 0x8D7A, 0x8D7A, 0x959B,   // 0x04F0 (1264)
+0x959B, 0x9DDB, 0xAE1B, 0xBE5B, 0xCE9B, 0x9CD4, 0xB5B7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0500 (1280)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB596, 0x94B3, 0xCEBB, 0xAE3A, 0x9DFB, 0x95DB,   // 0x0510 (1296)
+0x8D7B, 0x853B, 0x8D3B, 0x8D3A, 0x8D59, 0x8D59, 0x8D38, 0x8D38, 0x8D18, 0x9517, 0x9516, 0x9515, 0x9D15, 0xA514, 0xACF3, 0xA4D1,   // 0x0520 (1312)
+0xACD0, 0xACAF, 0xB4EF, 0xB4CE, 0xB4CE, 0xBD2F, 0xCDD1, 0xDE53, 0xE654, 0xE653, 0xDE13, 0xCDB1, 0xBD2F, 0xACAD, 0xAC8D, 0xAC6D,   // 0x0530 (1328)
+0xAC8E, 0xACAF, 0xACB0, 0xA4B1, 0xA4D3, 0x9CF4, 0x94F6, 0x9517, 0x9517, 0x8D18, 0x8D19, 0x8D19, 0x8D39, 0x853A, 0x855A, 0x857B,   // 0x0540 (1344)
+0x8D7B, 0x95BB, 0xA5DB, 0xB63B, 0xCEBC, 0x94B3, 0xB5B7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0550 (1360)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB596, 0x9492, 0xC67B, 0xADFA, 0x9DBA, 0x8D9B,   // 0x0560 (1376)
+0x8D5B, 0x851A, 0x851A, 0x8519, 0x8519, 0x8538, 0x8517, 0x8517, 0x8CF7, 0x8CF6, 0x8CF5, 0x94D4, 0x94D3, 0x9CF2, 0xA4B1, 0xA48F,   // 0x0570 (1392)
+0xACAE, 0xB4CF, 0xACAE, 0xD5D2, 0xF6F6, 0xFF79, 0xFFB9, 0xFFB9, 0xFFDA, 0xFFD9, 0xFFD9, 0xFFB9, 0xFF57, 0xF694, 0xD590, 0xB4AD,   // 0x0580 (1408)
+0xAC4C, 0xAC8E, 0xAC8F, 0xA4B1, 0x9CB2, 0x9CD3, 0x94D5, 0x8CF6, 0x8CF7, 0x84F7, 0x84F8, 0x84F8, 0x8519, 0x8519, 0x851A, 0x853A,   // 0x0590 (1424)
+0x8D5A, 0x957A, 0x9D9A, 0xB61B, 0xC65A, 0x9493, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x05A0 (1440)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD96, 0x94B3, 0xB63A, 0xAE1B, 0x9DBB, 0x855A,   // 0x05B0 (1456)
+0x853B, 0x851A, 0x851A, 0x7D19, 0x7CF8, 0x84F7, 0x84F7, 0x84F7, 0x8CD6, 0x8CD5, 0x94D4, 0x94D2, 0x94D1, 0xA4D0, 0xA4AF, 0xA4AE,   // 0x05C0 (1472)
+0xB4EE, 0xCD70, 0xFEF6, 0xFF57, 0xFF98, 0xFF57, 0xFF17, 0xFF17, 0xFEF7, 0xFEF6, 0xFF15, 0xFF15, 0xFF36, 0xFF77, 0xFF57, 0xEE53,   // 0x05D0 (1488)
+0xC50E, 0xAC6B, 0xAC6C, 0xA48E, 0xA490, 0x9CB2, 0x94B4, 0x8CD6, 0x84D7, 0x84D7, 0x84F8, 0x7CD8, 0x7CF8, 0x7CF9, 0x7D1A, 0x7D1A,   // 0x05E0 (1504)
+0x853A, 0x8D5A, 0x9D9A, 0xADFB, 0xBE3A, 0x9493, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x05F0 (1520)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9492, 0xBE3B, 0xA5DB, 0x957A, 0x855A,   // 0x0600 (1536)
+0x7D3A, 0x74FA, 0x74FA, 0x74F9, 0x7CF8, 0x7CD7, 0x84D7, 0x84B6, 0x84B5, 0x8CB4, 0x8C93, 0x9CD2, 0x9C8F, 0xA48D, 0xACAC, 0xB4CC,   // 0x0610 (1552)
+0xDE11, 0xFF16, 0xFF57, 0xFEF5, 0xFE93, 0xFE72, 0xFE52, 0xFE33, 0xFE13, 0xFE32, 0xFE71, 0xEE30, 0xFE73, 0xFE94, 0xFED4, 0xFF75,   // 0x0620 (1568)
+0xFEF3, 0xD5AE, 0xA46A, 0x9C4A, 0xACCF, 0x9470, 0x9473, 0x8C96, 0x7C76, 0x7CD7, 0x7CD7, 0x7CD8, 0x7CD9, 0x74D9, 0x7CFA, 0x7CFA,   // 0x0630 (1584)
+0x7D1A, 0x853B, 0x959B, 0xA5BB, 0xBE3A, 0x9493, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0640 (1600)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9492, 0xB61B, 0xA5DB, 0x8D5A, 0x853A,   // 0x0650 (1616)
+0x7D1A, 0x6CF9, 0x6CD9, 0x6CD9, 0x74B8, 0x7497, 0x7C96, 0x8496, 0x8494, 0x8C93, 0x9493, 0x9470, 0x9C8D, 0xA48B, 0xB4CB, 0xDDEF,   // 0x0660 (1632)
+0xFEF3, 0xFF14, 0xFEB4, 0xFE52, 0xFE10, 0xFDEF, 0xFDF0, 0xFDB1, 0xFDD1, 0xFDF0, 0xF60F, 0xF5EF, 0xFE11, 0xFE11, 0xF610, 0xFE71,   // 0x0670 (1648)
+0xFEF2, 0xF6D1, 0xD5CD, 0xACAA, 0x9C2B, 0x9C6F, 0x9452, 0x8C54, 0x7C75, 0x7C96, 0x7497, 0x74B7, 0x74B8, 0x74B8, 0x74B9, 0x74D9,   // 0x0680 (1664)
+0x74FA, 0x7D3B, 0x8D7B, 0x9DBB, 0xBE3B, 0x9493, 0xAD76, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0690 (1680)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9492, 0xB63B, 0x9DBB, 0x8D5B, 0x7D1A,   // 0x06A0 (1696)
+0x74FA, 0x6CD9, 0x64B9, 0x64B8, 0x6C98, 0x7497, 0x7C96, 0x7C95, 0x8474, 0x8493, 0x9491, 0x944E, 0xA48C, 0xACAA, 0xD56D, 0xFEF2,   // 0x06B0 (1712)
+0xFEF3, 0xF651, 0xF611, 0xF5F0, 0xF5CE, 0xFDCE, 0xFDCF, 0xFDB0, 0xFDB0, 0xFDCF, 0xFDEE, 0xFDAD, 0xFD8F, 0xFDAF, 0xF58E, 0xFDEE,   // 0x06C0 (1728)
+0xFE70, 0xFEB0, 0xFEB1, 0xD58D, 0x9BE9, 0xA44D, 0x9430, 0x8412, 0x7C74, 0x7475, 0x7497, 0x7497, 0x6C98, 0x6C98, 0x6CB9, 0x6CB9,   // 0x06D0 (1744)
+0x74FA, 0x7D1A, 0x855B, 0x9D9B, 0xB61A, 0x9493, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06E0 (1760)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x9493, 0xAE1B, 0x959B, 0x853B, 0x74FB,   // 0x06F0 (1776)
+0x6CDA, 0x64B9, 0x6499, 0x6499, 0x6C97, 0x6C77, 0x7476, 0x7455, 0x8474, 0x8472, 0x9470, 0x9C4D, 0xA46A, 0xCD0B, 0xFE70, 0xFEB1,   // 0x0700 (1792)
+0xF60F, 0xEDCE, 0xF5CF, 0xFDCE, 0xFDCD, 0xFDCE, 0xFDAE, 0xFD8E, 0xFDAE, 0xFDAE, 0xFDAE, 0xFDAE, 0xFD6E, 0xFD8E, 0xFDAD, 0xFDAD,   // 0x0710 (1808)
+0xFDCD, 0xF5ED, 0xFE6F, 0xFE70, 0xBCAB, 0x9BEA, 0x940E, 0x8C11, 0x8453, 0x7C75, 0x7476, 0x6C77, 0x6C98, 0x6498, 0x6C99, 0x6CB9,   // 0x0720 (1824)
+0x6CDA, 0x751A, 0x853B, 0x959B, 0xB5FA, 0x9493, 0xAD76, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0730 (1840)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9493, 0xADFB, 0x8D9B, 0x851B, 0x6CDA,   // 0x0740 (1856)
+0x6CBA, 0x5C99, 0x5C99, 0x5C79, 0x6477, 0x6C57, 0x7436, 0x7455, 0x7C53, 0x8451, 0x9C6F, 0xA46C, 0xB489, 0xE5CC, 0xFE8F, 0xFE0E,   // 0x0750 (1872)
+0xF5AC, 0xFDCD, 0xF5AD, 0xFDAD, 0xFDAC, 0xFDAC, 0xFDAD, 0xFD8D, 0xFD8D, 0xFDAD, 0xFD8C, 0xFD8D, 0xFD6D, 0xFD6D, 0xFD6C, 0xFD6B,   // 0x0760 (1888)
+0xFD8B, 0xFDCC, 0xF5EC, 0xFE8F, 0xE5AD, 0xA409, 0x93EC, 0x8C30, 0x8453, 0x7454, 0x6C56, 0x6457, 0x6457, 0x6478, 0x6458, 0x6479,   // 0x0770 (1904)
+0x649A, 0x6CDA, 0x853B, 0x957A, 0xADDA, 0x8C93, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0780 (1920)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8C93, 0xA5DB, 0x8D7B, 0x7D1B, 0x6CBA,   // 0x0790 (1936)
+0x6499, 0x5C79, 0x5458, 0x5C58, 0x6457, 0x6436, 0x6C35, 0x7434, 0x7C53, 0x8C50, 0x9C6D, 0xA44A, 0xC509, 0xFE4C, 0xFE2C, 0xF58B,   // 0x07A0 (1952)
+0xFDCC, 0xFD8B, 0xFD8C, 0xFD8B, 0xFD8B, 0xFD8B, 0xFD8B, 0xFD8C, 0xFDAB, 0xFDAB, 0xFD6B, 0xFD8C, 0xFD6B, 0xFD4B, 0xFD6A, 0xFD6A,   // 0x07B0 (1968)
+0xFD6A, 0xFD8A, 0xFDAA, 0xFDEC, 0xFE2D, 0xC4CA, 0x9BEA, 0x8C2F, 0x8472, 0x6BF3, 0x6435, 0x6436, 0x5C37, 0x5C58, 0x5C58, 0x5C79,   // 0x07C0 (1984)
+0x5C99, 0x6CDA, 0x7D1B, 0x8D7A, 0xA5DA, 0x9493, 0xAD76, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07D0 (2000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8C93, 0xA5DB, 0x855B, 0x74FB, 0x649A,   // 0x07E0 (2016)
+0x5C79, 0x5459, 0x4C38, 0x5438, 0x5C37, 0x6416, 0x6415, 0x6C14, 0x7C32, 0x842F, 0x942B, 0xAC69, 0xDD89, 0xFE6B, 0xFDEA, 0xFD89,   // 0x07F0 (2032)
+0xFDAA, 0xF549, 0xFD8A, 0xFD8A, 0xFD6A, 0xFD8A, 0xFD6A, 0xFD8B, 0xFDAA, 0xFDAA, 0xFD8B, 0xFD6B, 0xFD6A, 0xFD6A, 0xFD69, 0xFD69,   // 0x0800 (2048)
+0xF549, 0xF548, 0xFDA9, 0xF5A9, 0xFE4C, 0xDD8B, 0x9C2A, 0x83ED, 0x8451, 0x63D2, 0x6415, 0x5C16, 0x5C17, 0x5437, 0x5438, 0x5458,   // 0x0810 (2064)
+0x5C79, 0x64BA, 0x74FA, 0x8D7A, 0xA5B9, 0x9493, 0xB576, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0820 (2080)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD96, 0x8C93, 0x9DDA, 0x855B, 0x6D1B, 0x5C9A,   // 0x0830 (2096)
+0x5479, 0x4C38, 0x4C38, 0x4C17, 0x5417, 0x5BF5, 0x63F4, 0x6BF3, 0x73F1, 0x840E, 0x940A, 0xB488, 0xE5C9, 0xFE28, 0xFDC8, 0xFD88,   // 0x0840 (2112)
+0xFD68, 0xFD69, 0xFD89, 0xFD89, 0xFD89, 0xFD69, 0xFD89, 0xFD89, 0xFDA9, 0xFDA9, 0xFDAA, 0xFD89, 0xFD69, 0xFD89, 0xFD68, 0xFD47,   // 0x0850 (2128)
+0xFD68, 0xFD88, 0xF567, 0xFDC8, 0xFE2A, 0xE5CB, 0xA449, 0x83EB, 0x7410, 0x6C13, 0x5BF4, 0x5BF6, 0x5417, 0x5417, 0x5418, 0x5439,   // 0x0860 (2144)
+0x5459, 0x5C9A, 0x6CDA, 0x8D5A, 0xA5B9, 0x9494, 0xB576, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0870 (2160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x8C93, 0x9DBA, 0x7D3B, 0x6CDB, 0x549A,   // 0x0880 (2176)
+0x5479, 0x4C18, 0x4418, 0x4C17, 0x53F6, 0x53F5, 0x5BD4, 0x63F2, 0x73F0, 0x840D, 0x93E9, 0xC4E9, 0xF609, 0xFDE7, 0xFD87, 0xFD67,   // 0x0890 (2192)
+0xFD87, 0xFD88, 0xFD88, 0xFD88, 0xFD88, 0xFDA9, 0xFDA9, 0xFDA9, 0xFDA8, 0xFDA8, 0xFDA9, 0xFDA9, 0xFD88, 0xFD88, 0xFD66, 0xFD66,   // 0x08A0 (2208)
+0xFD67, 0xFD67, 0xF566, 0xFD87, 0xF5A7, 0xF62B, 0xAC69, 0x83CB, 0x73F0, 0x63B2, 0x5BF4, 0x53F6, 0x53F7, 0x4BF7, 0x4BF8, 0x4C39,   // 0x08B0 (2224)
+0x545A, 0x5C9A, 0x6CFA, 0x853A, 0xA5BA, 0x9493, 0xB576, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08C0 (2240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8C93, 0x9DDA, 0x7D5B, 0x64DB, 0x549B,   // 0x08D0 (2256)
+0x4C5A, 0x4419, 0x43F8, 0x43F8, 0x4BF7, 0x53F6, 0x5BF4, 0x63F2, 0x73F0, 0x83ED, 0x9C2A, 0xC509, 0xEDE7, 0xFE06, 0xFDA6, 0xFD66,   // 0x08E0 (2272)
+0xFD87, 0xFD86, 0xFDA7, 0xFD87, 0xFDA7, 0xFDA8, 0xFDA8, 0xFDA8, 0xFDA7, 0xFDA7, 0xF5A7, 0xFDA8, 0xFDA7, 0xFD86, 0xFD86, 0xFD85,   // 0x08F0 (2288)
+0xFD66, 0xFD66, 0xFD66, 0xFD65, 0xF5C6, 0xFE0B, 0xB489, 0x83AB, 0x73D0, 0x6BD3, 0x5BB4, 0x53B6, 0x4BF7, 0x4BF7, 0x4418, 0x4419,   // 0x0900 (2304)
+0x4C5A, 0x549A, 0x6CDB, 0x853A, 0xA5BA, 0x8C94, 0xB576, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0910 (2320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9493, 0x95BA, 0x753B, 0x5CDB, 0x4C9B,   // 0x0920 (2336)
+0x445A, 0x443A, 0x4419, 0x4419, 0x4BF8, 0x53F6, 0x5BF5, 0x63F3, 0x7C11, 0x8C2E, 0xA44B, 0xCD4A, 0xEE07, 0xFE05, 0xFDA6, 0xFD86,   // 0x0930 (2352)
+0xFD86, 0xFDA6, 0xFDA6, 0xFDA6, 0xFDA6, 0xFDA7, 0xFDA7, 0xFDA7, 0xFDC6, 0xFDC6, 0xFDA6, 0xFDA7, 0xFDA6, 0xFDA6, 0xFD85, 0xFD85,   // 0x0940 (2368)
+0xFD86, 0xFD65, 0xFD65, 0xF544, 0xFDC6, 0xFDEA, 0xB469, 0x838B, 0x73B0, 0x63B3, 0x5BB5, 0x53D6, 0x4BD7, 0x43D8, 0x43F8, 0x441A,   // 0x0950 (2384)
+0x4C5B, 0x549B, 0x64DB, 0x7D3B, 0x9D9A, 0x9494, 0xB576, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0960 (2400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8C93, 0x8D59, 0x64DA, 0x4C7B, 0x3C5B,   // 0x0970 (2416)
+0x3C3A, 0x3BF9, 0x3BF9, 0x3BD9, 0x43D8, 0x4BD7, 0x53D5, 0x63D3, 0x73F1, 0x840E, 0x9C2B, 0xCD6A, 0xEE07, 0xFE05, 0xFDA6, 0xFD85,   // 0x0980 (2432)
+0xFDA6, 0xFDA5, 0xFDC5, 0xFDC5, 0xFDC5, 0xFDC6, 0xFDC6, 0xFDC6, 0xFDC5, 0xFDC5, 0xFDC5, 0xFDC6, 0xFDA6, 0xFDA5, 0xFDA5, 0xFDA5,   // 0x0990 (2448)
+0xFD85, 0xFD65, 0xFD44, 0xFD64, 0xFDA6, 0xF5EA, 0xB449, 0x8B8B, 0x73B1, 0x5B73, 0x5BD6, 0x4BD7, 0x43D8, 0x3BD8, 0x3BD9, 0x3BFA,   // 0x09A0 (2464)
+0x3C1A, 0x445B, 0x549B, 0x74DA, 0x9559, 0x9494, 0xAD76, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09B0 (2480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x8C93, 0x8519, 0x5479, 0x3C19, 0x2BB9,   // 0x09C0 (2496)
+0x2398, 0x2358, 0x2378, 0x2B78, 0x3B98, 0x43B8, 0x4BB6, 0x5BB4, 0x6BD1, 0x7BCD, 0x8BA9, 0xC509, 0xEE06, 0xFE04, 0xFD84, 0xFD85,   // 0x09D0 (2512)
+0xFDC5, 0xFDC4, 0xFDE4, 0xF5E4, 0xFE05, 0xFDE6, 0xFDE6, 0xFDE5, 0xFDE5, 0xFDE4, 0xFDE4, 0xFDC5, 0xFDC5, 0xFDC5, 0xFDC4, 0xFDA4,   // 0x09E0 (2528)
+0xFDA4, 0xFD84, 0xFD63, 0xFD84, 0xF584, 0xFE0A, 0xB44A, 0x838C, 0x73B1, 0x5B53, 0x4B75, 0x4397, 0x3397, 0x3398, 0x2B78, 0x2378,   // 0x09F0 (2544)
+0x2378, 0x2B98, 0x4419, 0x5C78, 0x8D18, 0x9494, 0xB576, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A00 (2560)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x8C94, 0x7D19, 0x547A, 0x341A, 0x239A,   // 0x0A10 (2576)
+0x1358, 0x1317, 0x12F7, 0x12F7, 0x22F7, 0x2AF6, 0x3314, 0x4332, 0x5B50, 0x6B6C, 0x8389, 0xB488, 0xEE26, 0xF604, 0xFDA4, 0xFDA5,   // 0x0A20 (2592)
+0xFDE5, 0xFDE4, 0xFE04, 0xF604, 0xFE05, 0xFE05, 0xFE05, 0xFE05, 0xFDE4, 0xFE04, 0xFDE3, 0xFDE4, 0xFDC5, 0xFDC4, 0xFDC4, 0xFDC4,   // 0x0A30 (2608)
+0xFDA4, 0xFDA4, 0xFDA3, 0xFDC4, 0xF585, 0xF60A, 0xA409, 0x7B4B, 0x6350, 0x5353, 0x3B14, 0x3336, 0x2336, 0x1B17, 0x1B38, 0x1B18,   // 0x0A40 (2624)
+0x1B59, 0x2399, 0x3BF9, 0x5C59, 0x8519, 0x8CB5, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A50 (2640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x9494, 0x851A, 0x5C9B, 0x341B, 0x23BB,   // 0x0A60 (2656)
+0x1B79, 0x1339, 0x1B39, 0x1B39, 0x2318, 0x22F7, 0x2AF5, 0x4333, 0x5B51, 0x738E, 0x8389, 0xA406, 0xEE27, 0xF624, 0xFDE5, 0xFDC5,   // 0x0A70 (2672)
+0xFDE5, 0xFDE3, 0xFE24, 0xFE43, 0xFE24, 0xFE05, 0xFE25, 0xFE05, 0xFE04, 0xFE03, 0xFE03, 0xFE03, 0xFDE4, 0xFDE4, 0xFDE3, 0xFDE4,   // 0x0A80 (2688)
+0xFDE3, 0xF5C3, 0xFDE3, 0xFDE4, 0xF606, 0xDD88, 0x8B87, 0x6B0A, 0x530F, 0x42F2, 0x3314, 0x2315, 0x1AF6, 0x12F7, 0x1317, 0x1358,   // 0x0A90 (2704)
+0x1B9A, 0x23DA, 0x3C1A, 0x5C9A, 0x8519, 0x94B5, 0xAD77, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0AA0 (2720)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9494, 0x7D3A, 0x54BB, 0x343B, 0x23DB,   // 0x0AB0 (2736)
+0x137A, 0x0B39, 0x0B39, 0x1339, 0x1B38, 0x2337, 0x3336, 0x3B14, 0x4B11, 0x5B2E, 0x7B4A, 0x8B85, 0xE5E8, 0xF604, 0xFE04, 0xFDC3,   // 0x0AC0 (2752)
+0xFE04, 0xFE23, 0xFE43, 0xFE43, 0xFE44, 0xFE44, 0xFE45, 0xFE44, 0xFE43, 0xFE43, 0xFE22, 0xFE22, 0xFE23, 0xFE24, 0xFE03, 0xFE03,   // 0x0AD0 (2768)
+0xFDE3, 0xF5E3, 0xEDC2, 0xEDC3, 0xFE68, 0xC4E7, 0x72E6, 0x630C, 0x4AEF, 0x3AF2, 0x2B15, 0x2336, 0x2317, 0x1B58, 0x1379, 0x137A,   // 0x0AE0 (2784)
+0x139A, 0x23BA, 0x3C1A, 0x5CBA, 0x853A, 0x94B5, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0AF0 (2800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8CB4, 0x855A, 0x5CDC, 0x343B, 0x23FC,   // 0x0B00 (2816)
+0x139A, 0x0B7A, 0x137A, 0x1379, 0x1B58, 0x2337, 0x2B15, 0x3314, 0x4333, 0x5B50, 0x738D, 0x8BC8, 0xC507, 0xFE88, 0xFE44, 0xFE21,   // 0x0B10 (2832)
+0xFE43, 0xFE22, 0xFE43, 0xFE43, 0xFE63, 0xFE63, 0xFE83, 0xFE83, 0xFE83, 0xFE63, 0xFE62, 0xFE42, 0xFE22, 0xFE43, 0xFE23, 0xFDE2,   // 0x0B20 (2848)
+0xFE22, 0xF622, 0xF623, 0xEE04, 0xF68A, 0x9C06, 0x7329, 0x5B2E, 0x4AF1, 0x3314, 0x2B16, 0x2317, 0x1B18, 0x1339, 0x0B39, 0x0B5A,   // 0x0B30 (2864)
+0x137A, 0x23FB, 0x343B, 0x5CBB, 0x8D3A, 0x9495, 0xAD77, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B40 (2880)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8CB4, 0x857A, 0x5CDC, 0x343B, 0x241C,   // 0x0B50 (2896)
+0x13BB, 0x0B7A, 0x0B9A, 0x137A, 0x1358, 0x1B57, 0x2B36, 0x3B55, 0x4B95, 0x5BB3, 0x73B0, 0x83AA, 0x9C26, 0xE608, 0xFE65, 0xFE83,   // 0x0B60 (2912)
+0xFE61, 0xFE82, 0xFE83, 0xFE83, 0xFE83, 0xFEA2, 0xFEA2, 0xFEC2, 0xFEA3, 0xFEA2, 0xFE81, 0xFE81, 0xFE62, 0xFE62, 0xFE42, 0xFE42,   // 0x0B70 (2928)
+0xFE42, 0xEE01, 0xE602, 0xFEE9, 0xCD48, 0x8B87, 0x732C, 0x6351, 0x4B33, 0x3315, 0x2337, 0x1B38, 0x1B19, 0x1B5A, 0x137A, 0x0B7B,   // 0x0B80 (2944)
+0x13BB, 0x241C, 0x347B, 0x5CDB, 0x8D5A, 0x9495, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B90 (2960)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x94B4, 0x857A, 0x5CFC, 0x345C, 0x241C,   // 0x0BA0 (2976)
+0x13DB, 0x0BBB, 0x0B9A, 0x137A, 0x1379, 0x2378, 0x2B77, 0x3B76, 0x4395, 0x5394, 0x73F2, 0x736C, 0x83A7, 0xB4A6, 0xFEE9, 0xF663,   // 0x0BB0 (2992)
+0xF661, 0xFEA1, 0xFEA1, 0xFEA1, 0xFEA2, 0xFEC2, 0xFEC2, 0xFEC2, 0xFEC2, 0xFEC2, 0xFEC1, 0xFEC1, 0xFEA2, 0xFE82, 0xFE61, 0xFE60,   // 0x0BC0 (3008)
+0xFE81, 0xF642, 0xFEC7, 0xF66A, 0x9B85, 0x7AE8, 0x732E, 0x5B32, 0x4B34, 0x3B56, 0x2B57, 0x1B58, 0x235A, 0x1B7A, 0x0B7A, 0x0B9B,   // 0x0BD0 (3024)
+0x13BB, 0x241C, 0x3C7B, 0x64FB, 0x8D5A, 0x9495, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0BE0 (3040)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x94B4, 0x857B, 0x5CFC, 0x3C7C, 0x2C3D,   // 0x0BF0 (3056)
+0x1C1C, 0x13DB, 0x139B, 0x139B, 0x1BBA, 0x1BB8, 0x2B98, 0x3376, 0x3375, 0x4374, 0x5371, 0x73AF, 0x736A, 0x83A5, 0xCDA7, 0xFF08,   // 0x0C00 (3072)
+0xFF25, 0xF6A1, 0xFF01, 0xFEE1, 0xFEE1, 0xFEE2, 0xFF02, 0xFEE1, 0xFEE0, 0xFEE0, 0xFF01, 0xFEE1, 0xF6A1, 0xFEC1, 0xFEA0, 0xF660,   // 0x0C10 (3088)
+0xFE81, 0xF684, 0xFECB, 0xB487, 0x7AE6, 0x6ACB, 0x6B30, 0x5313, 0x4355, 0x3377, 0x2B78, 0x2399, 0x239A, 0x1B9B, 0x139B, 0x0B9B,   // 0x0C20 (3104)
+0x1BDC, 0x243C, 0x3C9B, 0x64FB, 0x8D5A, 0x94B5, 0xAD77, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C30 (3120)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x9494, 0x857B, 0x5D1C, 0x3C9D, 0x2C5D,   // 0x0C40 (3136)
+0x243C, 0x1BFC, 0x1BDC, 0x13BC, 0x1BBA, 0x1BB9, 0x2398, 0x2B97, 0x3BB7, 0x4395, 0x4B73, 0x5B50, 0x6B8D, 0x7BAA, 0x9C46, 0xDE29,   // 0x0C50 (3152)
+0xFF89, 0xF744, 0xF722, 0xF721, 0xF700, 0xFF00, 0xFF00, 0xFF20, 0xFF20, 0xFF40, 0xF720, 0xF740, 0xFF20, 0xFF00, 0xFEE0, 0xFEC2,   // 0x0C60 (3168)
+0xFF06, 0xFF0A, 0xBD08, 0x8B67, 0x7B4B, 0x630E, 0x5331, 0x4353, 0x3BB6, 0x2B97, 0x2398, 0x1BB9, 0x239B, 0x1BBB, 0x13DC, 0x13DC,   // 0x0C70 (3184)
+0x241C, 0x345D, 0x44BC, 0x651B, 0x8D5A, 0x9495, 0xAD97, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C80 (3200)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD96, 0x94B4, 0x859B, 0x5D3D, 0x44BD, 0x2C7D,   // 0x0C90 (3216)
+0x245D, 0x1C1D, 0x13DC, 0x13DC, 0x1BDB, 0x1BDA, 0x23B9, 0x2BB9, 0x2BB8, 0x3BB6, 0x4395, 0x4B31, 0x5B90, 0x7BEE, 0x948B, 0x9466,   // 0x0CA0 (3232)
+0xB585, 0xEF48, 0xF785, 0xFF84, 0xFF82, 0xFF82, 0xFF41, 0xFF61, 0xFF61, 0xFF61, 0xFF61, 0xF740, 0xEF00, 0xF721, 0xFF84, 0xFF67,   // 0x0CB0 (3248)
+0xE648, 0xACC7, 0x8388, 0x734B, 0x630E, 0x5B51, 0x4B53, 0x3B95, 0x33B8, 0x23B8, 0x1BD9, 0x1BBA, 0x1BBB, 0x1BDB, 0x13FC, 0x1C1C,   // 0x0CC0 (3264)
+0x243D, 0x347D, 0x44BC, 0x6D1B, 0x957A, 0x8C95, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CD0 (3280)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x94B4, 0x8D9B, 0x5D3D, 0x44DE, 0x347E,   // 0x0CE0 (3296)
+0x245D, 0x1C1D, 0x1BFD, 0x1BDD, 0x1BFC, 0x1BFB, 0x23DA, 0x23D9, 0x23B8, 0x2B96, 0x3355, 0x53F6, 0x5BB3, 0x6BF1, 0x73CD, 0x7BE9,   // 0x0CF0 (3312)
+0x7BC5, 0xB5A7, 0xE6E8, 0xEF46, 0xFFA5, 0xFFA4, 0xFFA3, 0xFF83, 0xFF63, 0xFF83, 0xF744, 0xFFA5, 0xFFE6, 0xFFC7, 0xEEE8, 0xC5A7,   // 0x0D00 (3328)
+0x9C68, 0x7348, 0x6B2C, 0x6B4F, 0x4AD0, 0x4B74, 0x4396, 0x33B8, 0x2399, 0x23DA, 0x1BFA, 0x1BFB, 0x1BFC, 0x1BFC, 0x141C, 0x1C1D,   // 0x0D10 (3344)
+0x243D, 0x347D, 0x44DD, 0x6D3B, 0x957A, 0x8CB5, 0xAD77, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D20 (3360)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x94B4, 0x8DBB, 0x5D3D, 0x44FE, 0x2C9D,   // 0x0D30 (3376)
+0x249E, 0x1C3D, 0x1C1E, 0x1C1D, 0x13FC, 0x1BFB, 0x1BDB, 0x1BDA, 0x23FA, 0x23D8, 0x33F8, 0x3BB5, 0x5416, 0x53B3, 0x6390, 0x6BCD,   // 0x0D40 (3392)
+0x7C2B, 0x8C88, 0x94A5, 0xAD44, 0xCE24, 0xEEE5, 0xFF46, 0xFF87, 0xFF88, 0xFF89, 0xFF8A, 0xF708, 0xDE86, 0xC5E5, 0xA4C5, 0x7BA5,   // 0x0D50 (3408)
+0x738A, 0x73AF, 0x5B0F, 0x5311, 0x4B54, 0x4396, 0x3398, 0x33FA, 0x23BA, 0x23FC, 0x1BFB, 0x1BFB, 0x1BFC, 0x1C1C, 0x1C3D, 0x1C5D,   // 0x0D60 (3424)
+0x245D, 0x349D, 0x4CFD, 0x6D5C, 0x959B, 0x8CB5, 0xAD77, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D70 (3440)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x8C94, 0x8DDC, 0x657D, 0x451E, 0x34BE,   // 0x0D80 (3456)
+0x249E, 0x1C5D, 0x1C3E, 0x1C1E, 0x1C1D, 0x1C1C, 0x1C1C, 0x1C1C, 0x243B, 0x243A, 0x3439, 0x3BF7, 0x43D7, 0x4BD5, 0x53B3, 0x5B91,   // 0x0D90 (3472)
+0x6BCF, 0x7C2D, 0x7C0A, 0x8C27, 0x9C65, 0x9C43, 0xACA3, 0xC546, 0xC566, 0xBD26, 0xACE6, 0x9C86, 0xA487, 0x9468, 0x73A8, 0x6B6A,   // 0x0DA0 (3488)
+0x636E, 0x6370, 0x5352, 0x4332, 0x43B6, 0x3B97, 0x2B99, 0x2BDB, 0x2BFB, 0x23FC, 0x1C1C, 0x1C3C, 0x1C3D, 0x1C3D, 0x1C3E, 0x1C5E,   // 0x0DB0 (3504)
+0x247E, 0x34BD, 0x4CFD, 0x6D5C, 0x959B, 0x9495, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DC0 (3520)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x8C94, 0x8DFC, 0x659D, 0x451E, 0x34DE,   // 0x0DD0 (3536)
+0x24BE, 0x1C7D, 0x1C5E, 0x1C3E, 0x143D, 0x1C3D, 0x1C3C, 0x1C3C, 0x1C5C, 0x243B, 0x2C3A, 0x33F8, 0x3BD8, 0x43D7, 0x4BB6, 0x5394,   // 0x0DE0 (3552)
+0x5BB3, 0x6BF1, 0x6BCE, 0x7BEC, 0x944C, 0x8BE9, 0x8BA7, 0x8BE8, 0x9C49, 0x8C08, 0x7B88, 0x7BEA, 0x6B69, 0x73ED, 0x6BCF, 0x6390,   // 0x0DF0 (3568)
+0x4B31, 0x42F1, 0x4374, 0x4BF7, 0x3397, 0x33D8, 0x33FB, 0x2BFB, 0x241B, 0x23FC, 0x1C1C, 0x143C, 0x1C3E, 0x1C5E, 0x145E, 0x1C7E,   // 0x0E00 (3584)
+0x249E, 0x34DE, 0x4D1D, 0x757C, 0x9DBB, 0x9495, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0E10 (3600)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x8C94, 0x8DFC, 0x659D, 0x453E, 0x34FE,   // 0x0E20 (3616)
+0x24BE, 0x1C9D, 0x1C7E, 0x1C5E, 0x1C5D, 0x1C5D, 0x1C7D, 0x1C7D, 0x1C7C, 0x1C5B, 0x2C5B, 0x2C1A, 0x33F9, 0x33D8, 0x3BB7, 0x43D6,   // 0x0E30 (3632)
+0x4BD5, 0x53F4, 0x53B2, 0x5B90, 0x73F1, 0x636E, 0x73CF, 0x6BAD, 0x7C70, 0x6C0F, 0x638E, 0x5B6E, 0x63D1, 0x5391, 0x53B2, 0x4B93,   // 0x0E40 (3648)
+0x4354, 0x43B6, 0x3B97, 0x33B8, 0x33F9, 0x2C19, 0x2C3A, 0x241A, 0x2C5B, 0x243C, 0x1C5C, 0x1C5D, 0x1C5E, 0x1C7E, 0x1C9E, 0x1C9E,   // 0x0E50 (3664)
+0x24BE, 0x34FE, 0x4D3D, 0x759C, 0x9DBB, 0x9495, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0E60 (3680)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x9494, 0x95FC, 0x65BE, 0x4D5E, 0x351E,   // 0x0E70 (3696)
+0x24FE, 0x1CBD, 0x1C9E, 0x1C7E, 0x1C9E, 0x1C9E, 0x249E, 0x249E, 0x249D, 0x249D, 0x245C, 0x2C5B, 0x2C3B, 0x33FA, 0x33F9, 0x3BF8,   // 0x0E80 (3712)
+0x4417, 0x43F6, 0x4BD5, 0x5C15, 0x5393, 0x5BD3, 0x5391, 0x6413, 0x5412, 0x5BF2, 0x53B2, 0x4352, 0x4B94, 0x4BB5, 0x3B95, 0x43F7,   // 0x0E90 (3728)
+0x3B76, 0x3BB8, 0x3BFA, 0x33FB, 0x347B, 0x243A, 0x247B, 0x1C5A, 0x2C7C, 0x245C, 0x249D, 0x1C9D, 0x1C7E, 0x1C9F, 0x1CBE, 0x1CDE,   // 0x0EA0 (3744)
+0x2CDF, 0x3D1E, 0x4D5D, 0x759D, 0x9DDB, 0x94B5, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0EB0 (3760)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x9494, 0x961C, 0x6DDE, 0x4D7E, 0x353E,   // 0x0EC0 (3776)
+0x2D1E, 0x24DE, 0x24BE, 0x24BE, 0x24BE, 0x1CBE, 0x24BE, 0x24BE, 0x1CBE, 0x24BD, 0x249D, 0x2C7C, 0x2C5C, 0x2C3A, 0x343A, 0x345A,   // 0x0ED0 (3792)
+0x3C59, 0x3C17, 0x33D5, 0x43F5, 0x5435, 0x4BD4, 0x4BB3, 0x43B3, 0x4435, 0x43D4, 0x43B4, 0x4394, 0x43D6, 0x3B96, 0x3BD7, 0x3BD8,   // 0x0EE0 (3808)
+0x4C1A, 0x3BFA, 0x3C1C, 0x343D, 0x1BFB, 0x2CBD, 0x24DD, 0x1C7C, 0x1C7D, 0x24BE, 0x1C9E, 0x1CBE, 0x24BF, 0x1CBF, 0x1CDF, 0x1CDE,   // 0x0EF0 (3824)
+0x2CFF, 0x3D3E, 0x4D7E, 0x75BD, 0x9DFC, 0x94B5, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0F00 (3840)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB576, 0x8CB4, 0x961C, 0x6DDE, 0x4D9E, 0x3D7F,   // 0x0F10 (3856)
+0x2D3E, 0x251E, 0x24DE, 0x24DF, 0x1CDF, 0x24DE, 0x24BE, 0x24BE, 0x24BE, 0x24BD, 0x24BD, 0x24BD, 0x249C, 0x2C7B, 0x2C7B, 0x347B,   // 0x0F20 (3872)
+0x345A, 0x3458, 0x4458, 0x4415, 0x5434, 0x6496, 0x5414, 0x4BF4, 0x3BD4, 0x4C16, 0x4BF5, 0x5436, 0x5C78, 0x43F6, 0x4417, 0x3BD6,   // 0x0F30 (3888)
+0x4BF8, 0x43F8, 0x3C1A, 0x343B, 0x3CFD, 0x24BC, 0x147C, 0x1CDD, 0x24DF, 0x1C9E, 0x1CBE, 0x1CBD, 0x24DE, 0x1CDF, 0x1CFF, 0x1CFE,   // 0x0F40 (3904)
+0x2D3F, 0x3D5E, 0x559D, 0x75DD, 0x9DFB, 0x94D5, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0F50 (3920)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB596, 0x94B4, 0x961C, 0x75FE, 0x559F, 0x3D7F,   // 0x0F60 (3936)
+0x2D5E, 0x253E, 0x24FE, 0x24FF, 0x24FF, 0x24FF, 0x24DF, 0x24DE, 0x24DE, 0x24DD, 0x24DD, 0x24DD, 0x24DC, 0x24BB, 0x2CBB, 0x349C,   // 0x0F70 (3952)
+0x345B, 0x3C3A, 0x43F6, 0x965D, 0xD7FF, 0xD7FF, 0xDFFF, 0x9DFA, 0x53D4, 0x5435, 0xB6FE, 0xD7FF, 0xD7FF, 0xD7FF, 0x7D38, 0x5C35,   // 0x0F80 (3968)
+0xAEDF, 0xCFFF, 0xC7FF, 0x8EDF, 0x3CB9, 0x249A, 0x2CFE, 0x24DF, 0x24DF, 0x24DF, 0x24DE, 0x24FE, 0x24DE, 0x1CFF, 0x1CFE, 0x1D1F,   // 0x0F90 (3984)
+0x2D3F, 0x3D5E, 0x4D9D, 0x75FD, 0x9E1B, 0x94B5, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0FA0 (4000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x94D4, 0x9E3C, 0x6DFE, 0x55BF, 0x3D7F,   // 0x0FB0 (4016)
+0x2D5E, 0x253E, 0x253F, 0x1D1F, 0x1CFF, 0x1CFF, 0x24FF, 0x251E, 0x24FE, 0x24FD, 0x24FD, 0x24FD, 0x24FC, 0x24FC, 0x2CDC, 0x2CBC,   // 0x0FC0 (4032)
+0x347C, 0x3C7A, 0x7DFD, 0xC7FF, 0x8DD8, 0x53AF, 0xAE79, 0xDFFF, 0x7D19, 0x7D5A, 0xDFFF, 0x9618, 0x5C31, 0xB71E, 0xD7DF, 0x6C95,   // 0x0FD0 (4048)
+0xD7DF, 0x3B2F, 0x2B4E, 0xBFFF, 0x2C77, 0x2CFC, 0x24DE, 0x24DF, 0x24DF, 0x24FF, 0x24FE, 0x24FE, 0x251E, 0x1D1E, 0x1D1E, 0x253E,   // 0x0FE0 (4064)
+0x2D3E, 0x3D7E, 0x559D, 0x75DD, 0x9DFB, 0x94B4, 0xB597, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0FF0 (4080)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x94D4, 0x9E5C, 0x763E, 0x55DE, 0x459F,   // 0x1000 (4096)
+0x357E, 0x253D, 0x1D5F, 0x1D5F, 0x1D3F, 0x1D3F, 0x253F, 0x253E, 0x251D, 0x251D, 0x251D, 0x251D, 0x24FD, 0x24FD, 0x24FD, 0x2CFD,   // 0x1010 (4112)
+0x34DC, 0x3C9A, 0x9F3F, 0xCFFF, 0x4BB3, 0x4BB1, 0x5C73, 0xCFFF, 0x95FC, 0x963D, 0x9EDE, 0x3390, 0x4412, 0x7DF9, 0xCFFF, 0x7517,   // 0x1020 (4128)
+0xDFDF, 0x5C54, 0x5494, 0xAFFF, 0x3D3A, 0x24DC, 0x2D3F, 0x24FF, 0x2D1E, 0x2CFE, 0x24FE, 0x251F, 0x253E, 0x253E, 0x253E, 0x2D3D,   // 0x1030 (4144)
+0x355E, 0x457E, 0x5DBE, 0x7DFE, 0xA61C, 0x94D5, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1040 (4160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x9CF5, 0x9E5C, 0x763E, 0x5DDE, 0x55BF,   // 0x1050 (4176)
+0x3D7E, 0x355E, 0x257F, 0x157F, 0x153F, 0x1D3F, 0x253F, 0x253F, 0x253D, 0x253D, 0x253E, 0x251E, 0x251E, 0x251E, 0x251E, 0x2D1D,   // 0x1060 (4192)
+0x2CDD, 0x3CBA, 0x4496, 0x4C54, 0x5435, 0x5C97, 0x8DFA, 0xD7FF, 0x6519, 0x33B4, 0x2BB3, 0x5D58, 0x96DC, 0xB7DF, 0xAF1F, 0x5414,   // 0x1070 (4208)
+0x9E5D, 0xC7FF, 0xBFFF, 0x7EFF, 0x34FA, 0x2D5E, 0x1CDE, 0x24FF, 0x355F, 0x24DD, 0x2D1E, 0x253F, 0x253F, 0x253E, 0x2D3E, 0x2D5E,   // 0x1080 (4224)
+0x357F, 0x459F, 0x5DBF, 0x75DD, 0xA65C, 0x94D4, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1090 (4240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD8, 0x9D15, 0x9E5C, 0x7E5E, 0x65FF, 0x559F,   // 0x10A0 (4256)
+0x3D5E, 0x3D7F, 0x2D7F, 0x257F, 0x255F, 0x253F, 0x255F, 0x253F, 0x255F, 0x255F, 0x2D3E, 0x2D3F, 0x253F, 0x255F, 0x253F, 0x251E,   // 0x10B0 (4272)
+0x2CFE, 0x34FC, 0x3C96, 0x54D6, 0x54B7, 0x9EDF, 0xC7FF, 0x8E9D, 0x3C35, 0x4CD9, 0x44D9, 0x5D5A, 0xAFBF, 0xC7FF, 0x9EFF, 0x6539,   // 0x10C0 (4288)
+0x3C16, 0x23B5, 0x23F5, 0x2477, 0x2D1B, 0x2D3D, 0x2D5F, 0x355F, 0x253E, 0x2D7F, 0x2D3F, 0x2D3F, 0x2D5F, 0x2D5F, 0x2D5F, 0x2D7F,   // 0x10D0 (4304)
+0x359F, 0x45DF, 0x55FF, 0x7E5E, 0x9E3B, 0x94F4, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x10E0 (4320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0xA556, 0xA65C, 0x8E7E, 0x763F, 0x55DF,   // 0x10F0 (4336)
+0x4DBF, 0x459F, 0x357F, 0x2D7F, 0x2D5F, 0x2D5F, 0x2D5F, 0x2D5F, 0x255F, 0x257F, 0x2D5F, 0x2D5F, 0x2D5F, 0x257F, 0x257F, 0x255F,   // 0x1100 (4352)
+0x2D3E, 0x3D3C, 0x5559, 0x6578, 0xBFFF, 0xC7FF, 0x7E1A, 0x3C32, 0x44D7, 0x6DFD, 0x65DD, 0x3C76, 0x33B2, 0x75D9, 0xC7FF, 0x867E,   // 0x1110 (4368)
+0x44DA, 0x3D3C, 0x353B, 0x355C, 0x355D, 0x2D3E, 0x357F, 0x2D5F, 0x255E, 0x255F, 0x257F, 0x257F, 0x2D7F, 0x357F, 0x357F, 0x359F,   // 0x1120 (4384)
+0x3DDF, 0x45FF, 0x5E1E, 0x7E5D, 0x9E3A, 0x94F4, 0xB5D7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1130 (4400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC659, 0xAD76, 0xA63B, 0x967E, 0x763E, 0x5E1F,   // 0x1140 (4416)
+0x4E1F, 0x3DBF, 0x35BE, 0x359E, 0x357F, 0x357E, 0x357E, 0x2D7F, 0x2D7F, 0x2D9F, 0x357E, 0x357E, 0x2D9F, 0x259F, 0x259F, 0x257F,   // 0x1150 (4432)
+0x355E, 0x3D5C, 0x5DBA, 0xB7FF, 0xC7FF, 0x5474, 0x4412, 0x5D16, 0x5559, 0xA7BF, 0xAFBF, 0x6D59, 0x5CF5, 0x7597, 0xC7FF, 0x7E5D,   // 0x1160 (4448)
+0x4D5C, 0x3D5D, 0x359E, 0x2D7D, 0x2D5D, 0x359E, 0x2D5E, 0x2D7F, 0x2DDF, 0x2DDF, 0x25BF, 0x25BE, 0x2DBF, 0x359F, 0x3D9F, 0x459F,   // 0x1170 (4464)
+0x45DF, 0x55FF, 0x761F, 0x861C, 0x9DF9, 0xA515, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1180 (4480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD67A, 0xB5D7, 0x9DD8, 0xA69D, 0x865E, 0x6E3F,   // 0x1190 (4496)
+0x55FE, 0x461F, 0x3DDE, 0x3DBE, 0x3DBE, 0x3DBE, 0x359E, 0x359E, 0x2DBF, 0x2D9F, 0x359E, 0x359E, 0x2DBF, 0x2DBF, 0x25BF, 0x2DBF,   // 0x11A0 (4512)
+0x359E, 0x459C, 0x977F, 0xBFFF, 0xB77F, 0xBFBF, 0xB7BF, 0xAFBF, 0x7E5D, 0x869F, 0xC7FF, 0xAF3F, 0xA6DD, 0xC7FF, 0xC7FF, 0x44F8,   // 0x11B0 (4528)
+0x455C, 0x45BF, 0x359E, 0x35DF, 0x35BE, 0x2D7E, 0x2D5F, 0x35DF, 0x259F, 0x25BE, 0x25FE, 0x2DDE, 0x35BE, 0x3DBF, 0x45BF, 0x4DDF,   // 0x11C0 (4544)
+0x55FF, 0x661F, 0x7E3D, 0xA69D, 0x9556, 0xA535, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x11D0 (4560)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0xC618, 0xA597, 0xAE5B, 0x9EBE, 0x867E,   // 0x11E0 (4576)
+0x663F, 0x565F, 0x461F, 0x45FF, 0x45FE, 0x45DE, 0x3DDE, 0x3DDE, 0x3DDF, 0x3DBF, 0x3DBE, 0x3DBE, 0x35BF, 0x35BF, 0x35DF, 0x3DBF,   // 0x11F0 (4592)
+0x3D9E, 0x4D9D, 0x7EBF, 0xA75F, 0xAF9F, 0xAF5F, 0xA77F, 0x9F3F, 0x763D, 0x44B7, 0x8E1D, 0xD7FF, 0xCFFF, 0xAF9F, 0x5518, 0x557B,   // 0x1200 (4608)
+0x457C, 0x3D5E, 0x3D9E, 0x359E, 0x3DDF, 0x45FF, 0x359F, 0x35BF, 0x35DF, 0x3E1F, 0x35FE, 0x3DFE, 0x3DFE, 0x45FE, 0x4DFF, 0x561F,   // 0x1210 (4624)
+0x663F, 0x765E, 0x965D, 0xA65B, 0x94D4, 0xB596, 0xCE59, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1220 (4640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0xCE79, 0xB5B7, 0xA5D8, 0xAEBC, 0x967D,   // 0x1230 (4656)
+0x7E9F, 0x665E, 0x563F, 0x563F, 0x4E3F, 0x4E1E, 0x45FE, 0x45FE, 0x45FF, 0x45FF, 0x45DE, 0x45DE, 0x45FF, 0x45FF, 0x45FF, 0x45FF,   // 0x1240 (4672)
+0x45DE, 0x4DBD, 0x44F8, 0x44D7, 0x4475, 0x4497, 0x3C76, 0x44D7, 0x553A, 0x5D9B, 0x54D7, 0x4C55, 0x3414, 0x3C96, 0x557B, 0x4D9C,   // 0x1250 (4688)
+0x4DDE, 0x4DDF, 0x45DE, 0x4DFF, 0x3D9E, 0x3DBF, 0x45FF, 0x3DDF, 0x461F, 0x45FE, 0x461F, 0x461F, 0x4E1E, 0x4E1F, 0x5E3E, 0x665E,   // 0x1260 (4704)
+0x7E5E, 0x8E7D, 0xAEBD, 0x9536, 0xA535, 0xBDF8, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1270 (4720)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xD6DA, 0xC638, 0xAD96, 0xAE39, 0xA69C,   // 0x1280 (4736)
+0x96BE, 0x869F, 0x6E7F, 0x5E3F, 0x5E5F, 0x561F, 0x565F, 0x563F, 0x561F, 0x563F, 0x561F, 0x561F, 0x561F, 0x4E1F, 0x4E1F, 0x4E1F,   // 0x1290 (4752)
+0x561F, 0x55FE, 0x5E1E, 0x5E1D, 0x5DFD, 0x5E1D, 0x5DFD, 0x5DFD, 0x5E1D, 0x5DFD, 0x65FC, 0x65DD, 0x5E1D, 0x563E, 0x563E, 0x561F,   // 0x12A0 (4768)
+0x561F, 0x561E, 0x561E, 0x561F, 0x561F, 0x4E1F, 0x4E1F, 0x4E1F, 0x563F, 0x563E, 0x4E3F, 0x565F, 0x5E7F, 0x5E5E, 0x6E7F, 0x7E9E,   // 0x12B0 (4784)
+0x8E7D, 0xA6BD, 0x9DB8, 0xA535, 0xB5D7, 0xCE59, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x12C0 (4800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xE6FB, 0xD69A, 0xBDF8, 0xAD76, 0xA5F9,   // 0x12D0 (4816)
+0xAEBD, 0x9EBE, 0x8EBF, 0x7E9F, 0x769F, 0x6E7F, 0x6E9F, 0x667F, 0x6E5F, 0x665F, 0x665F, 0x665F, 0x665F, 0x665F, 0x665F, 0x6E5F,   // 0x12E0 (4832)
+0x6E5F, 0x665F, 0x663E, 0x665E, 0x665E, 0x665E, 0x665E, 0x665E, 0x667E, 0x663E, 0x663D, 0x6E5E, 0x665E, 0x667F, 0x5E7F, 0x5E7F,   // 0x12F0 (4848)
+0x665F, 0x665E, 0x6E5F, 0x665F, 0x665F, 0x665F, 0x665F, 0x665F, 0x6E5E, 0x6E5E, 0x6E9F, 0x6E9F, 0x6E5E, 0x7E9F, 0x8EBE, 0x96BE,   // 0x1300 (4864)
+0xAEBD, 0xA5D9, 0xA556, 0xB5B7, 0xCE59, 0xDEDB, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1310 (4880)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xEF5D, 0xDEFB, 0xD679, 0xC618, 0xAD97,   // 0x1320 (4896)
+0x9D56, 0xAE5A, 0xAEBD, 0x9EDD, 0x8EBD, 0x8EBE, 0x86BE, 0x869E, 0x86BE, 0x7EBE, 0x7E9F, 0x7E9F, 0x869F, 0x869F, 0x869E, 0x869E,   // 0x1330 (4912)
+0x869F, 0x869F, 0x7E9F, 0x7E9F, 0x7E9E, 0x7E9E, 0x7E9E, 0x7E9F, 0x869E, 0x869F, 0x869E, 0x7E9E, 0x7E9F, 0x7EBE, 0x7E9F, 0x7EBF,   // 0x1340 (4928)
+0x7E9E, 0x7E9E, 0x869E, 0x869E, 0x869E, 0x7E9F, 0x7E9F, 0x869F, 0x869E, 0x869E, 0x869E, 0x8EBE, 0x96FE, 0x969D, 0xAEDE, 0xAE5B,   // 0x1350 (4944)
+0x9536, 0xA556, 0xBDD7, 0xCE59, 0xDEDA, 0xE71C, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1360 (4960)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xF79D, 0xEF3D, 0xDEFB, 0xD69A, 0xC618,   // 0x1370 (4976)
+0xB5B7, 0xA577, 0xA597, 0xA619, 0xAE9B, 0xB6FD, 0xAEBD, 0xA69D, 0xA6DD, 0xA6DD, 0xA6DD, 0xA6BE, 0xA6BE, 0xA6BD, 0xA6BD, 0xAEBD,   // 0x1380 (4992)
+0xA6BD, 0xA6BE, 0xA6DE, 0xA6DE, 0xA6BE, 0xA6BD, 0xA6BE, 0xA6BE, 0xA6BD, 0xA6BD, 0xA6BD, 0xA6BD, 0xA6BD, 0xA6DD, 0xA6BD, 0xA6BD,   // 0x1390 (5008)
+0xA6BD, 0xA6BD, 0xA6BD, 0xAEBD, 0xA69D, 0xA6BD, 0xA6BD, 0xA6BD, 0xA6BD, 0xAEDE, 0xAEDE, 0xAEBD, 0xA65B, 0xAE3A, 0x9D77, 0xA556,   // 0x13A0 (5024)
+0xB5B7, 0xC618, 0xCE79, 0xDEDB, 0xE73C, 0xEF7D, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x13B0 (5040)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BE, 0xEF9E, 0xEF5D, 0xE6FC, 0xD6BA,   // 0x13C0 (5056)
+0xCE59, 0xBE18, 0xB5B7, 0xAD76, 0xA535, 0x9D15, 0x9CD5, 0x94D5, 0x94B4, 0x94B3, 0x8CB3, 0x94B3, 0x94B3, 0x8CB3, 0x94B3, 0x9493,   // 0x13D0 (5072)
+0x9493, 0x9493, 0x8C93, 0x94B3, 0x94B3, 0x94B3, 0x94B3, 0x9493, 0x9493, 0x8C92, 0x94B3, 0x9493, 0x8CB3, 0x9493, 0x9493, 0x9493,   // 0x13E0 (5088)
+0x9493, 0x9493, 0x94B3, 0x9493, 0x94B3, 0x94B3, 0x8CB3, 0x8CB3, 0x94B3, 0x94B4, 0x94D4, 0x9CF5, 0xA515, 0xA556, 0xB5B7, 0xBDF8,   // 0x13F0 (5104)
+0xCE59, 0xD6BA, 0xDF1B, 0xE73D, 0xEF9E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1400 (5120)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E, 0xEF7D, 0xE73C,   // 0x1410 (5136)
+0xDEFB, 0xD6BA, 0xCE79, 0xC638, 0xBDF7, 0xBDD7, 0xB5B7, 0xB597, 0xB596, 0xB596, 0xAD76, 0xAD76, 0xAD76, 0xAD76, 0xAD75, 0xAD75,   // 0x1420 (5152)
+0xAD76, 0xAD76, 0xAD76, 0xAD76, 0xAD76, 0xAD76, 0xB596, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB575, 0xB576, 0xB576,   // 0x1430 (5168)
+0xAD76, 0xB596, 0xAD76, 0xB596, 0xAD76, 0xAD76, 0xAD76, 0xAD76, 0xB576, 0xB596, 0xB5B7, 0xBDD7, 0xBDF8, 0xC638, 0xCE79, 0xD6BA,   // 0x1440 (5184)
+0xDEFB, 0xE73C, 0xEF5D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1450 (5200)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF79E,   // 0x1460 (5216)
+0xEF5D, 0xEF5D, 0xDEFB, 0xDEDB, 0xD6BA, 0xD69A, 0xD69A, 0xCE7A, 0xCE79, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1470 (5232)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1480 (5248)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE79, 0xCE7A, 0xD69A, 0xD6BA, 0xDEDB, 0xDEFB, 0xE73C,   // 0x1490 (5264)
+0xEF5D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x14A0 (5280)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFDF,   // 0x14B0 (5296)
+0xF7BE, 0xF79E, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xDEFB, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x14C0 (5312)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x14D0 (5328)
+0xDEFB, 0xDEFB, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xF79E,   // 0x14E0 (5344)
+0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x14F0 (5360)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1500 (5376)
+0xFFDF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x1510 (5392)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x1520 (5408)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xFFDF,   // 0x1530 (5424)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1540 (5440)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1550 (5456)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7BE, 0xFFDF, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF,   // 0x1560 (5472)
+0xFFDF, 0xFFDF, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7BE, 0xFFDF,   // 0x1570 (5488)
+0xFFDF, 0xFFDF, 0xFFDF, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x1580 (5504)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1590 (5520)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x15A0 (5536)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C51, 0x0000, 0xBDD7, 0xFFFF, 0x2124, 0x2104, 0xFFFF, 0xCE59, 0x0000,   // 0x15B0 (5552)
+0x8C51, 0xFFFF, 0x9CD3, 0x1082, 0x0000, 0x0000, 0x4228, 0xDEFB, 0xFFFF, 0xFFFF, 0x94D3, 0x10A2, 0x0000, 0x0000, 0x4228, 0xDEFB,   // 0x15C0 (5568)
+0xFFFF, 0x31A6, 0x2104, 0x7BCF, 0x0000, 0x0000, 0x52AA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x15D0 (5584)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x15E0 (5600)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x15F0 (5616)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C51, 0x0000, 0x8451, 0xBDF7, 0x0000, 0x0000, 0xCE79, 0x8451, 0x0000,   // 0x1600 (5632)
+0x8C51, 0xAD55, 0x0000, 0x1082, 0x7BCF, 0x4228, 0x0000, 0x73CF, 0xFFFF, 0xAD55, 0x0020, 0x1082, 0x73CF, 0x4228, 0x0000, 0x73CF,   // 0x1610 (5648)
+0xFFFF, 0x1082, 0x0000, 0x0000, 0x4228, 0x1082, 0x1082, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1620 (5664)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1630 (5680)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1640 (5696)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CD3, 0x0000, 0x73CF, 0x632D, 0x0000, 0x0000, 0x9CD3, 0x4228, 0x0000,   // 0x1650 (5712)
+0xBDF7, 0x4228, 0x0000, 0xAD55, 0x8451, 0x1082, 0x0000, 0x8451, 0xFFFF, 0x4228, 0x0000, 0xAD55, 0x8C51, 0x1082, 0x0000, 0x8C51,   // 0x1660 (5728)
+0xFFFF, 0x1082, 0x0000, 0x8C51, 0xFFFF, 0x1082, 0x1082, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1670 (5744)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1680 (5760)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1690 (5776)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x0000, 0x52AB, 0x2124, 0x1082, 0x0000, 0x73CF, 0x1082, 0x1082,   // 0x16A0 (5792)
+0xFFFF, 0x10A2, 0x1082, 0x1082, 0x0000, 0x0000, 0x52AA, 0xFFFF, 0xFFFF, 0x1082, 0x1082, 0x1082, 0x0000, 0x0000, 0x52AA, 0xFFFF,   // 0x16B0 (5808)
+0xFFFF, 0x1082, 0x1082, 0xFFFF, 0xFFFF, 0x8C51, 0x8C51, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x16C0 (5824)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x16D0 (5840)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x16E0 (5856)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x1082, 0x1082, 0x0000, 0x8451, 0x1082, 0x1082, 0x0000, 0x632D,   // 0x16F0 (5872)
+0xFFFF, 0x1082, 0x0000, 0x0000, 0x52AB, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0x1082, 0x0000, 0x0000, 0x52AB, 0xDEFB, 0xFFFF, 0xFFFF,   // 0x1700 (5888)
+0xFFFF, 0x1082, 0x10A2, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1710 (5904)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1720 (5920)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1730 (5936)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x2104, 0x0000, 0x0000, 0xDEFB, 0x2104, 0x0000, 0x0000, 0x9CD3,   // 0x1740 (5952)
+0xFFFF, 0x2124, 0x0000, 0x73CF, 0xFFFF, 0xFFFF, 0x73CF, 0x0000, 0xBDF7, 0x2124, 0x0000, 0x7BCF, 0xFFFF, 0xFFFF, 0x73CF, 0x0000,   // 0x1750 (5968)
+0xBDF7, 0x1082, 0x1082, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1760 (5984)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1770 (6000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1780 (6016)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x73CF, 0x0000, 0x52AA, 0xFFFF, 0x73CF, 0x0000, 0x2124, 0xFFFF,   // 0x1790 (6032)
+0xFFFF, 0xCE79, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0xDEFB, 0xCE79, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104,   // 0x17A0 (6048)
+0xDEFB, 0x1082, 0x10A2, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x17B0 (6064)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x17C0 (6080)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x17D0 (6096)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0x73AE, 0xDEFB, 0xFFFF, 0xEF7D, 0x73AE, 0xAD55, 0xFFFF,   // 0x17E0 (6112)
+0xFFFF, 0xFFFF, 0xFFFF, 0x73CF, 0x73CE, 0x7BCF, 0x94D3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x73CF, 0x7BCF, 0x7BCF, 0x9CD3, 0xFFFF,   // 0x17F0 (6128)
+0xFFFF, 0x8C51, 0x8451, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1800 (6144)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1810 (6160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1820 (6176)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1830 (6192)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1840 (6208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1850 (6224)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1860 (6240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1870 (6256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1880 (6272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1890 (6288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18A0 (6304)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18B0 (6320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18C0 (6336)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18D0 (6352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18E0 (6368)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18F0 (6384)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1900 (6400)
+};

_718/win.ino

@@ -0,0 +1,587 @@
+void win()
+{
+    char* S1[]={"utleto.raw","dleto.raw","veleto.raw","letorain.raw","utroos.raw","dosen.raw","veosen.raw","osenrain.raw","utyzim.raw","dzima.raw","vzima.raw","utyzimsn.raw","dzima2.raw","new.raw","dvesna.raw","vevesna.raw","vesnarun.raw","dvesnar.raw","dvesnaun.raw","rain.raw"};//19
+  byte bait;
+byte bait1;
+byte q=0;
+
+mon1=t.mon;
+hour1=t.hour;
+days1=t.date;
+if ((mon1==12) || (mon1==1) || (mon1==2))//zima
+ { 
+   
+    if (hour1<10)
+   {q=8;
+     }
+   if ((hour1>9)&&(hour1<17))
+   {q=9;
+   }
+   if ((hour1>18)&&(hour1<24))
+   {q=10;
+     if ((mon1==12)&&(days1>25))
+     q=13;
+     if ((mon1==1)&&(days1<8))
+     q=13;
+     
+   }
+ }
+ 
+if (mon1==3)//mart
+ { 
+   
+    if (hour1<9)
+   {q=8;
+     }
+   if ((hour1>8)&&(hour1<15))
+   {q=17;
+   }
+    if ((hour1>14)&&(hour1<19))
+   {q=18;
+   }
+   
+   if ((hour1>18)&&(hour1<24))
+   {q=16;
+   }
+ } 
+ 
+ 
+ if ((mon1==4) || (mon1==5))
+ { 
+   
+    if (hour1<9)
+   {q=4;
+     }
+   if ((hour1>8)&&(hour1<19))
+   {q=14;
+   }
+   if ((hour1>18)&&(hour1<24))
+   {q=15;
+    if (hu>96) {q=19;}
+   }
+ }
+ 
+ 
+  if ((mon1==6) || (mon1==7) || (mon1==8))//leto
+ { 
+   
+    if (hour1<8)
+   {q=0;
+     }
+   if ((hour1>7)&&(hour1<20))
+   {q=1;
+     if (hu>90) {q=3;}
+   }
+   if ((hour1>19)&&(hour1<24))
+   {q=2;
+   if (hu>96) {q=19;}
+   }
+ }
+ 
+ 
+  if ((mon1==9) || (mon1==10) || (mon1==11))//leto
+ { 
+   
+    if (hour1<8)
+   {q=4;
+     }
+   if ((hour1>7)&&(hour1<20))
+   {q=5;
+     if (hu>90) {q=7;}
+   }
+   if ((hour1>19)&&(hour1<24))
+   {q=6;
+   if ((hu>96)&&(tu>10)) {q=19;}
+   }
+ }
+//pressure  hu  tu
+
+
+
+ sd.chdir("/");//установка раб директории 
+     delay (50);
+     sd.chdir("win");//установка раб директории 
+     delay (50);  
+     
+//myFiles.loadBitmap(0, 0, 640, 480, S1[q]); 
+
+
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open(S1[q], O_READ);
+  
+int n=0;
+int m1=0;
+int w;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m1, 640, 1, pic1, 1);
+ m1=m1+1;
+ }
+  }
+
+ myFile.close(); 
+
+
+ sd.chdir("/");//установка раб директории 
+   delay (50); 
+
+myGLCD.setFont( SevenSegNumFont); 
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+ 
+ if (pressure>759)
+   myGLCD.setColor(255,50,50);
+   
+    if (pressure<746)
+   myGLCD.setColor(0,0,255);
+   
+    if ((pressure>745)&&(pressure<760))
+  myGLCD.setColor(7,120,34);
+
+   myGLCD.printNumI(pressure,183-24,30+13);// myGLCD.print(":",cx+32+32, cy);
+  //  myGLCD.setColor(0,0,255);
+    myGLCD.setFont( Ubuntubold); 
+
+
+  //  myGLCD.print("mm",183-24+22, 30+16+20+24); 
+    
+  if (pres[0]>pres[1])
+  myGLCD.print("*",183-24+35,30+13-30); 
+  
+    if (pres[0]<pres[1])
+  myGLCD.print("*",183-24+35, 30+16+20+26);
+  
+  // myGLCD.setFont( BigFont);
+
+ if (pres[1]>759)
+   myGLCD.setColor(255,200,200);
+   
+    if (pres[1]<746)
+   myGLCD.setColor(200,200,255);
+   
+    if ((pres[1]>745)&&(pres[1]<760))
+  myGLCD.setColor(200,255,200);
+  
+ myGLCD.printNumI(pres[1],183-24+2-8+24,30+16+20+64); 
+ 
+  if (pres[2]>759)
+   myGLCD.setColor(255,200,200);
+   
+    if (pres[2]<746)
+   myGLCD.setColor(200,200,255);
+   
+    if ((pres[2]>745)&&(pres[2]<760))
+  myGLCD.setColor(200,255,200);
+ 
+ 
+ myGLCD.printNumI(pres[2],183-24+2-8+24,30+16+20+100);
+
+myGLCD.setFont( Ubuntubold);
+
+
+  
+ //*********TEMPUL**************************************    
+    //  myGLCD.setColor(255,142,21);
+      
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+ if (zn<2)
+ {myGLCD.setColor(0,0,255);//обводка
+   myGLCD.print("-",21-2, 235+15-2);
+ myGLCD.print("-",21+2, 235+15+2);
+  myGLCD.print("-",21-2, 235+15+2);
+   myGLCD.print("-",21+2, 235+15-2);
+ }
+ else
+ { myGLCD.setColor(VGA_RED);
+   myGLCD.print("+",21-2, 235+15-2);
+ myGLCD.print("+",21+2, 235+15+2);
+ myGLCD.print("+",21-2, 235+15+2);
+ myGLCD.print("+",21+2, 235+15-2);
+ }
+ myGLCD.setColor(VGA_RED);
+ //myGLCD.print(",",0+88-2, 235+24-2);
+ // myGLCD.print(",",0+88+2, 235+24+2);
+ myGLCD.print("C",16+88+28-2, 227-2);
+  myGLCD.print("C",16+88+28+2, 227+2);
+ 
+
+ //*********TEMPUL**************************************    
+    //  myGLCD.setColor(255,142,21);
+      myGLCD.setColor(VGA_WHITE);
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+ if (zn<2)
+ {myGLCD.print("-",21, 235+15);
+ }
+ else
+ {myGLCD.print("+",21, 235+15);
+ }
+ 
+
+ 
+ 
+  if (tu<10)
+ {  myGLCD.setFont( SevenSegNumFont);
+   myGLCD.printNumI(tu,16+24+32-20,235);// myGLCD.print(":",cx+32+32, cy);
+ myGLCD.setFont( Ubuntubold);
+   myGLCD.print(",",16+78-20, 235+24);
+ myGLCD.print("C",16+88+28, 227);
+ myGLCD.printNumI(tud,16+88+10-20,235+50-30); 
+ }
+ else
+ { myGLCD.setFont( SevenSegNumFont);
+   myGLCD.printNumI(tu,16+24,235);
+ myGLCD.setFont( Ubuntubold);
+  myGLCD.print(",",16+78, 235+24);
+ myGLCD.print("C",16+88+28, 227);
+ myGLCD.printNumI(tud,16+88+10,235+50-30); 
+ 
+ }
+//***********************************************************
+int Tm;
+int Tm1;
+ if (zn<2)
+ {Tm1=-1*tu;
+ }
+ else
+ {Tm1=tu;
+ }
+
+
+if (temul[1]>1000)
+    {   Tm=-1*(temul[1]-1000);
+      
+    }
+    else
+   {
+    Tm=temul[1];
+   }
+   myGLCD.setFont( Ubuntubold);
+if (Tm/10>Tm1)
+  myGLCD.print("*",24+32+35-18,235+58); 
+  
+    if (Tm/10<Tm1)
+  myGLCD.print("*",24+32+35-18,235-27);
+
+
+//myGLCD.setColor(VGA_WHITE);
+myGLCD.setColor(255,200,200);
+myGLCD.setFont( Ubuntubold);
+ if (temul[0]>=1000)
+    {   Tm=temul[0]-1000;
+     myGLCD.setColor(150,200,255);
+        myGLCD.print("-" ,100-24, 235+90+12);
+    }
+    else
+   { myGLCD.print("+" ,100-24, 235+90+12);
+    Tm=temul[0];
+    myGLCD.setColor(255,200,200);
+   }
+if (temul[0]<100)
+ { myGLCD.print("," ,100+24-8, 235+90+12);
+   myGLCD.printNumI(Tm/10,100,235+90+12);
+ 
+  myGLCD.printNumI(Tm%10,100+48-15,235+90+12);
+ }
+ else
+ { myGLCD.print("," ,100+48-8, 235+90+12);
+   myGLCD.printNumI(Tm/10,100,235+90+12);
+
+  myGLCD.printNumI (Tm%10,100+48+24-15,235+90+12);
+ }
+
+
+
+if (temul[1]>=1000)
+    {   Tm=temul[1]-1000;
+        myGLCD.print("-" ,30, 235+60+80+12);
+    }
+    else
+   { myGLCD.print("+" ,30, 235+60+80+12);
+    Tm=temul[1];
+   }
+if (temul[1]<100)
+ {  myGLCD.print("," ,30+24+24-8, 235+60+80+12);
+   myGLCD.printNumI(Tm/10,30+24,235+60+80+12);
+ 
+  myGLCD.printNumI(Tm%10,30+24+48,235+60+80+12);
+ }
+ else
+ { myGLCD.print("," ,30+24+48-8, 235+60+80+12);
+   myGLCD.printNumI(Tm/10,30+24,235+60+80+12);
+
+  myGLCD.printNumI (Tm%10,30+24+48+24-15,235+60+80+12);
+ }
+
+   
+ //*********HUG**************************************     
+  myGLCD.setColor(129,239,255);
+  
+ myGLCD.setBackColor( VGA_TRANSPARENT);    
+  myGLCD.setFont( Ubuntubold);
+ 
+  myGLCD.print("%",255+88, 235+24); 
+ myGLCD.setFont( SevenSegNumFont);
+ myGLCD.printNumI(hu,255+24,235);
+ //myGLCD.printNumI(hud,255+88+20,240);  
+   myGLCD.setFont( Ubuntubold);
+
+ if (hug[0]/10>hug[1]/10)
+  myGLCD.print("*",255+24+24,235-27); 
+  
+    if (hug[0]/10<hug[1]/10)
+  myGLCD.print("*",255+24+24,235+53);   
+   
+   
+   myGLCD.setColor(200,200,255);
+ myGLCD.printNumI(hug[1]/10,255+24+44,235+90+12);
+ myGLCD.print("%",255+24+44+48, 235+90+12);
+ 
+  myGLCD.printNumI(hug[2]/10,245,235+60+80+12);
+ myGLCD.print("%",245+48, 235+60+80+12);
+ 
+ myGLCD.setBackColor( VGA_TRANSPARENT); 
+ 
+ 
+ 
+ //*********************min max************************************************
+ // myGLCD.setBackColor(8,101,192); 
+  myGLCD.setColor(255, 55, 55);
+  myGLCD.setFont(BigFont);
+  int px=25;
+  int py=437;
+   byte hh;
+  byte mm;
+  byte d;
+  byte m;
+  word y;
+  //*************max****************************************
+  if (temul[24]>600)
+   {readmax();
+     }
+  d=time1[24]/1000;
+  m=(time1[24]%1000)/10;
+  y=((time1[24]%1000)%10)*10;
+  hh=time1[25]/1000;
+  mm=(time1[25]%1000)/10;
+   y=y+((time1[25]%1000)%10);
+      myGLCD.setBackColor(255,255,255); 
+  myGLCD.print("Tmax=+" ,px, py);
+   myGLCD.printNumI(temul[24]/10, px+16*6, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(temul[24]%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+     
+      myGLCD.setBackColor( VGA_TRANSPARENT); 
+      myGLCD.print(":" ,px-4+16*2, py+16);
+     if(hh<10)
+     { myGLCD.print("0" ,px, py+16);
+       myGLCD.printNumI(hh, px+16, py+16);
+     }
+    else 
+     {myGLCD.printNumI(hh, px, py+16);
+     }
+  //myGLCD.print(":" ,px+16*2, py+16);
+  
+   if(mm<10)
+     { myGLCD.print("0" ,px+16*3-8, py+16);
+       myGLCD.printNumI(mm, px+16*4-8, py+16);
+     }
+    else 
+     {myGLCD.printNumI(mm, px+16*3-8, py+16);
+     }
+ // myGLCD.print(" " ,px+16*5, py+16);
+  myGLCD.print("." ,px+16*7-4, py+16);
+  if(d<10)
+     { myGLCD.print("0" ,px+16*5, py+16);
+       myGLCD.printNumI(d, px+16*6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(d, px+16*5, py+16);
+     }
+  
+   myGLCD.print("." ,px+16*10-10, py+16);
+  if(m<10)
+     { myGLCD.print("0" ,px+16*8-6, py+16);
+       myGLCD.printNumI(m, px+16*9-6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(m, px+16*8-6, py+16);
+     }
+ // myGLCD.print("." ,px+16*11-12, py+16);
+  
+  myGLCD.printNumI(y, px+16*11-14, py+16);
+ 
+//*************min ***********************************************
+  myGLCD.setColor(55, 55, 255);
+  myGLCD.setBackColor(255,255,255); 
+ d=time1[26]/1000;
+  m=(time1[26]%1000)/10;
+  y=((time1[26]%1000)%10)*10;
+  hh=time1[27]/1000;
+  mm=(time1[27]%1000)/10;
+   y=y+((time1[27]%1000)%10);
+ // int Tm;
+  
+  py=437;
+  px=240;
+   if (temul[25]>1000)
+       {   Tm=temul[25]-1000;
+       
+        if(Tm<100)
+        {myGLCD.print("Tmin= -" ,px, py);
+        }
+        else
+        { myGLCD.print("Tmin=-" ,px, py);
+        }
+       }
+    else
+   {
+    Tm=temul[25];
+     if(Tm<100)
+        {myGLCD.print("Tmin= +" ,px, py);
+        }
+        else
+        { myGLCD.print("Tmin=+" ,px, py);
+        }
+   }
+  
+ if(Tm<100) 
+ { // myGLCD.print(" " ,px+16*6, py);
+   myGLCD.printNumI(Tm/10, px+16*7, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(Tm%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+ }  
+  else
+  { myGLCD.printNumI(Tm/10, px+16*6, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(Tm%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+  }  
+     
+      myGLCD.setBackColor( VGA_TRANSPARENT); 
+     myGLCD.print(":" ,px-4+16*2, py+16);
+     if(hh<10)
+     { myGLCD.print("0" ,px, py+16);
+       myGLCD.printNumI(hh, px+16, py+16);
+     }
+    else 
+     {myGLCD.printNumI(hh, px, py+16);
+     }
+ // myGLCD.print(":" ,px+16*2, py+16);
+  
+   if(mm<10)
+     { myGLCD.print("0" ,px+16*3-8, py+16);
+       myGLCD.printNumI(mm, px+16*4-8, py+16);
+     }
+    else 
+     {myGLCD.printNumI(mm, px+16*3-8, py+16);
+     }
+//  myGLCD.print(" " ,px+16*5, py+16);
+   myGLCD.print("." ,px+16*7-4, py+16);
+  if(d<10)
+     { myGLCD.print("0" ,px+16*5, py+16);
+       myGLCD.printNumI(d, px+16*6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(d, px+16*5, py+16);
+     }
+     
+   myGLCD.print("." ,px+16*10-10, py+16);
+  
+  if(m<10)
+     { myGLCD.print("0" ,px+16*8-6, py+16);
+       myGLCD.printNumI(m, px+16*9-6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(m, px+16*8-6, py+16);
+     }
+  
+  myGLCD.printNumI(y, px+16*11-14, py+16);
+  
+if(bt==0)  
+ { int xb=510;//390
+     barometr(xb); 
+     bt=1;
+ }
+ else
+ {int xtd=510;//512;
+ termdom(xtd);
+ bt=0;
+ }
+
+
+ 
+    myGLCD.setColor(255, 255, 255);
+  myGLCD.setFont( Ubuntubold);
+   
+} 
+
+//***************************************************************************
+//****************************************************************************
+void readmax()
+{
+  byte reader[47];//23:00 T=+25,8C Pmm=756 H=25% Tu=+25,6C Hu=75,6%
+    sd.chdir("/");
+  delay (100);
+   myFile.open("rab.txt", O_READ);
+   
+// пропускаем ненужные данные в файле rab.txt  
+    for (int n =0 ; n < 24; n = n++)// колво строк в файле
+ {  
+ for (int i =0 ; i < 47; i = i++) // колво байт в строку
+  {  byte b= myFile.read();
+   }
+  byte b= myFile.read()-48;//возврат коретки 2 байта
+ b= myFile.read()-48;
+} 
+//**************************************************************
+
+//читаем время и температуру максимальную с карты памяти в массив
+for (int n =0 ; n < 3; n = n+2)// колво строк в файле
+ {  
+ for (int i =0 ; i < 26; i = i++) // колво байт в строку
+  {  byte b= myFile.read();
+  if (b<48)
+  {reader[i]=b;
+  }
+  else
+  {  b=b-48;//получение цифры из байта
+ 
+   reader[i]=b;
+  }
+  
+  }
+    time1[n+24]=reader[0]*10000+reader[1]*1000+reader[3]*100+reader[4]*10+reader[6];//max 16.08. 1 16081
+    time1[n+1+24]=reader[9]*10000+reader[10]*1000+reader[12]*100+reader[13]*10+reader[7];//12:00 4  12004
+    
+    if (reader[20]==45)
+{temul[24+n/2]=reader[21]*100+reader[22]*10+reader[24]+1000;
+}
+else
+{temul[24+n/2]=reader[21]*100+reader[22]*10+reader[24];
+}
+
+   
+
+  
+    byte  b= myFile.read()-48;//возврат коретки 2 байта
+ b= myFile.read()-48;
+ 
+  myFile.close(); 
+  }
+  }

_718/xf.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: X.jpg
+// Time generated: 12.04.2014 22:14:47
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short xf[0x384] ={
+0xD0C4, 0xD8E5, 0xF0C4, 0xE984, 0xF166, 0xF1C8, 0xF1A7, 0xF1C9, 0xF1C8, 0xF1C7, 0xE9C7, 0xF1E8, 0xE9A8, 0xF1A8, 0xF1C8, 0xE9E8,   // 0x0010 (16)
+0xF1C8, 0xF1C8, 0xE9C6, 0xF1C8, 0xF1C8, 0xF1C8, 0xE9A8, 0xEA07, 0xF1E8, 0xEA27, 0xF229, 0xEA8A, 0xEAAB, 0xF28B, 0xC8A2, 0xD0A4,   // 0x0020 (32)
+0xE0E5, 0xE8E4, 0xF106, 0xF187, 0xE1C7, 0xE1C7, 0xE988, 0xE9A8, 0xF1C6, 0xE9A7, 0xE9C8, 0xF1A7, 0xF167, 0xE9C7, 0xE9A7, 0xE9C6,   // 0x0030 (48)
+0xF1A8, 0xE1A6, 0xE9C7, 0xE187, 0xF1E8, 0xF187, 0xE9A9, 0xF208, 0xF229, 0xF26B, 0xF2AC, 0xF2AC, 0xB8C3, 0xB8C3, 0xD0A4, 0xE0E5,   // 0x0040 (64)
+0xF125, 0xE146, 0xF947, 0xF186, 0xF167, 0xE966, 0xF167, 0xE986, 0xF166, 0xE967, 0xF186, 0xF186, 0xE9A6, 0xE966, 0xF167, 0xE1A6,   // 0x0050 (80)
+0xE966, 0xF167, 0xE184, 0xF946, 0xF187, 0xE1E6, 0xF209, 0xE269, 0xEAAB, 0xF2CC, 0xA0C2, 0xB883, 0xC8C5, 0xD8A3, 0xE903, 0xE104,   // 0x0060 (96)
+0xF146, 0xE924, 0xF905, 0xF147, 0xE126, 0xE946, 0xE945, 0xF126, 0xE946, 0xE925, 0xE925, 0xE927, 0xF146, 0xF106, 0xF166, 0xE945,   // 0x0070 (112)
+0xF126, 0xE946, 0xE947, 0xE9A6, 0xEA08, 0xF229, 0xFA8B, 0xEAEB, 0x98A3, 0xB0A3, 0xB8A4, 0xD0E5, 0xD8C5, 0xFFFC, 0xFFBF, 0xFFBF,   // 0x0080 (128)
+0xD945, 0xE8E5, 0xE925, 0xE925, 0xE925, 0xE925, 0xE8E5, 0xF105, 0xE126, 0xF104, 0xF105, 0xE904, 0xE8E5, 0xD925, 0xFFBE, 0xFFFC,   // 0x0090 (144)
+0xFFBE, 0xE187, 0xF1A7, 0xF22A, 0xFA8B, 0xF2AA, 0x9883, 0xB883, 0xC0A3, 0xC8C3, 0xE0C4, 0xE0C6, 0xFFBC, 0xFFDF, 0xFFBC, 0xE8E5,   // 0x00A0 (160)
+0xF8C4, 0xE8E4, 0xE0C5, 0xE8E5, 0xE904, 0xE0E4, 0xE905, 0xE8E4, 0xE903, 0xE905, 0xE125, 0xFF9E, 0xFFBE, 0xF79F, 0xF5F7, 0xE946,   // 0x00B0 (176)
+0xF1C7, 0xEA29, 0xEA8A, 0xF2EB, 0x9883, 0xA882, 0xB8A2, 0xC8A3, 0xE8A4, 0xE8E4, 0xE8C7, 0xF7BE, 0xFFDF, 0xF7FC, 0xE8E5, 0xE8A5,   // 0x00C0 (192)
+0xF0E6, 0xE0E4, 0xE104, 0xF0E4, 0xF0E4, 0xE8C4, 0xE8C5, 0xF0C4, 0xFF9E, 0xF7FE, 0xFFBD, 0xFFDF, 0xF105, 0xE925, 0xE9A7, 0xEA28,   // 0x00D0 (208)
+0xEA8A, 0xEACC, 0x98A3, 0xA882, 0xB8E3, 0xC8C4, 0xD8A4, 0xE8A3, 0xE8E5, 0xFE79, 0xF7BF, 0xFFFF, 0xFFBD, 0xD905, 0xF883, 0xE8E4,   // 0x00E0 (224)
+0xE8C4, 0xF0C4, 0xE8E3, 0xE0E4, 0xE0E6, 0xFFBE, 0xFFDF, 0xFFBF, 0xFFFE, 0xF0C5, 0xE8C5, 0xE966, 0xF988, 0xF209, 0xF26A, 0xF2AC,   // 0x00F0 (240)
+0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xFEDB, 0xFF9E, 0xFFDE, 0xF7DE, 0xF0A6, 0xE8E3, 0xF0C3, 0xE8E6,   // 0x0100 (256)
+0xF0E3, 0xE8C6, 0xF73D, 0xF7FE, 0xFFDF, 0xFF9F, 0xE0E4, 0xE8E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3,   // 0x0110 (272)
+0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E5, 0xF77B, 0xFF9F, 0xFFBF, 0xFF9E, 0xF0C4, 0xF0E3, 0xE0E3, 0xE8C4, 0xFEDC,   // 0x0120 (288)
+0xF7FE, 0xFFBE, 0xFFBD, 0xE8E3, 0xF0A6, 0xE8E4, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3,   // 0x0130 (304)
+0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8A3, 0xE904, 0xFFBE, 0xF7DF, 0xFFBE, 0xFFFD, 0xE8A4, 0xE8E6, 0xFFDD, 0xFFBD, 0xFFBF, 0xFFBE,   // 0x0140 (320)
+0xE905, 0xE0C3, 0xE8E4, 0xE0E4, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4,   // 0x0150 (336)
+0xE8E4, 0xE8E4, 0xE905, 0xE8A4, 0xE103, 0xFFDE, 0xFFDF, 0xFFBD, 0xFFBF, 0xFF7C, 0xF7DF, 0xFFBF, 0xFFBF, 0xF7DD, 0xF8E4, 0xE8E5,   // 0x0160 (352)
+0xF0C5, 0xF0E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4,   // 0x0170 (368)
+0xF0A4, 0xE8E4, 0xE8E4, 0xF0C5, 0xFFBE, 0xF7BF, 0xFFDF, 0xF7DF, 0xFFBF, 0xFFFE, 0xFFBE, 0xF0C4, 0xE8C4, 0xE0C5, 0xF0E4, 0xE0E4,   // 0x0180 (384)
+0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E4, 0xF0C5,   // 0x0190 (400)
+0xE8E5, 0xE8C3, 0xF0C6, 0xF7FE, 0xF79E, 0xFFDE, 0xFF9F, 0xF7FE, 0xE8C4, 0xE8E3, 0xF8C4, 0xF0E4, 0xE8C5, 0xE8E4, 0xE8E5, 0xE945,   // 0x01A0 (416)
+0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8C4, 0xE8E4, 0xF0A4, 0xF0C5,   // 0x01B0 (432)
+0xE0E4, 0xFFDE, 0xFF9F, 0xFFBE, 0xFF9F, 0xF7FE, 0xF0C3, 0xE0E5, 0xE8E3, 0xE904, 0xE8C5, 0xF0E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09,   // 0x01C0 (448)
+0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E4, 0xE904, 0xE8E3, 0xE0E5, 0xFFDE, 0xFF9E,   // 0x01D0 (464)
+0xFFBF, 0xFFBF, 0xFFDE, 0xFFDE, 0xFFDE, 0xE8C5, 0xF0C4, 0xF0A5, 0xE904, 0xE8C5, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB,   // 0x01E0 (480)
+0x98A2, 0xA882, 0xB8A3, 0xC8E2, 0xD8A3, 0xE0C5, 0xE0E5, 0xE8E4, 0xF0C5, 0xE8A4, 0xE904, 0xFFBC, 0xFFFF, 0xFF9E, 0xFF9F, 0xFFDE,   // 0x01F0 (496)
+0xFFDF, 0xFF9E, 0xFFDF, 0xFFDD, 0xF0E4, 0xE8E4, 0xE0E4, 0xF0E4, 0xE905, 0xE925, 0xF168, 0xEA29, 0xEA8B, 0xF2AC, 0x9882, 0xA883,   // 0x0200 (512)
+0xB0E2, 0xC8C4, 0xE0C4, 0xE8C4, 0xE8C4, 0xF0C3, 0xE8E4, 0xF105, 0xF7DF, 0xFFBF, 0xF77D, 0xFFDF, 0xE125, 0xE8A5, 0xF7DD, 0xFFDE,   // 0x0210 (528)
+0xFFBF, 0xFF9D, 0xF0C4, 0xD8E5, 0xF0E4, 0xE8E4, 0xE8E5, 0xF165, 0xF167, 0xF228, 0xF28A, 0xF2AB, 0x90C3, 0xB083, 0xB0A2, 0xC8A4,   // 0x0220 (544)
+0xE0A5, 0xE8C4, 0xE8E4, 0xE8E3, 0xE8E5, 0xFFBE, 0xFF9E, 0xFFBF, 0xFFDE, 0xE8E4, 0xE8E4, 0xE903, 0xF8A4, 0xFFBE, 0xFFFF, 0xFFBE,   // 0x0230 (560)
+0xFFBE, 0xF0E5, 0xF085, 0xE902, 0xE8E5, 0xE944, 0xF1A7, 0xEA29, 0xEA8A, 0xF2CB, 0xA063, 0xA8A2, 0xB8A4, 0xC8A4, 0xE0C4, 0xE0E4,   // 0x0240 (576)
+0xF0A4, 0xE106, 0xFFBD, 0xFFDE, 0xFFDE, 0xF7FD, 0xF0C4, 0xF0A4, 0xE0E3, 0xF0C5, 0xE8E4, 0xE906, 0xF79F, 0xFFDF, 0xFFDE, 0xFF7C,   // 0x0250 (592)
+0xE0C4, 0xE904, 0xF106, 0xE965, 0xE988, 0xF1E9, 0xF24A, 0xEACC, 0xA0A3, 0xA882, 0xB083, 0xC8E4, 0xD8C2, 0xE0C3, 0xE8C6, 0xFFBD,   // 0x0260 (608)
+0xFFBF, 0xFF9E, 0xF7BE, 0xE904, 0xE8E4, 0xE8E5, 0xF0C4, 0xE0E4, 0xE8C4, 0xE8E3, 0xFF1C, 0xFFBE, 0xFF9F, 0xF7BD, 0xFFDE, 0xF0E3,   // 0x0270 (624)
+0xE105, 0xF125, 0xE9A8, 0xEA28, 0xEA89, 0xEACC, 0xA062, 0xA0A3, 0xB8C4, 0xC0E3, 0xD8C3, 0xE8E4, 0xFFBC, 0xFFBF, 0xFFBF, 0xFFBF,   // 0x0280 (640)
+0xF0C5, 0xF0C4, 0xE104, 0xF0C4, 0xE8C4, 0xE904, 0xF0C3, 0xE0E4, 0xE0C5, 0xFFDE, 0xFFDF, 0xFF9F, 0xFFBE, 0xE8C5, 0xF104, 0xF164,   // 0x0290 (656)
+0xE987, 0xEA29, 0xF28A, 0xEAAB, 0x98A2, 0xA8A4, 0xB882, 0xC8E4, 0xD8A4, 0xE8C7, 0xFFBE, 0xFFDF, 0xFFDE, 0xE8C4, 0xE8C4, 0xE904,   // 0x02A0 (672)
+0xE103, 0xF0C4, 0xF0C5, 0xE8A3, 0xE8C4, 0xE8E5, 0xE904, 0xE8E5, 0xFFDC, 0xFFBE, 0xFF9F, 0xFFDE, 0xE8E6, 0xE944, 0xE9A7, 0xF20A,   // 0x02B0 (688)
+0xF26B, 0xEAEB, 0x9883, 0xA883, 0xB0E4, 0xC8A3, 0xD8C5, 0xF79C, 0xFFDE, 0xFF9E, 0xE8E3, 0xF0C4, 0xE8E3, 0xF0A4, 0xE0E5, 0xE8E4,   // 0x02C0 (704)
+0xE0E3, 0xE8C5, 0xE8C5, 0xE8E3, 0xF8C3, 0xE8E5, 0xE8A5, 0xFFDE, 0xFF9F, 0xFFDE, 0xFFDE, 0xE946, 0xF186, 0xF1E9, 0xF26B, 0xF2AA,   // 0x02D0 (720)
+0x9882, 0xA0A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4,   // 0x02E0 (736)
+0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE905, 0xE925, 0xE986, 0xF1E8, 0xEA6A, 0xF2AB, 0x9882, 0xA0A3,   // 0x02F0 (752)
+0xB0A3, 0xC0C3, 0xD0C4, 0xD8C4, 0xE0C4, 0xE0C4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4,   // 0x0300 (768)
+0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE8C4, 0xE8E5, 0xE946, 0xF1C7, 0xEA69, 0xEA8A, 0x9883, 0xA0A3, 0xA8A3, 0xB8C3,   // 0x0310 (784)
+0xC8C4, 0xD0C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4,   // 0x0320 (800)
+0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xE8E4, 0xE905, 0xF146, 0xF1E8, 0xF249, 0x9883, 0x9883, 0xA8A3, 0xB0A3, 0xB8A3, 0xC0C3,   // 0x0330 (816)
+0xC8A4, 0xC8A4, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3,   // 0x0340 (832)
+0xC8C3, 0xC8C3, 0xD0A4, 0xD8C4, 0xE0E4, 0xF125, 0xF187, 0xF1E8, 0x9883, 0xA083, 0xA083, 0xB0A3, 0xB8A3, 0xB8C3, 0xC0C4, 0xC0C4,   // 0x0350 (848)
+0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3,   // 0x0360 (864)
+0xC8A4, 0xC8C3, 0xD0E3, 0xE0E4, 0xE925, 0xE967, 0x98A3, 0xA0A3, 0xA883, 0xB0A3, 0xB8A3, 0xB8A2, 0xC082, 0xC082, 0xB8A3, 0xB8A3,   // 0x0370 (880)
+0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xC0A3, 0xC0C3,   // 0x0380 (896)
+0xC8C3, 0xE0A4, 0xE0E5, 0xE946, };

_719/Fl1.ino

@@ -0,0 +1,901 @@
+void flower1()
+
+{
+    byte bait;
+byte bait1;
+
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl1.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl ,80, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl ,59, 385); 
+ 
+//   myGLCD.setFont(Ubuntubold);
+// myGLCD.setColor(VGA_BLUE);
+//myGLCD.printNumI(osv ,440, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl ,65, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+// myGLCD.setColor(0,38,92);
+//  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+ //     myGLCD.setColor(255, 255, 255);//цвет обводки
+ // myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+//  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+
+graflawer();
+grafflm();
+
+//******************************************************************************************************************************
+
+
+
+}
+
+
+//********************************************************************************************************************
+ void graflawer()
+//*******рисуем график ********************************* 
+{       myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(215, 0, 635, 475);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(215, 0, 635, 475);//прямоугольник с  обводкой
+    int z=80;
+  int s=220;
+  myGLCD.setColor(30,55,90);
+  myGLCD.fillRoundRect(s+55, 5, s+55+15, 440-z);//рисуем синий пр-к1
+    myGLCD.setColor(45,55,105);
+  myGLCD.fillRoundRect(s+55+15, 5, s+55+30, 440-z);//рисуем синий пр-к2
+    myGLCD.setColor(60,55,110);
+  myGLCD.fillRoundRect(s+55+30, 5, s+55+45, 440-z);//рисуем синий пр-к3
+    myGLCD.setColor(75,55,115);
+  myGLCD.fillRoundRect(s+55+45, 5, s+55+60, 440-z);//рисуем синий пр-к4
+  
+   myGLCD.setColor(82,40,137);
+  myGLCD.fillRoundRect(s+55+60,5 , s+55+60+15, 440-z);//рисуем синий пр-к5
+  myGLCD.setColor(97,35,139);
+  myGLCD.fillRoundRect(s+55+60+15,5 , s+55+60+30, 440-z);//рисуем синий пр-к6
+  myGLCD.setColor(125,32,141);
+  myGLCD.fillRoundRect(s+55+60+30,5 , s+55+60+45, 440-z);//рисуем синий пр-к7
+  myGLCD.setColor(145,27,143);
+  myGLCD.fillRoundRect(s+55+60+45,5 , s+55+60+60, 440-z);//рисуем синий пр-к8
+  
+     myGLCD.setColor(163,25,146);
+  myGLCD.fillRoundRect(s+55+60+60,5 , s+55+60+60+15, 440-z);//рисуем синий пр-к9
+     myGLCD.setColor(173,35,136);
+  myGLCD.fillRoundRect(s+55+60+60+15,5 , s+55+60+60+30, 440-z);//рисуем синий пр-к10
+     myGLCD.setColor(187,45,120);
+  myGLCD.fillRoundRect(s+55+60+60+30,5 , s+55+60+60+45, 440-z);//рисуем синий пр-к11
+     myGLCD.setColor(195,55,106);
+  myGLCD.fillRoundRect(s+55+60+60+45,5 , s+55+60+60+60, 440-z);//рисуем синий пр-к 12
+  
+      myGLCD.setColor(200,64,97);
+  myGLCD.fillRoundRect(s+55+60+60+60,5 , s+55+60+60+60+15, 440-z);//рисуем синий пр-к13
+      myGLCD.setColor(195,75,92);
+  myGLCD.fillRoundRect(s+55+60+60+60+15,5 , s+55+60+60+60+30, 440-z);//рисуем синий пр-к14
+      myGLCD.setColor(190,85,87);
+  myGLCD.fillRoundRect(s+55+60+60+60+30,5 , s+55+60+60+60+45, 440-z);//рисуем синий пр-к15
+      myGLCD.setColor(180,95,82);
+  myGLCD.fillRoundRect(s+55+60+60+60+45,5 , s+55+60+60+60+60, 440-z);//рисуем синий пр-к 16
+  
+         myGLCD.setColor(171,103,76);
+  myGLCD.fillRoundRect(s+55+240,5 , s+55+240+15, 440-z);//рисуем синий пр-к 17
+         myGLCD.setColor(151,93,86);
+  myGLCD.fillRoundRect(s+55+240+15,5 , s+55+240+30, 440-z);//рисуем синий пр-к 18
+         myGLCD.setColor(131,83,96);
+  myGLCD.fillRoundRect(s+55+240+30,5 , s+55+240+45, 440-z);//рисуем синий пр-к 19
+         myGLCD.setColor(101,73,116);
+  myGLCD.fillRoundRect(s+55+240+45,5 , s+55+300, 440-z);//рисуем синий пр-к 20
+  
+        
+        myGLCD.setColor(82,40,137);
+  myGLCD.fillRoundRect(s+55+300,5 , s+55+315, 440-z);//рисуем синий пр-к 21 
+         myGLCD.setColor(60,55,110);
+  myGLCD.fillRoundRect(s+55+315,5 , s+55+330, 440-z);//рисуем синий пр-к 22 
+        myGLCD.setColor(30,55,90);
+  myGLCD.fillRoundRect(s+55+330,5 , s+55+345, 440-z);//рисуем синий пр-к 23
+
+
+
+
+
+  myGLCD.setBackColor(0,38,92);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setFont(BigFont);
+   myGLCD.drawLine(s+55, 10, s+55, 450-z);// ось у
+    myGLCD.drawLine(s+400, 10, s+400, 440-z);//ось у давление
+   myGLCD.drawLine(s+55, 90+180-z, s+400, 90+180-z);// ось х темп
+   myGLCD.drawLine(s+55, 440-z, s+400, 440-z);//ось х влажность
+ 
+  
+   myGLCD.setColor(35,173,255);
+    //myGLCD.drawLine(s+55, 270-80, s+400, 270-80);// ось 0
+     myGLCD.setColor(200,64,97);
+    myGLCD.drawLine(s+55, 270-200, s+400, 70);// ось 30
+      myGLCD.drawLine(s+55, 270-220, s+400, 50);// ось 35
+      myGLCD.drawLine(s+55, 440-30-z, s+400, 440-30-z);// ось 30
+      myGLCD.drawLine(s+55, 440-15-z, s+400, 440-15-z);// ось 30
+     myGLCD.setColor(45,112,56);
+     myGLCD.drawLine(s+55, 270-180, s+400, 270-180);// ось 25
+    myGLCD.drawLine(s+55, 270-160, s+400, 270-160);// ось 20
+    myGLCD.drawLine(s+55, 270-120, s+400, 270-120);// ось 10
+    myGLCD.drawLine(s+55, 270-100, s+400, 270-100);// ось 5
+    myGLCD.drawLine(s+55, 270-140, s+400, 270-140);// ось 15
+    myGLCD.drawLine(s+55, 440-105-z, s+400, 440-105-z);// ось 70
+    myGLCD.drawLine(s+55, 440-90-z, s+400, 440-90-z);// ось 60
+    myGLCD.drawLine(s+55, 440-75-z, s+400, 440-75-z);// ось 50
+    myGLCD.drawLine(s+55, 440-60-z, s+400, 440-60-z);// ось 40
+    myGLCD.drawLine(s+55, 440-45-z, s+400, 440-45-z);// ось 30
+    myGLCD.setColor(0,38,92);
+  //  myGLCD.drawLine(s+55, 270-60, s+400, 270-60);// ось -5
+ //  myGLCD.drawLine(s+55, 270-40, s+400, 270-40);// ось -10 
+//  myGLCD.drawLine(s+55, 270-20, s+400, 270-20);// ось -15 
+  myGLCD.drawLine(s+55, 440-135-z, s+400, 440-135-z);// ось 90
+  myGLCD.drawLine(s+55, 440-120-z, s+400, 440-120-z);// ось 80
+    myGLCD.setColor(255,75,29);
+     myGLCD.drawLine(s+55, 270-240, s+400, 270-240);// ось 40
+     myGLCD.drawLine(s+55, 270-260, s+400, 270-260);// ось 45
+    
+    
+   byte k=0;
+   myGLCD.setColor(VGA_WHITE);
+   for (int i =80 ; i < 270; i = i+4) //температура  шкала цифры
+    { 
+      myGLCD.drawLine(s+55, 90+180-i, s+52, 90+180-i);
+      myGLCD.drawLine(s+400, 90+180-i, s+403, 90+180-i);
+       k=k+1;
+        if((k==6)||(k==1))//верт метки tu td
+           {
+             if ((i/4-20)>29)
+             {myGLCD.setColor(255,62,62);
+              myGLCD.printNumI(i/4-20, s+5, 90+180-8-i);
+             }
+              if ((i/4-20)>0 && (i/4-20)<30)
+             {myGLCD.setColor(10,255,60);
+              myGLCD.printNumI(i/4-20, s+5, 90+180-8-i);
+             }
+             
+              if ((i/4-20)<1)
+             {myGLCD.setColor(35,173,255);
+              myGLCD.printNumI(i/4-20, s+5, 90+180-8-i);
+             }
+             
+           myGLCD.setColor(VGA_WHITE); 
+           myGLCD.drawLine(s+55, 90+180-i, s+55-9, 90+180-i);
+           myGLCD.drawLine(s+400, 90+180-i, s+400+9, 90+180-i);
+           k=1;}
+      
+      
+      
+    }
+
+    
+      k=0;
+   myGLCD.setColor(VGA_WHITE);
+   for (int i =0 ; i < 150; i = i+3) //влажность
+    { //myGLCD.drawLine(55, 440, 400, 440);//ось х давление
+    //myGLCD.drawLine(55, 10, 55, 450);// ось у
+       myGLCD.drawLine(s+55, 440-i-z, s+52, 440-i-z);
+       k=k+1;
+       
+       if((k==6)||(k==1))//верт метки tu td
+           {
+             if (i>119)
+             {myGLCD.setColor(35,173,255);
+               myGLCD.printNumI(i*2/3, s+5, 440-8-i-z);
+             }
+              if (i>31 && i<119)
+             {myGLCD.setColor(10,255,60);
+               myGLCD.printNumI(i*2/3, s+5, 440-8-i-z);
+             }
+             
+              if (i<31)
+             {myGLCD.setColor(255,255,0);
+              myGLCD.printNumI(i*2/3, s+5, 440-8-i-z);
+             }
+             
+           myGLCD.setColor(VGA_WHITE); 
+           myGLCD.drawLine(s+55, 440-i-z, s+55-9, 440-i-z);
+           k=1;}
+      
+    }
+ //*************************************   
+// int z=80;
+    k=0;
+    for (int i =0 ; i < 360; i = i+11) //гориз метки и шкала days
+    {
+      //for (byte n =0 ; n < 5; n = n++)
+        myGLCD.drawLine(s+55+i, 90+180-z, s+55+i, 90+180-z+5);
+         myGLCD.drawLine(s+55+i, 440-z, s+55+i, 440+5-z);
+        
+      
+      k=k+1;
+        if((k==6)||(k==1))
+           {myGLCD.printNumI(i/11, s+55+i-12, 90+180+10-z);
+           myGLCD.printNumI(i/11, s+55+i-12, 440+10-z);
+           myGLCD.drawLine(s+55+i, 90+180-z, s+55+i, 90+180+9-z);
+           myGLCD.drawLine(s+55+i, 440-z, s+55+i, 440+9-z);
+           k=1;}
+    }
+   myGLCD.setBackColor( VGA_TRANSPARENT);
+   myGLCD.setColor(255,62,62);
+   myGLCD.print("T C" ,s+59, 10);
+   myGLCD.print("T C" ,s+61, 10);
+   myGLCD.print("T C" ,s+60, 11);
+   myGLCD.print("T C" ,s+60, 9);
+     myGLCD.setColor(VGA_WHITE); 
+    myGLCD.print("T C" ,s+60, 10);
+    
+    
+     
+ //   myGLCD.setColor(10,255,60); 
+  // myGLCD.print("750" ,352, 250-8); 
+  // myGLCD.print("755" ,352, 230-8); 
+ //  myGLCD.print("760" ,352, 210-8);
+ //  myGLCD.print("765" ,352, 190-8);
+ //  myGLCD.print("770" ,352, 170-8);
+ //  myGLCD.setColor(0,38,92);
+//    myGLCD.print("Pmm" ,353, 170-35);
+  //   myGLCD.print("Pmm" ,351, 170-35);
+  //    myGLCD.print("Pmm" ,352, 171-35);
+   //    myGLCD.print("Pmm" ,352, 169-35);
+ //  myGLCD.setColor(VGA_WHITE);
+ //  myGLCD.print("Pmm" ,352, 170-35);
+   
+  myGLCD.setColor(35,173,255); 
+   myGLCD.print("H%" ,s+61, 290-z);
+   myGLCD.print("H%" ,s+59, 290-z);
+   myGLCD.print("H%" ,s+60, 291-z);
+   myGLCD.print("H%" ,s+60, 289-z);
+    myGLCD.setColor(VGA_WHITE);
+     myGLCD.print("H%" ,s+60, 290-z);
+  
+
+   
+ 
+}
+
+//***************************************************************
+void grafflm()
+{
+  boolean datm=1;
+  boolean daty=1;
+int m=t.mon;//месяц 
+int ye=t.year; //год
+// knopki******************************
+byte dat16=0;//16:00 date yes or no
+
+  myGLCD.setFont( Ubuntubold); 
+        myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 
+        myGLCD.print("M" ,235, 395);//выделение месяца цветом 440 203
+      
+      // myGLCD.setBackColor(8,101,192);
+       myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 440 243
+       myGLCD.print("Y" ,235, 435);
+       
+        myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 391, 400, 434-5);//рисуем синий пр-к  M
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 391, 400, 434-5);//прямоугольник с  обводкой 
+ 
+  myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 431, 400, 474-5);//рисуем синий пр-к  Y
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 431, 400, 474-5);//прямоугольник с  обводкой   
+  myGLCD.setBackColor(0,38,92);
+  
+  if (mon1<10)
+    {myGLCD.print("0" ,312, 395);
+    myGLCD.printNumI(m, 312+24, 395);
+    }
+  else
+    myGLCD.printNumI(m, 312, 395); 
+
+  myGLCD.printNumI(ye, 292, 435); 
+  
+   myGLCD.setColor(31,70,126);
+  myGLCD.print("<" ,312-32, 395); 
+ myGLCD.print(">" ,312+63, 395);
+  
+   myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(430, 391, 500, 434-5);//рисуем синий пр-к  RS
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+      myGLCD.drawRoundRect(430, 391, 500, 434-5);//прямоугольник с  обводкой
+      
+  myGLCD.setColor(0,38,92);     
+  myGLCD.fillRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  
+    myGLCD.setColor(0,38,92);     
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+
+        myGLCD.setColor(255, 255, 255);//цвет
+  
+  
+     myGLCD.setBackColor(0,38,92);
+    myGLCD.print("RS" ,440, 395);
+     myGLCD.print("OK" ,530, 395);
+     myGLCD.setColor(255, 97, 237);//цвет
+       myGLCD.print("QUIT" ,460, 435);
+    myGLCD.setColor(255, 255, 255);//цвет  
+    
+    
+//******************************************************************    
+graff:
+
+ byte dm=31;// макс день месяца  
+  if (m==2)
+     dm=28;
+    
+  if ((m==4)||(m==6)||(m==9)||(m==11))
+     dm=30;
+  
+ if(ye==t.year)//проверка на наличае данных
+   {if(m==t.mon)
+    { dm=t.date-1;
+    }
+   }
+//*************************GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG*******************************************************  
+word work[31]={100,250,250,244,245,246,240,248,249,245,250,249,250,250,250,244,245,246,250,248,250,250,250,249,250,250,250,250,250,250,249}; 
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  char* stry[] = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};  
+
+  char* name;
+  
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+  name= stry[ye-2014];
+                                                          
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+  //*************************************************************************
+   myFile.open("poliv.txt", O_READ);
+  char s;
+char token[] = "date:";  
+char token1[] = "16:00";  
+int n1=0;
+ int p=0; 
+int j=0; 
+int w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     w=10*(myFile.read()-48);//десятки даты
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+       for (j=0; j<8 ;j++)
+    { s=myFile.read();//пропуск 9 символов
+    //delay(10);
+    }
+  work[w-1]=10*(myFile.read()-48);//десятки t
+//  myGLCD.printNumI( work[w-1], 312-24, 10);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+  // myGLCD.printNumI(  work[w-1], 312+48, 10);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+ }//while 
+if (dat16==0)
+{
+ if (w>1){ work[w-1]=work[w-2];}
+}
+
+
+
+ }     
+    myFile.close();  
+  
+   delay (100);
+   
+   myGLCD.setColor(255, 0, 0);
+int y1;
+int y2;
+  //****************Рисуем графики   T*************************** 
+
+ // цвет графиа  
+    if(colorgraf>3)
+   colorgraf=0;
+    if(colorgraf==0)//выбор цвета графика
+     myGLCD.setColor(VGA_WHITE);
+     if(colorgraf==1)
+    myGLCD.setColor(35,173,255);
+      if(colorgraf==2)
+    myGLCD.setColor(255, 255, 0);
+     if(colorgraf==3)
+    myGLCD.setColor(10,255,60);
+   for ( byte x =1 ; x < dm; x = x+1) //****************темп дома постр  графика
+    { 
+        y1=190-(work[x-1]*4/10);
+        y2=190-(work[x]*4/10);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+       myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+      
+    }
+//********************************************************************************
+ //****************************влажность
+   strm = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+ stry = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};
+ 
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+ // name= stry[years1-2014];
+  name= stry[ye-2014];                                                         
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+
+  myFile.open("poliv.txt", O_READ);
+  w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     
+     w=10*(myFile.read()-48);//десятки даты
+ 
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+dat16=0;
+while (j<165) {
+   
+        if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+      s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск
+    
+  work[w-1]=10*(myFile.read()-48);//десятки t
+ // myGLCD.printNumI( work[w-1], 312-24, 250);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+// myGLCD.printNumI( work[w-1], 312+48, 250);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+      } 
+      
+       if (dat16==0)
+           {
+              if (w>1){ work[w-1]=work[w-2];}
+            } 
+
+ }     
+   
+     myFile.close();  
+  
+   
+  for ( byte x =1 ; x < dm; x = x+1) //******************************************влажность ул  постр  графика
+    { 
+      y1=360-(work[x-1]*15/100);
+      y2=360-(work[x]*15/100);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+      myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+    }
+  delay (100);  
+sd.chdir("/");  
+ //****************************************************************************  
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==45) )
+{
+
+ info(); 
+ }
+ 
+
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+           myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+      myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("x=    " , 650, 32);
+   //   myGLCD.printNumI(x , 700, 32);  
+   //   myGLCD.setFont( Ubuntubold);
+    //  myGLCD.print("y=    " ,650 , 72);
+    //  myGLCD.printNumI(y , 700, 72); 
+      
+    
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower1();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+           menu();
+        }
+       
+      } 
+      
+         if ((y>=400) && (y<=430))  //
+       {
+         if ((x>=280) && (x<=300))//<M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               myGLCD.print("<" ,312-32, 395); 
+                 //myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m-1;
+                   if (m==0)
+                       m=12;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                   myGLCD.setBackColor(0,38,92);
+                                if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print("<" ,312-32, 395);    
+                                
+       }
+       
+          if ((x>=370) && (x<=390))//>M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               //myGLCD.print("<" ,312-32, 395); 
+                 myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m+1;
+                   if (m==13)
+                       m=1;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                           myGLCD.setBackColor(0,38,92);
+                          if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print(">" ,312+63, 395); 
+          }
+          
+          
+          
+          
+          
+          if ((x>=435) && (x<=500))//RS
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("RS" ,440, 395);
+             //GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+                delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+                     graflawer();
+                grafflm();                                
+             }
+                else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("RS" ,440, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+             
+           }
+           
+           
+            if ((x>=525) && (x<=590))//OK
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("OK" ,530, 395);
+               delay(300);
+               colorgraf++;
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             goto graff;
+             }
+                  //*******GGGGGGGGGGGGGGGGGGGGGGGGG                              
+
+             
+                  else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("OK" ,530, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             
+          }
+          
+       }
+       
+         if ((y>=440) && (y<=470))  //
+       {
+          if ((x>=280) && (x<=300))//<Y
+            {daty=1;
+              ye=ye-1;
+             if(ye<2015)
+               ye=2015;
+                myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+           }
+          
+          
+   
+           if ((x>=370) && (x<=390))//>Y
+            {daty=1;
+              ye=ye+1;
+              myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+          }
+          
+           if ((x>=435) && (x<=590))//QUIT
+          {myGLCD.setBackColor(0,38,92);
+           myGLCD.setColor(59, 251, 104);//цвет
+            myGLCD.print("QUIT" ,460, 435);
+            delay(500);
+            flower();
+          }
+         
+       }
+      
+    }//touch
+
+
+}  
+  
+}

_719/Fl2.ino

@@ -0,0 +1,681 @@
+void flower2()
+
+{
+    byte bait;
+byte bait1;
+
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl2.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl2 ,80, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl2 ,59, 385); 
+ 
+//   myGLCD.setFont(Ubuntubold);
+// myGLCD.setColor(VGA_BLUE);
+//myGLCD.printNumI(osv ,440, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl2 ,65, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+// myGLCD.setColor(0,38,92);
+//  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+ //     myGLCD.setColor(255, 255, 255);//цвет обводки
+ // myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+//  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+
+graflawer();
+grafflm2();
+
+//******************************************************************************************************************************
+
+
+
+}
+
+
+
+
+//***************************************************************
+void grafflm2()
+{
+  boolean datm=1;
+  boolean daty=1;
+int m=t.mon;//месяц 
+int ye=t.year;  //год
+// knopki******************************
+byte dat16=0;//16:00 date yes or no
+
+  myGLCD.setFont( Ubuntubold); 
+        myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 
+        myGLCD.print("M" ,235, 395);//выделение месяца цветом 440 203
+      
+      // myGLCD.setBackColor(8,101,192);
+       myGLCD.setBackColor(0,38,92);
+        myGLCD.setColor(255, 255, 0);//цвет 440 243
+       myGLCD.print("Y" ,235, 435);
+       
+        myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 391, 400, 434-5);//рисуем синий пр-к  M
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 391, 400, 434-5);//прямоугольник с  обводкой 
+ 
+  myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(275, 431, 400, 474-5);//рисуем синий пр-к  Y
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(275, 431, 400, 474-5);//прямоугольник с  обводкой   
+  myGLCD.setBackColor(0,38,92);
+  
+  if (mon1<10)
+    {myGLCD.print("0" ,312, 395);
+    myGLCD.printNumI(m, 312+24, 395);
+    }
+  else
+    myGLCD.printNumI(m, 312, 395); 
+
+  myGLCD.printNumI(ye, 292, 435); 
+  
+   myGLCD.setColor(31,70,126);
+  myGLCD.print("<" ,312-32, 395); 
+ myGLCD.print(">" ,312+63, 395);
+  
+   myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(430, 391, 500, 434-5);//рисуем синий пр-к  RS
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+      myGLCD.drawRoundRect(430, 391, 500, 434-5);//прямоугольник с  обводкой
+      
+  myGLCD.setColor(0,38,92);     
+  myGLCD.fillRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(520, 391, 590, 434-5);//прямоугольник с  обводкой OK
+  
+    myGLCD.setColor(0,38,92);     
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+  myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(430, 431, 590, 474-5);//прямоугольник с  обводкой OK
+
+        myGLCD.setColor(255, 255, 255);//цвет
+  
+  
+     myGLCD.setBackColor(0,38,92);
+    myGLCD.print("RS" ,440, 395);
+     myGLCD.print("OK" ,530, 395);
+     myGLCD.setColor(255, 97, 237);//цвет
+       myGLCD.print("QUIT" ,460, 435);
+    myGLCD.setColor(255, 255, 255);//цвет  
+    
+    
+//******************************************************************    
+graff2:
+
+ byte dm=31;// макс день месяца  
+  if (m==2)
+     dm=28;
+    
+  if ((m==4)||(m==6)||(m==9)||(m==11))
+     dm=30;
+  
+ if(ye==t.year)//проверка на наличае данных
+   {if(m==t.mon)
+    { dm=t.date-1;
+    }
+   }
+//*************************GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG*******************************************************  
+word work[31]={100,250,250,244,245,246,240,248,249,245,250,249,250,250,250,244,245,246,250,248,250,250,250,249,250,250,250,250,250,250,249}; 
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+  char* stry[] = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};  
+
+  char* name;
+  
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+  name= stry[ye-2014];
+                                                          
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+  //*************************************************************************
+   myFile.open("poliv2.txt", O_READ);
+  char s;
+char token[] = "date:";  
+char token1[] = "16:00";  
+int n1=0;
+ int p=0; 
+int j=0; 
+int w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     w=10*(myFile.read()-48);//десятки даты
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+       for (j=0; j<8 ;j++)
+    { s=myFile.read();//пропуск 9 символов
+    //delay(10);
+    }
+  work[w-1]=10*(myFile.read()-48);//десятки t
+//  myGLCD.printNumI( work[w-1], 312-24, 10);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+  // myGLCD.printNumI(  work[w-1], 312+48, 10);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+ }//while 
+if (dat16==0)
+{
+ if (w>1){ work[w-1]=work[w-2];}
+}
+
+
+
+ }     
+    myFile.close();  
+  
+   delay (100);
+   
+   myGLCD.setColor(255, 0, 0);
+int y1;
+int y2;
+  //****************Рисуем графики   T*************************** 
+
+ // цвет графиа  
+    if(colorgraf>3)
+   colorgraf=0;
+    if(colorgraf==0)//выбор цвета графика
+     myGLCD.setColor(VGA_WHITE);
+     if(colorgraf==1)
+    myGLCD.setColor(35,173,255);
+      if(colorgraf==2)
+    myGLCD.setColor(255, 255, 0);
+     if(colorgraf==3)
+    myGLCD.setColor(10,255,60);
+   for ( byte x =1 ; x < dm; x = x+1) //****************темп дома постр  графика
+    { 
+        y1=190-(work[x-1]*4/10);
+        y2=190-(work[x]*4/10);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+       myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+      
+    }
+//********************************************************************************
+ //****************************влажность
+   strm = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+ stry = {"2014","2015","2016","2017","2018","2019","2020","2021","2022","2023","2024","2025","2026","2027","2028","2029","2030","2031","2032","2033","2034","2035"};
+ 
+     sd.chdir("/");
+  delay (100);
+ sd.chdir("flower");//23:00 T=+27,8C Hu=33,2%
+  delay (100);
+ // name= stry[years1-2014];
+  name= stry[ye-2014];                                                         
+      if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                       
+  delay (100);
+sd.chdir(name);// заходим в папку год
+delay (100);
+
+name= strm[m-1];
+ if (!sd.chdir(name))//проверка наличая папки на флешке
+  {sd.chdir("/");
+  delay (100);
+  return;
+  }
+                                                           
+    delay (100);
+sd.chdir(name);// заходим в папку месяц
+delay (100);
+
+
+
+   
+
+  myFile.open("poliv2.txt", O_READ);
+  w=0;
+ for (int d=0; d<dm ;d++){
+  p=0;
+j=0;
+n1=0;
+
+   while (j<165) {
+   
+     if (p==0){s =  myFile.read();}
+        if (s == token[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+            else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+     //s=myFile.read();//пробел
+     
+     w=10*(myFile.read()-48);//десятки даты
+ 
+   
+     w=w+(myFile.read()-48);//единицы даты
+
+     
+    j=167;
+     }
+     
+      } 
+ p=0;
+j=0;
+n1=0;
+dat16=0;
+while (j<165) {
+   
+        if (p==0){s =  myFile.read();}
+        if (s == token1[n1])
+         {s =  myFile.read();
+          n1++;
+          p=1;
+         }
+         else
+         {p=0;
+         n1=0;
+         }
+     j++;
+     if (n1==5){
+       dat16=1;
+      s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск 
+     s=myFile.read();//пропуск
+    
+  work[w-1]=10*(myFile.read()-48);//десятки t
+ // myGLCD.printNumI( work[w-1], 312-24, 250);
+     work[w-1]=work[w-1]+(myFile.read()-48);//единицы t
+// myGLCD.printNumI( work[w-1], 312+48, 250);
+     work[w-1]=work[w-1]*10;
+    j=167;
+     }
+     
+      } 
+      
+       if (dat16==0)
+           {
+              if (w>1){ work[w-1]=work[w-2];}
+            } 
+
+ }     
+   
+     myFile.close();  
+  
+   
+  for ( byte x =1 ; x < dm; x = x+1) //******************************************влажность ул  постр  графика
+    { 
+      y1=360-(work[x-1]*15/100);
+      y2=360-(work[x]*15/100);
+      myGLCD.drawLine(275+x*11, y1, 275+11*(x+1), y2); 
+      myGLCD.drawLine(275+x*11, y1-1, 275+11*(x+1), y2-1); 
+    }
+  delay (100);  
+sd.chdir("/");  
+ //****************************************************************************  
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==45) )
+{
+
+ info(); 
+ }
+ 
+
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+           myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+      myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("x=    " , 650, 32);
+   //   myGLCD.printNumI(x , 700, 32);  
+   //   myGLCD.setFont( Ubuntubold);
+    //  myGLCD.print("y=    " ,650 , 72);
+    //  myGLCD.printNumI(y , 700, 72); 
+      
+    
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower2();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+           menu();
+        }
+       
+      } 
+      
+         if ((y>=400) && (y<=430))  //
+       {
+         if ((x>=280) && (x<=300))//<M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               myGLCD.print("<" ,312-32, 395); 
+                 //myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m-1;
+                   if (m==0)
+                       m=12;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                   myGLCD.setBackColor(0,38,92);
+                                if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print("<" ,312-32, 395);    
+                                
+       }
+       
+          if ((x>=370) && (x<=390))//>M
+          {datm=1;
+            myGLCD.setBackColor(0,38,92);
+             myGLCD.setColor(218,231,250);// myGLCD.setColor(31,70,126);
+             
+               //myGLCD.print("<" ,312-32, 395); 
+                 myGLCD.print(">" ,312+63, 395);
+                 
+                 myGLCD.setColor(255,255,255);
+                  m=m+1;
+                   if (m==13)
+                       m=1;
+                             if(ye==t.year)
+                              {if(m>t.mon)
+                               {myGLCD.setColor(255,0,0);
+                                datm=0;
+                                 }
+                                  }
+                              if(ye<2016)
+                             {if(m<9)
+                              {myGLCD.setColor(255,0,0);
+                               datm=0;
+                                }
+                                }
+                           myGLCD.setBackColor(0,38,92);
+                          if (m<10)
+                               {myGLCD.print("0" ,312, 395);
+                                 myGLCD.printNumI(m, 312+24, 395);
+                                 }
+                                     else
+                                  myGLCD.printNumI(m, 312, 395); 
+                               delay (300); 
+                     myGLCD.setColor(31,70,126);
+                   myGLCD.print(">" ,312+63, 395); 
+          }
+          
+          
+          
+          
+          
+          if ((x>=435) && (x<=500))//RS
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("RS" ,440, 395);
+             //GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
+                delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+                     graflawer();
+                grafflm2();                                
+             }
+                else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("RS" ,440, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                      myGLCD.print("RS" ,440, 395);
+             
+           }
+           
+           
+            if ((x>=525) && (x<=590))//OK
+          {myGLCD.setBackColor(0,38,92);
+             if(daty+datm==2) 
+             {myGLCD.setColor(0,255,0);
+              myGLCD.print("OK" ,530, 395);
+               delay(300);
+               colorgraf++;
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             goto graff2;
+             }
+                  //*******GGGGGGGGGGGGGGGGGGGGGGGGG                              
+
+             
+                  else 
+             {myGLCD.setColor(255,0,0);
+                 myGLCD.print("OK" ,530, 395);
+                    }
+                    delay(300);
+                   myGLCD.setFont( Ubuntubold);
+                  myGLCD.setBackColor(0,38,92);
+                   myGLCD.setColor(255,255,255);
+                  myGLCD.print("OK" ,530, 395);
+             
+          }
+          
+       }
+       
+         if ((y>=440) && (y<=470))  //
+       {
+          if ((x>=280) && (x<=300))//<Y
+            {daty=1;
+              ye=ye-1;
+             if(ye<2015)
+               ye=2015;
+                myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+           }
+          
+          
+   
+           if ((x>=370) && (x<=390))//>Y
+            {daty=1;
+              ye=ye+1;
+              myGLCD.setBackColor(0,38,92);
+                myGLCD.setColor(255,255,255);
+                if((ye<2015) || (ye>t.year))
+                    { myGLCD.setColor(255,0,0);
+                       daty=0;
+                     }
+                   myGLCD.printNumI(ye, 292, 435); 
+               delay(300);
+          }
+          
+           if ((x>=435) && (x<=590))//QUIT
+          {myGLCD.setBackColor(0,38,92);
+           myGLCD.setColor(59, 251, 104);//цвет
+            myGLCD.print("QUIT" ,460, 435);
+            delay(500);
+            flower();
+          }
+         
+       }
+      
+    }//touch
+
+
+}  
+  
+}

_719/Fl3.ino

@@ -0,0 +1,151 @@
+void flower3()
+
+{
+    byte bait;
+byte bait1;
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl3.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl3 ,80, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl3 ,59, 385); 
+ 
+//   myGLCD.setFont(Ubuntubold);
+// myGLCD.setColor(VGA_BLUE);
+//myGLCD.printNumI(osv ,440, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl3 ,65, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+  kalend();
+  clc();
+
+
+ 
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==42) )
+{
+
+ info(); 
+ }
+ 
+ if ((sec==55) || (sec==25) )
+{
+
+ info();  
+
+ } 
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+           myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+      myGLCD.setFont( Ubuntubold);
+      myGLCD.print("x=    " , 650, 32);
+      myGLCD.printNumI(x , 700, 32);  
+      myGLCD.setFont( Ubuntubold);
+      myGLCD.print("y=    " ,650 , 72);
+      myGLCD.printNumI(y , 700, 72); 
+      
+    
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower3();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+           flower();
+        }
+       
+      } 
+    }//touch
+
+
+}
+
+
+}

_719/Flower_.ino

@@ -0,0 +1,186 @@
+void flower()
+{
+    byte bait;
+byte bait1;
+
+      myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+ delay (100);
+     sd.chdir("weat");//установка раб директории 
+     delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("fl.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 307200; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>639){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 640, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+//**************************************************
+   myGLCD.setBackColor(VGA_TRANSPARENT);
+  myGLCD.setColor(VGA_RED); 
+    myGLCD.setFont(Ubuntubold);
+    myGLCD.print("+" ,60, 56);
+     myGLCD.print("+" ,260, 56);
+      myGLCD.print("+" ,522, 56);
+    
+    myGLCD.setFont(SevenSegNumFont);  
+ myGLCD.printNumI(tfl ,80, 46);
+  myGLCD.printNumI(tfl2 ,280, 46);
+   myGLCD.printNumI(tfl3 ,542, 46);
+ 
+ 
+  myGLCD.setColor(VGA_AQUA); 
+  myGLCD.setFont(Ubuntubold);
+    myGLCD.print("%" ,122, 410);
+      myGLCD.print("%" ,318, 410);
+        myGLCD.print("%" ,565, 410);
+    
+   myGLCD.setFont(SevenSegNumFont);
+ myGLCD.printNumI(vfl ,59, 385);
+ myGLCD.printNumI(vfl2 ,255, 385); 
+ myGLCD.printNumI(vfl3 ,500, 385);  
+ 
+   myGLCD.setFont(Ubuntubold);
+ myGLCD.setColor(VGA_BLUE);
+myGLCD.printNumI(osv ,443, 43); 
+ 
+ myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_BLUE);
+  myGLCD.printNumI(dfl ,65, 455); 
+   myGLCD.printNumI(dfl2 ,261, 455); 
+    myGLCD.printNumI(dfl3 ,506, 455); 
+ myGLCD.print(":00",77+16, 455); 
+ myGLCD.print(":00",273+16, 455); 
+ myGLCD.print(":00",518+16, 455); 
+ 
+ //********************************************************
+  sd.chdir("/");//установка раб директории 
+     delay (50);
+//**************************************
+if (rawp==1)
+{delay (1000);
+rawp=0;
+return;
+}
+
+
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+  info();
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+
+ // kalend();
+ clc();
+
+
+ 
+    while(1)
+{
+ sec=t.sec;
+ 
+ if ((sec==0)||(sec==20)||(sec==40))
+{
+delay(800);
+clc();
+}
+
+if ((sec==11) || (sec==45) )
+{
+
+ info(); 
+ }
+ 
+
+ 
+  //*********************************TOUCH********************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+  //         myGLCD.setColor(VGA_BLUE);
+  //    myGLCD.setBackColor(255,255,255);
+ //     myGLCD.setFont( Ubuntubold);
+ //     myGLCD.print("x=    " , 650, 32);
+ //     myGLCD.printNumI(x , 700, 32);  
+ //     myGLCD.setFont( Ubuntubold);
+ //     myGLCD.print("y=    " ,650 , 72);
+ //     myGLCD.printNumI(y , 700, 72); 
+      
+        if ((y>=130) && (y<=450))  // Upper row
+      { if ((x>=40) && (x<=200))
+         {  flower1();
+         }
+         
+         if ((x>=230) && (x<=400))
+         {  flower2();
+         }
+         
+         if ((x>=480) && (x<=620))
+         {  flower3();
+         }
+    }
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            flower();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+          menu();
+        }
+       
+      } 
+    }//touch
+
+
+}
+
+
+}
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  

_719/Serialread.ino

@@ -0,0 +1,160 @@
+void Serialread()
+{
+
+  char c ;
+int xt, yt;
+  int x1, y1;
+  bool ter = 0;
+  x1 = 30;
+  y1 = 40;
+
+  myGLCD.fillScr(0, 0, 0);
+  //  myGLCD.fillScr(BIRD_BG);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(VGA_BLACK);
+  myGLCD.setFont(BigFont);
+  myGLCD.print("SERIAL 9600", CENTER, 10);
+  myGLCD.setColor(0, 0, 255);
+
+  myGLCD.fillRect(20, 30, 390, 450); //1 ter
+  myGLCD.fillRect(410, 30, 780, 450); //2 ter
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.drawRect(25, 35, 385, 445);//1ter obv
+  myGLCD.drawRect(415, 35, 775, 445);//2 ter obv
+  myGLCD.setBackColor(0, 0, 255);
+  digitalWrite(18, LOW);
+  delay(3000);
+  digitalWrite(18, HIGH);//reset WIFI
+  myGLCD.print("    reset     " , 280, 457);
+  delay(5000);
+  myGLCD.print("    redy    " , 280, 457);
+  while (1)
+  {
+    //***********  T  O  U  C  H  ********************
+    if (myTouch.dataAvailable())
+    { //myGLCD.fillScr(0, 0, 0);
+      myTouch.read();
+      xt = myTouch.getX();
+      yt = myTouch.getY();
+      // Serial.print("xt=");
+      // Serial.println(xt);
+      // Serial.print("yt=");
+      //  Serial.println(yt);
+      myGLCD.drawPixel(xt, yt);
+      if ((xt >= 600) && (xt <= 800)) // Upper row
+      { if ((yt >= 0) && (yt <= 30)) menu(); // Exit
+        if ((yt >= 50) && (yt <= 150))
+        { Serial2.print("7"); // Exit
+          myGLCD.print("   touch 7    " , 280, 457);
+          delay(1000);
+        }
+        if ((yt >= 200) && (yt < 300))
+        { Serial2.print("1");; // Exit
+          myGLCD.print("   touch 1    " , 280, 457);
+          delay(1000);
+        }
+        if ((yt >= 350) && (yt < 400))
+        { Serial2.print("2");; // Exit
+          myGLCD.print("   touch 2    " , 280, 457);
+          delay(1000);
+        }
+      }
+      if ((xt >= 0) && (xt <= 100)) // Upper row
+      { //if ((yt >= 0) && (yt <= 30)) menu(); // Exit
+        if ((yt >= 50) && (yt <= 150))
+        { //Serial2.print("7");; // Exit
+          digitalWrite(18, LOW);
+          delay(3000);
+          digitalWrite(18, HIGH);//reset WIFI
+          myGLCD.print("    reset     " , 280, 457);
+          //delay(5000);
+        }
+        if ((yt >= 200) && (yt < 300))
+        {
+          myGLCD.print("   touch     " , 280, 457);
+        }
+        if ((yt >= 350) && (yt < 400))
+        {
+          myGLCD.print("   touch     " , 280, 457);
+        }
+      }
+
+
+
+    }
+    //delay(500);
+    if (Serial2.available()) {
+
+      c = Serial2.read();
+
+      if (c == '\r')
+      {
+
+      }
+      else if (c == '\n')
+      { y1 = y1 + 20;
+
+        if (y1 > 430)
+        { y1 = 40;
+          if (ter == 0)
+          { myGLCD.setColor(0, 0, 255);
+            myGLCD.fillRect(410, 30, 780, 450); //2 ter
+            myGLCD.setColor(VGA_WHITE);
+            myGLCD.drawRect(415, 35, 775, 445);
+            // myGLCD.print(String(c) ,420, y1);
+          }
+          else
+          { myGLCD.setColor(0, 0, 255);
+            myGLCD.fillRect(20, 30, 390, 450); //1 ter
+            myGLCD.setColor(VGA_WHITE);
+            myGLCD.drawRect(25, 35, 385, 445);//1ter obv
+            // myGLCD.print(String(c) ,30, 40);
+          }
+          ter = !ter;
+        }
+        if (ter == 0)x1 = 30;
+        if (ter == 1)x1 = 420;
+      }
+      else
+      { myGLCD.print(String(c) , x1, y1);
+        x1 = x1 + 15;
+        if (ter == 0)
+        { if (x1 > 365)
+          { x1 = 30;
+            y1 = y1 + 20;
+          }
+          if (y1 > 430)
+          { y1 = 40;
+            myGLCD.setColor(0, 0, 255);
+            myGLCD.fillRect(410, 30, 780, 450); //2 ter
+            myGLCD.setColor(VGA_WHITE);
+            myGLCD.drawRect(415, 35, 775, 445);
+            ter = 1;
+            //myGLCD.print(String(c) ,420, y1);
+            x1 = 420;
+          }
+
+
+        }
+        else
+        { if (x1 > 755)
+          { x1 = 420;
+            y1 = y1 + 20;
+          }
+          if (y1 > 430)
+          { y1 = 40;
+            myGLCD.setColor(0, 0, 255);
+            myGLCD.fillRect(20, 30, 390, 450); //1 ter
+            myGLCD.setColor(VGA_WHITE);
+            myGLCD.drawRect(25, 35, 385, 445);//1ter obv
+            ter = 0;
+            // myGLCD.print(String(c) ,30, y1);
+            x1 = 30;
+          }
+
+
+        }
+      }
+    }
+  }
+}

_719/X.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: X.jpg
+// Time generated: 12.04.2014 22:14:47
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short X[0x384] ={
+0xD0C4, 0xD8E5, 0xF0C4, 0xE984, 0xF166, 0xF1C8, 0xF1A7, 0xF1C9, 0xF1C8, 0xF1C7, 0xE9C7, 0xF1E8, 0xE9A8, 0xF1A8, 0xF1C8, 0xE9E8,   // 0x0010 (16)
+0xF1C8, 0xF1C8, 0xE9C6, 0xF1C8, 0xF1C8, 0xF1C8, 0xE9A8, 0xEA07, 0xF1E8, 0xEA27, 0xF229, 0xEA8A, 0xEAAB, 0xF28B, 0xC8A2, 0xD0A4,   // 0x0020 (32)
+0xE0E5, 0xE8E4, 0xF106, 0xF187, 0xE1C7, 0xE1C7, 0xE988, 0xE9A8, 0xF1C6, 0xE9A7, 0xE9C8, 0xF1A7, 0xF167, 0xE9C7, 0xE9A7, 0xE9C6,   // 0x0030 (48)
+0xF1A8, 0xE1A6, 0xE9C7, 0xE187, 0xF1E8, 0xF187, 0xE9A9, 0xF208, 0xF229, 0xF26B, 0xF2AC, 0xF2AC, 0xB8C3, 0xB8C3, 0xD0A4, 0xE0E5,   // 0x0040 (64)
+0xF125, 0xE146, 0xF947, 0xF186, 0xF167, 0xE966, 0xF167, 0xE986, 0xF166, 0xE967, 0xF186, 0xF186, 0xE9A6, 0xE966, 0xF167, 0xE1A6,   // 0x0050 (80)
+0xE966, 0xF167, 0xE184, 0xF946, 0xF187, 0xE1E6, 0xF209, 0xE269, 0xEAAB, 0xF2CC, 0xA0C2, 0xB883, 0xC8C5, 0xD8A3, 0xE903, 0xE104,   // 0x0060 (96)
+0xF146, 0xE924, 0xF905, 0xF147, 0xE126, 0xE946, 0xE945, 0xF126, 0xE946, 0xE925, 0xE925, 0xE927, 0xF146, 0xF106, 0xF166, 0xE945,   // 0x0070 (112)
+0xF126, 0xE946, 0xE947, 0xE9A6, 0xEA08, 0xF229, 0xFA8B, 0xEAEB, 0x98A3, 0xB0A3, 0xB8A4, 0xD0E5, 0xD8C5, 0xFFFC, 0xFFBF, 0xFFBF,   // 0x0080 (128)
+0xD945, 0xE8E5, 0xE925, 0xE925, 0xE925, 0xE925, 0xE8E5, 0xF105, 0xE126, 0xF104, 0xF105, 0xE904, 0xE8E5, 0xD925, 0xFFBE, 0xFFFC,   // 0x0090 (144)
+0xFFBE, 0xE187, 0xF1A7, 0xF22A, 0xFA8B, 0xF2AA, 0x9883, 0xB883, 0xC0A3, 0xC8C3, 0xE0C4, 0xE0C6, 0xFFBC, 0xFFDF, 0xFFBC, 0xE8E5,   // 0x00A0 (160)
+0xF8C4, 0xE8E4, 0xE0C5, 0xE8E5, 0xE904, 0xE0E4, 0xE905, 0xE8E4, 0xE903, 0xE905, 0xE125, 0xFF9E, 0xFFBE, 0xF79F, 0xF5F7, 0xE946,   // 0x00B0 (176)
+0xF1C7, 0xEA29, 0xEA8A, 0xF2EB, 0x9883, 0xA882, 0xB8A2, 0xC8A3, 0xE8A4, 0xE8E4, 0xE8C7, 0xF7BE, 0xFFDF, 0xF7FC, 0xE8E5, 0xE8A5,   // 0x00C0 (192)
+0xF0E6, 0xE0E4, 0xE104, 0xF0E4, 0xF0E4, 0xE8C4, 0xE8C5, 0xF0C4, 0xFF9E, 0xF7FE, 0xFFBD, 0xFFDF, 0xF105, 0xE925, 0xE9A7, 0xEA28,   // 0x00D0 (208)
+0xEA8A, 0xEACC, 0x98A3, 0xA882, 0xB8E3, 0xC8C4, 0xD8A4, 0xE8A3, 0xE8E5, 0xFE79, 0xF7BF, 0xFFFF, 0xFFBD, 0xD905, 0xF883, 0xE8E4,   // 0x00E0 (224)
+0xE8C4, 0xF0C4, 0xE8E3, 0xE0E4, 0xE0E6, 0xFFBE, 0xFFDF, 0xFFBF, 0xFFFE, 0xF0C5, 0xE8C5, 0xE966, 0xF988, 0xF209, 0xF26A, 0xF2AC,   // 0x00F0 (240)
+0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xFEDB, 0xFF9E, 0xFFDE, 0xF7DE, 0xF0A6, 0xE8E3, 0xF0C3, 0xE8E6,   // 0x0100 (256)
+0xF0E3, 0xE8C6, 0xF73D, 0xF7FE, 0xFFDF, 0xFF9F, 0xE0E4, 0xE8E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3,   // 0x0110 (272)
+0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E5, 0xF77B, 0xFF9F, 0xFFBF, 0xFF9E, 0xF0C4, 0xF0E3, 0xE0E3, 0xE8C4, 0xFEDC,   // 0x0120 (288)
+0xF7FE, 0xFFBE, 0xFFBD, 0xE8E3, 0xF0A6, 0xE8E4, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3,   // 0x0130 (304)
+0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8A3, 0xE904, 0xFFBE, 0xF7DF, 0xFFBE, 0xFFFD, 0xE8A4, 0xE8E6, 0xFFDD, 0xFFBD, 0xFFBF, 0xFFBE,   // 0x0140 (320)
+0xE905, 0xE0C3, 0xE8E4, 0xE0E4, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4,   // 0x0150 (336)
+0xE8E4, 0xE8E4, 0xE905, 0xE8A4, 0xE103, 0xFFDE, 0xFFDF, 0xFFBD, 0xFFBF, 0xFF7C, 0xF7DF, 0xFFBF, 0xFFBF, 0xF7DD, 0xF8E4, 0xE8E5,   // 0x0160 (352)
+0xF0C5, 0xF0E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4,   // 0x0170 (368)
+0xF0A4, 0xE8E4, 0xE8E4, 0xF0C5, 0xFFBE, 0xF7BF, 0xFFDF, 0xF7DF, 0xFFBF, 0xFFFE, 0xFFBE, 0xF0C4, 0xE8C4, 0xE0C5, 0xF0E4, 0xE0E4,   // 0x0180 (384)
+0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E4, 0xF0C5,   // 0x0190 (400)
+0xE8E5, 0xE8C3, 0xF0C6, 0xF7FE, 0xF79E, 0xFFDE, 0xFF9F, 0xF7FE, 0xE8C4, 0xE8E3, 0xF8C4, 0xF0E4, 0xE8C5, 0xE8E4, 0xE8E5, 0xE945,   // 0x01A0 (416)
+0xF1A7, 0xEA09, 0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8C4, 0xE8E4, 0xF0A4, 0xF0C5,   // 0x01B0 (432)
+0xE0E4, 0xFFDE, 0xFF9F, 0xFFBE, 0xFF9F, 0xF7FE, 0xF0C3, 0xE0E5, 0xE8E3, 0xE904, 0xE8C5, 0xF0E3, 0xE8E5, 0xE945, 0xF1A7, 0xEA09,   // 0x01C0 (448)
+0xF26A, 0xF2CB, 0x9883, 0xA8A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0C4, 0xE8E4, 0xE8E4, 0xE8E4, 0xE904, 0xE8E3, 0xE0E5, 0xFFDE, 0xFF9E,   // 0x01D0 (464)
+0xFFBF, 0xFFBF, 0xFFDE, 0xFFDE, 0xFFDE, 0xE8C5, 0xF0C4, 0xF0A5, 0xE904, 0xE8C5, 0xE8E5, 0xE945, 0xF1A7, 0xEA09, 0xF26A, 0xF2CB,   // 0x01E0 (480)
+0x98A2, 0xA882, 0xB8A3, 0xC8E2, 0xD8A3, 0xE0C5, 0xE0E5, 0xE8E4, 0xF0C5, 0xE8A4, 0xE904, 0xFFBC, 0xFFFF, 0xFF9E, 0xFF9F, 0xFFDE,   // 0x01F0 (496)
+0xFFDF, 0xFF9E, 0xFFDF, 0xFFDD, 0xF0E4, 0xE8E4, 0xE0E4, 0xF0E4, 0xE905, 0xE925, 0xF168, 0xEA29, 0xEA8B, 0xF2AC, 0x9882, 0xA883,   // 0x0200 (512)
+0xB0E2, 0xC8C4, 0xE0C4, 0xE8C4, 0xE8C4, 0xF0C3, 0xE8E4, 0xF105, 0xF7DF, 0xFFBF, 0xF77D, 0xFFDF, 0xE125, 0xE8A5, 0xF7DD, 0xFFDE,   // 0x0210 (528)
+0xFFBF, 0xFF9D, 0xF0C4, 0xD8E5, 0xF0E4, 0xE8E4, 0xE8E5, 0xF165, 0xF167, 0xF228, 0xF28A, 0xF2AB, 0x90C3, 0xB083, 0xB0A2, 0xC8A4,   // 0x0220 (544)
+0xE0A5, 0xE8C4, 0xE8E4, 0xE8E3, 0xE8E5, 0xFFBE, 0xFF9E, 0xFFBF, 0xFFDE, 0xE8E4, 0xE8E4, 0xE903, 0xF8A4, 0xFFBE, 0xFFFF, 0xFFBE,   // 0x0230 (560)
+0xFFBE, 0xF0E5, 0xF085, 0xE902, 0xE8E5, 0xE944, 0xF1A7, 0xEA29, 0xEA8A, 0xF2CB, 0xA063, 0xA8A2, 0xB8A4, 0xC8A4, 0xE0C4, 0xE0E4,   // 0x0240 (576)
+0xF0A4, 0xE106, 0xFFBD, 0xFFDE, 0xFFDE, 0xF7FD, 0xF0C4, 0xF0A4, 0xE0E3, 0xF0C5, 0xE8E4, 0xE906, 0xF79F, 0xFFDF, 0xFFDE, 0xFF7C,   // 0x0250 (592)
+0xE0C4, 0xE904, 0xF106, 0xE965, 0xE988, 0xF1E9, 0xF24A, 0xEACC, 0xA0A3, 0xA882, 0xB083, 0xC8E4, 0xD8C2, 0xE0C3, 0xE8C6, 0xFFBD,   // 0x0260 (608)
+0xFFBF, 0xFF9E, 0xF7BE, 0xE904, 0xE8E4, 0xE8E5, 0xF0C4, 0xE0E4, 0xE8C4, 0xE8E3, 0xFF1C, 0xFFBE, 0xFF9F, 0xF7BD, 0xFFDE, 0xF0E3,   // 0x0270 (624)
+0xE105, 0xF125, 0xE9A8, 0xEA28, 0xEA89, 0xEACC, 0xA062, 0xA0A3, 0xB8C4, 0xC0E3, 0xD8C3, 0xE8E4, 0xFFBC, 0xFFBF, 0xFFBF, 0xFFBF,   // 0x0280 (640)
+0xF0C5, 0xF0C4, 0xE104, 0xF0C4, 0xE8C4, 0xE904, 0xF0C3, 0xE0E4, 0xE0C5, 0xFFDE, 0xFFDF, 0xFF9F, 0xFFBE, 0xE8C5, 0xF104, 0xF164,   // 0x0290 (656)
+0xE987, 0xEA29, 0xF28A, 0xEAAB, 0x98A2, 0xA8A4, 0xB882, 0xC8E4, 0xD8A4, 0xE8C7, 0xFFBE, 0xFFDF, 0xFFDE, 0xE8C4, 0xE8C4, 0xE904,   // 0x02A0 (672)
+0xE103, 0xF0C4, 0xF0C5, 0xE8A3, 0xE8C4, 0xE8E5, 0xE904, 0xE8E5, 0xFFDC, 0xFFBE, 0xFF9F, 0xFFDE, 0xE8E6, 0xE944, 0xE9A7, 0xF20A,   // 0x02B0 (688)
+0xF26B, 0xEAEB, 0x9883, 0xA883, 0xB0E4, 0xC8A3, 0xD8C5, 0xF79C, 0xFFDE, 0xFF9E, 0xE8E3, 0xF0C4, 0xE8E3, 0xF0A4, 0xE0E5, 0xE8E4,   // 0x02C0 (704)
+0xE0E3, 0xE8C5, 0xE8C5, 0xE8E3, 0xF8C3, 0xE8E5, 0xE8A5, 0xFFDE, 0xFF9F, 0xFFDE, 0xFFDE, 0xE946, 0xF186, 0xF1E9, 0xF26B, 0xF2AA,   // 0x02D0 (720)
+0x9882, 0xA0A3, 0xB8A3, 0xC8C3, 0xD8C4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4,   // 0x02E0 (736)
+0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE8C4, 0xE905, 0xE925, 0xE986, 0xF1E8, 0xEA6A, 0xF2AB, 0x9882, 0xA0A3,   // 0x02F0 (752)
+0xB0A3, 0xC0C3, 0xD0C4, 0xD8C4, 0xE0C4, 0xE0C4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4,   // 0x0300 (768)
+0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE0E4, 0xE8C4, 0xE8E5, 0xE946, 0xF1C7, 0xEA69, 0xEA8A, 0x9883, 0xA0A3, 0xA8A3, 0xB8C3,   // 0x0310 (784)
+0xC8C4, 0xD0C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4,   // 0x0320 (800)
+0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xD8C4, 0xE8E4, 0xE905, 0xF146, 0xF1E8, 0xF249, 0x9883, 0x9883, 0xA8A3, 0xB0A3, 0xB8A3, 0xC0C3,   // 0x0330 (816)
+0xC8A4, 0xC8A4, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3, 0xC8C3,   // 0x0340 (832)
+0xC8C3, 0xC8C3, 0xD0A4, 0xD8C4, 0xE0E4, 0xF125, 0xF187, 0xF1E8, 0x9883, 0xA083, 0xA083, 0xB0A3, 0xB8A3, 0xB8C3, 0xC0C4, 0xC0C4,   // 0x0350 (848)
+0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3, 0xC0A3,   // 0x0360 (864)
+0xC8A4, 0xC8C3, 0xD0E3, 0xE0E4, 0xE925, 0xE967, 0x98A3, 0xA0A3, 0xA883, 0xB0A3, 0xB8A3, 0xB8A2, 0xC082, 0xC082, 0xB8A3, 0xB8A3,   // 0x0370 (880)
+0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xB8A3, 0xC0A3, 0xC0C3,   // 0x0380 (896)
+0xC8C3, 0xE0A4, 0xE0E5, 0xE946, };

_719/_719.ino

@@ -0,0 +1,341 @@
+
+// This program requires the UTFT library.
+
+#define imagedatatype  unsigned short
+//#include <UTFT_Buttons.h>
+#include <UTouch.h>
+#include <UTFT.h>
+//#include <UTFT_tinyFAT.h>
+#include <SdFat.h>
+//#include <SdFatUtil.h>
+SdFat sd;
+SdFile myFile;
+//#include <Time.h>
+//#include <rtc_clock.h>
+#include <MP1090S.h>
+#include <Wire.h>
+//RTC_clock rtc_clock(XTAL);
+
+//*********************RTC*************************************************************
+#include <DS3231.h>
+// Init the DS3231 using the hardware interface
+DS3231  rtc(A2, A3);
+
+// Init a Time-data structure
+Time  t;
+
+
+//**************BMP085****************************************************************
+#define BMP085_ADDRESS 0x77        // I2C address of BMP085
+
+const unsigned char OSS = 0;       // Oversampling Setting
+
+//float temperatur;
+float pressure;
+boolean rawp=0;
+// Calibration values of BMP085:
+short ac1;
+short ac2; 
+short ac3; 
+unsigned short ac4;
+unsigned short ac5;
+unsigned short ac6;
+short b1; 
+short b2;
+short mb;
+short mc;
+short md;
+long b5; 
+// temul[24]max t
+// temul[25]min t
+//*****************************************************************************
+word temdom[24]={256,254,260,264,265,266,270,268,259,255,250,249,256,254,260,264,265,266,270,268,259,255,250,249};
+word temul[26]={256,254,260,264,265,266,270,268,259,255,250,249,256,254,260,264,265,266,270,268,259,255,250,249,490,152};// max t=49.0  min 15.2
+word pres[24]={756,754,760,764,765,766,770,768,759,755,750,749,756,754,760,764,765,766,770,768,759,755,750,749};
+word time1[28]={1000,1100,1200,1300,1400,1500,1600,1700,1800,1900,2000,2100,2200,2300,0,100,200,300,400,500,600,700,800,900,16081,12004,20021,6454};//max 16.08.14 12:00    min 2.02.14  6:45
+word hug[24]={756,754,760,764,765,766,770,768,759,755,750,749,756,754,760,764,765,766,770,768,759,755,750,749};
+byte h[24]={25,25,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,25,25};
+byte sun[24]={0,0,0,0,0,0,0,0,20,20,20,20,20,20,20,20,20,20,20,20,20,0,0,0};
+word t1[24]={201,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t2[24]={202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t3[24]={203,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t4[24]={204,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word t5[24]={205,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202,202};
+word bat[5]={300,300,300,300,300};
+byte h1[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h2[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h3[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h4[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+byte h5[24]={10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10};
+//word temul[24]={256,254,260,264,265,266,270,268,259,255,250,249,256,254,260,264,265,266,270,268,259,255,250,249};
+//*********************************************************************************
+
+extern uint8_t SevenSegNumFont[];
+extern uint8_t SmallFont[];
+extern uint8_t BigFont[];
+
+extern uint8_t Ubuntubold[];
+
+
+extern imagedatatype aandelen[];
+extern imagedatatype fotos[];
+extern imagedatatype instellingen[];
+extern imagedatatype radio[];
+extern imagedatatype klok[];
+extern imagedatatype cl[];
+extern imagedatatype pr[];
+extern imagedatatype le[];
+extern imagedatatype xf[];
+extern imagedatatype ad[];
+extern imagedatatype mi[];
+extern imagedatatype jar[];
+extern imagedatatype wer[];
+extern imagedatatype open[];//40
+extern imagedatatype del[];//40
+extern imagedatatype flr[];//40
+extern imagedatatype ints[];//40
+extern imagedatatype clokk[];//40
+extern imagedatatype dom1[];
+byte volume=7;
+byte rad=0;
+long StationFrequency;
+int vetzav;//napr vetra
+int vetczav;//skorost vetra
+int vetdzav;//skorost vetra dr
+int preszav;
+int vet;//napr vetra
+int vetc;//skorost vetra
+int vetd;//skorost vetra dr
+byte q=1;
+ byte hour1;
+byte hourp;//время пропуска данных massiv 623
+byte dd=0;// флаг перехода времени через 00
+  byte min1;
+ byte sec;
+ byte date;
+ byte mon;
+ word year1;
+ byte dow ;
+ byte night;
+int clockCenterX=300;
+int clockCenterY=230;
+int oldsec=0;
+char* str[] = {"MON","TUE","WED","THU","FRI","SAT","SUN"};
+const int chipSelect = 10;
+byte ptoday=0;//погода сегодня 0-солн 1-перемен обл 2-пасмурно 3-дождь 4- снег 5- туман 6-гроза
+byte pzav=0; //pogoda zavtra
+byte tu;
+//**********************************
+byte ntdat;//номер датчика
+byte zndat;//знак температуры 0+
+  int hourd1;//время прихода данных час
+  int mind1;//мин
+   int hourd2=2;//время прихода данных час
+  int mind2=2;//мин
+   int hourd3;//время прихода данных час
+  int mind3;//мин
+   int hourd4=4;//время прихода данных час
+  int mind4=4;//мин
+   int hourd5=5;//время прихода данных час
+  int mind5=5;//мин
+ boolean fh=0;// флаг данных одного часа записываются данные в файл только один раз в час
+ 
+ int hourdu=77;//время прихода данных час
+ int mindu=77;//мин
+ 
+  word h11=100;
+  word h12=100;
+  word h13=100;
+  word h14=100;
+  word h15=100;
+  word t11=202;
+  word t12=202;
+  word t13=202;
+  word t14=202;
+  word t15=202;
+ //********************************************
+ byte tud;
+byte  hu;
+byte   hud;
+ int volt;
+byte  zn;
+byte  znzav;
+byte tuzav;
+ byte tudzav;
+unsigned long currentMillis = millis();
+unsigned long previousMillis = 0; 
+int tab=0;
+boolean graf=0;
+byte colorgraf=0;
+ byte mon1;
+word years1;
+byte days1;
+int w=0;//счетчик строк при чтении из файла
+String bufer="";
+char* name; 
+boolean fa=0;//флаг изменения макс темп
+boolean fi=0;//флаг изменения мин темп
+boolean bt=0;//флаг показа барометра
+//boolean priemt=0;//флаг приема данных
+ long interval;  // interval at which to blink (milliseconds)
+
+//UTFT myGLCD(ITDB50,38,39,40,41);   // Remember to change the model parameter to suit your display module!
+UTFT myGLCD(TFT01_70,38,39,40,41);
+UTouch      myTouch(42,43,44,45,46);//TCLK, TCS, TDIN, TDOUT и IRQ.Папа
+//UTouch      myTouch(59,61,60,15,14);//TCLK, TCS, TDIN, TDOUT и IRQ.Вова
+//UTouch      myTouch(19,16,17,15,14);//TCLK, TCS, TDIN, TDOUT и IRQ.Вова
+//UTFT_Buttons  myButtons(&myGLCD, &myTouch);
+//int x,y;
+//UTFT_tinyFAT myFiles(&myGLCD);
+
+unsigned short pic1[0x320];
+
+
+ int color = 0;
+word colorlist[] = {VGA_WHITE, VGA_BLACK, VGA_RED, VGA_BLUE, VGA_GREEN, VGA_FUCHSIA, VGA_YELLOW, VGA_AQUA};
+int  bsize = 4;
+//unsigned short pic2[0x6400];
+//unsigned short pic3[0x6400];
+byte brightness=0;
+byte br;
+byte constbr=100;
+boolean c=0;
+boolean fcl=0;//флаг закрытия файла
+
+ // int pressed_button;
+  boolean default_colors = true;
+  
+boolean fsec=1;
+//**************************DHT11**********************************
+//#include "DHT.h"
+//#define DHTPIN 3     // what pin we're connected to
+//#define DHTTYPE DHT22   // DHT 22  (AM2302)
+//int humidity=50;
+//DHT dht(DHTPIN, DHTTYPE);
+  int tdc=20;
+ int tdd=0;
+  int hdc=50;
+ int hdd=0;
+//**************************************************************
+//#define SSID "VOVA-47" // введите ваш SSID
+//#define PASS "vovak26102003" // введите ваш пароль
+//#define DST_IP "188.226.224.148" //api.openweathermap.org
+boolean raw1=0;
+byte wifi=0;
+boolean fwifi=1;
+byte wifih=10;// час обновления данных
+byte wifim=15;// минуты
+//****************************************************************
+  int per=1;//номер передачи
+  //****************************************
+  int hour9;
+  int min9;
+  int t9;
+  int h9;
+  int osv9;
+  boolean zn9=0;
+    //****************************************
+int tfl=25;// temp flower
+int vfl=50;// vlaga flower
+int osv=37;// svet flower
+int dfl=12;// time flower
+
+int tfl2=26;// temp flower
+int vfl2=55;// vlaga flower
+int dfl2=13;// time flower
+
+int tfl3=27;// temp flower
+int vfl3=52;// vlaga flower
+int dfl3=14;// time flower
+  
+  //************************************
+  
+void setup()
+{   
+ rtc.begin();
+    Wire.begin();
+      Serial.begin(9600);       // скорость обмена по уарт  
+     
+  Serial3.begin(9600);       // скорость обмена по уарт  
+//  delay(200);
+Serial2.begin(9600);       // скорость обмена по уарт WIFI 
+//Serial2.begin(115200);       // скорость обмена по уарт WIFI 
+ delay(1000);
+  Serial2.setTimeout(5000);
+  bmp085Calibration();
+  delay(1000);
+ pinMode(65, OUTPUT);	
+ digitalWrite(65, LOW); 
+ Serial3.print(1); 
+ 
+ pinMode(18, OUTPUT);// reset WIFI 
+ digitalWrite(18, LOW);
+ delay(100);
+ digitalWrite(18, HIGH);
+ pinMode(53, OUTPUT);// reset nrf 
+ digitalWrite(53, LOW);
+ delay(100);
+ digitalWrite(53, HIGH);
+ // dumpRegisters();
+  //dps.dumpCalData();
+// uart(); 
+  pinMode(12, OUTPUT);
+   br=constbr+brightness;
+  analogWrite(12, 0);
+
+  delay(800);  // catch Due reset problem
+    pinMode(10, OUTPUT);
+  myGLCD.InitLCD();
+  myGLCD.setFont( BigFont);
+  myGLCD.fillScr(VGA_BLUE);
+//sd.begin(chipSelect, SPI_FULL_SPEED );
+sd.begin(chipSelect, SPI_HALF_SPEED );
+// file system
+SdFat sd;
+
+ myTouch.InitTouch();
+  myTouch.setPrecision(PREC_HI);
+ // dht.begin();
+  dtu21();
+ //    rtc_clock.init();
+ //readmasclok();
+ readmasrab(); 
+////  rtc.setTime(12, 39, 0);     // Set the time to 12:00:00 (24hr format)
+//rtc.setDate(29, 11, 2015);   // Set the date to January 1st, 2014
+//rtc.setDOW(THURSDAY); 
+
+     t = rtc.getTime();
+  years1=t.year;
+  days1=t.date;
+  mon1=t.mon;
+//  dow=calcDOW(days1, mon1, years1);
+//  rtc.setDOW(dow);
+dow=t.dow ;
+hour1=t.hour;
+min1=t.min; 
+delay(100);
+ 
+//  myButtons.setTextFont(BigFont);
+ // myButtons.setSymbolFont(Dingbats1_XL);
+//dtu21();
+// esp8266();
+ br=constbr+brightness;
+  analogWrite(12, br);
+}
+
+//myFiles.loadBitmap(0, 0, 320, 240, "33.raw");
+
+void loop()
+{
+ if (t.date==0)
+  {
+    setClock();
+  }  
+ 
+  
+  
+  
+  
+  
+  menu();
+}

_719/aandelen.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: aandelen.jpg
+// Time generated: 24.03.2014 12:01:54
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short aandelen[0x1900] ={
+0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0021, 0x0021, 0x0001, 0x0000, 0x0001, 0x0821, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0010 (16)
+0x0020, 0x0021, 0x0021, 0x0001, 0x0000, 0x0000, 0x0000, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0800,   // 0x0020 (32)
+0x0800, 0x0800, 0x0000, 0x0000, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0030 (48)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0040 (64)
+0x0001, 0x0801, 0x0821, 0x0000, 0x0000, 0x0820, 0x1021, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0820, 0x0800, 0x0000,   // 0x0050 (80)
+0x1000, 0x0800, 0x0820, 0x1061, 0x0841, 0x0000, 0x0000, 0x0001, 0x0882, 0x0842, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0060 (96)
+0x0000, 0x0001, 0x0021, 0x0042, 0x0041, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0070 (112)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0080 (128)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0821, 0x1062,   // 0x0090 (144)
+0x0842, 0x0001, 0x0001, 0x1042, 0x0021, 0x0000, 0x0801, 0x0842, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x00A0 (160)
+0x0800, 0x1040, 0x1020, 0x0000, 0x0000, 0x0042, 0x0883, 0x0063, 0x0001, 0x0001, 0x0001, 0x0001, 0x0021, 0x0841, 0x0021, 0x0000,   // 0x00B0 (176)
+0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00C0 (192)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,   // 0x00D0 (208)
+0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00E0 (224)
+0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x18A3, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0840,   // 0x00F0 (240)
+0x1040, 0x0820, 0x0000, 0x0000, 0x10A2, 0x0022, 0x0001, 0x0021, 0x0042, 0x0022, 0x2126, 0x52CC, 0x6BAF, 0x94D4, 0xBE19, 0xD6FD,   // 0x0100 (256)
+0xE73E, 0xDF5E, 0xDF5F, 0xD73E, 0xD73E, 0xDF3F, 0xDF3F, 0xD71E, 0xD71E, 0xDF1E, 0xDF3E, 0xDF3F, 0xDF3F, 0xDF3E, 0xDF1E, 0xDF1E,   // 0x0110 (272)
+0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF3E, 0xDF3E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E,   // 0x0120 (288)
+0xDF1F, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDF1E, 0xDEFE, 0xDEFE, 0xDEFE, 0xDF1E, 0xDF1E, 0xDF1F, 0xDEFE, 0xDF1D, 0xF7BE,   // 0x0130 (304)
+0xE75F, 0xC65A, 0xA536, 0x94B4, 0x5AED, 0x18E5, 0x0022, 0x10A3, 0x0021, 0x0000, 0x0021, 0x0841, 0x0021, 0x0000, 0x0000, 0x0020,   // 0x0140 (320)
+0x0800, 0x1020, 0x0820, 0x0000, 0x0001, 0x0001, 0x0001, 0x0002, 0x1926, 0x7412, 0xC69C, 0xDF5F, 0xD71D, 0xD6FD, 0xD6DD, 0xCEBC,   // 0x0150 (336)
+0xC6BC, 0xC6BD, 0xC6BD, 0xC6DE, 0xC6FE, 0xC6DE, 0xC6BE, 0xC6BE, 0xC6BD, 0xC6BE, 0xC6DE, 0xC6DE, 0xC6DE, 0xC6BE, 0xC6BE, 0xC6BE,   // 0x0160 (352)
+0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BE, 0xC69E, 0xC69E, 0xC69E, 0xC69E, 0xC69E,   // 0x0170 (368)
+0xC69E, 0xCE9E, 0xC69D, 0xC69D, 0xCEBE, 0xCEBE, 0xCEBE, 0xC69D, 0xC69D, 0xCE9E, 0xCEBE, 0xCEBE, 0xCEBE, 0xCEBE, 0xCE9D, 0xC65C,   // 0x0180 (384)
+0xC67C, 0xCEDE, 0xCEDE, 0xBE5B, 0xC69C, 0xC67B, 0x8453, 0x2147, 0x0022, 0x0001, 0x0001, 0x0001, 0x0041, 0x0021, 0x0000, 0x0000,   // 0x0190 (400)
+0x0800, 0x0820, 0x0820, 0x0000, 0x0001, 0x0002, 0x2167, 0x6BF2, 0xA5D9, 0xC6DD, 0xC6DD, 0xBE7C, 0xC69C, 0xC6BD, 0xCEDD, 0xCEFE,   // 0x01A0 (416)
+0xCEFF, 0xC6FF, 0xBEFF, 0xBEBE, 0xBEBE, 0xC6DF, 0xC6DF, 0xBEDF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF, 0xC6DF,   // 0x01B0 (432)
+0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xBEDF, 0xC6DF, 0xC6DF, 0xC6DF, 0xBEBF, 0xBEBF, 0xC6DF, 0xC6DF, 0xC6DF,   // 0x01C0 (448)
+0xC6BF, 0xC6BF, 0xC6BF, 0xC6BF, 0xC6BF, 0xC6BF, 0xC6BE, 0xC6BE, 0xC6BE, 0xC6BF, 0xCEBF, 0xC6BE, 0xCEBE, 0xC6BE, 0xC6BE, 0xCEFF,   // 0x01D0 (464)
+0xCF1F, 0xC6BE, 0xC6BD, 0xD71F, 0xD71F, 0xCEDE, 0xC67C, 0xB61A, 0x7412, 0x2167, 0x0001, 0x0001, 0x0000, 0x0021, 0x0020, 0x0000,   // 0x01E0 (480)
+0x0800, 0x1082, 0x1062, 0x0000, 0x0001, 0x424B, 0xA599, 0xDF7F, 0xCF3F, 0xBEBD, 0xBEBE, 0xC6DE, 0xBEBE, 0xBE9D, 0xBE7D, 0xB67D,   // 0x01F0 (496)
+0xB67D, 0xB69E, 0xB69E, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEBF, 0xBEBF, 0xBEDF, 0xBEDF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEDF, 0xB6BF,   // 0x0200 (512)
+0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF,   // 0x0210 (528)
+0xBEBF, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9F, 0xBE9E, 0xBE9E, 0xBE7E, 0xBE7E, 0xBE9E, 0xBE9E, 0xAE3D,   // 0x0220 (544)
+0xAE7D, 0xBEDE, 0xBEDE, 0xB65C, 0xBEBD, 0xCF1F, 0xCF1F, 0xBE7C, 0xCEFE, 0x9516, 0x3A2A, 0x0883, 0x0001, 0x0021, 0x0021, 0x0000,   // 0x0230 (560)
+0x0841, 0x0020, 0x0000, 0x0042, 0x3A2A, 0x8CF6, 0xBEBD, 0xBEDE, 0xAE5D, 0xB69E, 0xB6BE, 0xB6BE, 0xB6BE, 0xBEDF, 0xBEBE, 0xBEBF,   // 0x0240 (576)
+0xB6BF, 0xB6BF, 0xAE9F, 0xAEBF, 0xAE9F, 0xB69F, 0xB6BF, 0xB6BF, 0xB6BF, 0xB6BF, 0xB69F, 0xB69F, 0xAE9F, 0xB69F, 0xB6BF, 0xB6BF,   // 0x0250 (592)
+0xAE9F, 0xAE9F, 0xAE9F, 0xB69F, 0xB69F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F,   // 0x0260 (608)
+0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB69F, 0xB6BF, 0xB6BF, 0xB6BF, 0xBEBF, 0xBEBF, 0xB6BF, 0xB69F, 0xBE9F, 0xBEBF, 0xBEDF, 0xBEDF,   // 0x0270 (624)
+0xBEDF, 0xB6DF, 0xB6DF, 0xB6BF, 0xB69E, 0xB67E, 0xB69E, 0xBEBE, 0xBE9D, 0xCF1F, 0x9D57, 0x2167, 0x0022, 0x0001, 0x0021, 0x0000,   // 0x0280 (640)
+0x0821, 0x0000, 0x0000, 0x2147, 0x9D77, 0xB65C, 0xB67D, 0xB6BF, 0xB6BF, 0xAE9E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE9E,   // 0x0290 (656)
+0xAE9F, 0xAE7F, 0xA69F, 0xA69F, 0xA69F, 0xAE7F, 0xAE5F, 0xBEBF, 0xBEFF, 0xAE5E, 0xAE7F, 0xB69F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE7F,   // 0x02A0 (672)
+0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xAE9F, 0xA69F, 0xAE9F, 0xAE9F, 0xAE9F,   // 0x02B0 (688)
+0xAE7F, 0xAE9F, 0xAE7F, 0xAE9F, 0xAE7F, 0xAE7E, 0xAE9E, 0xBF3F, 0xB6DF, 0xAE7E, 0xAE9F, 0xAE7E, 0xAE9E, 0xAE9E, 0xAE9F, 0xAE9F,   // 0x02C0 (704)
+0xAE9F, 0xAE9F, 0xAE9F, 0xAE9E, 0xAE9E, 0xAE7E, 0xAE7E, 0xAE7E, 0xAE7D, 0xBEBE, 0xBE9D, 0x9517, 0x1126, 0x0001, 0x0001, 0x0021,   // 0x02D0 (720)
+0x0822, 0x0000, 0x0863, 0x4AAD, 0xB61B, 0xBE7D, 0xAE7E, 0xB69F, 0xAE9F, 0xA67E, 0xA65F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xA67F,   // 0x02E0 (736)
+0xA67F, 0xA67F, 0xA69F, 0xA69F, 0xA67F, 0xA67F, 0xAE3E, 0xB69F, 0xBEDF, 0xAE5E, 0xAE7E, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F,   // 0x02F0 (752)
+0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xAE7F, 0xA67F, 0xAE7F, 0xA67F, 0xA67F, 0xA69F, 0xA69F, 0xA69F, 0xA67F, 0xA67F,   // 0x0300 (768)
+0xA67F, 0xA67F, 0xA67E, 0xA67E, 0xA67E, 0xA67E, 0xA69E, 0xBF1F, 0xAEBF, 0xA65E, 0xAE7E, 0xA67E, 0xA67E, 0xAE7E, 0xA67E, 0xA67F,   // 0x0310 (784)
+0xA69F, 0xA67F, 0xA67F, 0xA67F, 0xA67F, 0xA67F, 0xAE7E, 0xAE7E, 0xAE7E, 0xB67D, 0xBE9E, 0xADFA, 0x42AD, 0x0863, 0x0001, 0x0022,   // 0x0320 (800)
+0x0001, 0x0000, 0x2167, 0x8474, 0xB65D, 0xB67E, 0xAE5E, 0xA65E, 0xA65F, 0x9E3E, 0x9E5F, 0xA67F, 0xA65F, 0xA65F, 0xA65F, 0xA65F,   // 0x0330 (816)
+0xA67F, 0x9E7F, 0x9E7F, 0x9E7F, 0x9E5F, 0xA63E, 0xA61E, 0xB69F, 0xBEDF, 0xA63E, 0xA63E, 0xAE5E, 0xA65E, 0xAE5E, 0xA65E, 0xA65E,   // 0x0340 (832)
+0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0xA65F, 0x9E5F, 0x9E7E, 0x9E7E, 0x9E7E, 0x9E7E, 0x9E7E,   // 0x0350 (848)
+0x9E5F, 0x9E7E, 0x9E7E, 0xA67E, 0x9E5E, 0x9E5E, 0xA67E, 0xB6FF, 0xAEBE, 0x9E5D, 0xA67E, 0x9E5E, 0xA65E, 0xA67E, 0xA67E, 0x9E7F,   // 0x0360 (864)
+0x9E7F, 0x9E7F, 0x9E7F, 0x9E7F, 0xA67F, 0xA67F, 0xA67E, 0xA67E, 0xA67E, 0xA63D, 0xAE5D, 0xB65D, 0x7C95, 0x2168, 0x0001, 0x0001,   // 0x0370 (880)
+0x0002, 0x0000, 0x3A0A, 0xA5BA, 0xB63C, 0xAE3D, 0xA63E, 0x9E5E, 0x9E3F, 0x9E3F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F,   // 0x0380 (896)
+0x9E5F, 0x9E5F, 0x9E5F, 0x965F, 0x9E3F, 0x9E1E, 0x9DFE, 0xAE7E, 0xB6BF, 0xA61E, 0xA61E, 0xA63E, 0x9E1E, 0xA63E, 0xA63E, 0x9E3E,   // 0x0390 (912)
+0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E3F, 0x9E5F, 0x9E5F, 0x9E5E, 0x9E5E, 0x9E5E, 0x9E5E, 0x9E5E,   // 0x03A0 (928)
+0x9E5E, 0x9E5E, 0x9E5E, 0x9E5E, 0x9E3E, 0x9E3E, 0x9E5E, 0xB6FF, 0xA69E, 0x9E3D, 0x9E5E, 0x9E3D, 0x9E3E, 0x9E5E, 0x9E5E, 0x9E5E,   // 0x03B0 (944)
+0x965F, 0x965F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5F, 0x9E5E, 0x9E5E, 0x9E5E, 0x9DFD, 0xA61C, 0xB65D, 0xADFB, 0x3A2C, 0x0001, 0x0002,   // 0x03C0 (960)
+0x0002, 0x0000, 0x428D, 0xB67D, 0xA5FC, 0x9DFD, 0x9E1E, 0x9E5F, 0x961F, 0x961F, 0x963F, 0x963F, 0x963F, 0x963F, 0x963E, 0x963E,   // 0x03D0 (976)
+0x963F, 0x963F, 0x963F, 0x963F, 0x963F, 0x9E1E, 0x9DFE, 0xAE7F, 0xB6BF, 0x9DFE, 0x9E1E, 0x9E1E, 0x9E1E, 0x9E1E, 0x9E1F, 0x9E3F,   // 0x03E0 (992)
+0x9E1F, 0x9E1F, 0x9E1F, 0x961F, 0x963F, 0x963F, 0x961F, 0x961F, 0x963F, 0x963F, 0x963F, 0x963F, 0x963F, 0x963E, 0x963E, 0x963E,   // 0x03F0 (1008)
+0x963E, 0x963E, 0x963E, 0x963E, 0x961E, 0x961E, 0x963E, 0xAEDF, 0xA67F, 0x961D, 0x9E3E, 0x9E1E, 0x9E3E, 0x9E3E, 0x9E3E, 0x963F,   // 0x0400 (1024)
+0x963F, 0x963F, 0x963F, 0x963F, 0x961F, 0x963F, 0x963F, 0x9E1E, 0x9E1E, 0x9DFD, 0x9DFD, 0xA61D, 0xB65D, 0x428E, 0x0001, 0x0003,   // 0x0410 (1040)
+0x0023, 0x0001, 0x428D, 0xBE7D, 0xA5DC, 0x9DDC, 0x95FE, 0x961F, 0x8DFF, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x961E, 0x961E, 0x961E,   // 0x0420 (1056)
+0x961E, 0x95FE, 0x95FE, 0x8E1F, 0x961E, 0x95FE, 0x95DE, 0xA65F, 0xAE9F, 0x9DFE, 0x95FE, 0x95FE, 0x95FE, 0x95FE, 0x961F, 0x961F,   // 0x0430 (1072)
+0x95FF, 0x95FF, 0x8E1F, 0x8DFF, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x961F, 0x961E, 0x961E, 0x961E, 0x961E,   // 0x0440 (1088)
+0x961E, 0x961E, 0x961E, 0x961E, 0x95FE, 0x8DFE, 0x961E, 0xAEBF, 0x9E5E, 0x95DD, 0x961E, 0x95FE, 0x961E, 0x961E, 0x961E, 0x961E,   // 0x0450 (1104)
+0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x8E1F, 0x961F, 0x95FF, 0x961E, 0x95FE, 0x9E1E, 0x9DFD, 0x9DDC, 0xB65D, 0x428E, 0x0002, 0x0003,   // 0x0460 (1120)
+0x0024, 0x0002, 0x426D, 0xB63D, 0xA5DC, 0x95DC, 0x8DDD, 0x8DFE, 0x8DDE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DDE,   // 0x0470 (1136)
+0x8DFD, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DDD, 0x8DDE, 0x9E5F, 0xA67F, 0x95DE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DFF, 0x8DFF,   // 0x0480 (1152)
+0x8DFF, 0x8DFF, 0x8DFF, 0x85FF, 0x85FF, 0x85FF, 0x85FF, 0x85FF, 0x85FF, 0x8DFF, 0x8DFF, 0x8DFF, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE,   // 0x0490 (1168)
+0x8DFE, 0x8DFF, 0x8DFE, 0x8DFE, 0x8DDE, 0x8DDE, 0x95DE, 0xA67F, 0x9E1E, 0x8DBD, 0x95FE, 0x8DDD, 0x95DE, 0x95DE, 0x95FE, 0x8DFE,   // 0x04A0 (1184)
+0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DFE, 0x8DDE, 0x8DDE, 0x95DE, 0x95FE, 0x9DFD, 0x9DBC, 0xAE1D, 0x3A6E, 0x0002, 0x0003,   // 0x04B0 (1200)
+0x0002, 0x0001, 0x322C, 0xA5FC, 0x9DFD, 0x95FD, 0x8DBD, 0x859D, 0x85BE, 0x8DFF, 0x8DFF, 0x8DDF, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE,   // 0x04C0 (1216)
+0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DBE, 0x8DBE, 0x9E3F, 0xA67F, 0x8DDE, 0x8DBE, 0x85BE, 0x85BE, 0x85DE, 0x8DDF, 0x85DF,   // 0x04D0 (1232)
+0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x85DF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF,   // 0x04E0 (1248)
+0x8DDE, 0x8DDF, 0x8DDE, 0x8DDE, 0x8DBE, 0x8DBE, 0x8DDE, 0xA65F, 0x95FF, 0x8D9E, 0x8DBE, 0x8DBE, 0x8DBE, 0x8DBE, 0x8DDE, 0x8DDE,   // 0x04F0 (1264)
+0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDF, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DDE, 0x8DBD, 0x959C, 0x959C, 0xA5FD, 0x3A6E, 0x0003, 0x0003,   // 0x0500 (1280)
+0x0001, 0x0000, 0x3A4D, 0x961D, 0x85BD, 0x85BE, 0x7DBE, 0x7D9D, 0x8DDE, 0x859D, 0x859D, 0x85BE, 0x85BF, 0x85BF, 0x85BF, 0x85BE,   // 0x0510 (1296)
+0x85BE, 0x85BE, 0x7DBF, 0x7DBF, 0x7DBF, 0x859E, 0x855D, 0x95FE, 0xA69F, 0x8DBE, 0x7D7E, 0x7D9E, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF,   // 0x0520 (1312)
+0x7DDF, 0x7DDF, 0x7DDF, 0x7DDF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7DBF, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x85BF, 0x85BF,   // 0x0530 (1328)
+0x85DF, 0x85BF, 0x85BE, 0x85BE, 0x859D, 0x857C, 0x859D, 0xA69F, 0x961E, 0x7D5C, 0x8DBE, 0x859D, 0x857D, 0x859E, 0x859E, 0x8DBF,   // 0x0540 (1344)
+0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BF, 0x85BE, 0x8D9D, 0x8D7B, 0x959B, 0x9DDC, 0x3A4D, 0x0002, 0x0003,   // 0x0550 (1360)
+0x0000, 0x0000, 0x326D, 0x8E1E, 0x7D9E, 0x75BF, 0x759F, 0x7D7E, 0x8DBE, 0x857D, 0x857D, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F,   // 0x0560 (1376)
+0x7D9F, 0x7D9E, 0x759F, 0x759F, 0x759F, 0x7D7E, 0x7D3D, 0x95FE, 0xA69F, 0x85BE, 0x7D7E, 0x7D7E, 0x7D9F, 0x759F, 0x759F, 0x759F,   // 0x0570 (1392)
+0x759F, 0x759F, 0x759F, 0x759F, 0x759F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x757E, 0x7D9F, 0x7DBF, 0x7DDF, 0x7D9F, 0x757F,   // 0x0580 (1408)
+0x755E, 0x7D7E, 0x859E, 0x85BE, 0x7D9D, 0x7D5C, 0x857C, 0xA6BF, 0x961E, 0x7D5C, 0x859E, 0x7D7D, 0x7D7E, 0x857F, 0x859F, 0x859F,   // 0x0590 (1424)
+0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x7D9F, 0x859E, 0x859D, 0x8D9C, 0x8D9B, 0x9DDC, 0x3A4D, 0x0002, 0x0003,   // 0x05A0 (1440)
+0x0000, 0x0000, 0x324D, 0x8DFE, 0x757E, 0x6D9F, 0x6D7F, 0x755E, 0x859E, 0x7D5C, 0x7D5D, 0x7D7E, 0x757F, 0x757F, 0x757F, 0x757F,   // 0x05B0 (1456)
+0x757F, 0x757E, 0x757F, 0x6D9F, 0x757F, 0x7D5E, 0x7D1D, 0x8DDE, 0x9E5F, 0x7D7E, 0x753E, 0x755E, 0x757F, 0x757E, 0x6D7F, 0x6D7F,   // 0x05C0 (1472)
+0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x755E, 0x757F, 0x759F, 0x759F, 0x759F, 0x759F, 0x757F, 0x757E,   // 0x05D0 (1488)
+0x755D, 0x7D5D, 0x7D7D, 0x7D9D, 0x7D7C, 0x753C, 0x7D5D, 0x9E9F, 0x8DFE, 0x753D, 0x7D9E, 0x755E, 0x757E, 0x7D7F, 0x7D9F, 0x755F,   // 0x05E0 (1504)
+0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757F, 0x757E, 0x7D7E, 0x7D7D, 0x857C, 0x857B, 0x95BB, 0x324D, 0x0003, 0x0003,   // 0x05F0 (1520)
+0x0800, 0x0000, 0x322C, 0x85BE, 0x6D5D, 0x6D7E, 0x655E, 0x6D3E, 0x7D7E, 0x7D5D, 0x753D, 0x755E, 0x6D7F, 0x6D5F, 0x6D7F, 0x6D7F,   // 0x0600 (1536)
+0x755E, 0x6D5E, 0x6D7F, 0x6D7F, 0x6D5F, 0x753E, 0x751D, 0x8DBE, 0x9E3F, 0x7D5E, 0x6D1D, 0x6D3E, 0x757E, 0x6D5E, 0x6D5E, 0x6D5E,   // 0x0610 (1552)
+0x6D5F, 0x6D5F, 0x6D5F, 0x6D5F, 0x6D5E, 0x755E, 0x755E, 0x755E, 0x755E, 0x755F, 0x757F, 0x6D5F, 0x6D3E, 0x6D3E, 0x755E, 0x755D,   // 0x0620 (1568)
+0x753C, 0x6CFB, 0x6CFA, 0x751B, 0x751C, 0x751C, 0x753C, 0x9E7F, 0x85BE, 0x6D1D, 0x757F, 0x6D5E, 0x6D5E, 0x6D7F, 0x6D7F, 0x6D5E,   // 0x0630 (1584)
+0x6D5E, 0x6D5E, 0x6D5E, 0x6D5E, 0x6D5E, 0x6D5F, 0x6D5E, 0x6D5E, 0x755E, 0x755D, 0x7D5C, 0x7D5B, 0x8D7B, 0x324E, 0x0003, 0x0004,   // 0x0640 (1600)
+0x0801, 0x0000, 0x322D, 0x85BE, 0x6D3D, 0x655E, 0x653E, 0x653E, 0x755E, 0x6D1D, 0x6D1D, 0x6D3F, 0x653F, 0x653F, 0x655F, 0x653F,   // 0x0650 (1616)
+0x6D3E, 0x655E, 0x655F, 0x655F, 0x653F, 0x6D3E, 0x6CFD, 0x859E, 0x961F, 0x755E, 0x6D1D, 0x6D1E, 0x6D5E, 0x6D3E, 0x653E, 0x655E,   // 0x0660 (1632)
+0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D3E, 0x6D1E, 0x64FE, 0x6D3F, 0x755F, 0x6D3D, 0x6CFC, 0x6CFA,   // 0x0670 (1648)
+0x6D1A, 0x7D3B, 0x7D3B, 0x753B, 0x74FB, 0x6CFB, 0x6CFC, 0x963F, 0x7D9E, 0x64FE, 0x6D5F, 0x653F, 0x653E, 0x5D5F, 0x655F, 0x655F,   // 0x0680 (1664)
+0x655E, 0x655E, 0x655E, 0x655F, 0x655F, 0x655F, 0x655E, 0x655E, 0x6D5E, 0x755E, 0x753D, 0x751B, 0x857C, 0x322E, 0x0004, 0x0005,   // 0x0690 (1680)
+0x0801, 0x0000, 0x2A0D, 0x7D9E, 0x651D, 0x5D1E, 0x5D1E, 0x651E, 0x6D5E, 0x6D1D, 0x651E, 0x653F, 0x5D3F, 0x5D3F, 0x5D3F, 0x5D3F,   // 0x06A0 (1696)
+0x653E, 0x653E, 0x653E, 0x5D3F, 0x653F, 0x651E, 0x64DD, 0x7D7E, 0x8DFF, 0x6D1E, 0x64FD, 0x651E, 0x653E, 0x651E, 0x651E, 0x653E,   // 0x06B0 (1712)
+0x653E, 0x653E, 0x651E, 0x651E, 0x651E, 0x651E, 0x6D1E, 0x651E, 0x6D1E, 0x6D1E, 0x64DE, 0x6D1F, 0x753E, 0x64DB, 0x5C79, 0x6D1A,   // 0x06C0 (1728)
+0x9E7D, 0xBF5F, 0xBF3F, 0xA67E, 0x7D3C, 0x647A, 0x6CDC, 0x8DFF, 0x757F, 0x5CDE, 0x5D3F, 0x551F, 0x553E, 0x555F, 0x555E, 0x5D5F,   // 0x06D0 (1744)
+0x5D5E, 0x5D5F, 0x5D5F, 0x5D5F, 0x5D3F, 0x5D3E, 0x653E, 0x653D, 0x653D, 0x6D3D, 0x753D, 0x74FC, 0x855C, 0x322F, 0x0004, 0x0045,   // 0x06E0 (1760)
+0x0802, 0x0000, 0x2A0D, 0x7D7D, 0x5CFD, 0x54FE, 0x54FE, 0x5CFE, 0x653F, 0x64FD, 0x5CFE, 0x551F, 0x551F, 0x551F, 0x551F, 0x551F,   // 0x06F0 (1776)
+0x5D1E, 0x5D1E, 0x5D1E, 0x5D1E, 0x5D1E, 0x64FD, 0x5CBD, 0x755E, 0x85FF, 0x651E, 0x5CDD, 0x5CFD, 0x5D1E, 0x5CFE, 0x5CFE, 0x5CFE,   // 0x0700 (1792)
+0x5D1E, 0x5D1E, 0x5D1E, 0x5CFE, 0x5CFE, 0x5CFE, 0x5CFE, 0x5CFE, 0x64FE, 0x64FE, 0x6CFF, 0x6CDD, 0x649B, 0x5C79, 0x74FA, 0xA67E,   // 0x0710 (1808)
+0xCF9F, 0xEFFF, 0xEFFF, 0xD7BF, 0x95BC, 0x5C39, 0x6C9B, 0x8DDF, 0x753F, 0x549D, 0x5D1F, 0x54FE, 0x4D1E, 0x4D3E, 0x555E, 0x553E,   // 0x0720 (1824)
+0x551E, 0x551F, 0x551F, 0x551F, 0x551E, 0x5D1E, 0x5D1D, 0x5D1C, 0x651C, 0x64FC, 0x6CDB, 0x6CBB, 0x7D1B, 0x2A2E, 0x0003, 0x0045,   // 0x0730 (1840)
+0x0801, 0x0000, 0x29ED, 0x755E, 0x54DD, 0x54FE, 0x4CFF, 0x4CDE, 0x651F, 0x54DE, 0x54DE, 0x551F, 0x4CFF, 0x4CFF, 0x551F, 0x54FF,   // 0x0740 (1856)
+0x5CFE, 0x5CFD, 0x5CFE, 0x5CFE, 0x5CFE, 0x5CDD, 0x5C9D, 0x6D3E, 0x7DDF, 0x5D1E, 0x54BD, 0x54DD, 0x5CFE, 0x54FE, 0x54FE, 0x54FE,   // 0x0750 (1872)
+0x54FF, 0x54FF, 0x54FF, 0x54FF, 0x54FF, 0x5CFF, 0x5CFF, 0x54FF, 0x5CFE, 0x64FE, 0x6CDE, 0x5C3A, 0x5418, 0x751A, 0xAE9E, 0xD7DF,   // 0x0760 (1888)
+0xDFDF, 0xCF5F, 0xCF5F, 0xEFFF, 0xA5FB, 0x5BD7, 0x6C9B, 0x8DBF, 0x751D, 0x547C, 0x5CFE, 0x54FE, 0x4D1D, 0x4D3D, 0x555E, 0x4D1D,   // 0x0770 (1904)
+0x4CFE, 0x54DF, 0x54DF, 0x54DF, 0x54DE, 0x54DD, 0x5CFC, 0x5CFC, 0x64FB, 0x5CBB, 0x5C39, 0x5C18, 0x7499, 0x29CC, 0x0002, 0x0023,   // 0x0780 (1920)
+0x0001, 0x0002, 0x21ED, 0x64DC, 0x54DD, 0x44BE, 0x44DF, 0x4CDF, 0x54DE, 0x54DF, 0x4CBE, 0x44BE, 0x4D1F, 0x44DF, 0x44DF, 0x54FE,   // 0x0790 (1936)
+0x5D1F, 0x5CDC, 0x54BC, 0x4C9C, 0x4C9C, 0x549C, 0x54BC, 0x6D5F, 0x759F, 0x54DD, 0x54BD, 0x5CFE, 0x54FE, 0x4C9D, 0x4C9D, 0x4CDE,   // 0x07A0 (1952)
+0x54DE, 0x4CDE, 0x54FF, 0x54FF, 0x54DF, 0x4C9E, 0x4CBF, 0x54DF, 0x54DF, 0x549D, 0x649C, 0x53D8, 0x6C79, 0xAE3E, 0xDFDF, 0xDFFF,   // 0x07B0 (1968)
+0xBEBC, 0xAE3B, 0xDFBF, 0xF7FF, 0xBEBD, 0x7479, 0x63F8, 0x853D, 0x7D5F, 0x6CDD, 0x549C, 0x445A, 0x54DC, 0x553D, 0x4CDB, 0x449C,   // 0x07C0 (1984)
+0x54FE, 0x54FF, 0x4C9F, 0x445E, 0x5CFF, 0x5CFE, 0x54BB, 0x549A, 0x43F7, 0x6CDB, 0x961F, 0xA63E, 0x9DBC, 0x320C, 0x0001, 0x0062,   // 0x07D0 (2000)
+0x0002, 0x0003, 0x21CD, 0x5CBC, 0x54FE, 0x44DF, 0x44DF, 0x44DF, 0x449E, 0x4C9E, 0x4CDE, 0x4CFF, 0x4D1F, 0x3C9E, 0x3C5D, 0x449D,   // 0x07E0 (2016)
+0x5CBC, 0x549B, 0x549B, 0x549B, 0x4C7A, 0x4C5B, 0x4C5B, 0x75BE, 0x8E5F, 0x443A, 0x4C9D, 0x4C9C, 0x445B, 0x54FE, 0x4CDE, 0x4CBE,   // 0x07F0 (2032)
+0x44BD, 0x44BE, 0x4CBE, 0x449E, 0x449E, 0x44BE, 0x4CBF, 0x4CDF, 0x44BE, 0x4C7C, 0x5C7A, 0x53B6, 0x8D3A, 0xD7BF, 0xE7FF, 0xA5F9,   // 0x0800 (2048)
+0x63F2, 0x7453, 0xC6DD, 0xDF7F, 0xBE9E, 0x84B8, 0x63F6, 0x8D9D, 0x7CFC, 0x5C39, 0x5459, 0x4C38, 0x4C78, 0x4C79, 0x4C7A, 0x54BC,   // 0x0810 (2064)
+0x54DE, 0x54BF, 0x4C5F, 0x4C5F, 0x54BE, 0x547B, 0x4418, 0x5457, 0x64DA, 0x9E5E, 0xD7DF, 0xE7FF, 0xDF9F, 0x4ACE, 0x0000, 0x0040,   // 0x0820 (2080)
+0x0002, 0x0003, 0x19CD, 0x549C, 0x4CDE, 0x44BF, 0x3CDF, 0x44DF, 0x3C9E, 0x449E, 0x3C9E, 0x3C9F, 0x3CBF, 0x3C7E, 0x44BE, 0x54BD,   // 0x0830 (2096)
+0x547A, 0x43F8, 0x4C18, 0x5459, 0x545A, 0x4C39, 0x43F9, 0x64FC, 0x7DDF, 0x54BC, 0x4C5A, 0x443A, 0x445B, 0x54BD, 0x4C9C, 0x4C9C,   // 0x0840 (2112)
+0x449D, 0x4CBD, 0x4CBE, 0x3C5D, 0x3C5D, 0x4CFF, 0x44BF, 0x3C9F, 0x447E, 0x4C5C, 0x53F7, 0x7479, 0xB69D, 0xEFFF, 0xDF9F, 0xAE1B,   // 0x0850 (2128)
+0x84D7, 0x84F6, 0xAE1B, 0xDF9F, 0xDF5F, 0x955A, 0x5B73, 0x9DDD, 0x7CDA, 0x4354, 0x53F6, 0x7D5C, 0x85BE, 0x64FA, 0x4C38, 0x549B,   // 0x0860 (2144)
+0x4C7C, 0x4C5E, 0x4C3F, 0x545F, 0x545D, 0x4BF9, 0x4BF8, 0x64D9, 0xA69E, 0xD7DF, 0xEFFF, 0xEFFF, 0xFFFF, 0x5B4E, 0x0000, 0x0000,   // 0x0870 (2160)
+0x0003, 0x0003, 0x118D, 0x3BFA, 0x343C, 0x243D, 0x2C5F, 0x34BF, 0x349E, 0x3C9E, 0x3C9F, 0x349F, 0x347E, 0x3C9E, 0x4CDE, 0x4C9B,   // 0x0880 (2176)
+0x4418, 0x4BD6, 0x751B, 0xA69E, 0xAEBE, 0x751C, 0x3B96, 0x4C39, 0x757E, 0x549A, 0x5CBA, 0x4C3A, 0x3BD8, 0x4C3A, 0x3BD9, 0x3BD9,   // 0x0890 (2192)
+0x443B, 0x4C7C, 0x4CDD, 0x445C, 0x445D, 0x54FF, 0x3C7E, 0x3C5E, 0x445E, 0x4C3A, 0x4395, 0x95DB, 0xDFDF, 0xD77E, 0x8D39, 0x7476,   // 0x08A0 (2208)
+0x6BF4, 0x63B3, 0x7436, 0xC6DD, 0xF7FF, 0xB65B, 0x5352, 0x9D9B, 0x74B7, 0x5373, 0x74B8, 0xBEFF, 0xD7FF, 0xAEDF, 0x6CDB, 0x4418,   // 0x08B0 (2224)
+0x43FA, 0x4C3D, 0x545F, 0x543F, 0x545D, 0x4BF9, 0x5C79, 0x961E, 0xCFBF, 0xCF7F, 0x955B, 0x5332, 0x6392, 0x2147, 0x0000, 0x10C1,   // 0x08C0 (2240)
+0x0024, 0x0004, 0x096D, 0x2398, 0x1B9A, 0x0B9B, 0x13DD, 0x243E, 0x2C3D, 0x345E, 0x3C9F, 0x3CBF, 0x3CBE, 0x3C7D, 0x3C3B, 0x3BF8,   // 0x08D0 (2256)
+0x53F7, 0x7CFB, 0xBEFE, 0xDFFF, 0xDFFF, 0xCF7F, 0x95DC, 0x8DBE, 0x8DDE, 0x4375, 0x43B6, 0x4BB6, 0x5437, 0x85FD, 0x967D, 0x6D5B,   // 0x08E0 (2272)
+0x3BD8, 0x3BB8, 0x443A, 0x445B, 0x4C7C, 0x4C9D, 0x3C3C, 0x445D, 0x443C, 0x3BD8, 0x5C78, 0xBEFD, 0xEFFF, 0xCF5F, 0x8D7B, 0x7C98,   // 0x08F0 (2288)
+0x6C17, 0x6C36, 0x84D9, 0xB67E, 0xDFDF, 0xCF5D, 0x9579, 0x9DBB, 0x6C54, 0x6C55, 0xBEDE, 0xE7DF, 0xEFFF, 0xEFFF, 0xB6FF, 0x5458,   // 0x0900 (2304)
+0x4419, 0x4C5D, 0x4C3E, 0x4BDD, 0x4BFB, 0x3B76, 0x5456, 0xBF7F, 0xD7FF, 0xA63E, 0x6419, 0x5B75, 0x6BD5, 0x29CB, 0x0041, 0x0861,   // 0x0910 (2320)
+0x0024, 0x0004, 0x096D, 0x2398, 0x0B7A, 0x037B, 0x039C, 0x0BDC, 0x13BB, 0x1BBB, 0x23FC, 0x241D, 0x345C, 0x23FA, 0x2B98, 0x4C19,   // 0x0920 (2336)
+0x857C, 0xC73F, 0xE7FF, 0xC71D, 0x9DBA, 0xD77F, 0xD7BF, 0xC71F, 0x95BC, 0x4B53, 0x3AD1, 0x6457, 0xA67E, 0xC75F, 0xD7FF, 0xB6FF,   // 0x0930 (2352)
+0x6D1C, 0x4C18, 0x43B8, 0x43F9, 0x4C5A, 0x4C5B, 0x443B, 0x445C, 0x33D9, 0x43F8, 0xA69E, 0xDFFF, 0xBF3D, 0x7D18, 0x6416, 0x5BD6,   // 0x0940 (2368)
+0x5BD7, 0x5BF8, 0x6C38, 0x6418, 0xAE7C, 0xE7FF, 0xBF3E, 0x95B9, 0x6C53, 0x9577, 0xE7FF, 0xD75F, 0xCEFF, 0xDF7F, 0xD79F, 0x755C,   // 0x0950 (2384)
+0x4C59, 0x3BDA, 0x3B9B, 0x335A, 0x3337, 0x1A93, 0x4BF5, 0xD7FF, 0xE7FF, 0x8519, 0x3272, 0x4AF4, 0x4AF2, 0x196A, 0x0001, 0x0000,   // 0x0960 (2400)
+0x0004, 0x0004, 0x096D, 0x23BA, 0x139B, 0x037B, 0x037C, 0x039C, 0x035A, 0x0B59, 0x137A, 0x0B7A, 0x1379, 0x0B17, 0x2BB8, 0x755D,   // 0x0970 (2416)
+0xBF3F, 0xE7FF, 0xE7BF, 0xA5DA, 0x7C96, 0xBE9E, 0xE7BF, 0xEFDF, 0xB65D, 0x5351, 0x6C15, 0xAE7D, 0xE7FF, 0xE7FF, 0xE7FF, 0xDFFF,   // 0x0980 (2432)
+0xBF3F, 0x85BD, 0x5418, 0x43D7, 0x4C19, 0x441A, 0x441A, 0x3BFA, 0x3BDA, 0x651B, 0xC7BF, 0xDFFF, 0xB6DD, 0x6C98, 0x5C18, 0x6C9B,   // 0x0990 (2448)
+0x74BD, 0x645B, 0x53D9, 0x645A, 0xAEBD, 0xE7FF, 0xDFFF, 0xBF1D, 0xBEDC, 0xDF7E, 0xEFFF, 0xBE5C, 0xADDC, 0xC6BE, 0xD7BF, 0xA6DF,   // 0x09A0 (2464)
+0x4C78, 0x1AF5, 0x22F8, 0x22F8, 0x1294, 0x22F3, 0x7539, 0xD7FF, 0xCFDF, 0x7D1A, 0x4B16, 0x5376, 0x5B95, 0x21CD, 0x0043, 0x0021,   // 0x09B0 (2480)
+0x0004, 0x0004, 0x116D, 0x23DA, 0x13BB, 0x039B, 0x039C, 0x039B, 0x0B59, 0x1379, 0x137A, 0x0B38, 0x02D6, 0x0AD6, 0x5CFB, 0xBF9F,   // 0x09C0 (2496)
+0xDFFF, 0xAE3C, 0x6BF4, 0x42AE, 0x42AE, 0x4AEF, 0xADDA, 0xF7FF, 0xE7BF, 0xAE1B, 0xCF1D, 0xF7FF, 0xD77E, 0x8D58, 0x6C56, 0xB67B,   // 0x09D0 (2512)
+0xEFFF, 0xB6FF, 0x5C57, 0x4375, 0x4BB7, 0x43D7, 0x4BD8, 0x3336, 0x5479, 0xB73F, 0xD7FF, 0xAEFD, 0x6CF7, 0x4BD6, 0x5418, 0x53FA,   // 0x09E0 (2528)
+0x5C5C, 0x543B, 0x3B78, 0x4BD8, 0x5417, 0x8599, 0xD7DF, 0xDFFF, 0xF7FF, 0xEFDF, 0xB67B, 0x5350, 0x31ED, 0x7C56, 0xD79F, 0xCFFF,   // 0x09F0 (2544)
+0x5497, 0x0A52, 0x1AB5, 0x22F6, 0x01F0, 0x4C16, 0xBF7F, 0xD7FF, 0x85BA, 0x4395, 0x3293, 0x3AB5, 0x63D7, 0x29AD, 0x0003, 0x0022,   // 0x0A00 (2560)
+0x0005, 0x0046, 0x118E, 0x2357, 0x2399, 0x133A, 0x0B5A, 0x1B7A, 0x2379, 0x2337, 0x2316, 0x1AD4, 0x22F4, 0x6CFB, 0xBF3F, 0xE7FF,   // 0x0A10 (2576)
+0xBF5F, 0x6CB8, 0x4353, 0x4352, 0x4B53, 0x3AB1, 0x6417, 0xBE9E, 0xEFFF, 0xE7FF, 0xDFFF, 0xC73F, 0x8D9B, 0x53B6, 0x3AD2, 0x8D7A,   // 0x0A20 (2592)
+0xEFFF, 0xD7BF, 0x8539, 0x4333, 0x2A90, 0x3AD2, 0x2A50, 0x53D6, 0xAE7D, 0xD7FF, 0xC77F, 0x85BC, 0x4C19, 0x3BB8, 0x4C3A, 0x43FB,   // 0x0A30 (2608)
+0x4C3C, 0x4C5D, 0x441C, 0x43FA, 0x3378, 0x4BF8, 0x7D7C, 0xAF1F, 0xA69E, 0x7D7A, 0x6C78, 0x3AF3, 0x32B3, 0x5C39, 0xA65F, 0xDFFF,   // 0x0A40 (2624)
+0xA6BD, 0x5C98, 0x32D2, 0x11CD, 0x1A0F, 0x8599, 0xDFFF, 0xBF9F, 0x6498, 0x4376, 0x4B57, 0x4B57, 0x6BF8, 0x31CD, 0x0004, 0x0023,   // 0x0A50 (2640)
+0x0004, 0x0005, 0x092B, 0x1A93, 0x1294, 0x0274, 0x02B6, 0x1AF6, 0x22F5, 0x22D3, 0x1A30, 0x32D2, 0x853B, 0xCF9F, 0xD7FF, 0x961D,   // 0x0A60 (2656)
+0x43D7, 0x22D3, 0x2314, 0x2B55, 0x2B35, 0x3336, 0x2294, 0x4C17, 0x85BC, 0x64B8, 0x5417, 0x3335, 0x22B4, 0x2AB4, 0x2AB3, 0x4BB6,   // 0x0A70 (2672)
+0x95FB, 0xDFFF, 0xC73F, 0x5BD4, 0x116C, 0x198D, 0x220E, 0x9D7A, 0xF7FF, 0xD7BF, 0x6CDB, 0x3378, 0x2317, 0x2317, 0x2B79, 0x237A,   // 0x0A80 (2688)
+0x237A, 0x237A, 0x2B9A, 0x2359, 0x2338, 0x1AF6, 0x22F6, 0x64DD, 0x43B9, 0x1274, 0x22B4, 0x22D5, 0x2B37, 0x2B37, 0x4BF8, 0xA69E,   // 0x0A90 (2704)
+0xDFFF, 0xD79F, 0x8D98, 0x4B10, 0x6435, 0xB6DD, 0xD7FF, 0x8DFD, 0x3355, 0x2AF5, 0x4B99, 0x4B98, 0x63B7, 0x218C, 0x0004, 0x0003,   // 0x0AA0 (2720)
+0x0041, 0x0000, 0x328C, 0x963C, 0x759A, 0x6DBA, 0x5D5B, 0x447A, 0x3396, 0x3334, 0x4BD5, 0x8DBB, 0xDFBF, 0xDFFF, 0x9E7E, 0x4419,   // 0x0AB0 (2736)
+0x12B4, 0x2B77, 0x33B8, 0x33B8, 0x33B9, 0x3379, 0x2B37, 0x4C5A, 0x6D5C, 0x33B6, 0x2315, 0x2B16, 0x3357, 0x3B78, 0x3357, 0x3334,   // 0x0AC0 (2752)
+0x64B8, 0xC79F, 0xDFFF, 0xA65C, 0x7CD9, 0x8D78, 0xAE3B, 0xE79E, 0xE7FF, 0x9E3D, 0x4BF9, 0x2B57, 0x2359, 0x2BBB, 0x341C, 0x2C1C,   // 0x0AD0 (2768)
+0x2BFC, 0x2BFC, 0x2BDC, 0x23BB, 0x2BBB, 0x2B9A, 0x2B99, 0x6D5E, 0x4C5B, 0x2B38, 0x3399, 0x2338, 0x2B78, 0x2B78, 0x3398, 0x5459,   // 0x0AE0 (2784)
+0xAEBE, 0xE7FF, 0xDFDF, 0xB6DD, 0xC77E, 0xDFFF, 0xB73F, 0x64FC, 0x3397, 0x2B58, 0x3B99, 0x4BB8, 0x63F8, 0x29CE, 0x0005, 0x0024,   // 0x0AF0 (2800)
+0x0040, 0x0000, 0x5B8D, 0xFFFF, 0xE7FF, 0xDFFF, 0xC7FF, 0xAF7F, 0x9EDD, 0x969C, 0xBF5D, 0xDFFF, 0xC79F, 0x7D7B, 0x3BB6, 0x1AF5,   // 0x0B00 (2816)
+0x1B58, 0x2BFB, 0x2399, 0x1B79, 0x2BBA, 0x2379, 0x2338, 0x4C7C, 0x657D, 0x33B7, 0x2357, 0x2B98, 0x3BDA, 0x33BA, 0x2B37, 0x2315,   // 0x0B10 (2832)
+0x3396, 0x64FA, 0x9EDE, 0xC7FF, 0xE7FF, 0xF7FF, 0xD7FF, 0xBF1D, 0x74F8, 0x2B34, 0x2356, 0x2359, 0x239A, 0x2BFB, 0x23FC, 0x23DC,   // 0x0B20 (2848)
+0x1BBC, 0x1BDC, 0x23FD, 0x23DC, 0x23DC, 0x23BA, 0x239A, 0x653F, 0x445C, 0x2339, 0x33BA, 0x2B79, 0x237A, 0x2379, 0x1B37, 0x1AF4,   // 0x0B30 (2864)
+0x3375, 0x64D8, 0x963C, 0xA6BE, 0xAEBE, 0x85FB, 0x5479, 0x2B77, 0x2B99, 0x2B79, 0x3379, 0x4398, 0x5BD8, 0x21AE, 0x0005, 0x0025,   // 0x0B40 (2880)
+0x1060, 0x0000, 0x428A, 0xAEBB, 0x8DFA, 0x861B, 0x96BE, 0xA77F, 0xBFDF, 0xBFFF, 0xBF9F, 0x9E9F, 0x755D, 0x3BB8, 0x1AF6, 0x1B59,   // 0x0B50 (2896)
+0x2BFD, 0x23FD, 0x139C, 0x139B, 0x23DC, 0x2BDC, 0x237A, 0x447C, 0x5D7E, 0x2BD8, 0x1B78, 0x2399, 0x2BDB, 0x2BFC, 0x239A, 0x2378,   // 0x0B60 (2912)
+0x2376, 0x2396, 0x5D1D, 0x7E3F, 0x863D, 0x759C, 0x5CDC, 0x4C59, 0x3BD7, 0x2B96, 0x2399, 0x23DB, 0x23FD, 0x241D, 0x1BFD, 0x1BDD,   // 0x0B70 (2928)
+0x1BFD, 0x1C1D, 0x1C1D, 0x241D, 0x241D, 0x23DC, 0x23DB, 0x5D7F, 0x449C, 0x239A, 0x341C, 0x23BB, 0x23DB, 0x23DB, 0x23DA, 0x2BFA,   // 0x0B80 (2944)
+0x1B56, 0x2355, 0x4C59, 0x5CDA, 0x4C59, 0x33B7, 0x2357, 0x1B79, 0x23BA, 0x2BDB, 0x33DB, 0x43DA, 0x5C1A, 0x21CF, 0x0005, 0x0025,   // 0x0B90 (2960)
+0x1040, 0x0000, 0x1946, 0x4372, 0x2AF2, 0x12D3, 0x1B56, 0x343A, 0x4479, 0x3C18, 0x3BD8, 0x3397, 0x2316, 0x2B79, 0x239B, 0x139B,   // 0x0BA0 (2976)
+0x1BDE, 0x0B7D, 0x1BDF, 0x1C1F, 0x1BDE, 0x23DD, 0x1B7B, 0x3C9D, 0x5DBF, 0x345B, 0x23DA, 0x1BBA, 0x23BB, 0x23BC, 0x1BBC, 0x1BBA,   // 0x0BB0 (2992)
+0x1377, 0x0B35, 0x23B8, 0x1B99, 0x0AF7, 0x0AB7, 0x1317, 0x1B77, 0x2397, 0x1B97, 0x1BBA, 0x1BFC, 0x241D, 0x1BFD, 0x13FD, 0x1C1E,   // 0x0BC0 (3008)
+0x1C3F, 0x1C3E, 0x13FD, 0x13FD, 0x1C1D, 0x1BDC, 0x1BDB, 0x5D9F, 0x3CBD, 0x1B9B, 0x241C, 0x1BDB, 0x1BFC, 0x23FC, 0x23FB, 0x1BDB,   // 0x0BD0 (3024)
+0x1BBA, 0x23B8, 0x2397, 0x1315, 0x1315, 0x1B77, 0x1B99, 0x139A, 0x1BDC, 0x23DC, 0x2BBB, 0x3BDA, 0x4BF9, 0x19AE, 0x0005, 0x0024,   // 0x0BE0 (3040)
+0x0002, 0x0002, 0x216B, 0x53B7, 0x3B97, 0x1B37, 0x1318, 0x1379, 0x1B79, 0x1317, 0x2358, 0x2B99, 0x1B18, 0x239B, 0x23DC, 0x1BFE,   // 0x0BF0 (3056)
+0x13FE, 0x13FD, 0x1C5F, 0x1C5F, 0x13DE, 0x243E, 0x1BDC, 0x34BD, 0x55DF, 0x2C7C, 0x1C1B, 0x1BDC, 0x1BFD, 0x1C1D, 0x1C1D, 0x243C,   // 0x0C00 (3072)
+0x243B, 0x13B9, 0x13B9, 0x0B79, 0x0B59, 0x137A, 0x1BFC, 0x241B, 0x1BD9, 0x1378, 0x13BA, 0x1C1D, 0x1C3E, 0x141D, 0x143E, 0x1C7E,   // 0x0C10 (3088)
+0x1C9E, 0x145E, 0x141E, 0x143D, 0x1C3D, 0x1C1D, 0x1C1C, 0x5DDF, 0x3CFD, 0x1BDC, 0x243D, 0x1BFC, 0x1C1D, 0x1C3D, 0x1C1C, 0x0BBB,   // 0x0C20 (3104)
+0x13FC, 0x241C, 0x1BD9, 0x1358, 0x23DA, 0x2C1B, 0x1BFB, 0x0B7B, 0x243D, 0x243E, 0x2BFC, 0x3BFB, 0x541A, 0x21CF, 0x0005, 0x0025,   // 0x0C30 (3120)
+0x0005, 0x0004, 0x218E, 0x53FA, 0x3BBA, 0x2BBC, 0x1BBD, 0x1BBC, 0x139B, 0x23DB, 0x2BFB, 0x2BDA, 0x2BDB, 0x1BBB, 0x1C1C, 0x1C1D,   // 0x0C40 (3136)
+0x143D, 0x1C7F, 0x1C7E, 0x145E, 0x1C5E, 0x2C5E, 0x1BFC, 0x3CFE, 0x55DF, 0x245B, 0x13FB, 0x1C1D, 0x245E, 0x245F, 0x1C3E, 0x1C3D,   // 0x0C50 (3152)
+0x1C7D, 0x1C5C, 0x13FA, 0x141B, 0x1C1D, 0x13DC, 0x0BBC, 0x13FC, 0x1C3B, 0x1C3B, 0x1C3C, 0x1C5D, 0x1C3E, 0x141D, 0x13FD, 0x1C7E,   // 0x0C60 (3168)
+0x1C9F, 0x145E, 0x141D, 0x249E, 0x249E, 0x1BFC, 0x1BFC, 0x55DF, 0x3CFD, 0x1BFC, 0x2C7E, 0x243D, 0x245D, 0x1C3D, 0x141D, 0x1C7F,   // 0x0C70 (3184)
+0x13FD, 0x141C, 0x245D, 0x2C3C, 0x1BFC, 0x241C, 0x1C3D, 0x1C1E, 0x1C3E, 0x241D, 0x23FC, 0x3BFB, 0x545A, 0x220F, 0x0025, 0x0025,   // 0x0C80 (3200)
+0x0026, 0x0004, 0x19AE, 0x4C3A, 0x2BB9, 0x23DC, 0x13FD, 0x13DD, 0x0BBA, 0x1BDB, 0x1BDA, 0x241A, 0x2C5A, 0x243A, 0x1C5C, 0x1C5C,   // 0x0C90 (3216)
+0x143C, 0x1C7D, 0x145D, 0x145D, 0x1C7D, 0x243D, 0x13DC, 0x34DE, 0x55DF, 0x245B, 0x141B, 0x1C5D, 0x245F, 0x1C5E, 0x1C3E, 0x141C,   // 0x0CA0 (3232)
+0x143C, 0x1C5C, 0x145C, 0x147D, 0x1C7E, 0x143E, 0x141D, 0x143D, 0x1C5C, 0x1C5C, 0x1C5D, 0x1C5D, 0x1C5D, 0x143D, 0x143D, 0x147E,   // 0x0CB0 (3248)
+0x145F, 0x145E, 0x143E, 0x1C7E, 0x247E, 0x13FC, 0x1BFC, 0x4D9F, 0x3CDD, 0x1BFB, 0x245C, 0x245D, 0x1C5D, 0x1C3D, 0x143D, 0x1C7F,   // 0x0CC0 (3264)
+0x141D, 0x141C, 0x243D, 0x243D, 0x1BDC, 0x13FC, 0x1C3E, 0x247F, 0x143E, 0x1BFD, 0x23DB, 0x33D9, 0x5439, 0x19CD, 0x0004, 0x0003,   // 0x0CD0 (3280)
+0x0024, 0x0003, 0x21CD, 0x54BB, 0x345B, 0x245C, 0x1C7D, 0x1C9E, 0x1C7C, 0x1C5C, 0x245A, 0x245A, 0x2459, 0x245A, 0x1C7B, 0x1C9B,   // 0x0CE0 (3296)
+0x1C9C, 0x1C9C, 0x1C9C, 0x1C9B, 0x249C, 0x2C7D, 0x243C, 0x3D1E, 0x55FF, 0x247B, 0x1C5C, 0x247E, 0x247E, 0x247F, 0x249F, 0x1C7E,   // 0x0CF0 (3312)
+0x147C, 0x147C, 0x147C, 0x147D, 0x147E, 0x1C7E, 0x1C7E, 0x1C7E, 0x1C9D, 0x1C9D, 0x1C7D, 0x1C7D, 0x1C7E, 0x1C9E, 0x1C9E, 0x1C7E,   // 0x0D00 (3328)
+0x1C9E, 0x1C9E, 0x1C7E, 0x1C7D, 0x249D, 0x245C, 0x245C, 0x55DF, 0x453E, 0x243B, 0x247C, 0x247D, 0x247D, 0x249E, 0x1C9E, 0x1C9F,   // 0x0D10 (3344)
+0x1C9F, 0x1C9E, 0x1C7D, 0x247D, 0x247E, 0x247E, 0x1C7F, 0x1C7F, 0x1C7F, 0x2C9F, 0x347D, 0x3C5A, 0x64BA, 0x2A2E, 0x0003, 0x0003,   // 0x0D20 (3360)
+0x0043, 0x0002, 0x19ED, 0x4CBB, 0x2C5B, 0x1C5C, 0x149D, 0x149E, 0x149D, 0x147C, 0x1C7B, 0x1C7A, 0x1C7A, 0x1C7B, 0x1C7B, 0x1C9C,   // 0x0D30 (3376)
+0x1C9C, 0x1C9C, 0x1C9C, 0x249C, 0x247C, 0x2C7D, 0x241C, 0x3D1D, 0x55FF, 0x247A, 0x1C5B, 0x247D, 0x247E, 0x1C7E, 0x249F, 0x1C9E,   // 0x0D40 (3392)
+0x1C9C, 0x1C9C, 0x1C9D, 0x149D, 0x147E, 0x1C7E, 0x1C7E, 0x147D, 0x147D, 0x1C7C, 0x1C9D, 0x1C9D, 0x1C9D, 0x1C9D, 0x1C9D, 0x1C9E,   // 0x0D50 (3408)
+0x1C9E, 0x1C9D, 0x1C9E, 0x1C9D, 0x249D, 0x245C, 0x245B, 0x55DF, 0x3D1D, 0x1C1B, 0x247B, 0x249C, 0x247D, 0x1C7D, 0x1CBE, 0x1CBE,   // 0x0D60 (3424)
+0x14BF, 0x1CBE, 0x249E, 0x249E, 0x247E, 0x249E, 0x249E, 0x1C9F, 0x1C9F, 0x247E, 0x2C5B, 0x3C39, 0x5C99, 0x220D, 0x0002, 0x0002,   // 0x0D70 (3440)
+0x0063, 0x0002, 0x222D, 0x551B, 0x34BB, 0x24BD, 0x1CFE, 0x1CFF, 0x1CFE, 0x1CBE, 0x1CBD, 0x24DD, 0x24BD, 0x24BE, 0x24BE, 0x24BF,   // 0x0D80 (3456)
+0x24BF, 0x24DF, 0x24DF, 0x2CBF, 0x2CBE, 0x2CBE, 0x245B, 0x3D3D, 0x561F, 0x2CBB, 0x247B, 0x24BD, 0x24BE, 0x24BF, 0x24BF, 0x24DE,   // 0x0D90 (3472)
+0x24FD, 0x24FD, 0x1CFE, 0x1CDE, 0x1CDF, 0x1CBF, 0x1CBF, 0x1CBE, 0x1CDD, 0x24DD, 0x24DE, 0x24DE, 0x24DE, 0x24DE, 0x24DE, 0x24DF,   // 0x0DA0 (3488)
+0x24DF, 0x24DE, 0x24DE, 0x24DD, 0x2CBD, 0x2C9B, 0x247B, 0x5DFF, 0x455D, 0x245B, 0x2C9C, 0x2CBD, 0x24BD, 0x24BD, 0x1CDE, 0x1CFE,   // 0x0DB0 (3504)
+0x1CFE, 0x1CDE, 0x24BE, 0x24BE, 0x24BE, 0x24BE, 0x24BF, 0x24BF, 0x24DF, 0x24BE, 0x2C7B, 0x3C59, 0x5CB8, 0x222C, 0x0003, 0x0002,   // 0x0DC0 (3520)
+0x0043, 0x0002, 0x220D, 0x551B, 0x34BB, 0x24BD, 0x14FF, 0x1CFF, 0x14FF, 0x1CDF, 0x1CBE, 0x1C9D, 0x1C9D, 0x1C9E, 0x1C9E, 0x1CBE,   // 0x0DD0 (3536)
+0x1C9F, 0x1C9F, 0x1C9F, 0x1C9F, 0x249E, 0x2C9E, 0x245B, 0x3D5D, 0x563F, 0x24BA, 0x249B, 0x24BD, 0x24BE, 0x24BE, 0x24DF, 0x24DD,   // 0x0DE0 (3552)
+0x1CDC, 0x1CDC, 0x1CBD, 0x1CBE, 0x1CBE, 0x1C9E, 0x1C9E, 0x1CBE, 0x1CBD, 0x1CBD, 0x1CBD, 0x1CBD, 0x1CBD, 0x1CBE, 0x1CBD, 0x1CBE,   // 0x0DF0 (3568)
+0x1CBE, 0x1CBD, 0x1CBD, 0x24BD, 0x24BC, 0x247B, 0x247B, 0x55FF, 0x455D, 0x245B, 0x249C, 0x24BC, 0x24BD, 0x24DD, 0x1CDE, 0x1CDE,   // 0x0E00 (3584)
+0x14DE, 0x1CDD, 0x1CBD, 0x24BD, 0x24BE, 0x1CBE, 0x1CBE, 0x1CBF, 0x1CBE, 0x24DE, 0x34DC, 0x3C99, 0x5CF9, 0x224C, 0x0002, 0x0002,   // 0x0E10 (3600)
+0x0023, 0x0002, 0x220D, 0x54FB, 0x34BC, 0x24BE, 0x1CFF, 0x151F, 0x14FF, 0x14DF, 0x1CFF, 0x24FF, 0x24FF, 0x1CFF, 0x1CFF, 0x1CFF,   // 0x0E20 (3616)
+0x1CFF, 0x1CFF, 0x24FF, 0x24DF, 0x2CDF, 0x2CDE, 0x247B, 0x457D, 0x565F, 0x24DB, 0x24BB, 0x24DD, 0x2CDE, 0x24DF, 0x2CFF, 0x24FE,   // 0x0E30 (3632)
+0x1CFD, 0x24FD, 0x251E, 0x251F, 0x24FF, 0x251F, 0x24FF, 0x251F, 0x251E, 0x251E, 0x251E, 0x251E, 0x251F, 0x24FF, 0x251F, 0x251F,   // 0x0E40 (3648)
+0x251F, 0x251E, 0x24FE, 0x251E, 0x2CFD, 0x249C, 0x24BB, 0x5E3F, 0x457D, 0x247B, 0x24BD, 0x2CFD, 0x24FE, 0x24FE, 0x1D1E, 0x1D1E,   // 0x0E50 (3664)
+0x1D1E, 0x1CFD, 0x24FD, 0x24DE, 0x24DE, 0x24DE, 0x24FF, 0x1CFF, 0x1CFF, 0x24FE, 0x2CDC, 0x3CB9, 0x5CF8, 0x224C, 0x0022, 0x0002,   // 0x0E60 (3680)
+0x0023, 0x0002, 0x220D, 0x5D1B, 0x3CBB, 0x24DE, 0x1D1F, 0x1D3F, 0x1D1F, 0x151F, 0x1CFE, 0x1CFE, 0x1CFE, 0x1D1E, 0x151F, 0x151F,   // 0x0E70 (3696)
+0x151F, 0x151F, 0x1CFF, 0x1CFF, 0x24FE, 0x24DE, 0x1C7B, 0x3D7D, 0x565E, 0x24BA, 0x1C9B, 0x24DD, 0x24DE, 0x24DE, 0x24FE, 0x24FE,   // 0x0E80 (3712)
+0x1CFD, 0x1D1D, 0x1CFD, 0x1CFE, 0x1CFF, 0x1CFF, 0x1CFF, 0x1CFF, 0x1D1E, 0x1D1E, 0x1CFE, 0x1CFE, 0x1CFE, 0x1CFE, 0x1CFE, 0x1CFF,   // 0x0E90 (3728)
+0x1CFF, 0x1CFE, 0x1CFE, 0x24FE, 0x24DD, 0x249C, 0x249B, 0x561F, 0x3D7D, 0x1C9C, 0x24DD, 0x24FD, 0x1CFD, 0x1CFE, 0x1D1E, 0x151E,   // 0x0EA0 (3744)
+0x1D3D, 0x1D1D, 0x24FD, 0x24DD, 0x24DE, 0x1CFE, 0x1CFE, 0x1D1E, 0x1CFE, 0x1CFE, 0x2CDC, 0x34B9, 0x54F8, 0x224C, 0x0022, 0x0022,   // 0x0EB0 (3760)
+0x0043, 0x0002, 0x222D, 0x653B, 0x44DB, 0x351E, 0x255F, 0x259F, 0x1D5F, 0x1D7F, 0x255E, 0x257D, 0x257D, 0x1D7D, 0x1D7E, 0x1D7E,   // 0x0EC0 (3776)
+0x1D7F, 0x1D7E, 0x1D7E, 0x255D, 0x255D, 0x2D3E, 0x24DC, 0x45BE, 0x5E9F, 0x2D3B, 0x2D1D, 0x2D3E, 0x2D5F, 0x2D3F, 0x2D5F, 0x2D5F,   // 0x0ED0 (3792)
+0x2D5F, 0x255E, 0x255F, 0x255F, 0x253F, 0x253F, 0x253F, 0x253F, 0x253F, 0x253E, 0x253F, 0x253F, 0x253F, 0x253F, 0x253F, 0x255F,   // 0x0EE0 (3808)
+0x255F, 0x253F, 0x253F, 0x253F, 0x2D3E, 0x2D1D, 0x2CFD, 0x5E9F, 0x4DDF, 0x2CFD, 0x2D3E, 0x2D5F, 0x2D5F, 0x2D5F, 0x257F, 0x259F,   // 0x0EF0 (3824)
+0x257E, 0x257E, 0x2D5E, 0x2D5F, 0x2D3F, 0x255F, 0x255F, 0x257F, 0x257F, 0x255F, 0x2D1D, 0x3CDA, 0x5519, 0x226D, 0x0023, 0x0023,   // 0x0F00 (3840)
+0x0023, 0x0002, 0x21EB, 0x651A, 0x4CDB, 0x3D1D, 0x2D3F, 0x251E, 0x257F, 0x257E, 0x1D5D, 0x1D1C, 0x255D, 0x257D, 0x255C, 0x1D5C,   // 0x0F10 (3856)
+0x1D5C, 0x1D5C, 0x1D7D, 0x1D7D, 0x253D, 0x24FD, 0x1C9B, 0x3D9D, 0x567F, 0x24DB, 0x1CFC, 0x251D, 0x1CFE, 0x251F, 0x253F, 0x253F,   // 0x0F20 (3872)
+0x255F, 0x2D5F, 0x255F, 0x1D1E, 0x1CFF, 0x1D1F, 0x253F, 0x1D1F, 0x1D1E, 0x255E, 0x255F, 0x1D3F, 0x1D3F, 0x255F, 0x1D3F, 0x1D1F,   // 0x0F30 (3888)
+0x1D1F, 0x253E, 0x253E, 0x2D3E, 0x2D3D, 0x24DC, 0x24FC, 0x565F, 0x3D9D, 0x1CBC, 0x251D, 0x251D, 0x251E, 0x253F, 0x253E, 0x1D1D,   // 0x0F40 (3904)
+0x253E, 0x253E, 0x251E, 0x251E, 0x253F, 0x253F, 0x1CFF, 0x14DE, 0x251F, 0x355F, 0x3D3D, 0x3D1A, 0x5D7B, 0x2A6E, 0x0003, 0x0023,   // 0x0F50 (3920)
+0x0065, 0x0003, 0x2A0C, 0x6D5B, 0x5D3C, 0x4D5D, 0x353E, 0x2D1E, 0x2D9F, 0x2D9F, 0x255E, 0x2D3D, 0x359D, 0x359D, 0x357D, 0x357C,   // 0x0F60 (3936)
+0x2D7D, 0x2D7D, 0x259E, 0x2D9E, 0x2D7E, 0x353D, 0x2CFC, 0x4DFE, 0x5EBF, 0x24FB, 0x2D5E, 0x2D7E, 0x253E, 0x2D7F, 0x2D9F, 0x2D5F,   // 0x0F70 (3952)
+0x2D5F, 0x359F, 0x2D5F, 0x355F, 0x2D7F, 0x2D7F, 0x359F, 0x1D1E, 0x1D1E, 0x35DF, 0x2D7F, 0x255F, 0x2D5F, 0x2D9F, 0x253E, 0x253E,   // 0x0F80 (3968)
+0x2D7E, 0x359E, 0x2D5D, 0x355D, 0x2D5D, 0x2D1C, 0x2D3C, 0x569F, 0x3DBD, 0x24FC, 0x355E, 0x355D, 0x2D3E, 0x355E, 0x355E, 0x355F,   // 0x0F90 (3984)
+0x359F, 0x357F, 0x2D5F, 0x357F, 0x357F, 0x2D7F, 0x2D5F, 0x24FE, 0x357F, 0x457E, 0x453C, 0x44DA, 0x657B, 0x2A6E, 0x0003, 0x0043,   // 0x0FA0 (4000)
+0x0064, 0x0023, 0x222C, 0x6CF9, 0x5D1A, 0x3479, 0x2C9B, 0x3D5E, 0x2D3D, 0x1CFC, 0x24FC, 0x353C, 0x353C, 0x2CFA, 0x351B, 0x355C,   // 0x0FB0 (4016)
+0x355C, 0x251B, 0x1D1C, 0x1D3D, 0x2D3D, 0x2D1B, 0x34DA, 0x4D9C, 0x563F, 0x2CDB, 0x2D1B, 0x2D5C, 0x253C, 0x2D3C, 0x2D3C, 0x2D3D,   // 0x0FC0 (4032)
+0x351D, 0x351D, 0x249B, 0x351C, 0x3D5D, 0x351C, 0x3D5D, 0x2CDB, 0x24DB, 0x353D, 0x24FC, 0x353D, 0x353D, 0x2CFC, 0x2CFC, 0x353D,   // 0x0FD0 (4048)
+0x355D, 0x2D1B, 0x2CFA, 0x2D1B, 0x2D1B, 0x2CFA, 0x2CFA, 0x561F, 0x3D7C, 0x24BA, 0x353B, 0x2CFB, 0x2CFC, 0x351C, 0x353C, 0x3D5D,   // 0x0FE0 (4064)
+0x355D, 0x24DC, 0x1CBB, 0x2D3D, 0x1CDC, 0x2D1D, 0x3D9E, 0x351D, 0x2CDC, 0x3CFC, 0x4D1B, 0x4CD9, 0x6519, 0x222D, 0x0003, 0x0063,   // 0x0FF0 (4080)
+0x0022, 0x0002, 0x2A4B, 0x6D18, 0x6D5A, 0x551A, 0x4D5D, 0x55FF, 0x561F, 0x45BE, 0x3D7D, 0x45BD, 0x4DFD, 0x3D5B, 0x457B, 0x4DFE,   // 0x1000 (4096)
+0x4DDD, 0x3D9D, 0x359D, 0x35BE, 0x3DDE, 0x4DBD, 0x4D9C, 0x55FC, 0x5E5E, 0x4DBC, 0x459C, 0x45DC, 0x4DDD, 0x45BC, 0x45BD, 0x4DBC,   // 0x1010 (4112)
+0x4D7C, 0x4D9C, 0x5DDD, 0x453B, 0x44FA, 0x559C, 0x4D7C, 0x5DFD, 0x5DFD, 0x4D7C, 0x559C, 0x5DDD, 0x559E, 0x4D7C, 0x4D7C, 0x55BD,   // 0x1020 (4128)
+0x55DD, 0x4D9C, 0x457B, 0x4D9C, 0x4DBC, 0x4DBC, 0x4DBC, 0x669F, 0x55FD, 0x457C, 0x4DDD, 0x4DBC, 0x4DDD, 0x4DDD, 0x4DDD, 0x3D5C,   // 0x1030 (4144)
+0x4DBD, 0x459D, 0x3D5C, 0x45BD, 0x3D5C, 0x459D, 0x55DE, 0x4D7D, 0x55BE, 0x5D9C, 0x659C, 0x75BB, 0x6D59, 0x226D, 0x0024, 0x0064,   // 0x1040 (4160)
+0x0062, 0x0021, 0x2A2A, 0x7558, 0x7DDB, 0x8EBF, 0x767F, 0x5DDD, 0x663D, 0x5E1E, 0x5DFE, 0x665E, 0x7F1F, 0x663E, 0x661E, 0x667E,   // 0x1050 (4176)
+0x5E5E, 0x565F, 0x567F, 0x569F, 0x569F, 0x5E9F, 0x5E7F, 0x5EBF, 0x5EDF, 0x569F, 0x567F, 0x56BF, 0x5EBF, 0x567F, 0x5E7F, 0x5E7F,   // 0x1060 (4192)
+0x5E5F, 0x663E, 0x6E5E, 0x76BF, 0x769F, 0x6E5E, 0x5DFD, 0x6E7D, 0x6E5D, 0x5E1D, 0x767F, 0x65DD, 0x5DDD, 0x6E5F, 0x663F, 0x55FE,   // 0x1070 (4208)
+0x5E1E, 0x5E5F, 0x5E5F, 0x669F, 0x5E9F, 0x565F, 0x565F, 0x66FF, 0x567F, 0x4E1F, 0x565F, 0x565F, 0x567F, 0x565F, 0x5E5F, 0x665F,   // 0x1080 (4224)
+0x5DFD, 0x6E3E, 0x7EDF, 0x7EFF, 0x769F, 0x65FD, 0x65DD, 0x763E, 0x6DDC, 0x6DBB, 0x863D, 0x965D, 0x7518, 0x220B, 0x0023, 0x0043,   // 0x1090 (4240)
+0x0021, 0x0000, 0x1105, 0x4BB0, 0x7D98, 0x9EDE, 0x865D, 0x4D19, 0x3C77, 0x4519, 0x4D39, 0x5DBB, 0x86DE, 0x559B, 0x4539, 0x3D3A,   // 0x10A0 (4256)
+0x353B, 0x357D, 0x359E, 0x35BF, 0x2D9F, 0x35BE, 0x2D9E, 0x2D9D, 0x2D9D, 0x2DBE, 0x259D, 0x25DD, 0x2DDE, 0x257D, 0x2D7C, 0x357D,   // 0x10B0 (4272)
+0x355C, 0x3D3C, 0x3D3C, 0x76DE, 0x875F, 0x55BC, 0x4539, 0x34D8, 0x34D8, 0x3D19, 0x55BC, 0x3498, 0x3498, 0x5DBD, 0x4DBD, 0x351B,   // 0x10C0 (4288)
+0x2D1B, 0x357D, 0x2D7D, 0x35BE, 0x2D9E, 0x2D9E, 0x2D9E, 0x35DF, 0x259E, 0x255D, 0x2D9E, 0x2D9E, 0x2D9E, 0x2D9E, 0x355C, 0x4D9B,   // 0x10D0 (4304)
+0x44F8, 0x65DA, 0x8EFF, 0x7E7E, 0x7E7D, 0x5D38, 0x4475, 0x6539, 0x5CF7, 0x4C35, 0x5455, 0x74D6, 0x4350, 0x1107, 0x0002, 0x0022,   // 0x10E0 (4320)
+0x0041, 0x0020, 0x0062, 0x2249, 0x7D36, 0xB73E, 0xB79F, 0x8E7C, 0x5CF7, 0x75FB, 0x7E5D, 0x8EDD, 0xAFFF, 0x6E3C, 0x559B, 0x4D9B,   // 0x10F0 (4336)
+0x3D9C, 0x45FE, 0x463F, 0x361F, 0x35FF, 0x3E3F, 0x3E1F, 0x361E, 0x35FE, 0x361F, 0x363F, 0x363F, 0x361E, 0x35FE, 0x3DFE, 0x3DBD,   // 0x1100 (4352)
+0x3D9C, 0x4DBC, 0x76BF, 0x8F7F, 0x8F5F, 0x7EBF, 0x5D9A, 0x767D, 0x765C, 0x5559, 0x8EFE, 0x7E3C, 0x6DFC, 0x767F, 0x769F, 0x5E1E,   // 0x1110 (4368)
+0x4DBD, 0x45BD, 0x3DBE, 0x35BE, 0x35FF, 0x361F, 0x361F, 0x361F, 0x361F, 0x361F, 0x3E1F, 0x3E3F, 0x3E3F, 0x3E1F, 0x45BC, 0x4539,   // 0x1120 (4384)
+0x65DB, 0x975E, 0xAFFF, 0x8EBE, 0xAFBF, 0x969C, 0x6D38, 0x8DFA, 0xA6DD, 0x9E3B, 0x8D98, 0x7D16, 0x328B, 0x08E5, 0x0042, 0x0042,   // 0x1130 (4400)
+0x0040, 0x0020, 0x0000, 0x08C4, 0x5390, 0xBEFC, 0xE7FF, 0xBF9E, 0x7DDA, 0x8E7C, 0x9EFE, 0xA77F, 0xB7FF, 0x6DFA, 0x4D79, 0x4DBB,   // 0x1140 (4416)
+0x45DD, 0x461E, 0x3E3F, 0x363F, 0x35FF, 0x465F, 0x3E3E, 0x361E, 0x3E1E, 0x3E1E, 0x467F, 0x3E3E, 0x3DFD, 0x461D, 0x4E1D, 0x4DDC,   // 0x1150 (4432)
+0x4DBB, 0x5DDB, 0xA7BF, 0xA79F, 0x9F5F, 0xA77F, 0x6DDA, 0xA75E, 0x96FC, 0x5D16, 0xC7BF, 0xD7FF, 0xAF5E, 0x7E3C, 0x8EBE, 0x8F3F,   // 0x1160 (4448)
+0x6E7D, 0x4DBC, 0x563F, 0x4E5F, 0x3E1E, 0x35DE, 0x361F, 0x35FE, 0x35FE, 0x3E1F, 0x3E3F, 0x3E3E, 0x461E, 0x3DDD, 0x3D9B, 0x55BB,   // 0x1170 (4464)
+0x5578, 0x763B, 0x9F3E, 0x867D, 0x9EFE, 0xA6DD, 0xAF1E, 0xCFFF, 0xB6BC, 0xCF5E, 0xD75E, 0x84F5, 0x2166, 0x0001, 0x0021, 0x0001,   // 0x1180 (4480)
+0x0021, 0x0021, 0x0000, 0x0021, 0x1967, 0x84F5, 0xCF7F, 0xC79F, 0xAEBC, 0x9E9C, 0xA6FE, 0xAF7F, 0xAFBF, 0x6DFA, 0x4D7A, 0x4DDB,   // 0x1190 (4496)
+0x461D, 0x463E, 0x3E5F, 0x367F, 0x3E7F, 0x467F, 0x465F, 0x463E, 0x465E, 0x465E, 0x4E9F, 0x467E, 0x461D, 0x4E5E, 0x4E3D, 0x563D,   // 0x11A0 (4512)
+0x663D, 0x767D, 0xA77F, 0x9F5E, 0xA75E, 0xB7BF, 0x8E9B, 0xAF9F, 0xA73D, 0x7DF9, 0xBFBF, 0xD7FF, 0xAEFC, 0x75D9, 0x867B, 0x8EFE,   // 0x11B0 (4528)
+0x661C, 0x4579, 0x4DFD, 0x45FD, 0x461E, 0x465F, 0x467F, 0x3E3E, 0x3E5E, 0x467F, 0x4E7F, 0x4E7F, 0x4E7F, 0x4E3D, 0x4DFC, 0x55DB,   // 0x11C0 (4544)
+0x65FB, 0x7E5C, 0x7E5C, 0x6D99, 0xAF7E, 0xBFBE, 0xB6FD, 0xC75F, 0xCF5D, 0xBE7A, 0x84B4, 0x428B, 0x0861, 0x0000, 0x0041, 0x0862,   // 0x11D0 (4560)
+0x0000, 0x0821, 0x0822, 0x0000, 0x0000, 0x08C4, 0x536F, 0xA61A, 0xC73C, 0xB6FD, 0x963A, 0x7DD9, 0x7E3B, 0x765C, 0x661B, 0x561C,   // 0x11E0 (4576)
+0x4E3E, 0x4E5E, 0x465F, 0x3E9F, 0x469F, 0x467F, 0x465F, 0x4E7F, 0x4E7F, 0x4E7F, 0x467F, 0x4E7F, 0x4E7E, 0x4E5E, 0x563D, 0x55FC,   // 0x11F0 (4592)
+0x5DFC, 0x769E, 0x761D, 0x4CB6, 0x4496, 0x7E1B, 0x8E7C, 0x8E9C, 0x96DD, 0x9EFD, 0x967B, 0x8E3A, 0x9EDC, 0xB7DF, 0xB7FF, 0x8F1E,   // 0x1200 (4608)
+0x6E5C, 0x5E3C, 0x5E5D, 0x4E1D, 0x4E3E, 0x4E5F, 0x465F, 0x4E7F, 0x467E, 0x467E, 0x465E, 0x4E5E, 0x4E5E, 0x4E5E, 0x563D, 0x55FC,   // 0x1210 (4624)
+0x555A, 0x763B, 0x9F5D, 0x971D, 0x9EBD, 0x7537, 0x6473, 0x9E19, 0xCF1C, 0x8472, 0x1945, 0x0062, 0x0000, 0x0000, 0x0000, 0x0021,   // 0x1220 (4640)
+0x0801, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x08A4, 0x21A8, 0x42ED, 0x5C11, 0x5C53, 0x5C94, 0x6557, 0x6DB9, 0x6E1B, 0x665C,   // 0x1230 (4656)
+0x5EBE, 0x569E, 0x4E5E, 0x463D, 0x463E, 0x4E5F, 0x4E5F, 0x4E5F, 0x4E5F, 0x4E7F, 0x4E7F, 0x4E7F, 0x4E7F, 0x565E, 0x565E, 0x55FD,   // 0x1240 (4672)
+0x559B, 0x555A, 0x4D19, 0x5518, 0x54F7, 0x4495, 0x54B6, 0x54D6, 0x4494, 0x4453, 0x54B4, 0x5CD4, 0x75B8, 0x96DD, 0x96FE, 0x765C,   // 0x1250 (4688)
+0x559A, 0x559A, 0x5E5D, 0x66BF, 0x5E9F, 0x4E5E, 0x4E7F, 0x4E5F, 0x4E5E, 0x4E5E, 0x4E7E, 0x565E, 0x4E5E, 0x565E, 0x5E3D, 0x5DFC,   // 0x1260 (4704)
+0x6DFC, 0x4CF8, 0x3414, 0x5CB6, 0x4C13, 0x6CF6, 0x8536, 0x3AAD, 0x1946, 0x0083, 0x0021, 0x0000, 0x0000, 0x0800, 0x0000, 0x0000,   // 0x1270 (4720)
+0x0800, 0x0000, 0x0800, 0x0001, 0x0022, 0x0001, 0x0000, 0x0022, 0x1126, 0x2A2A, 0x5C11, 0x7D57, 0x7D98, 0x7DFA, 0x761A, 0x6E3B,   // 0x1280 (4736)
+0x6E7C, 0x6E9D, 0x669D, 0x66DE, 0x6EDF, 0x66BF, 0x669F, 0x66BF, 0x66BF, 0x66BF, 0x66BF, 0x66BF, 0x66BF, 0x669F, 0x6E9F, 0x76DF,   // 0x1290 (4752)
+0x7E9F, 0x6DFC, 0x6DBC, 0x96BE, 0x96DE, 0x6DBB, 0x865D, 0x8E7D, 0x863C, 0x7DFA, 0x7DDA, 0x7578, 0x6D77, 0x75B9, 0x761B, 0x6DDA,   // 0x12A0 (4768)
+0x65BB, 0x663C, 0x6E9E, 0x6EBF, 0x6EBF, 0x669F, 0x669F, 0x66BF, 0x66BF, 0x66BF, 0x669F, 0x669F, 0x6EBF, 0x6E9F, 0x6E7E, 0x767E,   // 0x12B0 (4784)
+0x869E, 0x7E1C, 0x6D99, 0x7DDA, 0x6D16, 0x6453, 0x42CD, 0x08C5, 0x0021, 0x0000, 0x0000, 0x0000, 0x0841, 0x0840, 0x0820, 0x0000,   // 0x12C0 (4800)
+0x0801, 0x0000, 0x0821, 0x0821, 0x0821, 0x0000, 0x0000, 0x0001, 0x0022, 0x0043, 0x0905, 0x19E9, 0x32ED, 0x43B0, 0x5C73, 0x64F5,   // 0x12D0 (4816)
+0x6D58, 0x6557, 0x5D16, 0x54F5, 0x54F6, 0x5CF7, 0x5CF8, 0x5CF8, 0x5518, 0x5518, 0x5518, 0x5538, 0x5518, 0x5D18, 0x5CF7, 0x6518,   // 0x12E0 (4832)
+0x6517, 0x5C75, 0x5C55, 0x74F7, 0x74F7, 0x5433, 0x64B5, 0x6CF6, 0x6CB4, 0x6CD5, 0x7D57, 0x74D5, 0x5C33, 0x5412, 0x5C53, 0x5C74,   // 0x12F0 (4848)
+0x5CB5, 0x64F6, 0x5CF6, 0x54B5, 0x54D6, 0x5D17, 0x5D17, 0x5517, 0x5517, 0x5D17, 0x5D17, 0x5D17, 0x5CF7, 0x5CF7, 0x64F7, 0x64F7,   // 0x1300 (4864)
+0x64D6, 0x5C75, 0x4BD2, 0x32CE, 0x1A2B, 0x08C5, 0x0000, 0x0001, 0x0883, 0x0863, 0x0001, 0x0021, 0x0821, 0x0000, 0x0000, 0x0000,   // 0x1310 (4880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0021, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0042, 0x0043, 0x0002, 0x0001,   // 0x1320 (4896)
+0x0001, 0x0001, 0x0001, 0x0021, 0x0021, 0x0001, 0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,   // 0x1330 (4912)
+0x0022, 0x0022, 0x0001, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000,   // 0x1340 (4928)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,   // 0x1350 (4944)
+0x0042, 0x0022, 0x0022, 0x0043, 0x0042, 0x0042, 0x0022, 0x0001, 0x0002, 0x0822, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1360 (4960)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0040, 0x0840, 0x0820, 0x0020, 0x0021, 0x0042, 0x0022, 0x0001, 0x0042, 0x0042, 0x0002, 0x0021,   // 0x1370 (4976)
+0x0021, 0x0021, 0x0021, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0000, 0x0000,   // 0x1380 (4992)
+0x0001, 0x0041, 0x0041, 0x0000, 0x0020, 0x0861, 0x0021, 0x0020, 0x0020, 0x0020, 0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0001,   // 0x1390 (5008)
+0x0000, 0x0000, 0x0000, 0x0021, 0x0021, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0021,   // 0x13A0 (5024)
+0x0021, 0x0021, 0x0021, 0x0001, 0x0001, 0x0041, 0x0041, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0841, 0x0821, 0x0000,   // 0x13B0 (5040)
+0x0060, 0x0040, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0021, 0x0001, 0x0001, 0x0000,   // 0x13C0 (5056)
+0x0820, 0x0820, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000,   // 0x13D0 (5072)
+0x0021, 0x0841, 0x0862, 0x0001, 0x0001, 0x0841, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0023, 0x0002, 0x0002, 0x0001, 0x0001,   // 0x13E0 (5088)
+0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x13F0 (5104)
+0x0000, 0x0041, 0x0861, 0x0020, 0x0841, 0x0020, 0x0000, 0x0821, 0x0801, 0x0821, 0x0821, 0x0000, 0x0821, 0x0841, 0x0841, 0x0000,   // 0x1400 (5120)
+0x0020, 0x0020, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1410 (5136)
+0x0800, 0x0800, 0x0820, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1420 (5152)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0822,   // 0x1430 (5168)
+0x0821, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0800, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0820,   // 0x1440 (5184)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0800, 0x0821, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1450 (5200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1460 (5216)
+0x0000, 0x0000, 0x0840, 0x0841, 0x0000, 0x0000, 0x0820, 0x0840, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x0020, 0x0000,   // 0x1470 (5232)
+0x0000, 0x0021, 0x0000, 0x0020, 0x0021, 0x0021, 0x0000, 0x18E4, 0x3186, 0x2104, 0x0841, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000,   // 0x1480 (5248)
+0x0000, 0x0020, 0x0000, 0x2104, 0x31A6, 0x2124, 0x0000, 0x0000, 0x0841, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x1490 (5264)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0820, 0x0820, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14A0 (5280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0020, 0x2104, 0x2945, 0x18E3,   // 0x14B0 (5296)
+0x0841, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0841, 0x0000, 0x10A2, 0x0020, 0x0000,   // 0x14C0 (5312)
+0x0000, 0x0000, 0x0841, 0x0000, 0x0020, 0x10A2, 0x0000, 0xA514, 0xFFFF, 0xE71C, 0x1082, 0x0000, 0x0000, 0x0000, 0x0840, 0x0020,   // 0x14D0 (5328)
+0x0000, 0x0000, 0x0861, 0xCE79, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0x0020, 0x0000, 0x0020, 0x0841, 0x1082, 0x0861, 0x0000, 0x0000,   // 0x14E0 (5344)
+0x0000, 0x0841, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14F0 (5360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0xD69A, 0xFFFF, 0xBDD7,   // 0x1500 (5376)
+0x0020, 0x0000, 0x0861, 0x0861, 0x0000, 0x0000, 0x0000, 0x0841, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1510 (5392)
+0x0020, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xA514, 0xFFFF, 0xE71C, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1520 (5408)
+0x0000, 0x0000, 0x0020, 0xC638, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0x0000, 0x0020, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1530 (5424)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0841, 0x0882, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1540 (5440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x39C7, 0xD6BA, 0xFFFF, 0xBDD7,   // 0x1550 (5456)
+0x1082, 0x0000, 0x0000, 0x0000, 0x0020, 0x2965, 0x2945, 0x2104, 0x18C3, 0x0020, 0x0000, 0x0861, 0x2945, 0x2945, 0x2124, 0x2104,   // 0x1560 (5472)
+0x10A2, 0x0000, 0x0000, 0x0020, 0x10A2, 0x2104, 0x1082, 0xAD55, 0xFFFF, 0xDEFB, 0x10A2, 0x0000, 0x1082, 0x2104, 0x2104, 0x2945,   // 0x1570 (5488)
+0x10A2, 0x0000, 0x0861, 0xCE59, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0x1082, 0x2104, 0x2104, 0x2104, 0x10A2, 0x0020, 0x0020, 0x2124,   // 0x1580 (5504)
+0x2104, 0x2104, 0x2104, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1590 (5520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4208, 0xFFFF, 0xE73C, 0xEF7D, 0xFFFF,   // 0x15A0 (5536)
+0xF79E, 0x2104, 0x0000, 0x0000, 0x2124, 0xD69A, 0xFFDF, 0xFFFF, 0xDEFB, 0x2124, 0x0000, 0x7BEF, 0xFFFF, 0xFFFF, 0xF79E, 0xFFFF,   // 0x15B0 (5552)
+0xC638, 0x10A2, 0x0020, 0x0000, 0x632C, 0xFFFF, 0xF7BE, 0xFFDF, 0xFFFF, 0xD6BA, 0x18C3, 0x0000, 0x8410, 0xFFFF, 0xF79E, 0xFFFF,   // 0x15C0 (5568)
+0x94B2, 0x0000, 0x0000, 0xC618, 0xFFFF, 0xBDD7, 0x0000, 0x0000, 0xAD55, 0xFFFF, 0xEF5D, 0xFFFF, 0x6B6D, 0x0000, 0x2965, 0xF79E,   // 0x15D0 (5584)
+0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0x632C, 0x0000, 0x0000, 0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15E0 (5600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4A49, 0xEF7D, 0x18C3, 0x7BEF, 0xFFFF,   // 0x15F0 (5616)
+0xD6BA, 0x18E3, 0x0000, 0x0841, 0x0000, 0x0020, 0x0000, 0x6B6D, 0xFFFF, 0xFFFF, 0x2945, 0x5AEB, 0xFFFF, 0xFFFF, 0x18E3, 0x632C,   // 0x1600 (5632)
+0xFFFF, 0xF7BE, 0x18E3, 0x8410, 0xFFFF, 0xE73C, 0x0841, 0x8C51, 0xFFFF, 0xDEFB, 0x0020, 0xA514, 0xFFFF, 0xD69A, 0x18E3, 0xBDD7,   // 0x1610 (5648)
+0xFFFF, 0xC618, 0x0000, 0xC618, 0xFFFF, 0xAD55, 0x1082, 0xD6BA, 0xFFFF, 0xA514, 0x1082, 0xDEDB, 0xFFFF, 0x8C71, 0x0861, 0xEF7D,   // 0x1620 (5664)
+0xFFFF, 0x7BCF, 0x10A2, 0xFFDF, 0xFFFF, 0x8410, 0x0000, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1630 (5680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0xFFFF, 0x3186, 0x8C51, 0xFFFF,   // 0x1640 (5696)
+0xF79E, 0x4208, 0x0000, 0x0000, 0x31A6, 0xEF5D, 0xFFFF, 0xF79E, 0xFFFF, 0xFFFF, 0x2945, 0x5ACB, 0xFFFF, 0xFFFF, 0x18E3, 0x6B6D,   // 0x1650 (5712)
+0xFFFF, 0xE73C, 0x10A2, 0x7BCF, 0xFFFF, 0xEF5D, 0x0841, 0x9492, 0xFFFF, 0xDEFB, 0x1082, 0xA514, 0xFFFF, 0xFFFF, 0xFFDF, 0xD6BA,   // 0x1660 (5728)
+0xEF7D, 0xAD75, 0x0000, 0xC618, 0xFFFF, 0xAD75, 0x0000, 0xD6BA, 0xFFFF, 0xF79E, 0xF7BE, 0xEF5D, 0xFFFF, 0x7BEF, 0x0861, 0xE73C,   // 0x1670 (5744)
+0xFFFF, 0x8430, 0x2104, 0xF79E, 0xFFFF, 0x8C51, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1680 (5760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8430, 0xFFFF, 0xEF5D, 0xFFDF, 0xEF5D, 0xE73C,   // 0x1690 (5776)
+0xFFFF, 0xFFFF, 0x4A49, 0x4208, 0xFFFF, 0xFFFF, 0x31A6, 0x4A69, 0xFFFF, 0xFFFF, 0x2945, 0x5AEB, 0xFFFF, 0xFFDF, 0x2124, 0x6B6D,   // 0x16A0 (5792)
+0xFFFF, 0xF7BE, 0x10A2, 0x8410, 0xFFFF, 0xE71C, 0x0841, 0x9492, 0xFFFF, 0xD69A, 0x0020, 0xA534, 0xFFFF, 0xCE59, 0x0841, 0x0000,   // 0x16B0 (5808)
+0x0000, 0x0000, 0x0020, 0xC638, 0xFFFF, 0xAD75, 0x0020, 0xD69A, 0xFFFF, 0xAD75, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0xEF7D,   // 0x16C0 (5824)
+0xFFFF, 0x73AE, 0x10A2, 0xFFDF, 0xFFFF, 0x8410, 0x0000, 0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16D0 (5840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x9CD3, 0xDEFB, 0x0000, 0x0000, 0x0000, 0x4A69,   // 0x16E0 (5856)
+0xFFFF, 0xFFFF, 0x52AA, 0x39E7, 0xF7BE, 0xFFFF, 0x4228, 0x5ACB, 0xFFFF, 0xFFFF, 0x2945, 0x5AEB, 0xFFFF, 0xFFFF, 0x18E3, 0x6B6D,   // 0x16F0 (5872)
+0xFFFF, 0xF79E, 0x10A2, 0x738E, 0xFFFF, 0xEF7D, 0x2104, 0x94B2, 0xFFFF, 0xDEFB, 0x0020, 0x94B2, 0xFFFF, 0xDEDB, 0x2104, 0x0841,   // 0x1700 (5888)
+0x10A2, 0x0841, 0x0000, 0xC638, 0xFFFF, 0xB596, 0x10A2, 0xBDF7, 0xFFFF, 0xBDD7, 0x0861, 0x1082, 0x1082, 0x0000, 0x2124, 0xE73C,   // 0x1710 (5904)
+0xFFFF, 0x7BEF, 0x2124, 0xFFDF, 0xFFFF, 0x8430, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1720 (5920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x8C51, 0xCE59, 0x0841, 0x0000, 0x0000, 0x4228,   // 0x1730 (5936)
+0xEF7D, 0xFFFF, 0x5AEB, 0x0000, 0x18E3, 0xCE79, 0xFFFF, 0xFFDF, 0xF7BE, 0xFFDF, 0x2945, 0x5ACB, 0xFFFF, 0xE73C, 0x18E3, 0x6B6D,   // 0x1740 (5952)
+0xFFFF, 0xE73C, 0x2945, 0x0000, 0x4208, 0xF79E, 0xFFFF, 0xF7BE, 0xFFFF, 0xD6BA, 0x18E3, 0x0000, 0x630C, 0xFFFF, 0xF79E, 0xFFFF,   // 0x1750 (5968)
+0xFFFF, 0xAD75, 0x0861, 0xB5B6, 0xFFFF, 0xAD75, 0x0000, 0x0000, 0x9492, 0xFFFF, 0xEF7D, 0xFFDF, 0xFFFF, 0x8C71, 0x0861, 0xE71C,   // 0x1760 (5984)
+0xFFFF, 0x73AE, 0x1082, 0xEF5D, 0xFFFF, 0x7BCF, 0x0000, 0x0861, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1770 (6000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0861, 0x0841, 0x0000,   // 0x1780 (6016)
+0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000, 0x0000,   // 0x1790 (6032)
+0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17A0 (6048)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0000,   // 0x17B0 (6064)
+0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0861, 0x1082, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17C0 (6080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17D0 (6096)
+0x0000, 0x0000, 0x0861, 0x0861, 0x0000, 0x0020, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0020, 0x0020, 0x0000, 0x0841, 0x0020,   // 0x17E0 (6112)
+0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0841, 0x0861, 0x0000, 0x0020, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000,   // 0x17F0 (6128)
+0x0000, 0x0000, 0x0000, 0x0861, 0x0861, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0861, 0x0841, 0x0000, 0x0000, 0x0000,   // 0x1800 (6144)
+0x0020, 0x0020, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1810 (6160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0020, 0x0000, 0x0000, 0x0841,   // 0x1820 (6176)
+0x0861, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0020, 0x0000, 0x0841, 0x0000, 0x0841,   // 0x1830 (6192)
+0x0841, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0861, 0x0861, 0x0000, 0x0000, 0x0841,   // 0x1840 (6208)
+0x0020, 0x0000, 0x0020, 0x0000, 0x0000, 0x0020, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0841,   // 0x1850 (6224)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0861, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1860 (6240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000,   // 0x1870 (6256)
+0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0000, 0x10A2, 0x1082, 0x0000, 0x0000, 0x0000, 0x0020, 0x0861, 0x0020, 0x0000, 0x0000,   // 0x1880 (6272)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0841, 0x0000, 0x0020, 0x1082, 0x1082, 0x0020, 0x0000, 0x0020, 0x0841, 0x0000,   // 0x1890 (6288)
+0x0000, 0x0020, 0x0841, 0x0841, 0x0020, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0841, 0x1082, 0x0020, 0x0000, 0x0020, 0x0020,   // 0x18A0 (6304)
+0x0000, 0x0020, 0x0861, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18B0 (6320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0861, 0x0841,   // 0x18C0 (6336)
+0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x0861, 0x0841, 0x0000, 0x1082, 0x0841,   // 0x18D0 (6352)
+0x0020, 0x10A2, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0000, 0x0000, 0x0000, 0x0841, 0x1082, 0x0841, 0x0000,   // 0x18E0 (6368)
+0x0000, 0x0000, 0x0841, 0x0000, 0x0000, 0x0020, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0841, 0x0841,   // 0x18F0 (6384)
+0x0000, 0x0020, 0x0841, 0x0000, 0x0000, 0x0841, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1900 (6400)
+};

_719/acloc.ino

@@ -0,0 +1,529 @@
+
+
+void drawDisplay()
+{
+  //t = rtc.getTime();
+//  t.hour=rtc_clock.get_hours();
+//  t.min=rtc_clock.get_minutes()
+// sec=t.sec;
+  t = rtc.getTime();
+min1= t.min;
+hour1=t.hour;
+  drawSec(t.sec);
+  oldsec=t.sec;
+if (t.sec==0)
+{
+  if(( t.hour>5)&&( t.hour<7)&&(t.min>29))
+{night=0;
+savefld();//запись новой даты в файлы полива цветов
+}
+else
+{night=1;
+}
+
+ drawMin(t.min);
+  drawHour(t.hour, t.min);
+    myGLCD.setColor(255, 255, 255);
+  myGLCD.setBackColor(0, 0, 0);
+   myGLCD.setFont( SevenSegNumFont);
+//   myGLCD.print(rtc_clock.get_hours(), clockCenterX+92+111+32, clockCenterY-8-20);
+  if (night==1) 
+{  myGLCD.setColor(192, 192, 255);
+
+}
+else
+{  myGLCD.setColor(255,255, 255);
+
+}  
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340, clockCenterY-8-20);
+    myGLCD.printNumI(t.hour, clockCenterX+340+32, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,clockCenterX+340, clockCenterY-8-20);
+  }
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340+96, clockCenterY-8-20);
+    myGLCD.printNumI(t.min, clockCenterX+340+128, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, clockCenterX+340+96, clockCenterY-8-20);
+  }
+  
+}
+if (q==1)
+{ drawMin(t.min);
+  drawHour(t.hour, t.min);
+  printDate();
+}
+if( (hour1==0) && (min1==0))
+{ 
+  printDate();
+}
+}
+//****************************************************************************
+void drawMark(int h)
+{
+  float x1, y1, x2, y2;
+  
+  h=h*30;
+  h=h+270;
+  
+  x1=2*110*cos(h*0.0175);
+  y1=2*110*sin(h*0.0175);
+  x2=2*100*cos(h*0.0175);
+  y2=2*100*sin(h*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+}
+
+void drawSec(int s)
+{
+  float x1, y1, x2, y2;
+  int ps = s-1;
+  
+  myGLCD.setColor(0, 0, 0);
+  if (ps==-1)
+    ps=59;
+  ps=ps*6;
+  ps=ps+270;
+  
+  x1=2*95*cos(ps*0.0175);
+  y1=2*95*sin(ps*0.0175);
+  x2=2*80*cos(ps*0.0175);
+  y2=2*80*sin(ps*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+
+  myGLCD.setColor(255,255,255);
+  s=s*6;
+  s=s+270;
+  
+  x1=2*95*cos(s*0.0175);
+  y1=2*95*sin(s*0.0175);
+  x2=2*80*cos(s*0.0175);
+  y2=2*80*sin(s*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+}
+
+void drawMin(int m)
+{
+  float x1, y1, x2, y2, x3, y3, x4, y4;
+  int pm = m-1;
+  
+  myGLCD.setColor(0, 0, 0);
+  if (pm==-1)
+    pm=59;
+  pm=pm*6;
+  pm=pm+270;
+  
+  x1=2*80*cos(pm*0.0175);
+  y1=2*80*sin(pm*0.0175);
+  x2=2*5*cos(pm*0.0175);
+  y2=2*5*sin(pm*0.0175);
+  x3=2*30*cos((pm+4)*0.0175);
+  y3=2*30*sin((pm+4)*0.0175);
+  x4=2*30*cos((pm-4)*0.0175);
+  y4=2*30*sin((pm-4)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+
+  myGLCD.setColor(0, 255, 0);
+  m=m*6;
+  m=m+270;
+  
+  x1=2*80*cos(m*0.0175);
+  y1=2*80*sin(m*0.0175);
+  x2=2*5*cos(m*0.0175);
+  y2=2*5*sin(m*0.0175);
+  x3=2*30*cos((m+4)*0.0175);
+  y3=2*30*sin((m+4)*0.0175);
+  x4=2*30*cos((m-4)*0.0175);
+  y4=2*30*sin((m-4)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+}
+
+void drawHour(int h, int m)
+{
+  float x1, y1, x2, y2, x3, y3, x4, y4;
+  int ph = h;
+  
+  myGLCD.setColor(0, 0, 0);
+  if (m==0)
+  {
+    ph=((ph-1)*30)+((m+59)/2);
+  }
+  else
+  {
+    ph=(ph*30)+((m-1)/2);
+  }
+  ph=ph+270;
+  
+  x1=2*60*cos(ph*0.0175);
+  y1=2*60*sin(ph*0.0175);
+  x2=2*5*cos(ph*0.0175);
+  y2=2*5*sin(ph*0.0175);
+  x3=2*20*cos((ph+5)*0.0175);
+  y3=2*20*sin((ph+5)*0.0175);
+  x4=2*20*cos((ph-5)*0.0175);
+  y4=2*20*sin((ph-5)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+
+  myGLCD.setColor(255, 255, 0);
+  h=(h*30)+(m/2);
+  h=h+270;
+  
+  x1=2*60*cos(h*0.0175);
+  y1=2*60*sin(h*0.0175);
+  x2=2*5*cos(h*0.0175);
+  y2=2*5*sin(h*0.0175);
+  x3=2*20*cos((h+5)*0.0175);
+  y3=2*20*sin((h+5)*0.0175);
+  x4=2*20*cos((h-5)*0.0175);
+  y4=2*20*sin((h-5)*0.0175);
+  
+  myGLCD.drawLine(x1+clockCenterX, y1+clockCenterY, x3+clockCenterX, y3+clockCenterY);
+  myGLCD.drawLine(x3+clockCenterX, y3+clockCenterY, x2+clockCenterX, y2+clockCenterY);
+  myGLCD.drawLine(x2+clockCenterX, y2+clockCenterY, x4+clockCenterX, y4+clockCenterY);
+  myGLCD.drawLine(x4+clockCenterX, y4+clockCenterY, x1+clockCenterX, y1+clockCenterY);
+}
+
+
+
+//**************************************************
+void printDate()
+{
+  myGLCD.setFont( Ubuntubold);
+ // Time t_temp;
+  
+  //t_temp = rtc.getTime();
+ 
+if (night==1) 
+{   myGLCD.setColor(142, 142, 200);//ночной календарь
+  myGLCD.setBackColor(0,38,92);
+}
+else
+{  myGLCD.setColor(0, 0, 255);
+  myGLCD.setBackColor(255, 255, 255);
+}  
+  dow= t.dow;
+
+   myGLCD.print(str[dow-1], 272+450-80, 24);
+//  myGLCD.print(rtc.getDOWStr(FORMAT_SHORT), 256+450, 8);
+  if (t.date<10)
+    myGLCD.printNumI(t.date, 272+450-50, 58);
+  else
+    myGLCD.printNumI(t.date, 264+450-50, 58);
+  myGLCD.printNumI(t.mon, 256+450-50, 92);
+  myGLCD.printNumI(t.year, 248+450-50, 126);
+   myGLCD.setFont(BigFont);
+}
+
+void clearDate()
+{
+  if (night==1) 
+{ myGLCD.setColor (0,38,92);
+ }
+else
+{  myGLCD.setColor(255, 255, 255);
+  }
+  
+  myGLCD.fillRect(240+450-80, 15, 319+450, 166);
+  // myGLCD.fillRoundRect(240+450-80, 0, 319+450, 85+80);
+}
+//*************************************************************************
+//******************************************************************
+void clok()
+
+{   //t = rtc.getTime();
+ int a=0;
+ q=1;
+  int x, y;
+do
+  {
+ t = rtc.getTime();
+ 
+if( night==1 )
+{constbr=20;
+        br=constbr+brightness;
+       analogWrite(12, br);    
+}
+else
+{constbr=200;
+        br=constbr+brightness;
+       analogWrite(12, br);
+  if (rawp==1)
+  {rawp=0;
+  myGLCD.fillScr(VGA_AQUA);//выход утром в RAW
+  byte bait;
+byte bait1;
+ int w; 
+ sd.chdir("/");
+  delay (100);
+
+   myFile.open("33.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 96000; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>399){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, 2*m, 400, 1, pic1, 2);
+ m=m+1;
+ }
+  } 
+  myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok  
+ kalend(); 
+  
+  
+  
+  
+  
+  
+  
+  raw();
+  }
+       
+}
+
+if (q==1)
+{
+  
+  // Clear screen
+  myGLCD.clrScr();
+  
+  // Draw Clockface
+  myGLCD.setColor(0, 0, 255);
+  myGLCD.setBackColor(0, 0, 0);
+  for (int i=0; i<5; i++)
+  {
+    myGLCD.drawCircle(clockCenterX, clockCenterY, 230-i);//119-i
+  }
+  for (int i=0; i<5; i++)
+  {
+    myGLCD.drawCircle(clockCenterX, clockCenterY, 2*i);
+  }
+  
+  myGLCD.setColor(192, 192, 255);
+   myGLCD.setFont( SevenSegNumFont);
+  myGLCD.print("3", clockCenterX+92+111-16, clockCenterY-8-20);
+  myGLCD.print("6", clockCenterX-32+12, clockCenterY+95+111-30);
+  myGLCD.print("9", clockCenterX-109-111, clockCenterY-8-20);
+  myGLCD.print("12", clockCenterX-32, clockCenterY-109-111);
+  for (int i=0; i<12; i++)
+  {
+    if ((i % 3)!=0)
+      drawMark(i);
+  }
+  // myGLCD.setFont(BigFont);
+   
+   // Draw calendar
+if (night==1) 
+{ myGLCD.setColor(0,38,92);
+
+}
+else
+{ myGLCD.setColor(255, 255, 255);
+
+}
+
+ // myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(240+450-80, 0, 319+450, 85+80);
+  
+if (night==1) 
+{ myGLCD.setColor(255, 255, 255);
+
+}
+else
+{  myGLCD.setColor(0, 0, 0);
+
+}  
+ // myGLCD.setColor(0, 0, 0); 
+ 
+  for (int i=0; i<14; i++)
+  {
+    myGLCD.drawLine(249+450-80+(i*10), 0, 248+450-80+(i*10), 7);
+    myGLCD.drawLine(250+450-80+(i*10), 0, 249+450-80+(i*10), 7);
+    myGLCD.drawLine(251+450-80+(i*10), 0, 250+450-80+(i*10), 7);
+  }
+myGLCD.setFont( BigFont);
+  // Draw SET button
+  myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(260+450, 200+200, 319+450, 239+200);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(260+450, 200+200, 319+450, 239+200);
+  myGLCD.setBackColor(64, 64, 128);
+  myGLCD.print("SET", 266+450, 212+200);
+  myGLCD.setBackColor(0, 0, 0);
+  // Draw exit button
+    myGLCD.setColor(64, 64, 128);
+  myGLCD.fillRoundRect(260+450, 200+150, 319+450, 239+150);
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(260+450, 200+150, 319+450, 239+150);
+  myGLCD.setBackColor(64, 64, 128);
+  myGLCD.print("EXT", 266+450, 212+150);
+  myGLCD.setBackColor(0, 0, 0);
+  
+  
+  if (night==1) 
+{  myGLCD.setColor(192, 192, 255);
+
+}
+else
+{  myGLCD.setColor(255,255, 255);
+
+}  
+  
+ 
+  myGLCD.setBackColor(0, 0, 0);
+  myGLCD.setFont( SevenSegNumFont);
+
+ t = rtc.getTime();
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340, clockCenterY-8-20);
+    myGLCD.printNumI(t.hour, clockCenterX+340+32, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,clockCenterX+340, clockCenterY-8-20);
+  }
+  myGLCD.print(":",clockCenterX+340+64, clockCenterY-8-20);
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,clockCenterX+340+96, clockCenterY-8-20);
+    myGLCD.printNumI(t.min, clockCenterX+340+128, clockCenterY-8-20);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, clockCenterX+340+96, clockCenterY-8-20);
+  }
+ 
+}  
+
+  if (t.date==0)
+  {
+    setClock();
+  }
+
+ drawDisplay();
+// printDate();
+q=0;
+
+    
+
+    if (myTouch.dataAvailable())
+    {
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      if (((y>=200+200) && (y<=239+200)) && ((x>=260+450) && (x<=319+450)))
+      {
+        myGLCD.setColor (255, 0, 0);
+        myGLCD.drawRoundRect(260+450, 200+200, 319+450, 239+200);
+        setClock();
+      }
+       if (((y>=200+150) && (y<=239+150)) && ((x>=260+450) && (x<=319+450)))
+      {
+        if (c==1)
+        {
+          menu();
+        }
+        myGLCD.setColor (255, 0, 0);
+        myGLCD.drawRoundRect(260+450, 200+150, 319+450, 239+150);
+        menu();
+      }
+      
+    }
+//**********TOUCH    
+    delay(10);
+     t = rtc.getTime();
+ // rawp=1 ; 
+ if (rawp==1)   
+{   if (t.sec==17)
+  {  prognoz();
+    q=1;
+    delay(5000);
+  } 
+   if (t.sec==37)
+  {  nightgraf();
+  q=1;
+  delay(5000);
+    } 
+   if ((sec==10) || (sec==29) )
+{
+ if(Serial.available()) {  
+ priem();
+}
+ 
+ }
+}
+ //**************************massiv******************
+//  t = rtc.getTime();
+ if (t.min==0)
+ {
+if ((t.sec==0)||(t.sec==1))
+  {
+  //  printmassiv();
+  if (fsec==1)
+  {uart();
+  bmp085();
+  uart();
+  savemastd();
+  
+  
+  fsec=0;  //delay (300); 
+  if(t.hour==23)
+  {sdwrite();
+   savemasclok();
+   saveminmax();//запись макс  мин и средних значений датчиков за день
+  } 
+  if((t.hour>=0)||(t.hour<23))
+  {
+   savemasclok();//запись времени на sd 12:56 15/05/14 и массива rab
+  } 
+  
+  }    
+  }
+}
+//*****************************************************
+ if (t.min>3)
+ {fsec=1;
+ }
+ //***************************************************************** 
+
+
+
+} while (a<1);
+}

_719/ad.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: +.jpg
+// Time generated: 12.04.2014 22:13:58
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short ad[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x211F, 0x211F, 0x213F, 0x191F, 0x193F, 0x191F, 0x213F, 0x211F,   // 0x0010 (16)
+0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211E, 0x191F, 0x211F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FE, 0x18FF, 0x18FF, 0x18FE, 0x18FF, 0x211F, 0x18DD, 0x20FF, 0x18DF, 0x20FF,   // 0x0030 (48)
+0x18DE, 0x18FF, 0x18FF, 0x20FF, 0x18FE, 0x18FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x18BF, 0x18BF, 0x189F, 0x18DF, 0x109F, 0x10DE, 0x10BF, 0x18DF, 0x10BF,   // 0x0050 (80)
+0x109E, 0x18DF, 0x10BF, 0x10DF, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x089F, 0x089F, 0x085F, 0x087F, 0x085E, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087E, 0x087F, 0x109F, 0x085E,   // 0x0070 (112)
+0x085F, 0x107F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x085F, 0x003F, 0x005F, 0x085F, 0x085F, 0x005F, 0x007E, 0x003F, 0x005F, 0x085F, 0x005F, 0x005F, 0x003F, 0x003F, 0x085F, 0x083F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E,   // 0x00A0 (160)
+0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005E, 0x001F, 0x083F, 0x001F, 0x003F, 0x001E, 0x003F, 0x001E, 0x003F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x081F, 0x081F, 0x081E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x081F,   // 0x00E0 (224)
+0xF7FF, 0xF7FF, 0xEFFF, 0x081E, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0013, 0x0017, 0x0019, 0x0019, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF,   // 0x0100 (256)
+0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0016, 0x0017,   // 0x0110 (272)
+0x0018, 0x001D, 0x001D, 0x001E, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001E, 0xFFDF, 0xFFFF, 0xFFFF, 0x001F,   // 0x0120 (288)
+0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0017, 0x0018, 0x001C,   // 0x0130 (304)
+0x001E, 0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001E,   // 0x0140 (320)
+0x001F, 0x003F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0015, 0x0019, 0x001B, 0x001D, 0x001D,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E, 0x001E, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001E, 0x005F, 0x001F, 0x081E,   // 0x0170 (368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0xF7FF, 0xF7FF, 0xF7FF, 0x213F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0016, 0x0019, 0x001A, 0x001D, 0x001F, 0x001D, 0xF7FF, 0xFFDF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFFD, 0xFFDF, 0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0018, 0x0018, 0x001C, 0x001F, 0x001E, 0x001F, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xF7FF, 0xFFFF, 0xF7FE, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001D, 0x001F, 0x081F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFE, 0xFFFF,   // 0x01D0 (464)
+0xFFFF, 0xF7FF, 0xFFFE, 0xFFFE, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xFFFE, 0xFFFF,   // 0x01F0 (496)
+0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x081F, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFE, 0x001F,   // 0x0210 (528)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x005F, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F,   // 0x0250 (592)
+0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001E, 0x001F, 0x003F, 0x001F, 0x001E, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x003E, 0xFFFF, 0xFFFE, 0xF7FF, 0x003E, 0x001F, 0x003E, 0x001E, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x001F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x081E, 0x081F, 0x081F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E,   // 0x0300 (768)
+0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B,   // 0x0340 (832)
+0x001B, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_719/bar.ino

@@ -0,0 +1,189 @@
+void bar(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+    myGLCD.setColor(0,0,255);
+    myGLCD.fillRoundRect(x-5, y-5, l+x+5, h+y+5);//рисуем синий пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+  myGLCD.fillRoundRect(x, y, pos*l/100+x, h+y);
+  myGLCD.setFont(BigFont);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,255);
+  myGLCD.print("BRIGHT", x-48+(l/2), y-25);
+  myGLCD.printNumI(abs(pos), x-10+(l/2), y+2);// уровень в процентах
+  
+  
+  
+  
+}
+
+
+void bright()
+{
+   int x=200;
+  int y=200;
+  int pos;
+  int h=20;//высота шкалы
+  int l=300;//длинна шкалы
+  
+
+//***************** 
+myGLCD.setColor(255, 255, 255);
+   myGLCD.drawBitmap (x+l-30, y-37, 30, 30, xf);
+    myGLCD.drawRoundRect (x+l-30, y-37, x+l-30+30, y-37+30);// Aandelend
+ //  myGLCD.setColor(255, 0, 0);
+ //    myGLCD.fillRoundRect ( x+l-30, y-37, x+l-30+30, y-37+30);
+ //    myGLCD.setColor(255, 255, 255);
+ //     myGLCD.setBackColor(255,0,0);
+ //    myGLCD.setFont(BigFont); 
+ //    myGLCD.drawRoundRect ( x+l-30, y-37, x+l-30+30, y-37+30); //X
+ //    myGLCD.print("X", x+l-30+8, y-37+7);
+//*********************************** 
+//***************** 
+ //  myGLCD.setColor(0, 0, 255);
+ //    myGLCD.fillRoundRect ( x+l-30, y+26, x+l-30+30, y+26+30);
+  //   myGLCD.setColor(255, 255, 255);
+    //  myGLCD.setBackColor(0,0,255);
+    // myGLCD.setFont(BigFont); 
+    myGLCD.drawBitmap (x+l-30, y+26, 30, 30, pr);
+     myGLCD.drawRoundRect ( x+l-30, y+26, x+l-30+30, y+26+30); //>>
+    // myGLCD.print(">", x+l-30+8, y+26+7);
+//*********************************** 
+//***************** 
+//   myGLCD.setColor(0, 0, 255);
+//     myGLCD.fillRoundRect (  x+l-60, y+26,  x+l-60+30, y+26+30);
+//     myGLCD.setColor(255, 255, 255);
+ //     myGLCD.setBackColor(0,0,255);
+   //  myGLCD.setFont(BigFont); 
+     myGLCD.drawBitmap (x+l-60, y+26, 30, 30, ad);
+     myGLCD.drawRoundRect (  x+l-60, y+26,  x+l-60+30, y+26+30); //+
+    // myGLCD.print("+", x+l-60+8, y+26+7);
+//*********************************** 
+     myGLCD.drawBitmap (x, y+26, 30, 30, le);
+     myGLCD.drawRoundRect (  x, y+26,  x+30, y+26+30); //<
+//***************** 
+ //  myGLCD.setColor(0, 0, 255);
+ //    myGLCD.fillRoundRect (  x+30, y+26,  x+30+30, y+26+30);
+ //    myGLCD.setColor(255, 255, 255);
+    //  myGLCD.setBackColor(0,0,255);
+    // myGLCD.setFont(BigFont);
+    myGLCD.drawBitmap (x+30, y+26, 30, 30, mi); 
+     myGLCD.drawRoundRect (  x+30, y+26,  x+30+30, y+26+30); //-
+    // myGLCD.print("-", x+30+8, y+26+7);
+//*********************************** 
+//***************** 
+//   myGLCD.setColor(0, 0, 255);
+ //    myGLCD.fillRoundRect (  x, y+26,  x+30, y+26+30);
+  //   myGLCD.setColor(255, 255, 255);
+   //   myGLCD.setBackColor(0,0,255);
+     //myGLCD.setFont(BigFont); 
+
+  //   myGLCD.print("<", x+8, y+26+7);
+//*********************************** 
+
+ pos=100*br/255;  
+bar(x,y, pos,l,h);
+
+  interval = 5000;
+  previousMillis =millis();
+while(1)
+{ 
+
+ 
+   currentMillis = millis();
+  
+ if(currentMillis - previousMillis >= interval) 
+ {
+    // save the last time you blinked the LED 
+    previousMillis = currentMillis;
+    interval = 10000;
+     previousMillis=0;
+    return;
+   
+ }
+  
+    if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+     int x1=myTouch.getX();
+      int y1=myTouch.getY();
+      
+      if ((y1>=y-37) && (y1<=y-37+30))  // Upper row
+      {
+        
+        if ((x1>= x+l-30) && (x1<= x+l-30+30))  // Aandelend
+           {waitForIt1( x+l-30, y-37, x+l-30+30, y-37+30);
+           interval = 10000;
+            previousMillis=0;
+             return;
+           }
+      }
+  
+   if ((y1>=y+26) && (y1<=y+26+30))  // Upper row
+      {
+        
+        if ((x1>= x+l-30) && (x1<= x+l-30+30))  //>
+      {brightness=brightness+25;
+       br=constbr+brightness;
+      if (br>255)
+      {br=255;
+     brightness=55;
+      }
+      waitForIt1( x+l-30, y+26, x+l-30+30, y+26+30);
+       pos=100*br/255 ; 
+        bar(x,y, pos,l,h);
+        analogWrite(12, br);
+        
+      }
+        if ((x1>= x+l-60) && (x1<= x+l-60+30))  // +
+          {brightness=brightness+1;
+          br=constbr+brightness;
+      if (br>255)
+      {br=255;
+     brightness=55;
+      }
+       waitForIt1(  x+l-60, y+26,  x+l-60+30, y+26+30);
+       pos=100*br/255 ; 
+        bar(x,y, pos,l,h);
+        analogWrite(12, br);
+        
+      }
+     
+      if ((x1>= x+30) && (x1<= x+30+30))  //- 
+       {brightness=brightness-1;
+        br=constbr+brightness;
+      if (br<1)
+      {br=1;
+      }
+       waitForIt1 (  x+30, y+26,  x+30+30, y+26+30);
+       pos=100*br/255;  
+       bar(x,y, pos,l,h);
+        analogWrite(12, br);
+      } 
+      
+       if ((x1>= x) && (x1<= x+30))  //<
+       {brightness=brightness-25;
+        br=constbr+brightness;
+      if (br<1)
+      {br=1;
+      }
+       waitForIt1 (  x, y+26,  x+30, y+26+30);
+       pos=100*br/255;  
+        bar(x,y, pos,l,h);
+        analogWrite(12, br);
+      } 
+      
+      
+      }        
+  
+  previousMillis = currentMillis; 
+    }  
+  
+ 
+}
+}

_719/bmp085.ino

@@ -0,0 +1,181 @@
+//----------------------------------------------------------------------------------------------------------
+void bmp085()
+{float temperature;
+temperature = bmp085GetTemperature(bmp085ReadUT());
+  pressure = bmp085GetPressure(bmp085ReadUP())*10.023/1333;
+ // pressureNN = pressure / pressureCorrection;
+  
+  
+ // Serial.print("Temperature: ");
+//  Serial.print(temperature,1);
+//  Serial.print(" C, Pressure: ");
+//  Serial.print(pressure,1);
+//  Serial.print(" hPa in 103m height above sea level, Pressure-NN: ");
+//  Serial.print(pressureNN,1);
+//  Serial.println(" hPa");
+  delay(500);
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Stores all of the bmp085's calibration values into global variables
+// Calibration values are required to calculate temp and pressure
+// This function should be called at the beginning of the program
+void bmp085Calibration()
+{
+  ac1 = bmp085ReadInt(0xAA);
+  ac2 = bmp085ReadInt(0xAC);
+  ac3 = bmp085ReadInt(0xAE);
+  ac4 = bmp085ReadInt(0xB0);
+  ac5 = bmp085ReadInt(0xB2);
+  ac6 = bmp085ReadInt(0xB4);
+  b1 = bmp085ReadInt(0xB6);
+  b2 = bmp085ReadInt(0xB8);
+  mb = bmp085ReadInt(0xBA);
+  mc = bmp085ReadInt(0xBC);
+  md = bmp085ReadInt(0xBE);
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Calculate temperature given ut.
+// Value returned will be in units of 0.1 deg C
+short bmp085GetTemperature(unsigned short ut)
+{
+  long x1, x2;
+  
+  x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
+  x2 = ((long)mc << 11)/(x1 + md);
+  b5 = x1 + x2;
+
+  return ((b5 + 8)>>4);  
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Calculate pressure given up
+// calibration values must be known
+// b5 is also required so bmp085GetTemperature(...) must be called first.
+// Value returned will be pressure in units of Pa.
+long bmp085GetPressure(unsigned long up)
+{
+  long x1, x2, x3, b3, b6, p;
+  unsigned long b4, b7;
+  
+  b6 = b5 - 4000;
+  // Calculate B3
+  x1 = (b2 * (b6 * b6)>>12)>>11;
+  x2 = (ac2 * b6)>>11;
+  x3 = x1 + x2;
+  b3 = (((((long)ac1)*4 + x3)<<OSS) + 2)>>2;
+  
+  // Calculate B4
+  x1 = (ac3 * b6)>>13;
+  x2 = (b1 * ((b6 * b6)>>12))>>16;
+  x3 = ((x1 + x2) + 2)>>2;
+  b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
+  
+  b7 = ((unsigned long)(up - b3) * (50000>>OSS));
+  if (b7 < 0x80000000)
+    p = (b7<<1)/b4;
+  else
+    p = (b7/b4)<<1;
+    
+  x1 = (p>>8) * (p>>8);
+  x1 = (x1 * 3038)>>16;
+  x2 = (-7357 * p)>>16;
+  p += (x1 + x2 + 3791)>>4;
+  
+  return p;
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read 1 byte from the BMP085 at 'address'
+char bmp085Read(unsigned char address)
+{
+  unsigned char data;
+  
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(address);
+  Wire.endTransmission();
+  
+  Wire.requestFrom(BMP085_ADDRESS, 1);
+  while(!Wire.available())
+    ;
+    
+  return Wire.read();
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read 2 bytes from the BMP085
+// First byte will be from 'address'
+// Second byte will be from 'address'+1
+short bmp085ReadInt(unsigned char address)
+{
+  unsigned char msb, lsb;
+  
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(address);
+  Wire.endTransmission();
+  
+  Wire.requestFrom(BMP085_ADDRESS, 2);
+  while(Wire.available()<2)
+    ;
+  msb = Wire.read();
+  lsb = Wire.read();
+  
+  return (short) msb<<8 | lsb;
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read the uncompensated temperature value
+unsigned short bmp085ReadUT()
+{
+  unsigned short ut;
+  
+  // Write 0x2E into Register 0xF4
+  // This requests a temperature reading
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(0xF4);
+  Wire.write(0x2E);
+  Wire.endTransmission();
+  
+  // Wait at least 4.5ms
+  delay(10);
+  
+  // Read two bytes from registers 0xF6 and 0xF7
+  ut = bmp085ReadInt(0xF6);
+  return ut;
+}
+
+//----------------------------------------------------------------------------------------------------------
+// Read the uncompensated pressure value
+unsigned long bmp085ReadUP()
+{
+  unsigned char msb, lsb, xlsb;
+  unsigned long up = 0;
+  
+  // Write 0x34+(OSS<<6) into register 0xF4
+  // Request a pressure reading w/ oversampling setting
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(0xF4);
+  Wire.write(0x34 + (OSS<<6));
+  Wire.endTransmission();
+  
+  // Wait for conversion, delay time dependent on OSS
+  delay(2 + (3<<OSS));
+  
+  // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB)
+  Wire.beginTransmission(BMP085_ADDRESS);
+  Wire.write(0xF6);
+  Wire.endTransmission();
+  Wire.requestFrom(BMP085_ADDRESS, 3);
+  
+  // Wait for data to become available
+  while(Wire.available() < 3) ;
+  msb = Wire.read();
+  lsb = Wire.read();
+  xlsb = Wire.read();
+  
+  up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS);
+  
+  return up;
+}
+//---------------------------------------------------------------------------------------------------------

_719/cl.c

@@ -0,0 +1,808 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: cl.jpg
+// Time generated: 30.03.2014 12:02:55
+// Dimensions    : 160x80 pixels
+// Size          : 25 600 Bytes
+
+const unsigned short cl[0x3200] ={
+0xD657, 0xDEB8, 0xE6D8, 0xE6D7, 0xE6D7, 0xDED7, 0xDEB7, 0xE6D7, 0xDED7, 0xE6D8, 0xE6F8, 0xE6D8, 0xE6D8, 0xDED7, 0xE6F8, 0xE6F8,   // 0x0010 (16)
+0xE718, 0xE718, 0xE718, 0xE718, 0xE718, 0xE718, 0xEF38, 0xEF38, 0xEF38, 0xEF38, 0xEF38, 0xEF38, 0xEF39, 0xEF59, 0xEF59, 0xEF59,   // 0x0020 (32)
+0xEF59, 0xEF59, 0xEF59, 0xF77A, 0xCE76, 0x41E6, 0x2143, 0x2123, 0x2123, 0x2123, 0x2122, 0x2123, 0x2143, 0x2123, 0x2143, 0x2943,   // 0x0030 (48)
+0x2943, 0x2964, 0x3164, 0x3184, 0x3184, 0x3184, 0x39C5, 0x39C5, 0x39C5, 0x39C5, 0x41E6, 0x41E6, 0x4206, 0x41E6, 0x4A27, 0x4A26,   // 0x0040 (64)
+0x4A26, 0x4226, 0x4A26, 0x4A27, 0x4A27, 0x4A47, 0x4A46, 0x4A47, 0x4A27, 0x4A47, 0x5267, 0x5247, 0x5268, 0x5268, 0x5247, 0x5247,   // 0x0050 (80)
+0x4A27, 0x5227, 0x5248, 0x5248, 0x5268, 0x5268, 0x5248, 0x5228, 0x4A48, 0x5248, 0x4A48, 0x4A28, 0x4A27, 0x5227, 0x4A27, 0x4A27,   // 0x0060 (96)
+0x4A27, 0x5247, 0x5267, 0x5247, 0x5267, 0x5268, 0x5247, 0x4A47, 0x5247, 0x5248, 0x5268, 0x5268, 0x5248, 0x5268, 0x5268, 0x5268,   // 0x0070 (112)
+0x4A27, 0x4207, 0x4207, 0x4207, 0x41E6, 0x41C6, 0x39C6, 0x39C6, 0x39C6, 0x39A6, 0x39A6, 0x39A6, 0x3985, 0x3185, 0x3185, 0x3185,   // 0x0080 (128)
+0x3985, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3985, 0x39A6, 0x31A5, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185,   // 0x0090 (144)
+0x3985, 0x3185, 0x3185, 0x3985, 0x3185, 0x39A6, 0x31A5, 0x3185, 0x3185, 0x3185, 0x3185, 0x3185, 0x3165, 0x3145, 0x2924, 0x2943,   // 0x00A0 (160)
+0xD6D8, 0xE6F9, 0xE719, 0xE719, 0xE719, 0xE719, 0xE739, 0xE739, 0xE739, 0xE739, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A,   // 0x00B0 (176)
+0xEF5A, 0xEF5A, 0xEF5A, 0xEF5A, 0xEF5B, 0xEF5B, 0xEF5B, 0xEF5B, 0xEF7B, 0xEF7B, 0xEF7B, 0xEF7A, 0xEF7B, 0xF79B, 0xF79B, 0xF79A,   // 0x00C0 (192)
+0xEF7A, 0xF77A, 0xF79A, 0xFFDB, 0xDEF7, 0x39E6, 0x2964, 0x2944, 0x2963, 0x2943, 0x2943, 0x2944, 0x2964, 0x2964, 0x2964, 0x2983,   // 0x00D0 (208)
+0x3163, 0x3184, 0x2963, 0x3184, 0x2984, 0x3184, 0x39A4, 0x39A5, 0x31A5, 0x31A5, 0x39A5, 0x39C4, 0x41E5, 0x4205, 0x41E5, 0x4205,   // 0x00E0 (224)
+0x4206, 0x4206, 0x4206, 0x4206, 0x4226, 0x4226, 0x4226, 0x4A47, 0x4A26, 0x4A26, 0x4A46, 0x4A46, 0x5267, 0x4A67, 0x4A47, 0x4A66,   // 0x00F0 (240)
+0x4A46, 0x4A46, 0x4A46, 0x4A26, 0x4A46, 0x4A67, 0x4A67, 0x4A46, 0x4A66, 0x4A66, 0x4A66, 0x4A66, 0x4A66, 0x4A67, 0x5287, 0x4A67,   // 0x0100 (256)
+0x5AA7, 0x5AC8, 0x5AC8, 0x5AE8, 0x62E8, 0x6309, 0x5AE8, 0x5AE8, 0x62E8, 0x6308, 0x62E8, 0x6308, 0x62E8, 0x6308, 0x6309, 0x6309,   // 0x0110 (272)
+0x5AC7, 0x5AC7, 0x5AA7, 0x5AC8, 0x5AC8, 0x5AC7, 0x5AC8, 0x5AC8, 0x62E8, 0x5AC7, 0x62E8, 0x5AE8, 0x5AC7, 0x5AC8, 0x5AC8, 0x5AC8,   // 0x0120 (288)
+0x5AC8, 0x5AC8, 0x5AE8, 0x5AC8, 0x62C8, 0x62C8, 0x5AC8, 0x62C8, 0x5AC7, 0x5AC7, 0x5AC7, 0x5AA7, 0x5AA7, 0x5AA7, 0x5AA7, 0x5AC7,   // 0x0130 (304)
+0x5AC8, 0x5AC8, 0x5AC7, 0x5AC8, 0x5AC7, 0x5AC7, 0x5AA7, 0x5AA7, 0x5AC7, 0x5AA7, 0x5AC7, 0x5AA7, 0x5AA7, 0x5A87, 0x39C4, 0x2943,   // 0x0140 (320)
+0xEF9D, 0xEF9E, 0xEF9E, 0xEF9E, 0xEF9E, 0xEF7F, 0xEF9F, 0xEF9F, 0xEF9E, 0xEF9E, 0xF79F, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF,   // 0x0150 (336)
+0xF7DF, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DE,   // 0x0160 (352)
+0xF7BE, 0xF79E, 0xF79E, 0xF7BE, 0xDF1B, 0x3A08, 0x2125, 0x2124, 0x2124, 0x2124, 0x2124, 0x2105, 0x2104, 0x2124, 0x2124, 0x2124,   // 0x0170 (368)
+0x2124, 0x2125, 0x2125, 0x2125, 0x2125, 0x2125, 0x2125, 0x2925, 0x2124, 0x2944, 0x2144, 0x2145, 0x2925, 0x2125, 0x2124, 0x2124,   // 0x0180 (384)
+0x2145, 0x2145, 0x2125, 0x2945, 0x2945, 0x2945, 0x2945, 0x2966, 0x2966, 0x2946, 0x2946, 0x2966, 0x2945, 0x2946, 0x2965, 0x2965,   // 0x0190 (400)
+0x2966, 0x2945, 0x2945, 0x2946, 0x2945, 0x2945, 0x2125, 0x2125, 0x2105, 0x2104, 0x2105, 0x2104, 0x2104, 0x2104, 0x2104, 0x2104,   // 0x01A0 (416)
+0x2103, 0x18E3, 0x2103, 0x18E3, 0x18E3, 0x18E3, 0x18E3, 0x18E3, 0x1903, 0x18E3, 0x18E3, 0x20E3, 0x18E3, 0x2103, 0x2103, 0x20E3,   // 0x01B0 (432)
+0x1903, 0x1903, 0x2103, 0x2103, 0x1903, 0x2103, 0x2103, 0x20E3, 0x2103, 0x2103, 0x2103, 0x2104, 0x2104, 0x18E3, 0x2103, 0x18E3,   // 0x01C0 (448)
+0x2104, 0x1903, 0x2103, 0x2103, 0x2104, 0x20E4, 0x20E4, 0x20E4, 0x2103, 0x2103, 0x2103, 0x2103, 0x18E3, 0x2103, 0x2103, 0x1903,   // 0x01D0 (464)
+0x18E3, 0x18E3, 0x18E3, 0x2103, 0x2103, 0x2103, 0x2103, 0x2103, 0x20E3, 0x2103, 0x2103, 0x2103, 0x18E3, 0x18E3, 0x18E3, 0x2103,   // 0x01E0 (480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01F0 (496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0200 (512)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF9D, 0x4A8A, 0x29A7, 0x31A7, 0x2987, 0x2966, 0x2986, 0x2966, 0x2986, 0x29A6, 0x29A6, 0x29A6,   // 0x0210 (528)
+0x29A7, 0x31A7, 0x31A7, 0x31A7, 0x39C8, 0x31C7, 0x31C8, 0x31E8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39C8, 0x31C8,   // 0x0220 (544)
+0x39C8, 0x39E8, 0x39E9, 0x4209, 0x4209, 0x4229, 0x3A29, 0x424A, 0x424A, 0x424A, 0x424A, 0x424A, 0x424A, 0x4229, 0x3A09, 0x3A09,   // 0x0230 (560)
+0x3A09, 0x3A09, 0x422A, 0x424A, 0x4229, 0x39E8, 0x39E8, 0x39C7, 0x31C7, 0x31C7, 0x31A7, 0x2986, 0x31A7, 0x31A7, 0x3187, 0x2986,   // 0x0240 (576)
+0x2986, 0x31A7, 0x31A7, 0x31A7, 0x3186, 0x3187, 0x3187, 0x3187, 0x2986, 0x2986, 0x3186, 0x3186, 0x2986, 0x2986, 0x3186, 0x3186,   // 0x0250 (592)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2966, 0x2986, 0x2986, 0x2966, 0x2966, 0x2966, 0x3186, 0x2986, 0x2965, 0x2986,   // 0x0260 (608)
+0x3186, 0x2966, 0x2965, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2965, 0x2944, 0x2165, 0x2145, 0x2945, 0x2945, 0x2944,   // 0x0270 (624)
+0x2145, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2144, 0x2144, 0x2144, 0x2945, 0x2944, 0x2124, 0x2144, 0x2144, 0x2124, 0x2104,   // 0x0280 (640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0290 (656)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x02A0 (672)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0x6B6F, 0x4A6A, 0x422A, 0x424A, 0x424A, 0x426A, 0x426A, 0x428A, 0x428B, 0x4AAC, 0x4A8B,   // 0x02B0 (688)
+0x4AAC, 0x52CC, 0x52CD, 0x5B0D, 0x5B0D, 0x5B0D, 0x5B4E, 0x636F, 0x638F, 0x6370, 0x6B90, 0x6B90, 0x6B90, 0x73B1, 0x73B1, 0x7BF2,   // 0x02C0 (704)
+0x83F3, 0x83F3, 0x8413, 0x8434, 0x8454, 0x8C75, 0x8C95, 0x8CB5, 0x9CF7, 0x9D18, 0x9D17, 0x9D17, 0x9D17, 0x94D6, 0x94B6, 0x94D6,   // 0x02D0 (720)
+0x94B6, 0x94D6, 0x94B6, 0x8C75, 0x8413, 0x73D2, 0x6B91, 0x6B71, 0x6B70, 0x6350, 0x634F, 0x634F, 0x632F, 0x5B0E, 0x5B0E, 0x5AED,   // 0x02E0 (736)
+0x52CD, 0x52CD, 0x5AED, 0x52ED, 0x52CC, 0x4AAC, 0x4A8B, 0x4A8B, 0x426B, 0x424A, 0x424A, 0x424A, 0x422A, 0x3A29, 0x3A29, 0x4229,   // 0x02F0 (752)
+0x4229, 0x4229, 0x4209, 0x3A09, 0x3A08, 0x3A08, 0x3A09, 0x4209, 0x3A08, 0x3A08, 0x39E8, 0x3A08, 0x3A08, 0x4269, 0x3A29, 0x3208,   // 0x0300 (768)
+0x3A08, 0x3A28, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x31E7, 0x31E8, 0x31E7, 0x31C7, 0x31A6, 0x29A6, 0x31C7, 0x31A7, 0x3186, 0x31A6,   // 0x0310 (784)
+0x31A6, 0x31A6, 0x3186, 0x3186, 0x2966, 0x2965, 0x2965, 0x2945, 0x2986, 0x2966, 0x2966, 0x3186, 0x2986, 0x2986, 0x2986, 0x2965,   // 0x0320 (800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0330 (816)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0340 (832)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE9B, 0x73F0, 0x530C, 0x52EC, 0x5B2D, 0x636E, 0x638E, 0x6BAF, 0x73F0, 0x7C31, 0x7C52,   // 0x0350 (848)
+0x7C31, 0x7431, 0x7C72, 0x84B3, 0x8CB4, 0x94D4, 0x9D36, 0xA576, 0xA597, 0xADB7, 0xB5D8, 0xBE19, 0xC65A, 0xCEBB, 0xCEBB, 0xDEFB,   // 0x0360 (864)
+0xDF1C, 0xDF1C, 0xDF1C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C,   // 0x0370 (880)
+0xE73C, 0xE73C, 0xE73C, 0xE6FC, 0xDEFC, 0xDEFC, 0xD6DB, 0xD6BB, 0xD6BB, 0xCE9B, 0xCE9B, 0xC67B, 0xBE3A, 0xB5D9, 0xADB8, 0xA576,   // 0x0380 (896)
+0x94F5, 0x9515, 0x9515, 0x8CB4, 0x8493, 0x7C52, 0x7C52, 0x6BCF, 0x6B8F, 0x634E, 0x5B4D, 0x5B4D, 0x5B2D, 0x5B2D, 0x530D, 0x52EC,   // 0x0390 (912)
+0x52CB, 0x52CB, 0x52EC, 0x52CC, 0x4ACB, 0x4AAB, 0x52CB, 0x4AAA, 0x4A8B, 0x4A8A, 0x4A8A, 0x4AAB, 0x4AAB, 0x4ACB, 0x52CC, 0x4AAB,   // 0x03A0 (928)
+0x428A, 0x4AAB, 0x4A6A, 0x4A6A, 0x4AAA, 0x4A8A, 0x4249, 0x4229, 0x3A09, 0x3A08, 0x3A28, 0x39E8, 0x31C7, 0x39C7, 0x39C7, 0x3A08,   // 0x03B0 (944)
+0x39E8, 0x31C7, 0x31A7, 0x31A7, 0x3186, 0x3186, 0x2985, 0x2965, 0x2945, 0x2945, 0x2965, 0x31A6, 0x31A6, 0x31A6, 0x31A7, 0x3187,   // 0x03C0 (960)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03D0 (976)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03E0 (992)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD76, 0x632D, 0x4AAB, 0x4ACB, 0x52CB, 0x52EC, 0x52EC, 0x5B2D, 0x634E, 0x5B4E, 0x6BAF,   // 0x03F0 (1008)
+0x6BCF, 0x5B6E, 0x638E, 0x638E, 0x6B8F, 0x6B8F, 0x6BAF, 0x73F0, 0x73F0, 0x7C11, 0x7C31, 0x7C51, 0x8471, 0x8492, 0x8CD3, 0x94F4,   // 0x0400 (1024)
+0x9514, 0x9D14, 0x9D35, 0xA535, 0xAD55, 0xAD96, 0xB5B7, 0xBDF8, 0xBE18, 0xBE18, 0xBE18, 0xBDF8, 0xBDF8, 0xBDF7, 0xBDF7, 0xBDF8,   // 0x0410 (1040)
+0xC618, 0xBDD7, 0xBDF8, 0xC618, 0xBDF8, 0xB5B7, 0xAD96, 0x9D34, 0x9D14, 0xA535, 0x94F4, 0x8CD3, 0x8CB3, 0x8492, 0x8471, 0x7C31,   // 0x0420 (1056)
+0x7C30, 0x7C31, 0x7C11, 0x73F0, 0x6BF0, 0x6BCF, 0x638E, 0x5B0D, 0x5B2D, 0x530C, 0x52EC, 0x52EB, 0x52CB, 0x52CC, 0x52CC, 0x4AAB,   // 0x0430 (1072)
+0x52AB, 0x4AAB, 0x4AAB, 0x4AAB, 0x4AAB, 0x4A8B, 0x4AAA, 0x4A8A, 0x4A8A, 0x4AAB, 0x52CB, 0x52CB, 0x530C, 0x4AAB, 0x4AAB, 0x4AAB,   // 0x0440 (1088)
+0x4AAB, 0x4AAB, 0x4A6A, 0x424A, 0x4269, 0x4249, 0x4229, 0x4229, 0x4229, 0x4249, 0x4229, 0x39E8, 0x31A7, 0x31C7, 0x31C7, 0x3A08,   // 0x0450 (1104)
+0x3A08, 0x31C7, 0x31A7, 0x3186, 0x3186, 0x3186, 0x2965, 0x2965, 0x2965, 0x2145, 0x2945, 0x2965, 0x2986, 0x2985, 0x2965, 0x3186,   // 0x0460 (1120)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0470 (1136)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0480 (1152)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CD4, 0x4229, 0x4249, 0x4229, 0x3A29, 0x3A29, 0x4249, 0x3A29, 0x4269, 0x4249, 0x4249,   // 0x0490 (1168)
+0x424A, 0x3A49, 0x3A29, 0x4249, 0x4229, 0x4229, 0x4249, 0x4249, 0x428A, 0x4289, 0x428A, 0x4AAB, 0x4AAB, 0x4ACB, 0x4AAB, 0x4A8A,   // 0x04A0 (1184)
+0x4AAB, 0x4AAB, 0x52CB, 0x52EB, 0x4AEB, 0x530C, 0x5B2C, 0x5B4D, 0x5B4D, 0x636E, 0x638E, 0x638E, 0x6B8E, 0x6BAF, 0x638E, 0x638E,   // 0x04B0 (1200)
+0x6BAF, 0x6BAF, 0x638F, 0x638E, 0x636E, 0x5B2D, 0x52EC, 0x530C, 0x52CC, 0x4AAB, 0x4AAA, 0x4AAA, 0x4AAA, 0x4AAB, 0x4AAB, 0x4A8B,   // 0x04C0 (1216)
+0x4A8A, 0x4AAB, 0x52CB, 0x4AAA, 0x4AAA, 0x4269, 0x4249, 0x4229, 0x4229, 0x3A29, 0x3A49, 0x3A08, 0x4229, 0x4229, 0x4229, 0x4229,   // 0x04D0 (1232)
+0x4229, 0x4229, 0x4229, 0x3A08, 0x3A28, 0x4229, 0x4229, 0x424A, 0x4249, 0x4A6A, 0x4A8A, 0x4A8A, 0x4A8A, 0x4A6A, 0x4A6A, 0x4A6A,   // 0x04E0 (1248)
+0x4249, 0x3A08, 0x39E8, 0x3A08, 0x3208, 0x31E8, 0x39E8, 0x39E8, 0x31E8, 0x31E7, 0x31C7, 0x31C7, 0x31A7, 0x31A6, 0x31C7, 0x31C7,   // 0x04F0 (1264)
+0x31E7, 0x31C7, 0x3186, 0x3186, 0x3186, 0x3186, 0x2966, 0x2965, 0x2965, 0x2165, 0x2144, 0x2124, 0x2145, 0x2125, 0x2145, 0x2124,   // 0x0500 (1280)
+0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0510 (1296)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0520 (1312)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73D, 0x4A6A, 0x31E9, 0x3A08, 0x3A08, 0x31E7, 0x31E7, 0x31E7, 0x31E7, 0x39E8, 0x39E8,   // 0x0530 (1328)
+0x31E7, 0x31E7, 0x31E7, 0x39E7, 0x39E7, 0x39E8, 0x31E7, 0x31C7, 0x31E8, 0x3A09, 0x3A29, 0x3A29, 0x3A28, 0x3A48, 0x4228, 0x3A08,   // 0x0540 (1344)
+0x3A08, 0x3A08, 0x3A28, 0x4249, 0x4229, 0x3A29, 0x426A, 0x4AAA, 0x4A8A, 0x4A8A, 0x428A, 0x4ACB, 0x52CC, 0x4ACC, 0x4AAB, 0x4A8A,   // 0x0550 (1360)
+0x4AAB, 0x4A8B, 0x426A, 0x426A, 0x424A, 0x4249, 0x3A29, 0x3A49, 0x4228, 0x3A08, 0x3A08, 0x39E8, 0x3A08, 0x3A29, 0x3A09, 0x3A09,   // 0x0560 (1376)
+0x3A08, 0x3A29, 0x3A29, 0x3A08, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x3A08, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x31C7, 0x31C7, 0x31E8,   // 0x0570 (1392)
+0x31C8, 0x31C8, 0x31E8, 0x39E8, 0x39E8, 0x3A08, 0x3A08, 0x3A09, 0x3A09, 0x3A09, 0x4229, 0x4229, 0x3A08, 0x4229, 0x4229, 0x3A08,   // 0x0580 (1408)
+0x39E8, 0x39C8, 0x31C7, 0x31A7, 0x31C7, 0x31C7, 0x31A7, 0x31A7, 0x31A7, 0x31A7, 0x29A6, 0x29A6, 0x29A6, 0x29A6, 0x29A6, 0x31C7,   // 0x0590 (1424)
+0x2986, 0x2986, 0x2986, 0x31A7, 0x39A7, 0x2965, 0x2945, 0x2145, 0x2945, 0x2145, 0x2124, 0x1924, 0x2104, 0x2103, 0x2104, 0x2104,   // 0x05A0 (1440)
+0xEFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x05B0 (1456)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x05C0 (1472)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC639, 0x424A, 0x2967, 0x31A7, 0x29A7, 0x2987, 0x2986, 0x2986, 0x2986, 0x29A7,   // 0x05D0 (1488)
+0x2987, 0x2986, 0x31A7, 0x31A7, 0x3186, 0x3187, 0x31A7, 0x31A7, 0x31A7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C8, 0x31C8,   // 0x05E0 (1504)
+0x39C8, 0x39E8, 0x31C7, 0x31C6, 0x39E7, 0x39C7, 0x39E7, 0x3A08, 0x4229, 0x4269, 0x428A, 0x4AAB, 0x428A, 0x3A4A, 0x3A29, 0x3A08,   // 0x05F0 (1520)
+0x3A08, 0x3A28, 0x3A08, 0x3A08, 0x3A08, 0x3A08, 0x3A08, 0x39E7, 0x39E8, 0x39E8, 0x39E7, 0x31C7, 0x31E8, 0x39C8, 0x39E8, 0x39E8,   // 0x0600 (1536)
+0x39E8, 0x39E9, 0x39E9, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C8, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31C7, 0x31A6, 0x31A6, 0x31A6,   // 0x0610 (1552)
+0x31C7, 0x31C7, 0x31C6, 0x31C6, 0x31E7, 0x3207, 0x39E7, 0x3A07, 0x3A08, 0x3A08, 0x3A08, 0x3A08, 0x3A07, 0x3A07, 0x3A07, 0x31E7,   // 0x0620 (1568)
+0x31C7, 0x31C7, 0x31A7, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x2986, 0x2965, 0x2986, 0x2986, 0x29A6,   // 0x0630 (1584)
+0x2986, 0x2965, 0x2945, 0x2965, 0x2965, 0x2965, 0x2945, 0x2945, 0x2945, 0x2145, 0x2124, 0x2124, 0x2124, 0x2103, 0x2103, 0x18E3,   // 0x0640 (1600)
+0xE7BF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0650 (1616)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0660 (1632)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x8C73, 0x5B0E, 0x52AD, 0x4A4C, 0x528D, 0x528D, 0x52CD, 0x52AC,   // 0x0670 (1648)
+0x52AD, 0x52AC, 0x52AC, 0x52AC, 0x52AC, 0x528C, 0x528C, 0x4A8C, 0x526C, 0x4A6C, 0x4A6C, 0x4A4C, 0x4A4B, 0x4A4B, 0x4A4B, 0x4A4B,   // 0x0680 (1664)
+0x4A6C, 0x4A6C, 0x4A4B, 0x4A4C, 0x526C, 0x526D, 0x5A8D, 0x5AAE, 0x5AEE, 0x52AD, 0x52CD, 0x5AEE, 0x630E, 0x5B0E, 0x5AED, 0x5ACD,   // 0x0690 (1680)
+0x52CD, 0x52CD, 0x52CD, 0x52AC, 0x4A8C, 0x4A6C, 0x4A6C, 0x4A6C, 0x4A6B, 0x4A4B, 0x422A, 0x424B, 0x4A4B, 0x422A, 0x4A2A, 0x4A2A,   // 0x06A0 (1696)
+0x424A, 0x424A, 0x424A, 0x422A, 0x422A, 0x422A, 0x422B, 0x4A4B, 0x4A6C, 0x4A8C, 0x4A6C, 0x4A6C, 0x4A4C, 0x4A4B, 0x4A4B, 0x4A4B,   // 0x06B0 (1712)
+0x422B, 0x422B, 0x420B, 0x420A, 0x420A, 0x420A, 0x420A, 0x422A, 0x422A, 0x3A0A, 0x3A0A, 0x39EA, 0x3A09, 0x39E9, 0x39E9, 0x39E9,   // 0x06C0 (1728)
+0x31C8, 0x31A8, 0x31A8, 0x31A8, 0x31A8, 0x3188, 0x3188, 0x3188, 0x3988, 0x3188, 0x3188, 0x3188, 0x3187, 0x2967, 0x2126, 0x2105,   // 0x06D0 (1744)
+0x2145, 0x2964, 0x2945, 0x2945, 0x2144, 0x2145, 0x2145, 0x2945, 0x2145, 0x2144, 0x2124, 0x2124, 0x2104, 0x2104, 0x18E3, 0x18E3,   // 0x06E0 (1760)
+0xE79F, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06F0 (1776)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0700 (1792)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79F, 0xEF7E, 0xF79F, 0xF7BF, 0xF7BF, 0xF7DF,   // 0x0710 (1808)
+0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7DF, 0xFFDF, 0xFFBF, 0xF7BF, 0xF79F, 0xF79E, 0xF79E, 0xEF7E, 0xEF7D,   // 0x0720 (1824)
+0xEF7D, 0xEF5D, 0xEF5E, 0xEF7E, 0xEF5F, 0xEF5E, 0xF77F, 0xF79F, 0xF79F, 0xE73E, 0xEF3E, 0xEF5E, 0xF77F, 0xF79F, 0xF79F, 0xF7BF,   // 0x0730 (1840)
+0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF79F, 0xF79F, 0xF79E, 0xF77E, 0xF79E, 0xEF7E, 0xEF5E, 0xEF5D, 0xEF5D, 0xE73D, 0xE73D, 0xE73C,   // 0x0740 (1856)
+0xE71C, 0xE71C, 0xE6FC, 0xDEFC, 0xE6FC, 0xDEFC, 0xE71C, 0xE73D, 0xEF5E, 0xEF7F, 0xEF7F, 0xEF7F, 0xEF7E, 0xEF5E, 0xEF7F, 0xEF7F,   // 0x0750 (1872)
+0xEF5E, 0xEF3E, 0xEF5E, 0xE73E, 0xE73E, 0xE73D, 0xE73D, 0xE73D, 0xE71D, 0xDF1D, 0xDEFC, 0xDEDC, 0xDEDC, 0xDEDC, 0xD6BB, 0xD6BB,   // 0x0760 (1888)
+0xD6BB, 0xD69B, 0xD69A, 0xD69B, 0xCE7A, 0xCE7A, 0xCE7A, 0xCE7B, 0xCE7A, 0xCE7B, 0xCE7A, 0xD6BC, 0xD69B, 0xC65A, 0xB5B8, 0x9CD4,   // 0x0770 (1904)
+0x5AEE, 0x2968, 0x2105, 0x2945, 0x2946, 0x2944, 0x2144, 0x2145, 0x2144, 0x2145, 0x2145, 0x2124, 0x2124, 0x2124, 0x18E3, 0x18E3,   // 0x0780 (1920)
+0xE77E, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0790 (1936)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07A0 (1952)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07B0 (1968)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07C0 (1984)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07D0 (2000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07E0 (2016)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07F0 (2032)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0800 (2048)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0810 (2064)
+0xFFFF, 0xD69B, 0x73B1, 0x2947, 0x2125, 0x2145, 0x2144, 0x2144, 0x2145, 0x2145, 0x2125, 0x2124, 0x2124, 0x2104, 0x1903, 0x18E3,   // 0x0820 (2080)
+0xE79F, 0xEFDF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0830 (2096)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0840 (2112)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0850 (2128)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0860 (2144)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0870 (2160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0880 (2176)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0890 (2192)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08A0 (2208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08B0 (2224)
+0xFFFF, 0xFFFF, 0xFFFF, 0xC619, 0x39EA, 0x1905, 0x2165, 0x2145, 0x2145, 0x2145, 0x2945, 0x2925, 0x2124, 0x2104, 0x2103, 0x18E3,   // 0x08C0 (2240)
+0xDF7F, 0xE7DF, 0xEFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08D0 (2256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08E0 (2272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08F0 (2288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0900 (2304)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0910 (2320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0920 (2336)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0930 (2352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0940 (2368)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0950 (2384)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFD, 0x4A4B, 0x2126, 0x2946, 0x2145, 0x2945, 0x2945, 0x2945, 0x2124, 0x2104, 0x2103, 0x2103,   // 0x0960 (2400)
+0xDF7E, 0xEFDF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0970 (2416)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0980 (2432)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0990 (2448)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09A0 (2464)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09B0 (2480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09C0 (2496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09D0 (2512)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09E0 (2528)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09F0 (2544)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFD, 0x39EA, 0x2125, 0x2144, 0x2945, 0x2945, 0x2125, 0x2124, 0x2124, 0x2103, 0x1903,   // 0x0A00 (2560)
+0xDF5E, 0xEFBF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A10 (2576)
+0xFFFF, 0xF7BE, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7E, 0xEF9E, 0xEF9E, 0xEF9E, 0xEF9E, 0xF79E, 0xEF9E, 0xEF7D,   // 0x0A20 (2592)
+0xEF7D, 0xEF7D, 0xEF7E, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0A30 (2608)
+0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E,   // 0x0A40 (2624)
+0xF79E, 0xEF7E, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xFFDE, 0xFFDF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E,   // 0x0A50 (2640)
+0xF79E, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xF79E, 0xF7BE, 0xF79E, 0xEF9E, 0xEF9E, 0xF79E, 0xEF9E, 0xEF9D, 0xEF7D,   // 0x0A60 (2656)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0A70 (2672)
+0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0A80 (2688)
+0xEF9E, 0xEF9D, 0xEF9D, 0xEF9E, 0xEF9E, 0xEF9D, 0xEF9D, 0xEF9E, 0xEF9E, 0xF79E, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A90 (2704)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5F8, 0x2126, 0x2965, 0x2965, 0x2945, 0x2945, 0x2145, 0x2124, 0x2104, 0x2104,   // 0x0AA0 (2720)
+0xDF5E, 0xE7BF, 0xF7DF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0AB0 (2736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AC0 (2752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AD0 (2768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AE0 (2784)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0AF0 (2800)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B00 (2816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B10 (2832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B20 (2848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B30 (2864)
+0x012B, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x634E, 0x2105, 0x2945, 0x2965, 0x2946, 0x2945, 0x2124, 0x2103, 0x2104,   // 0x0B40 (2880)
+0xDF5D, 0xE79F, 0xEFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0B50 (2896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B60 (2912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B70 (2928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B80 (2944)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0B90 (2960)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BA0 (2976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BB0 (2992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BC0 (3008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0BD0 (3024)
+0x012B, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xBDD8, 0x2126, 0x2945, 0x2946, 0x2966, 0x2965, 0x2145, 0x2104, 0x2104,   // 0x0BE0 (3040)
+0xE75E, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x012B,   // 0x0BF0 (3056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C00 (3072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C10 (3088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C20 (3104)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C30 (3120)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C40 (3136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C50 (3152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C60 (3168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0C70 (3184)
+0x012B, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7E, 0x39EA, 0x2925, 0x2966, 0x2966, 0x2966, 0x2966, 0x2125, 0x2104,   // 0x0C80 (3200)
+0xDF5D, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0C90 (3216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CA0 (3232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CB0 (3248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CC0 (3264)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CD0 (3280)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CE0 (3296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0CF0 (3312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D00 (3328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D10 (3344)
+0x012B, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x630E, 0x2105, 0x2966, 0x2945, 0x2966, 0x2965, 0x2125, 0x2104,   // 0x0D20 (3360)
+0xDF3D, 0xE7BF, 0xEFFF, 0xEFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0D30 (3376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D40 (3392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D50 (3408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D60 (3424)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D70 (3440)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D80 (3456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0D90 (3472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DA0 (3488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DB0 (3504)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0x8432, 0x2105, 0x2966, 0x2945, 0x2145, 0x2125, 0x2124, 0x2104,   // 0x0DC0 (3520)
+0xDF5E, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0DD0 (3536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DE0 (3552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0DF0 (3568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E00 (3584)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E10 (3600)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E20 (3616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E30 (3632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E40 (3648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E50 (3664)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0x8C53, 0x2105, 0x2145, 0x2145, 0x2124, 0x2125, 0x2104, 0x2104,   // 0x0E60 (3680)
+0xDF3D, 0xE79F, 0xEFDF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0E70 (3696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E80 (3712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0E90 (3728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EA0 (3744)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EB0 (3760)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EC0 (3776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0ED0 (3792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EE0 (3808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0EF0 (3824)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x8412, 0x1904, 0x2145, 0x2145, 0x2125, 0x2124, 0x2104, 0x1904,   // 0x0F00 (3840)
+0xDF3D, 0xE79F, 0xEFDF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0F10 (3856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F20 (3872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F30 (3888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F40 (3904)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F50 (3920)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F60 (3936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F70 (3952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F80 (3968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0F90 (3984)
+0x012B, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x7BF1, 0x2105, 0x2166, 0x2165, 0x2144, 0x2125, 0x2104, 0x2104,   // 0x0FA0 (4000)
+0xD73D, 0xE77E, 0xEFBF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x0FB0 (4016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FC0 (4032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FD0 (4048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FE0 (4064)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x0FF0 (4080)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1000 (4096)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1010 (4112)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1020 (4128)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1030 (4144)
+0x012B, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x73B0, 0x2105, 0x2145, 0x2145, 0x2124, 0x2125, 0x2104, 0x1904,   // 0x1040 (4160)
+0xD73D, 0xE77E, 0xEFBF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1050 (4176)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1060 (4192)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1070 (4208)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1080 (4224)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1090 (4240)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10A0 (4256)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10B0 (4272)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10C0 (4288)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x10D0 (4304)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x6B6F, 0x2105, 0x2946, 0x2945, 0x2145, 0x2124, 0x2104, 0x1903,   // 0x10E0 (4320)
+0xD71D, 0xE79F, 0xE7BF, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x10F0 (4336)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1100 (4352)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1110 (4368)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1120 (4384)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1130 (4400)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1140 (4416)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1150 (4432)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1160 (4448)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1170 (4464)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0x6B4F, 0x2105, 0x2945, 0x2145, 0x2144, 0x2145, 0x2124, 0x1903,   // 0x1180 (4480)
+0xDF1D, 0xE77E, 0xE7BF, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1190 (4496)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11A0 (4512)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11B0 (4528)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11C0 (4544)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11D0 (4560)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11E0 (4576)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x11F0 (4592)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1200 (4608)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1210 (4624)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0x6B2E, 0x2104, 0x2945, 0x2945, 0x2125, 0x2124, 0x1903, 0x1903,   // 0x1220 (4640)
+0xDF1D, 0xE77E, 0xE7BF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1230 (4656)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1240 (4672)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1250 (4688)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1260 (4704)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1270 (4720)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1280 (4736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1290 (4752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12A0 (4768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12B0 (4784)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0x5ACD, 0x2125, 0x2945, 0x2945, 0x2125, 0x2124, 0x2124, 0x1903,   // 0x12C0 (4800)
+0xDF3D, 0xE77E, 0xEFBF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x12D0 (4816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12E0 (4832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x12F0 (4848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1300 (4864)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1310 (4880)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1320 (4896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1330 (4912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1340 (4928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1350 (4944)
+0x012B, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xEFBF, 0x52AC, 0x2125, 0x2125, 0x2125, 0x2145, 0x2124, 0x2103, 0x1903,   // 0x1360 (4960)
+0xDF3D, 0xE79E, 0xEFBF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1370 (4976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1380 (4992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1390 (5008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13A0 (5024)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13B0 (5040)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13C0 (5056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13D0 (5072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13E0 (5088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x13F0 (5104)
+0x012B, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xEF9E, 0x4A6B, 0x2125, 0x2145, 0x2125, 0x2144, 0x2124, 0x2104, 0x18E3,   // 0x1400 (5120)
+0xE77E, 0xEFDF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1410 (5136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1420 (5152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1430 (5168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1440 (5184)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1450 (5200)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1460 (5216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1470 (5232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1480 (5248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1490 (5264)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xEF7E, 0x422A, 0x2125, 0x2125, 0x2145, 0x2124, 0x2124, 0x2103, 0x18E3,   // 0x14A0 (5280)
+0x738E, 0x7BD0, 0x8431, 0xA556, 0xE73D, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x14B0 (5296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14C0 (5312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14D0 (5328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14E0 (5344)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x14F0 (5360)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1500 (5376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1510 (5392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1520 (5408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1530 (5424)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xE75D, 0x420A, 0x2125, 0x2145, 0x2925, 0x2124, 0x2104, 0x2104, 0x18E3,   // 0x1540 (5440)
+0x10A2, 0x18C3, 0x18C3, 0x1904, 0x424A, 0x9D14, 0xFFDF, 0xFFFF, 0xF7FF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1550 (5456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1560 (5472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1570 (5488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1580 (5504)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1590 (5520)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15A0 (5536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15B0 (5552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15C0 (5568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x15D0 (5584)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xE75D, 0x41E9, 0x2125, 0x2125, 0x2925, 0x2124, 0x2104, 0x2104, 0x2104,   // 0x15E0 (5600)
+0x18E3, 0x1904, 0x1924, 0x2124, 0x18E4, 0x2946, 0x8C52, 0xFFFF, 0xF7FF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0x012B,   // 0x15F0 (5616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1600 (5632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1610 (5648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1620 (5664)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1630 (5680)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1640 (5696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1650 (5712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1660 (5728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1670 (5744)
+0x012B, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xDF3D, 0x39C8, 0x2125, 0x2945, 0x2145, 0x2124, 0x2104, 0x2104, 0x2103,   // 0x1680 (5760)
+0x18C3, 0x18E4, 0x1904, 0x2103, 0x2124, 0x1904, 0x2146, 0xBE19, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1690 (5776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16A0 (5792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16B0 (5808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16C0 (5824)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16D0 (5840)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16E0 (5856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x16F0 (5872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1700 (5888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1710 (5904)
+0x012B, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xD71C, 0x31A8, 0x2945, 0x2966, 0x2946, 0x2125, 0x2124, 0x2104, 0x18E3,   // 0x1720 (5920)
+0x10E3, 0x18E3, 0x1904, 0x2104, 0x2104, 0x2124, 0x18E4, 0x73F2, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1730 (5936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1740 (5952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1750 (5968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1760 (5984)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1770 (6000)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1780 (6016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1790 (6032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17A0 (6048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17B0 (6064)
+0x012B, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7DF, 0xF7FF, 0xD6DC, 0x3187, 0x2945, 0x2966, 0x2946, 0x2124, 0x2104, 0x2125, 0x18E4,   // 0x17C0 (6080)
+0x18C3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x2104, 0x18E3, 0x5AEE, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x17D0 (6096)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17E0 (6112)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x17F0 (6128)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1800 (6144)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1810 (6160)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1820 (6176)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1830 (6192)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1840 (6208)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1850 (6224)
+0x012B, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xCEBB, 0x2967, 0x2125, 0x2945, 0x2945, 0x2125, 0x2104, 0x2104, 0x2104,   // 0x1860 (6240)
+0x18C3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x2104, 0x1903, 0x52AD, 0xEFDF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1870 (6256)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1880 (6272)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1890 (6288)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18A0 (6304)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18B0 (6320)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18C0 (6336)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18D0 (6352)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18E0 (6368)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x18F0 (6384)
+0x012B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7FF, 0xCE9B, 0x2946, 0x2145, 0x2945, 0x2945, 0x2145, 0x2125, 0x2104, 0x2104,   // 0x1900 (6400)
+0x18C3, 0x18E3, 0x1903, 0x1904, 0x1904, 0x1904, 0x1903, 0x4A6B, 0xF79F, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x1910 (6416)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1920 (6432)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1930 (6448)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1940 (6464)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1950 (6480)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1960 (6496)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1970 (6512)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1980 (6528)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1990 (6544)
+0x012B, 0xFFFF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7BF, 0xF7FF, 0xC67B, 0x2926, 0x2945, 0x2945, 0x2945, 0x2945, 0x2124, 0x2104, 0x1904,   // 0x19A0 (6560)
+0x18C3, 0x18E3, 0x1904, 0x1904, 0x2104, 0x2124, 0x1903, 0x4A2B, 0xEF7E, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x012B,   // 0x19B0 (6576)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19C0 (6592)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19D0 (6608)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19E0 (6624)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x19F0 (6640)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A00 (6656)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A10 (6672)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A20 (6688)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A30 (6704)
+0x012B, 0xFFFF, 0xF7FF, 0xF7DF, 0xEFBF, 0xEFDF, 0xF7FF, 0xBE3A, 0x2126, 0x2945, 0x2945, 0x2145, 0x2144, 0x2124, 0x2104, 0x18E4,   // 0x1A40 (6720)
+0x18C3, 0x18E3, 0x18E4, 0x1904, 0x1904, 0x2124, 0x1903, 0x420A, 0xEF5E, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1A50 (6736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A60 (6752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A70 (6768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A80 (6784)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1A90 (6800)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AA0 (6816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AB0 (6832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AC0 (6848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1AD0 (6864)
+0x012B, 0xFFFF, 0xF7FF, 0xEFDF, 0xEFDF, 0xF7DF, 0xF7FF, 0xBE19, 0x2125, 0x2945, 0x2125, 0x2125, 0x2124, 0x2124, 0x18E3, 0x18E3,   // 0x1AE0 (6880)
+0x18C3, 0x18C3, 0x18E3, 0x18E3, 0x1904, 0x2124, 0x18E3, 0x39C9, 0xE73E, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1AF0 (6896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B00 (6912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B10 (6928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B20 (6944)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B30 (6960)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B40 (6976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B50 (6992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B60 (7008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1B70 (7024)
+0x012B, 0xFFFF, 0xEFDF, 0xEFDF, 0xF7DF, 0xEFBF, 0xF7FF, 0xBE19, 0x2125, 0x2945, 0x2124, 0x2125, 0x2124, 0x2104, 0x2104, 0x18C3,   // 0x1B80 (7040)
+0x18C2, 0x18C3, 0x18E3, 0x1903, 0x1904, 0x1904, 0x18E3, 0x39A9, 0xE71D, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1B90 (7056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BA0 (7072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BB0 (7088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BC0 (7104)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BD0 (7120)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BE0 (7136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1BF0 (7152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C00 (7168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C10 (7184)
+0x012B, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xEFBF, 0xF7FF, 0xB5F9, 0x2105, 0x2945, 0x2945, 0x2125, 0x2124, 0x2104, 0x2104, 0x18E3,   // 0x1C20 (7200)
+0x10C2, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1904, 0x3188, 0xDEFD, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1C30 (7216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C40 (7232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C50 (7248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C60 (7264)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C70 (7280)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C80 (7296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1C90 (7312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CA0 (7328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CB0 (7344)
+0x012B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xD6DC, 0x3187, 0x2125, 0x2945, 0x2945, 0x2124, 0x2104, 0x2104, 0x18E3,   // 0x1CC0 (7360)
+0x18C2, 0x18E3, 0x18E4, 0x18E4, 0x18E4, 0x1904, 0x1903, 0x2968, 0xD6DC, 0xF7FF, 0xEFDF, 0xF7DF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1CD0 (7376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CE0 (7392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1CF0 (7408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D00 (7424)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D10 (7440)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D20 (7456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D30 (7472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D40 (7488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D50 (7504)
+0x012B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF, 0xEFDF, 0xF7FF, 0x6B6F, 0x18E5, 0x2945, 0x2125, 0x2124, 0x2104, 0x2103, 0x18E3,   // 0x1D60 (7520)
+0x18E3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1903, 0x2967, 0xD6BC, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1D70 (7536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D80 (7552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1D90 (7568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DA0 (7584)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DB0 (7600)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DC0 (7616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DD0 (7632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DE0 (7648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1DF0 (7664)
+0x012B, 0xFFFF, 0xF7DF, 0xF7DF, 0xEFBF, 0xF7BF, 0xEF9F, 0xEFDF, 0xD6DC, 0x39C8, 0x18E4, 0x2945, 0x2924, 0x2124, 0x2124, 0x18E3,   // 0x1E00 (7680)
+0x18E3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1904, 0x2967, 0xD67B, 0xF7FF, 0xF7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1E10 (7696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E20 (7712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E30 (7728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E40 (7744)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E50 (7760)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E60 (7776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E70 (7792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E80 (7808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1E90 (7824)
+0x012B, 0xF7FF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEFBF, 0xF7FF, 0xCE9A, 0x52CC, 0x2946, 0x2105, 0x18E4, 0x18E3, 0x10C3,   // 0x1EA0 (7840)
+0x18C3, 0x18E3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1924, 0x2946, 0xC63A, 0xF7FF, 0xEFDF, 0xEFFF, 0xF7FF, 0xEFFF, 0xFFFF, 0x012B,   // 0x1EB0 (7856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1EC0 (7872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1ED0 (7888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1EE0 (7904)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1EF0 (7920)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F00 (7936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F10 (7952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F20 (7968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F30 (7984)
+0x012B, 0xF7FF, 0xF7BF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xF7FF, 0xF7BF, 0xC65A, 0xA576, 0x9D35, 0x94B3, 0x8451,   // 0x1F40 (8000)
+0x10C3, 0x18E3, 0x18E3, 0x18E4, 0x1904, 0x1904, 0x1924, 0x18E5, 0xBDD9, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xF7FF, 0xFFFF, 0x012B,   // 0x1F50 (8016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F60 (8032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F70 (8048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F80 (8064)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1F90 (8080)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FA0 (8096)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FB0 (8112)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FC0 (8128)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x1FD0 (8144)
+0x012B, 0xF7FF, 0xF7BF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xEF9F, 0xEFBF, 0xEFBF, 0xEFBF, 0xE79F, 0xE75E, 0xD6FC, 0xCE9B,   // 0x1FE0 (8160)
+0x10C3, 0x10C3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x1924, 0x18E4, 0xB5B8, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xEFFF, 0xFFFF, 0x012B,   // 0x1FF0 (8176)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2000 (8192)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2010 (8208)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2020 (8224)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2030 (8240)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2040 (8256)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2050 (8272)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2060 (8288)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2070 (8304)
+0x012B, 0xF7FF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xE79F, 0xEFBF, 0xEFBF, 0xE79F, 0xE77E, 0xDF3D, 0xD6FC, 0xCE9B, 0xC63A,   // 0x2080 (8320)
+0x18C3, 0x18E3, 0x1903, 0x1904, 0x1904, 0x2124, 0x1924, 0x18C4, 0xAD98, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xEFFF, 0xF7FF, 0x012B,   // 0x2090 (8336)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20A0 (8352)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20B0 (8368)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20C0 (8384)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20D0 (8400)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20E0 (8416)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x20F0 (8432)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2100 (8448)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2110 (8464)
+0x012B, 0xF7DF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE7BF, 0xEFBF, 0xE79E, 0xE77E, 0xDF5E, 0xD6FD, 0xCE9B, 0xC639,   // 0x2120 (8480)
+0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x2125, 0x1924, 0x18C4, 0xAD77, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xEFFF, 0xF7FF, 0x012B,   // 0x2130 (8496)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2140 (8512)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2150 (8528)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2160 (8544)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2170 (8560)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2180 (8576)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2190 (8592)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21A0 (8608)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21B0 (8624)
+0x012B, 0xEFFF, 0xEFBF, 0xEFBF, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xEFBF, 0xE79F, 0xE77E, 0xDF3E, 0xD6FC, 0xCE9B, 0xBE19,   // 0x21C0 (8640)
+0x18E3, 0x18E3, 0x2104, 0x1904, 0x1904, 0x1924, 0x1924, 0x18E4, 0xA537, 0xFFFF, 0xEFDF, 0xF7DF, 0xF7FF, 0xF7DF, 0xF7FF, 0x012B,   // 0x21D0 (8656)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21E0 (8672)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x21F0 (8688)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2200 (8704)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2210 (8720)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2220 (8736)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2230 (8752)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2240 (8768)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2250 (8784)
+0x012B, 0xEFDF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xEF9F, 0xEF9F, 0xE79F, 0xE77E, 0xDF3E, 0xD6FC, 0xCE9B, 0xBE19,   // 0x2260 (8800)
+0x18C3, 0x18E3, 0x18E3, 0x1904, 0x1904, 0x1904, 0x2124, 0x18C4, 0x9CF5, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0x012B,   // 0x2270 (8816)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2280 (8832)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2290 (8848)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22A0 (8864)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22B0 (8880)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22C0 (8896)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22D0 (8912)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22E0 (8928)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x22F0 (8944)
+0x012B, 0xEFDF, 0xEF9F, 0xEFBF, 0xEF9F, 0xE79F, 0xEF9F, 0xEF9F, 0xE79F, 0xEF9F, 0xE79F, 0xE77E, 0xDF3D, 0xD6FC, 0xCE9B, 0xBE19,   // 0x2300 (8960)
+0x18E3, 0x18E3, 0x18E3, 0x18E4, 0x1904, 0x1924, 0x1924, 0x18C4, 0x94D5, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2310 (8976)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2320 (8992)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2330 (9008)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2340 (9024)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2350 (9040)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2360 (9056)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2370 (9072)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2380 (9088)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2390 (9104)
+0x012B, 0xE7DF, 0xEF9F, 0xEFBF, 0xE79F, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xE75E, 0xDF3D, 0xD6DC, 0xC67A, 0xBE18,   // 0x23A0 (9120)
+0x18E3, 0x18E4, 0x18E4, 0x1904, 0x1904, 0x1904, 0x1924, 0x18E4, 0x8C93, 0xFFFF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xEFFF, 0x012B,   // 0x23B0 (9136)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23C0 (9152)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23D0 (9168)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23E0 (9184)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x23F0 (9200)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2400 (9216)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2410 (9232)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2420 (9248)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2430 (9264)
+0x012B, 0xEFBF, 0xEFBF, 0xE7BF, 0xE79F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xDF7E, 0xDF3D, 0xD6DC, 0xC69A, 0xBE18,   // 0x2440 (9280)
+0x18E3, 0x1904, 0x18E4, 0x1904, 0x1904, 0x1904, 0x2125, 0x10C3, 0x8C53, 0xFFFF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2450 (9296)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2460 (9312)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2470 (9328)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2480 (9344)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2490 (9360)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24A0 (9376)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24B0 (9392)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24C0 (9408)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x24D0 (9424)
+0x014B, 0xEFBF, 0xEF9F, 0xE7BF, 0xE79F, 0xE79E, 0xE79E, 0xE79E, 0xE79F, 0xE79F, 0xE77F, 0xE75E, 0xDF3D, 0xD6DC, 0xC69A, 0xBE18,   // 0x24E0 (9440)
+0x18E3, 0x18E4, 0x1904, 0x1904, 0x1904, 0x1904, 0x2125, 0x10C3, 0x8413, 0xFFFF, 0xF7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xEFFF, 0x012C,   // 0x24F0 (9456)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2500 (9472)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2510 (9488)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2520 (9504)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2530 (9520)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2540 (9536)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2550 (9552)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2560 (9568)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x014B, 0x012B,   // 0x2570 (9584)
+0x012B, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xE75E, 0xDF3D, 0xD6DC, 0xC69A, 0xBDF8,   // 0x2580 (9600)
+0x18E3, 0x1904, 0x1904, 0x1924, 0x2124, 0x2124, 0x2105, 0x18E3, 0x7BF3, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2590 (9616)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25A0 (9632)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25B0 (9648)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25C0 (9664)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25D0 (9680)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25E0 (9696)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x25F0 (9712)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2600 (9728)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2610 (9744)
+0x012B, 0xEFBF, 0xEFBF, 0xE79F, 0xE79F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE79F, 0xE77E, 0xDF5E, 0xD73D, 0xD6DC, 0xC69A, 0xB618,   // 0x2620 (9760)
+0x18E3, 0x1904, 0x1904, 0x1924, 0x2124, 0x2124, 0x2125, 0x18E3, 0x7390, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x2630 (9776)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2640 (9792)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2650 (9808)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2660 (9824)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2670 (9840)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2680 (9856)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2690 (9872)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26A0 (9888)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26B0 (9904)
+0x014B, 0xEFBF, 0xEF9F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE79F, 0xDF9E, 0xE79E, 0xE77E, 0xDF5E, 0xD73D, 0xD6FC, 0xC67A, 0xB618,   // 0x26C0 (9920)
+0x18E3, 0x1903, 0x1904, 0x1904, 0x1904, 0x1924, 0x1944, 0x1904, 0x4A4B, 0xEFBF, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0x012B,   // 0x26D0 (9936)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26E0 (9952)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x26F0 (9968)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2700 (9984)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2710 (10000)
+0x012B, 0x014B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2720 (10016)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2730 (10032)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2740 (10048)
+0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B, 0x012B,   // 0x2750 (10064)
+0x012B, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xE79F, 0xE79F, 0xE79E, 0xE79F, 0xE79F, 0xE77E, 0xDF5E, 0xDF1D, 0xCEDB, 0xC67A, 0xBDF8,   // 0x2760 (10080)
+0x18E3, 0x18E3, 0x1904, 0x2104, 0x2104, 0x1924, 0x2124, 0x2125, 0x2147, 0xC67B, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF,   // 0x2770 (10096)
+0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7DF, 0xDEFC, 0xC659, 0xC619, 0xC639, 0xC639, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x2780 (10112)
+0xC619, 0xC619, 0xBE18, 0xBE18, 0xBE18, 0xC619, 0xC619, 0xC619, 0xC639, 0xC639, 0xC639, 0xC639, 0xCE5A, 0xCE5A, 0xCE5A, 0xCE5A,   // 0x2790 (10128)
+0xCE59, 0xCE59, 0xC659, 0xC659, 0xCE59, 0xCE59, 0xCE59, 0xC659, 0xC659, 0xC659, 0xC659, 0xC659, 0xC659, 0xC639, 0xC639, 0xC639,   // 0x27A0 (10144)
+0xC639, 0xCE5A, 0xCE7A, 0xCE7A, 0xCE7A, 0xD67A, 0xD69A, 0xD69A, 0xD67A, 0xD69A, 0xD69A, 0xD67A, 0xCE7A, 0xCE7A, 0xCE7A, 0xCE7A,   // 0x27B0 (10160)
+0xD67A, 0xD69B, 0xD69B, 0xD69B, 0xD6BB, 0xD6BB, 0xDEBB, 0xDEBC, 0xDEDC, 0xDEDC, 0xDEDC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEDB, 0xDEDB,   // 0x27C0 (10176)
+0xDEDC, 0xDEDC, 0xDEBB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6BB, 0xD6DB, 0xDEDB, 0xDEDB, 0xDEDB,   // 0x27D0 (10192)
+0xDEDC, 0xD6BB, 0xD6BC, 0xDEDC, 0xDEDC, 0xDEDC, 0xDEFC, 0xDEFC, 0xDEDC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEDC, 0xDEDC,   // 0x27E0 (10208)
+0xDEFC, 0xDEDC, 0xDEDC, 0xDEDC, 0xDEFC, 0xE6FC, 0xE71D, 0xE71C, 0xE71C, 0xE71D, 0xE71D, 0xE73D, 0xE73E, 0xEF5E, 0xF7BF, 0xEFBF,   // 0x27F0 (10224)
+0xE7BF, 0xEFBF, 0xEFBF, 0xEFBF, 0xE79F, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE75E, 0xDF3E, 0xD71D, 0xCEBB, 0xC65A, 0xB5F8,   // 0x2800 (10240)
+0x18E3, 0x18E3, 0x1904, 0x2104, 0x2104, 0x2124, 0x2125, 0x2124, 0x18E5, 0x7BD1, 0xFFFF, 0xF7FF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF,   // 0x2810 (10256)
+0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2820 (10272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2830 (10288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2840 (10304)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2850 (10320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2860 (10336)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2870 (10352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2880 (10368)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7DF, 0xEFDF, 0xEFBF, 0xEF9F, 0xEFBF,   // 0x2890 (10384)
+0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77F, 0xE77F, 0xE77E, 0xE75E, 0xDF3D, 0xD71D, 0xCEBC, 0xC65A, 0xB5F8,   // 0x28A0 (10400)
+0x2103, 0x1903, 0x1903, 0x1903, 0x2104, 0x2124, 0x2124, 0x2125, 0x2124, 0x2967, 0xD67B, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF,   // 0x28B0 (10416)
+0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28C0 (10432)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28D0 (10448)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28E0 (10464)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x28F0 (10480)
+0xFFDF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2900 (10496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF,   // 0x2910 (10512)
+0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7DF,   // 0x2920 (10528)
+0xEFBF, 0xEFBF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0xEFDF, 0xEFDF, 0xF7DF, 0xF7DF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF,   // 0x2930 (10544)
+0xEFBF, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xE75E, 0xDF3E, 0xD6FD, 0xCEBC, 0xC65A, 0xB5F8,   // 0x2940 (10560)
+0x2104, 0x1903, 0x1903, 0x1903, 0x1903, 0x2124, 0x1904, 0x2125, 0x2125, 0x1904, 0x528C, 0xF79E, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF,   // 0x2950 (10576)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xFFFF, 0xF7FF, 0xFFFF, 0xB5B7, 0x6B4D, 0x2965, 0x0020, 0x2945,   // 0x2960 (10592)
+0x6B6D, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x6B4D, 0x2965, 0x0020, 0x2965, 0x6B4D,   // 0x2970 (10608)
+0xBDD7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x6B4D, 0x2965, 0x0020, 0x2965, 0x6B4D, 0xBDD7, 0xFFFF,   // 0x2980 (10624)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x6B4D, 0x2965, 0x0020, 0x2965, 0x6B4D, 0xB5B6, 0xFFFF, 0xFFFF,   // 0x2990 (10640)
+0xFFDF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFDF, 0xF7BE, 0xF79E, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x29A0 (10656)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF,   // 0x29B0 (10672)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xEFBF,   // 0x29C0 (10688)
+0xF7DF, 0xF7DF, 0xF7BF, 0xF7DF, 0xEFDF, 0xF7DF, 0xEFDF, 0xEFBF, 0xEFDF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F,   // 0x29D0 (10704)
+0xEF9F, 0xEFBF, 0xEF9F, 0xE79F, 0xE79F, 0xEF9F, 0xE79F, 0xE79F, 0xE77F, 0xE77E, 0xE75E, 0xDF3E, 0xD6FD, 0xCEBC, 0xC65A, 0xB5F8,   // 0x29E0 (10720)
+0x2123, 0x2103, 0x2103, 0x1903, 0x18E3, 0x1904, 0x1904, 0x2124, 0x2105, 0x2124, 0x1904, 0x634E, 0xF7BF, 0xFFFF, 0xF7FF, 0xF7FF,   // 0x29F0 (10736)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0x8C92, 0x10C2, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2A00 (10752)
+0x0000, 0x18C3, 0x8C92, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C92, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2A10 (10768)
+0x10A2, 0x9492, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x9492,   // 0x2A20 (10784)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x9492, 0xFFFF,   // 0x2A30 (10800)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2A40 (10816)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2A50 (10832)
+0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7DF,   // 0x2A60 (10848)
+0xF7DF, 0xF7BF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F,   // 0x2A70 (10864)
+0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xDF5E, 0xDF3D, 0xD6FD, 0xCEBB, 0xC65A, 0xB5F8,   // 0x2A80 (10880)
+0x2944, 0x2965, 0x2144, 0x2124, 0x2103, 0x1904, 0x1904, 0x1904, 0x1924, 0x2125, 0x2125, 0x20E4, 0x632D, 0xEF3D, 0xFFFF, 0xFFFF,   // 0x2A90 (10896)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xAD75, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2AA0 (10912)
+0x0000, 0x0000, 0x0882, 0xAD75, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2AB0 (10928)
+0x0000, 0x1082, 0xAD75, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082,   // 0x2AC0 (10944)
+0xAD75, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x0882, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0xAD55,   // 0x2AD0 (10960)
+0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DF, 0xF7DF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2AE0 (10976)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xFFDF, 0xF7DF,   // 0x2AF0 (10992)
+0xF7DF, 0xF7FF, 0xF7DF, 0xF7DF, 0xF7DF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xF7DF,   // 0x2B00 (11008)
+0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xE79F,   // 0x2B10 (11024)
+0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xDF5E, 0xDF3D, 0xD71D, 0xCEBB, 0xC65A, 0xB5F8,   // 0x2B20 (11040)
+0x3186, 0x39E7, 0x31C6, 0x3185, 0x2144, 0x2124, 0x1904, 0x1924, 0x1924, 0x2124, 0x2125, 0x2125, 0x1904, 0x422A, 0xB5D7, 0xFFDF,   // 0x2B30 (11056)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0x52CB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2B40 (11072)
+0x0000, 0x0000, 0x0000, 0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2B50 (11088)
+0x0000, 0x0000, 0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2B60 (11104)
+0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB,   // 0x2B70 (11120)
+0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2B80 (11136)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF,   // 0x2B90 (11152)
+0xF7FF, 0xF7FF, 0xFFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DF, 0xEFBF, 0xEFBF, 0xEFBF, 0xF7DF, 0xF7DF, 0xEFDF, 0xEFBF, 0xEFBF, 0xEFBF,   // 0x2BA0 (11168)
+0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEF9F, 0xEFBF, 0xE7BF, 0xE7BF, 0xEF9F, 0xEF9F,   // 0x2BB0 (11184)
+0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xE79F, 0xEF9F, 0xE79E, 0xE77E, 0xDF7E, 0xE75E, 0xDF3E, 0xDF1D, 0xD6FD, 0xCEBB, 0xC65A, 0xB5D8,   // 0x2BC0 (11200)
+0x2104, 0x31A6, 0x4207, 0x4207, 0x31A6, 0x2965, 0x2125, 0x2124, 0x1904, 0x2104, 0x2123, 0x2125, 0x2145, 0x18E5, 0x2146, 0x5B0D,   // 0x2BD0 (11216)
+0xA515, 0xD6BB, 0xEF7E, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7FF, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2BE0 (11232)
+0x0000, 0x0000, 0x0000, 0x18C3, 0xFFDF, 0xF7DF, 0xF7DF, 0xF7BF, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2BF0 (11248)
+0x0000, 0x0000, 0x18C3, 0xFFDF, 0xF7DF, 0xFFDF, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x2C00 (11264)
+0x18E3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3,   // 0x2C10 (11280)
+0xFFFF, 0xFFDF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7DF, 0xF7BF, 0xF79E, 0xEF7E, 0xEF7D, 0xEF5D, 0xE75D, 0xE73C, 0xE73D,   // 0x2C20 (11296)
+0xE73C, 0xE73D, 0xE73C, 0xE73D, 0xE73C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDEFC, 0xDEFC, 0xD6DB, 0xDEFB, 0xDF1C,   // 0x2C30 (11312)
+0xD6FB, 0xD6FB, 0xDEFC, 0xDEFB, 0xD6DB, 0xDF1C, 0xEFBE, 0xF7FF, 0xEFDF, 0xEFDF, 0xEFBF, 0xEFBF, 0xEFBF, 0xEFBF, 0xE7BF, 0xE79F,   // 0x2C40 (11328)
+0xE79E, 0xE79E, 0xE79E, 0xE79E, 0xE79E, 0xE79E, 0xE77F, 0xE79F, 0xEF9F, 0xE77F, 0xE77F, 0xE79F, 0xE79F, 0xE77E, 0xE77E, 0xE77F,   // 0x2C50 (11344)
+0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE75E, 0xE75E, 0xDF5E, 0xDF5D, 0xDF3D, 0xDF1D, 0xD6FC, 0xCE9B, 0xC639, 0xB5F8,   // 0x2C60 (11360)
+0x18E3, 0x2103, 0x2124, 0x2145, 0x2145, 0x2945, 0x2125, 0x2104, 0x2124, 0x2123, 0x2104, 0x2124, 0x2125, 0x2124, 0x2124, 0x1904,   // 0x2C70 (11376)
+0x1904, 0x2986, 0x39E8, 0x4A6A, 0x528B, 0x4A8A, 0x4A6A, 0x4A8B, 0x528B, 0xEF7E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2C80 (11392)
+0xFFFF, 0xFFFF, 0xFFFF, 0xEF7E, 0x52CB, 0x52AB, 0x52CB, 0x52CB, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2C90 (11408)
+0xFFFF, 0xFFFF, 0xEF7D, 0x528A, 0x4A6A, 0x528A, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2CA0 (11424)
+0xF79E, 0x73CF, 0x73AF, 0x73CF, 0x6B8E, 0xEF9E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D,   // 0x2CB0 (11440)
+0x632D, 0x52CC, 0x632D, 0x632D, 0x630C, 0x5AEC, 0x5AEC, 0x5ACC, 0x5ACC, 0x528B, 0x4A6A, 0x4A6A, 0x4A49, 0x4A49, 0x4229, 0x4229,   // 0x2CC0 (11456)
+0x4208, 0x4208, 0x39E8, 0x39E8, 0x39C8, 0x39C8, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x39C8, 0x39E8, 0x39E8, 0x31C7, 0x31C7, 0x39E8,   // 0x2CD0 (11472)
+0x31C7, 0x39E8, 0x39E8, 0x39E8, 0x39E8, 0x3A08, 0x52AB, 0x94F3, 0xEF9E, 0xEF9F, 0xE77F, 0xE77F, 0xE79F, 0xE77F, 0xE77E, 0xE77E,   // 0x2CE0 (11488)
+0xE75E, 0xE75E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xE77E, 0xDF7E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE75E, 0xE73E,   // 0x2CF0 (11504)
+0xE75E, 0xDF5E, 0xDF5E, 0xDF5E, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF1C, 0xD71C, 0xD6DC, 0xCE9B, 0xC659, 0xB5D8,   // 0x2D00 (11520)
+0x2944, 0x2124, 0x2145, 0x2125, 0x2144, 0x2144, 0x2144, 0x2944, 0x2944, 0x2944, 0x2124, 0x2124, 0x2124, 0x2124, 0x2124, 0x2144,   // 0x2D10 (11536)
+0x2145, 0x2145, 0x2124, 0x2125, 0x2125, 0x2124, 0x2125, 0x2945, 0x2145, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2D20 (11552)
+0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x2145, 0x2125, 0x2144, 0x2144, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2D30 (11568)
+0xFFFF, 0xFFFF, 0xB596, 0x2145, 0x2945, 0x2125, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2D40 (11584)
+0xB5B6, 0x2945, 0x2946, 0x2946, 0x2145, 0xB5B7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB596,   // 0x2D50 (11600)
+0x2945, 0x2965, 0x2945, 0x2945, 0x2145, 0x2125, 0x2945, 0x2945, 0x2925, 0x2925, 0x2945, 0x2945, 0x2945, 0x2945, 0x2965, 0x2945,   // 0x2D60 (11616)
+0x2946, 0x2945, 0x2945, 0x2945, 0x2946, 0x2145, 0x2145, 0x2945, 0x2945, 0x2965, 0x2965, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2D70 (11632)
+0x2966, 0x2965, 0x2946, 0x2946, 0x2966, 0x2966, 0x2945, 0x2104, 0x634D, 0xE75E, 0xE77E, 0xE75D, 0xDF5D, 0xDF5E, 0xDF3D, 0xDF5E,   // 0x2D80 (11648)
+0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xDF5D, 0xE73D, 0xDF3D, 0xDF3D, 0xE75D, 0xE75D, 0xDF5D, 0xDF3D,   // 0x2D90 (11664)
+0xDF5D, 0xDF5D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xDF3D, 0xD71D, 0xD6FC, 0xCEDB, 0xC69A, 0xBE59, 0xB5D8,   // 0x2DA0 (11680)
+0x3185, 0x2965, 0x2965, 0x2986, 0x2986, 0x2965, 0x2965, 0x2945, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2945, 0x2965, 0x2965,   // 0x2DB0 (11696)
+0x2986, 0x31C7, 0x31E7, 0x31C7, 0x3186, 0x2985, 0x2985, 0x2966, 0x2966, 0x6B8E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2DC0 (11712)
+0xFFFF, 0xFFFF, 0xF79E, 0x6B8E, 0x2966, 0x2986, 0x2965, 0x2965, 0x738E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2DD0 (11728)
+0xFFFF, 0xF79E, 0x6B8E, 0x2966, 0x2966, 0x2966, 0x738E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E,   // 0x2DE0 (11744)
+0x73AE, 0x2966, 0x2986, 0x2986, 0x3186, 0x738E, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x738E,   // 0x2DF0 (11760)
+0x2966, 0x2966, 0x2965, 0x2966, 0x2966, 0x2965, 0x2945, 0x2946, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2E00 (11776)
+0x2965, 0x2945, 0x2945, 0x2965, 0x2965, 0x2965, 0x2145, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2E10 (11792)
+0x2945, 0x2945, 0x2946, 0x2946, 0x2966, 0x2966, 0x2966, 0x2966, 0x2124, 0x8C71, 0xEF7E, 0xDF1C, 0xDEFC, 0xDEFC, 0xDF1C, 0xDF1C,   // 0x2E20 (11808)
+0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1D, 0xDF1C, 0xDF1D, 0xDF1D, 0xDF3C, 0xDF1C, 0xDF1D, 0xDF3C,   // 0x2E30 (11824)
+0xDF1C, 0xDF1C, 0xDF1C, 0xDF1C, 0xDEFC, 0xDEFC, 0xD71C, 0xD71C, 0xD6FC, 0xD6FC, 0xD6FC, 0xD6DB, 0xCEBB, 0xC67A, 0xC639, 0xBDF8,   // 0x2E40 (11840)
+0x3186, 0x31A6, 0x31A7, 0x31A6, 0x31A6, 0x3186, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2985, 0x2986, 0x2986, 0x3186, 0x31A6,   // 0x2E50 (11856)
+0x31A6, 0x31C7, 0x31E7, 0x31C7, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x8C71, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2E60 (11872)
+0xFFFF, 0xEF7D, 0x8C71, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x8C51, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x2E70 (11888)
+0xEF7D, 0x8C71, 0x31C7, 0x31A6, 0x3186, 0x3186, 0x31A6, 0x8C71, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0x8C71,   // 0x2E80 (11904)
+0x31C6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A7, 0x8C72, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0x8C51, 0x3186,   // 0x2E90 (11920)
+0x3186, 0x3186, 0x3186, 0x3186, 0x2965, 0x2965, 0x2965, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945,   // 0x2EA0 (11936)
+0x2965, 0x2945, 0x2965, 0x2965, 0x2965, 0x2966, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2946, 0x2945, 0x2945, 0x2945,   // 0x2EB0 (11952)
+0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2965, 0x2925, 0x4208, 0xD6BA, 0xDEFC, 0xD6FC, 0xD6FC, 0xD6DB, 0xDEFC,   // 0x2EC0 (11968)
+0xD6FB, 0xD6FB, 0xDEFC, 0xDEFB, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFB, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xDEFC, 0xD6FC,   // 0x2ED0 (11984)
+0xD6FC, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DC, 0xD6BB, 0xCEBB, 0xCE9B, 0xCE9B, 0xCE9A, 0xC65A, 0xC639, 0xBE19,   // 0x2EE0 (12000)
+0x2986, 0x2986, 0x31A6, 0x31A6, 0x2985, 0x3186, 0x2985, 0x2985, 0x2965, 0x2985, 0x2985, 0x2985, 0x2986, 0x3186, 0x2986, 0x2986,   // 0x2EF0 (12016)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x31A6, 0x6B6D, 0xAD55, 0xDEDB, 0xFFDF, 0xDEFB,   // 0x2F00 (12032)
+0xAD75, 0x6B6D, 0x31A6, 0x39C6, 0x31C6, 0x31C6, 0x31C7, 0x31C7, 0x31A6, 0x31C6, 0x6B6D, 0xAD75, 0xDEFB, 0xFFDF, 0xDEFB, 0xAD55,   // 0x2F10 (12048)
+0x6B6D, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31C6, 0x31A6, 0x39C6, 0x6B6D, 0xAD55, 0xDEFB, 0xFFDF, 0xDEFB, 0xAD55, 0x6B6D, 0x31A6,   // 0x2F20 (12064)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x6B6D, 0xAD55, 0xDEFB, 0xFFDF, 0xDEFB, 0xAD75, 0x6B6D, 0x3186, 0x31A6,   // 0x2F30 (12080)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x3186,   // 0x2F40 (12096)
+0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3166, 0x3166, 0x2965, 0x2965, 0x3186, 0x2965, 0x2965, 0x3165,   // 0x2F50 (12112)
+0x2965, 0x3165, 0x2965, 0x3166, 0x3166, 0x3166, 0x2966, 0x2966, 0x3166, 0x31A6, 0xBDF7, 0xDF1C, 0xDEDB, 0xD6DB, 0xDEFB, 0xDEFB,   // 0x2F60 (12128)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xD6FB,   // 0x2F70 (12144)
+0xDEFB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6DB, 0xD6BB, 0xD6BB, 0xD6BB, 0xCEBA, 0xCE9A, 0xCE9A, 0xCE7A, 0xC679, 0xC659, 0xC639,   // 0x2F80 (12160)
+0x2985, 0x2985, 0x2985, 0x29A6, 0x2985, 0x2985, 0x2985, 0x2985, 0x2985, 0x3186, 0x2986, 0x2985, 0x2985, 0x3185, 0x2985, 0x2985,   // 0x2F90 (12176)
+0x2985, 0x2985, 0x2985, 0x2985, 0x2985, 0x2986, 0x2986, 0x3186, 0x2986, 0x3186, 0x3186, 0x3186, 0x3185, 0x31A6, 0x3186, 0x3186,   // 0x2FA0 (12192)
+0x3186, 0x31A6, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A7, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x2FB0 (12208)
+0x31A5, 0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3185, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x2FC0 (12224)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x2FD0 (12240)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186,   // 0x2FE0 (12256)
+0x3186, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3166, 0x3186, 0x3186, 0x3186, 0x3166, 0x3186, 0x3166,   // 0x2FF0 (12272)
+0x3165, 0x3165, 0x3186, 0x3166, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x39C6, 0xC618, 0xE73C, 0xDF1B, 0xDF1B, 0xDF1B, 0xE71B,   // 0x3000 (12288)
+0xE73B, 0xE73C, 0xE73C, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73C, 0xDF3C, 0xE71C, 0xE71C, 0xE71B, 0xDF1B,   // 0x3010 (12304)
+0xDF1B, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xD6DB, 0xD6DB, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xCE9A, 0xCE9A, 0xCE9A, 0xCE9A,   // 0x3020 (12320)
+0x2985, 0x2985, 0x29A5, 0x2985, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3185, 0x3185, 0x2985,   // 0x3030 (12336)
+0x29A5, 0x29A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x3040 (12352)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31C6,   // 0x3050 (12368)
+0x31C6, 0x31C6, 0x31A6, 0x31A6, 0x39C6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x39C6, 0x39C6, 0x39C6, 0x31A6,   // 0x3060 (12384)
+0x31A6, 0x3186, 0x31A6, 0x3185, 0x3185, 0x3185, 0x3186, 0x3185, 0x3186, 0x31A6, 0x39C7, 0x39E7, 0x39E7, 0x4228, 0x4208, 0x4228,   // 0x3070 (12400)
+0x4A49, 0x4228, 0x4208, 0x4208, 0x41E8, 0x41E7, 0x41E7, 0x39C7, 0x39C7, 0x39C7, 0x39C7, 0x39C7, 0x39A7, 0x39A6, 0x39A6, 0x39A6,   // 0x3080 (12416)
+0x39C7, 0x39C7, 0x39C7, 0x39C7, 0x39A7, 0x31A7, 0x31A6, 0x39A6, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186,   // 0x3090 (12432)
+0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x3186, 0x31A6, 0x39C7, 0x39C7, 0x4208, 0xCE79, 0xE73C, 0xE73B, 0xE73B, 0xE73B, 0xE75B,   // 0x30A0 (12448)
+0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE75C, 0xE73C, 0xE73C, 0xE75C, 0xE75C, 0xE73C, 0xE73B, 0xE73B, 0xE73B,   // 0x30B0 (12464)
+0xE73B, 0xE73B, 0xE71B, 0xE71B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDEFB, 0xDEDA, 0xDEDA, 0xDEDA, 0xD6DA, 0xD6FB, 0xDEFB, 0xDEFB,   // 0x30C0 (12480)
+0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31C6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x30D0 (12496)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6,   // 0x30E0 (12512)
+0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A5, 0x31A6, 0x31A6, 0x3186, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A5, 0x31A5,   // 0x30F0 (12528)
+0x3185, 0x2985, 0x31A6, 0x3185, 0x31A5, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x31A6, 0x3185, 0x3185, 0x2965, 0x3165, 0x2944, 0x2924,   // 0x3100 (12544)
+0x2924, 0x2924, 0x2924, 0x2924, 0x2944, 0x2945, 0x3185, 0x3185, 0x31A6, 0x39C6, 0x39E7, 0x41E7, 0x41E7, 0x4208, 0x41E7, 0x4208,   // 0x3110 (12560)
+0x4208, 0x39C7, 0x39C7, 0x39C7, 0x39A7, 0x39A6, 0x39A6, 0x39A6, 0x3185, 0x3185, 0x3185, 0x3165, 0x3165, 0x3165, 0x3165, 0x3165,   // 0x3120 (12576)
+0x3145, 0x2945, 0x2945, 0x2945, 0x2945, 0x2945, 0x2924, 0x2924, 0x2924, 0x2944, 0x2924, 0x2925, 0x2924, 0x2924, 0x2924, 0x2945,   // 0x3130 (12592)
+0x2945, 0x2945, 0x2925, 0x2965, 0x2985, 0x3186, 0x39C7, 0x39C7, 0x31A7, 0x4208, 0xCE79, 0xE73B, 0xE71A, 0xE73A, 0xE73A, 0xE73A,   // 0x3140 (12608)
+0xE73B, 0xE73B, 0xE73B, 0xE75B, 0xE75B, 0xE75B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B, 0xE73B,   // 0x3150 (12624)
+0xE73B, 0xE73B, 0xE73A, 0xE73A, 0xDF1A, 0xDF1A, 0xDF1A, 0xDF1A, 0xDEFA, 0xDEFA, 0xDEFA, 0xDEFA, 0xDEFA, 0xDF1A, 0xDF1A, 0xDF1A,   // 0x3160 (12640)
+0x2966, 0x2966, 0x2965, 0x2966, 0x2965, 0x2965, 0x2985, 0x2985, 0x2985, 0x3185, 0x3186, 0x3186, 0x3186, 0x3185, 0x2965, 0x2965,   // 0x3170 (12656)
+0x2965, 0x2965, 0x2965, 0x2965, 0x2985, 0x2985, 0x2985, 0x3185, 0x31A6, 0x3186, 0x3186, 0x3186, 0x3186, 0x3185, 0x3186, 0x2985,   // 0x3180 (12672)
+0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2965, 0x2985, 0x2965, 0x2965, 0x2945, 0x2945, 0x2965, 0x2965, 0x2965, 0x3186, 0x3186,   // 0x3190 (12688)
+0x3185, 0x3185, 0x3185, 0x3185, 0x3165, 0x3165, 0x2944, 0x2944, 0x2924, 0x2103, 0x2103, 0x20E3, 0x18E2, 0x18C2, 0x18C2, 0x18C2,   // 0x31A0 (12704)
+0x20C2, 0x20C3, 0x20C3, 0x20C3, 0x20E3, 0x2124, 0x2104, 0x2104, 0x2103, 0x2924, 0x2924, 0x2904, 0x2104, 0x2104, 0x2924, 0x2104,   // 0x31B0 (12720)
+0x2104, 0x2104, 0x2104, 0x2104, 0x20E3, 0x20E3, 0x20E3, 0x20E3, 0x20C2, 0x18C2, 0x18C2, 0x18C2, 0x2103, 0x2103, 0x2103, 0x2103,   // 0x31C0 (12736)
+0x2924, 0x2904, 0x2104, 0x2103, 0x2904, 0x2924, 0x2924, 0x2924, 0x2904, 0x2924, 0x2924, 0x2924, 0x2904, 0x2903, 0x2104, 0x2104,   // 0x31D0 (12752)
+0x2924, 0x2925, 0x31A6, 0x3186, 0x39C7, 0x39C7, 0x39E7, 0x4208, 0x39E8, 0x4A6A, 0xC617, 0xDEDA, 0xE71B, 0xE71B, 0xE71B, 0xE71B,   // 0x31E0 (12768)
+0xE73B, 0xE71B, 0xE71C, 0xE71B, 0xE71B, 0xE71C, 0xE71C, 0xE71B, 0xE71B, 0xE71C, 0xE71B, 0xE71B, 0xE71B, 0xE71C, 0xE71B, 0xE71B,   // 0x31F0 (12784)
+0xE71C, 0xE73B, 0xE73B, 0xE73B, 0xE71B, 0xDF3B, 0xDF3B, 0xE71B, 0xE71B, 0xE71B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDF1B, 0xDF1B, 0xD6FA,   // 0x3200 (12800)
+};

_719/clokk.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: clokk.jpg
+// Time generated: 14.09.2015 16:54:41
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short clokk[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00D0 (208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0110 (272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0120 (288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01A0 (416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01B0 (432)
+0x001F, 0x089D, 0x297A, 0x31D5, 0x31AF, 0x31AA, 0x29A7, 0x2966, 0x2145, 0x2946, 0x2966, 0x2986, 0x31AA, 0x29AF, 0x29B3, 0x31BA,   // 0x01C0 (448)
+0x10BD, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01D0 (464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x107E, 0x2178,   // 0x0200 (512)
+0x39D1, 0x2987, 0x2145, 0x2105, 0x2124, 0x2125, 0x2966, 0x2987, 0x31A7, 0x31A7, 0x2987, 0x2966, 0x2145, 0x2125, 0x2125, 0x2125,   // 0x0210 (528)
+0x2967, 0x31CE, 0x2996, 0x089D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0220 (544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BE, 0x31B5, 0x31A9, 0x2145,   // 0x0250 (592)
+0x2124, 0x2966, 0x39E9, 0x4AAC, 0x73F1, 0x84B5, 0x9538, 0x9D99, 0xA5BA, 0xA5BA, 0x9D9A, 0x9D58, 0x8CD6, 0x7413, 0x52ED, 0x3A09,   // 0x0260 (608)
+0x2166, 0x2125, 0x2125, 0x2988, 0x31D3, 0x18DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0270 (624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0290 (656)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F, 0x2996, 0x2989, 0x2125, 0x2125, 0x31C8,   // 0x02A0 (672)
+0x5B4F, 0x8CF7, 0xAE3C, 0xBE9E, 0xBEBF, 0xC6DF, 0xBEBF, 0xBEBE, 0xBEBF, 0xBEBF, 0xBEBE, 0xBEBE, 0xBEBF, 0xC6DF, 0xBE9F, 0xB63C,   // 0x02B0 (688)
+0x9538, 0x6390, 0x3A09, 0x2125, 0x2124, 0x2987, 0x31D4, 0x10BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x193C, 0x31AC, 0x2945, 0x2145, 0x39E9, 0x7412, 0xAE1B,   // 0x02F0 (752)
+0xBEBF, 0xBEBF, 0xBE9E, 0xBE9E, 0xC6BF, 0xBEBF, 0xBEBF, 0xBE9E, 0xBE7D, 0xB67D, 0xBE9E, 0xBEBF, 0xBEBF, 0xBEBF, 0xBE9F, 0xBE9E,   // 0x0300 (768)
+0xBEBF, 0xBEBF, 0xB63C, 0x7C74, 0x424A, 0x2145, 0x2125, 0x318A, 0x297A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0310 (784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0330 (816)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31B8, 0x2966, 0x2145, 0x2986, 0x6B90, 0xAE1C, 0xC6BF, 0xBE9E,   // 0x0340 (832)
+0xBE9E, 0xC6DF, 0xB67E, 0xA5BA, 0x84B5, 0x6370, 0x52ED, 0x4AAC, 0x426B, 0x426A, 0x4A8B, 0x52CD, 0x5B4F, 0x7C74, 0x9D99, 0xB65D,   // 0x0350 (848)
+0xC6BF, 0xBE9E, 0xBE9E, 0xBEBF, 0xB65D, 0x7C33, 0x31C8, 0x2145, 0x2146, 0x39F4, 0x005F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0360 (864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0380 (896)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31B3, 0x2945, 0x2145, 0x424A, 0x9D79, 0xBEDF, 0xBE9E, 0xBE9E, 0xC6DF,   // 0x0390 (912)
+0xADFB, 0x73F2, 0x426B, 0x2986, 0x2145, 0x2145, 0x2145, 0x2966, 0x2966, 0x2966, 0x2966, 0x2965, 0x2145, 0x2145, 0x2966, 0x422A,   // 0x03A0 (928)
+0x6391, 0xA5BA, 0xBEBF, 0xBEBE, 0xBE9E, 0xBEDF, 0xADFB, 0x52ED, 0x2125, 0x2145, 0x31CF, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03B0 (944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03D0 (976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x31F3, 0x2125, 0x2145, 0x530E, 0xAE3C, 0xBEBF, 0xBE9E, 0xBEDF, 0xADFB, 0x6BB1,   // 0x03E0 (992)
+0x31C8, 0x2125, 0x2966, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2986, 0x2966,   // 0x03F0 (1008)
+0x1925, 0x2987, 0x632F, 0xA59A, 0xC6DF, 0xBE9F, 0xBE9E, 0xBE9E, 0x6BD1, 0x2966, 0x2125, 0x31AE, 0x087F, 0x001F, 0x001F, 0x001F,   // 0x0400 (1024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0420 (1056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x31F4, 0x2125, 0x2126, 0x6BB1, 0xBE9E, 0xBE9E, 0xBE9E, 0xBE9E, 0x7C73, 0x31C8, 0x2125,   // 0x0430 (1072)
+0x2966, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987, 0x2986,   // 0x0440 (1088)
+0x2986, 0x2966, 0x2125, 0x2987, 0x6BD1, 0xB65D, 0xBEBF, 0xBE9E, 0xC6DF, 0x8474, 0x2966, 0x2125, 0x31CF, 0x085F, 0x001F, 0x001F,   // 0x0450 (1104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0470 (1136)
+0x001F, 0x001F, 0x001F, 0x001F, 0x39F5, 0x2125, 0x2145, 0x6BD2, 0xBEBF, 0xBE7E, 0xBEBF, 0xADFB, 0x52CD, 0x2125, 0x2966, 0x2987,   // 0x0480 (1152)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2987, 0x2986, 0x2986, 0x2966, 0x2987, 0x2166, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0490 (1168)
+0x2987, 0x3186, 0x2987, 0x2986, 0x2125, 0x424A, 0x9D79, 0xC6BF, 0xBE7E, 0xC6DF, 0x84B5, 0x2966, 0x2125, 0x31D0, 0x005F, 0x001F,   // 0x04A0 (1184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04C0 (1216)
+0x001F, 0x001F, 0x001F, 0x31BA, 0x2145, 0x2125, 0x6390, 0xBEBF, 0xBE9E, 0xBEDF, 0x9D58, 0x31C8, 0x2145, 0x2987, 0x2986, 0x2986,   // 0x04D0 (1232)
+0x2986, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x8495, 0xA59A, 0x4AAC, 0x2166, 0x2987, 0x2987, 0x2986, 0x2987,   // 0x04E0 (1248)
+0x2987, 0x2987, 0x2986, 0x2987, 0x2986, 0x2945, 0x2986, 0x84B5, 0xC6DF, 0xB69E, 0xC6DF, 0x7C54, 0x2145, 0x2125, 0x39D5, 0x001F,   // 0x04F0 (1264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0510 (1296)
+0x001F, 0x001F, 0x18FE, 0x2988, 0x2125, 0x52CC, 0xBE9E, 0xBE9E, 0xC6DF, 0x9538, 0x29A7, 0x2946, 0x2987, 0x2986, 0x2987, 0x2987,   // 0x0520 (1312)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xBE9E, 0xC6FF, 0x8494, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x0530 (1328)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x2146, 0x7C74, 0xC6BF, 0xBE9E, 0xBEBF, 0x6390, 0x2125, 0x2945, 0x297C,   // 0x0540 (1344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0560 (1376)
+0x001F, 0x001F, 0x39F0, 0x2125, 0x3A09, 0xADFC, 0xBE9E, 0xBEBF, 0xA599, 0x31A8, 0x2946, 0x2987, 0x2986, 0x2987, 0x2986, 0x2987,   // 0x0570 (1392)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x0580 (1408)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2946, 0x8CD6, 0xBEBF, 0xBE9E, 0xB67E, 0x4AAC, 0x2125, 0x31AB,   // 0x0590 (1424)
+0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05B0 (1456)
+0x001F, 0x299C, 0x2145, 0x2166, 0x8CD6, 0xC6DF, 0xBE9E, 0xB65D, 0x3A2A, 0x2945, 0x3187, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987,   // 0x05C0 (1472)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x05D0 (1488)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x29A7, 0xA5BA, 0xC6BF, 0xBEBE, 0xA5BA, 0x3187, 0x2125,   // 0x05E0 (1504)
+0x31D6, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0600 (1536)
+0x003F, 0x31ED, 0x2104, 0x52ED, 0xBE9F, 0xBE7E, 0xBEBF, 0x636F, 0x2125, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0610 (1552)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x0620 (1568)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2145, 0x4A8B, 0xBE7E, 0xB69E, 0xC6BF, 0x6BD1, 0x2124,   // 0x0630 (1584)
+0x29A9, 0x10BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0650 (1616)
+0x297B, 0x2145, 0x2967, 0x9D79, 0xBEBF, 0xBEBF, 0x9517, 0x2946, 0x2986, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0660 (1632)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x424A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2986,   // 0x0670 (1648)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2125, 0x7432, 0xBEDF, 0xBE9E, 0xAE1C, 0x39E9,   // 0x0680 (1664)
+0x2105, 0x31F7, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06A0 (1696)
+0x31F0, 0x2105, 0x5B0E, 0xBEBF, 0xBE7E, 0xBE7D, 0x426B, 0x2946, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2987, 0x2987, 0x2987,   // 0x06B0 (1712)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2966, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2987, 0x2987, 0x2987,   // 0x06C0 (1728)
+0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x31A8, 0xADFB, 0xBE9E, 0xC6DF, 0x73F2,   // 0x06D0 (1744)
+0x2125, 0x31AA, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FE,   // 0x06F0 (1776)
+0x2966, 0x2145, 0x9517, 0xBEBF, 0xC6DF, 0x84B5, 0x2125, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986,   // 0x0700 (1792)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2166, 0x3A2A, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2986, 0x2986, 0x2986, 0x2987,   // 0x0710 (1808)
+0x2986, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2125, 0x6BB1, 0xC6DF, 0xBE9E, 0xA5DB,   // 0x0720 (1824)
+0x31A7, 0x2125, 0x299B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x29B7,   // 0x0740 (1856)
+0x2125, 0x422A, 0xB65D, 0xBE9E, 0xB67E, 0x4A8B, 0x2145, 0x2987, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2987,   // 0x0750 (1872)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x3A2A, 0xB65D, 0xC6DF, 0x7C74, 0x2125, 0x2986, 0x2986, 0x2986, 0x2987,   // 0x0760 (1888)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2987, 0x2987, 0x2986, 0x2986, 0x2966, 0x31C8, 0xAE3C, 0xBE9E, 0xBEBE,   // 0x0770 (1904)
+0x5AED, 0x1904, 0x39F1, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31CE,   // 0x0790 (1936)
+0x1904, 0x6BB1, 0xC6DF, 0xBEBF, 0x9537, 0x2945, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x07A0 (1952)
+0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2987, 0x2166, 0x422A, 0xB65D, 0xC6DF, 0x7C74, 0x2125, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x07B0 (1968)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2966, 0x2125, 0x7C74, 0xBEBF, 0xBEBF,   // 0x07C0 (1984)
+0x84B5, 0x2125, 0x31A9, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109E, 0x29A9,   // 0x07E0 (2016)
+0x2125, 0x9517, 0xBEBF, 0xC6DF, 0x63B1, 0x2125, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x07F0 (2032)
+0x2966, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2165, 0x422A, 0xB67D, 0xC6DF, 0x7C74, 0x2145, 0x2986, 0x2987, 0x2986, 0x2986,   // 0x0800 (2048)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2145, 0x4AAC, 0xBE9E, 0xBEBE,   // 0x0810 (2064)
+0xA5BA, 0x2986, 0x2146, 0x213D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x191C, 0x2165,   // 0x0830 (2096)
+0x31A7, 0xA5DB, 0xBEBE, 0xBE9E, 0x426B, 0x2146, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0840 (2112)
+0x2987, 0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2166, 0x422A, 0xB65D, 0xC6DF, 0x8494, 0x2125, 0x2987, 0x2986, 0x2986, 0x2986,   // 0x0850 (2128)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2966, 0x31C8, 0xAE1C, 0xBE9E,   // 0x0860 (2144)
+0xB65D, 0x424A, 0x2105, 0x29B8, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x2999, 0x2125,   // 0x0880 (2176)
+0x426B, 0xB67D, 0xBE9E, 0xADFB, 0x31C8, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0890 (2192)
+0x2986, 0x2986, 0x2987, 0x2986, 0x2986, 0x2987, 0x2946, 0x4229, 0xB65D, 0xC6DF, 0x7C74, 0x2145, 0x2987, 0x2986, 0x2986, 0x2986,   // 0x08A0 (2208)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2945, 0x9517, 0xBEBF,   // 0x08B0 (2224)
+0xBEBE, 0x5B0E, 0x2104, 0x31B3, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39F4, 0x2104,   // 0x08D0 (2256)
+0x52ED, 0xBEBE, 0xBEBF, 0x9537, 0x2145, 0x2987, 0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x08E0 (2272)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2145, 0x3A09, 0xB67D, 0xC6DF, 0x7C74, 0x1905, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x08F0 (2288)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987, 0x2125, 0x7C74, 0xBEBF,   // 0x0900 (2304)
+0xBEDF, 0x6BD1, 0x2104, 0x29AE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31CE, 0x2105,   // 0x0920 (2336)
+0x6370, 0xBEBF, 0xBEDF, 0x8CD6, 0x2145, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0930 (2352)
+0x2987, 0x2986, 0x2987, 0x2986, 0x2987, 0x2986, 0x2986, 0x8495, 0xBE9E, 0xBE9E, 0xAE1B, 0x4AAC, 0x2145, 0x2986, 0x2987, 0x2986,   // 0x0940 (2368)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987, 0x2987, 0x2986, 0x2125, 0x6BD1, 0xC6DF,   // 0x0950 (2384)
+0xBEDF, 0x8495, 0x2145, 0x296B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x214B, 0x2126,   // 0x0970 (2416)
+0x6BB1, 0xC6DF, 0xBEBF, 0x7C74, 0x2125, 0x2986, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0980 (2432)
+0x2986, 0x2987, 0x2986, 0x2987, 0x2987, 0x2145, 0x6BB0, 0xC6DF, 0xB67E, 0xB67E, 0xBEBE, 0xA5DA, 0x31C8, 0x2966, 0x2967, 0x2986,   // 0x0990 (2448)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2987, 0x2125, 0x5B4F, 0xBEBF,   // 0x09A0 (2464)
+0xBEBF, 0x8CD6, 0x2145, 0x212A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x2129, 0x2125,   // 0x09C0 (2496)
+0x6BD1, 0xC6BF, 0xBEBF, 0x7434, 0x2125, 0x2986, 0x2986, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x09D0 (2512)
+0x2986, 0x2987, 0x2986, 0x2986, 0x2986, 0x2125, 0x8CD6, 0xBEDF, 0xB67E, 0xB67D, 0xB67E, 0xB67E, 0x422A, 0x2946, 0x2986, 0x2986,   // 0x09E0 (2528)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2125, 0x5B2E, 0xBEBF,   // 0x09F0 (2544)
+0xBEBF, 0x8CD7, 0x2145, 0x212A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x212A, 0x2125,   // 0x0A10 (2576)
+0x6BD1, 0xC6BF, 0xBEBF, 0x7C54, 0x2125, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0A20 (2592)
+0x2986, 0x2966, 0x2966, 0x2987, 0x2986, 0x2125, 0x7C54, 0xC6FF, 0xB69D, 0xBE7E, 0xB67E, 0xBE7E, 0x4AAC, 0x2125, 0x2966, 0x2986,   // 0x0A30 (2608)
+0x2966, 0x2986, 0x2986, 0x2986, 0x2966, 0x2966, 0x2986, 0x2967, 0x2986, 0x2966, 0x2966, 0x2986, 0x2967, 0x2125, 0x5B2F, 0xBEBE,   // 0x0A40 (2624)
+0xBEBF, 0x8CD6, 0x2945, 0x212A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x298C, 0x2125,   // 0x0A60 (2656)
+0x6390, 0xC6DF, 0xBEBF, 0x84B5, 0x2145, 0x2986, 0x2966, 0x2987, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0A70 (2672)
+0x2987, 0x2966, 0x2986, 0x2986, 0x2987, 0x2966, 0x3A29, 0xADFB, 0xC6DF, 0xBEDF, 0xBE9E, 0xBE9E, 0xADFC, 0x424A, 0x2125, 0x2986,   // 0x0A80 (2688)
+0x2986, 0x2967, 0x2987, 0x2966, 0x2967, 0x2986, 0x2966, 0x2986, 0x2986, 0x2987, 0x2987, 0x2986, 0x3187, 0x2125, 0x6390, 0xBEBF,   // 0x0A90 (2704)
+0xBEBF, 0x84B6, 0x2125, 0x214A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31F2, 0x1904,   // 0x0AB0 (2736)
+0x5B0E, 0xBEBF, 0xBEBF, 0x8CF7, 0x2945, 0x2987, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0AC0 (2752)
+0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x3187, 0x2145, 0x3A09, 0x7413, 0x8495, 0xB65C, 0xBE9E, 0xBEBF, 0xAE1C, 0x426A, 0x2125,   // 0x0AD0 (2768)
+0x2987, 0x3187, 0x2966, 0x2987, 0x2987, 0x2966, 0x2987, 0x2966, 0x2986, 0x2966, 0x2987, 0x2986, 0x2986, 0x2125, 0x7433, 0xBEBF,   // 0x0AE0 (2784)
+0xBEBF, 0x7433, 0x2124, 0x298E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x29B7, 0x2125,   // 0x0B00 (2816)
+0x4A8B, 0xBE9E, 0xBEBE, 0x9D9A, 0x2986, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0B10 (2832)
+0x2986, 0x2986, 0x2986, 0x2987, 0x2986, 0x2966, 0x2987, 0x2966, 0x2125, 0x2104, 0x52CC, 0xB65D, 0xBE9E, 0xBEBE, 0xAE1C, 0x426A,   // 0x0B20 (2848)
+0x2125, 0x2987, 0x2987, 0x2986, 0x2986, 0x2986, 0x2967, 0x2967, 0x2986, 0x2986, 0x2966, 0x2986, 0x2986, 0x2945, 0x8CD6, 0xBEBF,   // 0x0B30 (2864)
+0xBEBF, 0x5B4F, 0x1904, 0x31B1, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x215A, 0x2125,   // 0x0B50 (2896)
+0x39E8, 0xAE3C, 0xBE9E, 0xB65D, 0x3A2A, 0x2945, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0B60 (2912)
+0x2966, 0x2987, 0x2986, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2967, 0x2125, 0x52CD, 0xB65E, 0xBE9E, 0xC69F, 0xAE3C,   // 0x0B70 (2928)
+0x4AAC, 0x2125, 0x2986, 0x2987, 0x2986, 0x2987, 0x2966, 0x2986, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2987, 0xA5BA, 0xBEBF,   // 0x0B80 (2944)
+0xBE9E, 0x4AAC, 0x2105, 0x31D7, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18DE, 0x2987,   // 0x0BA0 (2976)
+0x2146, 0x9558, 0xBEBF, 0xBEBF, 0x5B2F, 0x2145, 0x2966, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0BB0 (2992)
+0x2986, 0x2966, 0x2987, 0x2966, 0x2986, 0x2986, 0x2986, 0x2987, 0x2966, 0x2967, 0x2986, 0x2125, 0x52CC, 0xB65D, 0xBE9E, 0xBE9F,   // 0x0BC0 (3008)
+0xB65D, 0x4AAC, 0x2125, 0x2987, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2966, 0x2946, 0x424A, 0xB67E, 0xBE9E,   // 0x0BD0 (3024)
+0xAE1C, 0x31C8, 0x2145, 0x297C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31ED,   // 0x0BF0 (3056)
+0x1904, 0x7C33, 0xC6DF, 0xBEBF, 0x8495, 0x2125, 0x2966, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986,   // 0x0C00 (3072)
+0x2986, 0x2986, 0x2987, 0x2986, 0x2966, 0x2986, 0x2987, 0x2986, 0x2967, 0x3187, 0x2986, 0x2967, 0x2125, 0x52CD, 0xBE9E, 0xBE9E,   // 0x0C10 (3088)
+0xBE9E, 0xB63D, 0x426B, 0x2125, 0x2986, 0x2986, 0x2967, 0x2986, 0x2986, 0x2986, 0x2986, 0x2986, 0x2125, 0x6BB1, 0xBEBF, 0xBEBF,   // 0x0C20 (3104)
+0x9517, 0x2145, 0x29A7, 0x18DE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31D4,   // 0x0C40 (3136)
+0x2104, 0x4AAC, 0xBE9E, 0xBE9E, 0xAE1C, 0x31E8, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0C50 (3152)
+0x2967, 0x2966, 0x2986, 0x2967, 0x2967, 0x2966, 0x2967, 0x2966, 0x2986, 0x2967, 0x2986, 0x2986, 0x2966, 0x2125, 0x5B0E, 0xBE9E,   // 0x0C60 (3168)
+0xBE9E, 0xBEBF, 0xAE1C, 0x424A, 0x2125, 0x2987, 0x2986, 0x2966, 0x2986, 0x2966, 0x2967, 0x2966, 0x2986, 0xA599, 0xBEBF, 0xC6DF,   // 0x0C70 (3184)
+0x63B0, 0x1904, 0x31CE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x217C,   // 0x0C90 (3216)
+0x2125, 0x2986, 0xA5BA, 0xBEBE, 0xC6DF, 0x6BD2, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2967, 0x2967, 0x2966, 0x2986,   // 0x0CA0 (3232)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2125, 0x5B0D,   // 0x0CB0 (3248)
+0xB67D, 0xBE9E, 0xBEBF, 0xAE1C, 0x424B, 0x2125, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2125, 0x52ED, 0xBEBF, 0xBE9E, 0xB63D,   // 0x0CC0 (3264)
+0x3A09, 0x1904, 0x31F8, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F,   // 0x0CE0 (3296)
+0x31CB, 0x1904, 0x6BB1, 0xC6DF, 0xBE9E, 0xADFB, 0x31A7, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2986, 0x2966,   // 0x0CF0 (3312)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x1905,   // 0x0D00 (3328)
+0x52CC, 0xBE7E, 0xBE9E, 0xBEBE, 0xAE1C, 0x424A, 0x2125, 0x2966, 0x2986, 0x2966, 0x2966, 0x2946, 0x9538, 0xBEBE, 0xBEBF, 0x84B5,   // 0x0D10 (3344)
+0x2125, 0x2967, 0x18FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D30 (3376)
+0x31D7, 0x2104, 0x31C8, 0xAE1C, 0xBE9E, 0xBEDF, 0x73F2, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2986,   // 0x0D40 (3392)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986,   // 0x0D50 (3408)
+0x2125, 0x52CC, 0xBE7D, 0xBE9E, 0xBEBE, 0xAE1C, 0x422A, 0x2145, 0x2986, 0x2966, 0x2125, 0x5B0E, 0xBEBF, 0xBE7E, 0xBE9E, 0x4A6B,   // 0x0D60 (3424)
+0x20E4, 0x3A12, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D80 (3456)
+0x10BE, 0x2988, 0x1904, 0x73D2, 0xC6DF, 0xBE9E, 0xB65E, 0x424A, 0x2925, 0x2966, 0x2966, 0x2967, 0x2967, 0x2986, 0x2966, 0x2967,   // 0x0D90 (3472)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0DA0 (3488)
+0x2967, 0x2105, 0x52CC, 0xB67E, 0xBEBF, 0xC6FF, 0x7C74, 0x2125, 0x2966, 0x2946, 0x31A7, 0xA5DB, 0xBE9E, 0xBEDF, 0x84D6, 0x2125,   // 0x0DB0 (3504)
+0x2146, 0x213C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DD0 (3536)
+0x001F, 0x39F7, 0x2104, 0x29A7, 0xA5BA, 0xBE9E, 0xC6BF, 0x9D79, 0x2966, 0x2966, 0x2967, 0x2967, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0DE0 (3552)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0DF0 (3568)
+0x2986, 0x2967, 0x2125, 0x52AC, 0xAE1C, 0xB65D, 0x52ED, 0x2145, 0x2966, 0x2125, 0x84B5, 0xC6DF, 0xBE9E, 0xB65D, 0x3A29, 0x1904,   // 0x0E00 (3584)
+0x39F2, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E20 (3616)
+0x001F, 0x109F, 0x31AA, 0x1904, 0x52ED, 0xBE9E, 0xBE9E, 0xC6DF, 0x7C54, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0E30 (3632)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0E40 (3648)
+0x2966, 0x2986, 0x2966, 0x2145, 0x31A7, 0x31C8, 0x2146, 0x2967, 0x2105, 0x636F, 0xBEBF, 0xB69D, 0xBEBF, 0x6BB1, 0x2105, 0x2966,   // 0x0E50 (3664)
+0x211D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E70 (3696)
+0x001F, 0x001F, 0x299A, 0x2145, 0x2125, 0x6BF1, 0xC6DF, 0xBE9E, 0xBEBF, 0x6BD1, 0x2125, 0x2966, 0x2966, 0x2986, 0x2986, 0x2966,   // 0x0E80 (3712)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0E90 (3728)
+0x2966, 0x2966, 0x2967, 0x2986, 0x2946, 0x2966, 0x2967, 0x2105, 0x52ED, 0xB67E, 0xBE9E, 0xBEDF, 0x8CD6, 0x2124, 0x2125, 0x39F6,   // 0x0EA0 (3744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EC0 (3776)
+0x001F, 0x001F, 0x001F, 0x39F2, 0x2125, 0x2145, 0x8CD6, 0xC6DF, 0xBE9E, 0xBE9F, 0x6BF1, 0x2125, 0x2946, 0x2967, 0x2966, 0x2986,   // 0x0ED0 (3792)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0EE0 (3808)
+0x2967, 0x2966, 0x2987, 0x2966, 0x2966, 0x2966, 0x2124, 0x5B0E, 0xB67D, 0xBE9E, 0xBEDE, 0x9D9A, 0x31A7, 0x2125, 0x31CD, 0x085F,   // 0x0EF0 (3824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F10 (3856)
+0x001F, 0x001F, 0x001F, 0x087F, 0x31CD, 0x2105, 0x2986, 0x9538, 0xC6DF, 0xBE9E, 0xBEBF, 0x7C74, 0x3187, 0x2125, 0x2966, 0x2967,   // 0x0F20 (3872)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2986, 0x2967, 0x2966, 0x2966, 0x2986, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0F30 (3888)
+0x2987, 0x2966, 0x2967, 0x2966, 0x2925, 0x2946, 0x73F2, 0xBE9E, 0xBE9E, 0xBEBF, 0xA5FB, 0x39E9, 0x2105, 0x2988, 0x211E, 0x001F,   // 0x0F40 (3904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F60 (3936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x18FE, 0x31AB, 0x1904, 0x31A7, 0x9558, 0xBEDF, 0xBE9E, 0xC6BF, 0xA59A, 0x4AAB, 0x2125, 0x2145,   // 0x0F70 (3952)
+0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966,   // 0x0F80 (3968)
+0x2966, 0x2966, 0x2946, 0x2105, 0x3A2A, 0x9538, 0xBEBF, 0xBE9E, 0xC6DF, 0xADDB, 0x3A09, 0x2104, 0x2987, 0x215C, 0x001F, 0x001F,   // 0x0F90 (3984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FB0 (4016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FE, 0x31AA, 0x2104, 0x2966, 0x8CB6, 0xC6BF, 0xBE9E, 0xBEBE, 0xBE9E, 0x8474, 0x39E9,   // 0x0FC0 (4032)
+0x2125, 0x2125, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2967,   // 0x0FD0 (4048)
+0x2145, 0x2125, 0x31A8, 0x73F2, 0xB65D, 0xBEBF, 0xBE7E, 0xC6DF, 0x9D59, 0x31E8, 0x2105, 0x2967, 0x297C, 0x001F, 0x001F, 0x001F,   // 0x0FE0 (4064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1000 (4096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FE, 0x31CC, 0x2105, 0x2145, 0x6BB0, 0xBE7E, 0xBEBF, 0xBE9E, 0xC6DF, 0xB63C,   // 0x1010 (4112)
+0x7C74, 0x428B, 0x2145, 0x2125, 0x2125, 0x2146, 0x2946, 0x2966, 0x2966, 0x2966, 0x2966, 0x2966, 0x2946, 0x2145, 0x2125, 0x2125,   // 0x1020 (4128)
+0x3A2A, 0x73F2, 0xADFB, 0xBEDF, 0xBE9E, 0xBE9E, 0xC6BF, 0x7C54, 0x2986, 0x1905, 0x2988, 0x295C, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1030 (4144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1050 (4176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10DE, 0x31AD, 0x2125, 0x2104, 0x4A8B, 0x9D58, 0xBEDF, 0xBE9E, 0xBE9E,   // 0x1060 (4192)
+0xBEDF, 0xBE9E, 0x9538, 0x73F1, 0x4AAC, 0x3A09, 0x3187, 0x2946, 0x2145, 0x2146, 0x2946, 0x2986, 0x31E8, 0x428B, 0x6BB0, 0x8CF7,   // 0x1070 (4208)
+0xB65D, 0xC6DF, 0xBE9E, 0xBE9E, 0xC6DF, 0xA5DB, 0x5B0D, 0x2125, 0x2105, 0x298A, 0x215C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1080 (4224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10A0 (4256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x31F4, 0x2145, 0x2104, 0x2946, 0x5B4F, 0xA5BA, 0xBEBF,   // 0x10B0 (4272)
+0xBEBF, 0xBE9E, 0xBEBE, 0xC6DF, 0xBE9E, 0xAE3C, 0xA5DA, 0x9D59, 0x9537, 0x9537, 0x9558, 0xA5BA, 0xAE1C, 0xBE9E, 0xBEBF, 0xBEBF,   // 0x10C0 (4288)
+0xBE9E, 0xBEBE, 0xC6BF, 0xAE1C, 0x6BD1, 0x2987, 0x20E4, 0x2125, 0x31D1, 0x10BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10D0 (4304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10F0 (4336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x215B, 0x31AC, 0x2125, 0x18E4, 0x2966, 0x5B2E,   // 0x1100 (4352)
+0x9538, 0xB65D, 0xC6DF, 0xC6DF, 0xBEBE, 0xBEBE, 0xBE9E, 0xBEBF, 0xBEBF, 0xBEBF, 0xBEBF, 0xBE9F, 0xBEBE, 0xBE9F, 0xC6BF, 0xC6BF,   // 0x1110 (4368)
+0xBE7D, 0x9D79, 0x6390, 0x31A7, 0x1904, 0x2104, 0x298A, 0x3199, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1120 (4384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1140 (4416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F, 0x31B9, 0x298B, 0x2125, 0x18E4,   // 0x1150 (4432)
+0x2125, 0x3A09, 0x5B4F, 0x8495, 0x9D79, 0xADFB, 0xB65D, 0xBEBE, 0xBEBF, 0xBEBE, 0xBEBE, 0xB67D, 0xAE1C, 0x9D9A, 0x8CD5, 0x6390,   // 0x1160 (4448)
+0x424A, 0x2145, 0x1904, 0x2125, 0x2989, 0x31D6, 0x089E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1170 (4464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1190 (4496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085E, 0x319A, 0x31CF,   // 0x11A0 (4512)
+0x2967, 0x2104, 0x18E4, 0x2104, 0x2965, 0x31A7, 0x424A, 0x4AAC, 0x52CD, 0x52ED, 0x4ACC, 0x426A, 0x31A7, 0x2966, 0x2104, 0x18E4,   // 0x11B0 (4528)
+0x2104, 0x2166, 0x31CD, 0x29B7, 0x109E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11C0 (4544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11E0 (4576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11F0 (4592)
+0x18FD, 0x2177, 0x3211, 0x31CB, 0x2967, 0x2145, 0x2125, 0x2125, 0x2125, 0x2125, 0x2125, 0x2105, 0x2145, 0x2966, 0x29AA, 0x39F0,   // 0x1200 (4608)
+0x2996, 0x191C, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1210 (4624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1230 (4656)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1240 (4672)
+0x001F, 0x001F, 0x001F, 0x10BE, 0x213B, 0x2157, 0x2954, 0x1911, 0x18CF, 0x18EF, 0x18F0, 0x2154, 0x2156, 0x215A, 0x10DE, 0x003F,   // 0x1250 (4688)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1260 (4704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1280 (4736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1290 (4752)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12A0 (4768)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12B0 (4784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12D0 (4816)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12E0 (4832)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12F0 (4848)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1330 (4912)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1340 (4928)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x211F, 0x421F, 0x191F, 0x001F, 0x001F, 0x001F, 0x001F, 0x41FF, 0x41FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x317F, 0x3A1F, 0x107F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x319F, 0xCE7F,   // 0x1460 (5216)
+0xFFFF, 0xFFDF, 0xFFDF, 0xCE7F, 0x107F, 0x001F, 0x211F, 0xFFFF, 0xCE7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1470 (5232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xE6FF, 0xFFFF, 0x211F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x737F, 0x9CFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xCE7F, 0xFFFF,   // 0x14B0 (5296)
+0xCE7F, 0x7BFF, 0xE6FF, 0xFFDF, 0x7BFF, 0x001F, 0x62FF, 0xFFFF, 0x9CFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14C0 (5312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xFFDF, 0xF77F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x7BFF, 0xFFFF, 0x83FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x9CFF, 0xFFFF, 0xCE7F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x191F, 0xBDFF, 0xAD7F, 0x001F, 0x8C7F, 0xFFFF, 0x739F, 0x001F, 0x527F, 0xD67F, 0xFFFF, 0xD67F, 0x6B7F, 0x001F,   // 0x1510 (5392)
+0x001F, 0x001F, 0x62FF, 0xBDFF, 0xFFFF, 0xAD7F, 0x297F, 0x001F, 0x41FF, 0xFFFF, 0xBE1F, 0x317F, 0xBDFF, 0xBDFF, 0x631F, 0x001F,   // 0x1520 (5408)
+0x001F, 0x001F, 0x001F, 0x737F, 0xBDFF, 0x8C7F, 0xDEFF, 0xEF7F, 0x7BFF, 0x001F, 0x001F, 0x4A7F, 0xDEFF, 0xFFDF, 0xB57F, 0x3A1F,   // 0x1530 (5424)
+0x001F, 0x737F, 0xEF7F, 0xFFFF, 0xD67F, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xCE9F, 0xFFFF, 0x41FF,   // 0x1550 (5456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xC5FF, 0xFFFF, 0x317F, 0x421F, 0xFFFF, 0xFFDF, 0x9CFF, 0xE6FF, 0xFFFF, 0x62FF,   // 0x1560 (5472)
+0x001F, 0x5AFF, 0xFFFF, 0xE6FF, 0xB57F, 0xFFFF, 0xBDFF, 0x001F, 0x7BFF, 0xFFDF, 0xAD7F, 0xEF7F, 0xFFFF, 0x62FF, 0x001F, 0x001F,   // 0x1570 (5488)
+0x001F, 0x001F, 0x001F, 0xBDFF, 0xFFFF, 0xF77F, 0x9CFF, 0xFFDF, 0xFFDF, 0x001F, 0x41FF, 0xFFFF, 0xEF7F, 0x9CFF, 0xEF7F, 0xE6FF,   // 0x1580 (5504)
+0x001F, 0x8C7F, 0xFFFF, 0xFFDF, 0xBDFF, 0x107F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0x001F, 0xAD7F, 0xFFFF, 0x7BFF, 0x001F, 0x41FF, 0xFFDF, 0xAD7F,   // 0x15B0 (5552)
+0x001F, 0xEF7F, 0xFFFF, 0x317F, 0x001F, 0x6B9F, 0x737F, 0x001F, 0xAD7F, 0xFFFF, 0xFFDF, 0xFFFF, 0x737F, 0x001F, 0x001F, 0x001F,   // 0x15C0 (5568)
+0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0x317F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0x9CFF, 0xFFFF, 0x947F, 0x41FF, 0xBDFF, 0xFFFF,   // 0x15D0 (5584)
+0x297F, 0x211F, 0xFFDF, 0xD67F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFDF, 0xFFDF, 0x109F,   // 0x15F0 (5616)
+0x001F, 0x001F, 0x8C7F, 0x8C7F, 0x41FF, 0x319F, 0xFFDF, 0xBDFF, 0x001F, 0xE6FF, 0xFFDF, 0x317F, 0x001F, 0x631F, 0xFFFF, 0xC5FF,   // 0x1600 (5632)
+0x299F, 0xFFFF, 0xCE7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xEF7F, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C7F, 0x001F, 0x001F, 0x001F,   // 0x1610 (5648)
+0x001F, 0x001F, 0x317F, 0xFFDF, 0xD67F, 0x001F, 0x319F, 0xFFFF, 0xC5FF, 0x001F, 0xE6FF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x1620 (5664)
+0x421F, 0x5AFF, 0xFFFF, 0x9CFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xEF7F, 0xFFDF, 0x8C7F,   // 0x1640 (5696)
+0x211F, 0x737F, 0xFFFF, 0xEF7F, 0x107F, 0x737F, 0xFFFF, 0x947F, 0x001F, 0xBDFF, 0xFFDF, 0x4A7F, 0x089F, 0xC5FF, 0xFFDF, 0x8C7F,   // 0x1650 (5712)
+0x211F, 0xFFFF, 0xCE7F, 0x001F, 0x8C7F, 0xE6FF, 0x6B9F, 0x20FF, 0xFFFF, 0xEF7F, 0x41FF, 0xFFFF, 0xE6FF, 0x001F, 0x001F, 0x41FF,   // 0x1660 (5728)
+0x317F, 0x001F, 0x5AFF, 0xFFFF, 0x8C7F, 0x001F, 0x737F, 0xFFFF, 0x947F, 0x001F, 0xAD7F, 0xFFFF, 0x191F, 0x211F, 0x7BFF, 0x62FF,   // 0x1670 (5744)
+0x001F, 0x83FF, 0xFFFF, 0x737F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7BFF, 0xFFDF, 0xFFFF,   // 0x1690 (5776)
+0xFFFF, 0xFFDF, 0xFFFF, 0x527F, 0x001F, 0x9CFF, 0xFFDF, 0x5AFF, 0x001F, 0x529F, 0xFFFF, 0xFFDF, 0xEF7F, 0xFFFF, 0xEF7F, 0x107F,   // 0x16A0 (5792)
+0x001F, 0xBE1F, 0xFFDF, 0xFFFF, 0xFFDF, 0xE6FF, 0x109F, 0x527F, 0xFFFF, 0xAD7F, 0x001F, 0xCE7F, 0xFFFF, 0x299F, 0x41FF, 0xFFFF,   // 0x16B0 (5808)
+0xBDFF, 0x001F, 0x9D1F, 0xFFFF, 0x62FF, 0x001F, 0x9CFF, 0xFFFF, 0x62FF, 0x001F, 0x631F, 0xFFDF, 0xF77F, 0xEF7F, 0xFFFF, 0x83FF,   // 0x16C0 (5824)
+0x001F, 0x9CFF, 0xFFDF, 0xE6FF, 0x527F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x62FF, 0xC5FF,   // 0x16E0 (5856)
+0xC5FF, 0x737F, 0x211F, 0x001F, 0x001F, 0x947F, 0xBDFF, 0x317F, 0x001F, 0x001F, 0x4A9F, 0xAD7F, 0xBDFF, 0x9CFF, 0x211F, 0x001F,   // 0x16F0 (5872)
+0x001F, 0x211F, 0x739F, 0xBDFF, 0x7BFF, 0x211F, 0x001F, 0x631F, 0xBDFF, 0x62FF, 0x001F, 0x41FF, 0x7BFF, 0x39FF, 0x631F, 0xC5FF,   // 0x1700 (5888)
+0x62FF, 0x001F, 0x947F, 0xBDFF, 0x299F, 0x001F, 0x947F, 0xBE1F, 0x211F, 0x001F, 0x001F, 0x421F, 0x9CDF, 0xB57F, 0x631F, 0x001F,   // 0x1710 (5904)
+0x001F, 0x299F, 0xA4FF, 0xBDFF, 0x317F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1740 (5952)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1750 (5968)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1790 (6032)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_719/del.c

@@ -0,0 +1,108 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: del.jpg
+// Time generated: 04.05.2014 19:24:57
+// Dimensions    : 40x40 pixels
+// Size          : 3 200 Bytes
+
+const unsigned short del[0x640] ={
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0010 (16)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0020 (32)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0030 (48)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0040 (64)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0050 (80)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0060 (96)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0070 (112)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0080 (128)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0090 (144)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00A0 (160)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00B0 (176)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00C0 (192)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00D0 (208)
+0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x2B14, 0x0020, 0x0020, 0x0020, 0x0021, 0x0020, 0x0021, 0x2B14,   // 0x00E0 (224)
+0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x00F0 (240)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x039F, 0x037F, 0x2B34, 0x0001, 0x0020,   // 0x0100 (256)
+0x0021, 0x2B14, 0x2B14, 0x2B15, 0x2B14, 0x2B14, 0x0020, 0x0020, 0x0021, 0x0021, 0x2B14, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0110 (272)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0120 (288)
+0x037F, 0x037F, 0x037F, 0x0B7D, 0x0020, 0x0000, 0x2AF3, 0x2AF3, 0x2AF3, 0x2B13, 0x2B13, 0x2AF3, 0x2AF3, 0x2AF3, 0x2AF3, 0x2B13,   // 0x0130 (304)
+0x2AF3, 0x0020, 0x0000, 0x0000, 0x139E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0140 (320)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0020, 0x0000, 0x2AB0, 0x2B35, 0x2B76,   // 0x0150 (336)
+0x3355, 0x2B35, 0x2B34, 0x2B14, 0x2B14, 0x2B34, 0x2B75, 0x2B97, 0x2BB8, 0x2B77, 0x2B13, 0x0000, 0x0041, 0x035E, 0x039F, 0x037F,   // 0x0160 (352)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0170 (368)
+0x037F, 0x037F, 0x0841, 0x32D0, 0x343C, 0x343B, 0x33F9, 0x33B7, 0x3375, 0x2B34, 0x2B13, 0x2B13, 0x2B13, 0x2B34, 0x2B55, 0x3397,   // 0x0180 (384)
+0x33D9, 0x341B, 0x3C7D, 0x34BE, 0x0021, 0x037E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0190 (400)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x035F, 0x0021, 0xCE79, 0x4C7C, 0x33FA, 0x2BB8, 0x2B78,   // 0x01A0 (416)
+0x2B76, 0x2B35, 0x2B14, 0x2B33, 0x2B13, 0x3314, 0x3355, 0x3397, 0x33D9, 0x341B, 0x3C5D, 0x3C7E, 0x0021, 0x035E, 0x037F, 0x037F,   // 0x01B0 (432)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x01C0 (448)
+0x037F, 0x037F, 0x139C, 0x0020, 0xCE59, 0x8538, 0x751A, 0x5C79, 0x43D7, 0x3375, 0x3334, 0x2B14, 0x2B14, 0x2B34, 0x3355, 0x3396,   // 0x01D0 (464)
+0x33B6, 0x4396, 0x0020, 0x0000, 0x0000, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x01E0 (480)
+0x037F, 0x037F, 0x039E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x8539, 0x0020, 0x0000, 0x4A69, 0x4A69,   // 0x01F0 (496)
+0xCE59, 0x7C31, 0x636E, 0x4AAC, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x116B, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0200 (512)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0210 (528)
+0x037F, 0x037F, 0x037F, 0x855B, 0xB63B, 0x9578, 0x0021, 0x0020, 0x0000, 0x0020, 0x0001, 0x0021, 0x0000, 0x0020, 0x0021, 0x0021,   // 0x0220 (544)
+0x12B5, 0x0AD6, 0x0AB8, 0x0A96, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0230 (560)
+0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0xB61A, 0x9579, 0x6C77, 0x3B34,   // 0x0240 (576)
+0x1293, 0x0294, 0x0AF6, 0x1379, 0x13BC, 0x1BFE, 0x143F, 0x141F, 0x13BD, 0x0B3B, 0x0AB8, 0x0A97, 0x037F, 0x039F, 0x037F, 0x037F,   // 0x0250 (592)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0xE8E4, 0xE8E4, 0xE8E4,   // 0x0260 (608)
+0x037F, 0x037F, 0x037F, 0x855A, 0xB61A, 0x9D79, 0x6C77, 0x6455, 0x5C35, 0x8BF4, 0xE8E4, 0x5251, 0x137A, 0x13DC, 0x13FE, 0x13DE,   // 0x0270 (624)
+0x137C, 0x0B19, 0x0AB8, 0x3233, 0xE8E5, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0280 (640)
+0x037F, 0x037F, 0x039F, 0x0B5F, 0x0B5E, 0xE8E4, 0xE105, 0xB96A, 0xE8E4, 0x037F, 0x037F, 0x855B, 0x857B, 0xA5D9, 0xCEDC, 0xFFFF,   // 0x0290 (656)
+0xFFFF, 0xFFFF, 0xE8E4, 0xFFDF, 0x341B, 0x13BC, 0x13FE, 0x13DE, 0x137C, 0x12F9, 0x0A97, 0x0A96, 0xE8E5, 0x037F, 0x037F, 0x037F,   // 0x02A0 (672)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7E, 0xE105, 0x037F, 0x037F,   // 0x02B0 (688)
+0xE8E4, 0xE0E5, 0x037F, 0x855B, 0xFFDF, 0xE8E4, 0xE8E4, 0xFFDF, 0xFFFF, 0xFFFF, 0xE8E4, 0xFFFF, 0x33FA, 0x12D8, 0xE8E4, 0xE8C4,   // 0x02C0 (704)
+0x12D7, 0x0AF9, 0x5211, 0xE8E4, 0xE8E4, 0xE8E5, 0x037F, 0x0B7E, 0xE8E4, 0xE8E4, 0x037E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x02D0 (720)
+0x037F, 0x037F, 0x037F, 0x0B7F, 0x0B5E, 0xE105, 0x037F, 0x037F, 0x0B7F, 0xE8C4, 0x0B7E, 0x853A, 0xE8E4, 0xFFDF, 0xFFDF, 0xE8E4,   // 0x02E0 (736)
+0x4B32, 0xFFFF, 0xE8C4, 0xFFDF, 0x4A52, 0xE8E4, 0x12D8, 0x12D8, 0xE8C4, 0x0A97, 0x2255, 0x1296, 0xE8C4, 0x037F, 0x0B7F, 0xE8C4,   // 0x02F0 (752)
+0x037F, 0x0B7E, 0xE8E4, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7E, 0xE8E5, 0x037F, 0x037F,   // 0x0300 (768)
+0x0B5F, 0xE8E4, 0x0B5E, 0x8539, 0xE8E4, 0xFFFF, 0xFFFF, 0xE8E4, 0x4B32, 0xFFFF, 0xE8E4, 0xFFFF, 0xFFDF, 0xE8E4, 0x239B, 0x13BD,   // 0x0310 (784)
+0xE8E4, 0x0A96, 0x0A97, 0x1296, 0xE8C5, 0x039F, 0x0B7E, 0xE8E4, 0x037F, 0x039F, 0xE8C4, 0x0B7F, 0x037F, 0x039F, 0x037F, 0x037F,   // 0x0320 (800)
+0x037F, 0x037F, 0x037F, 0x037F, 0x0B5E, 0xE8E5, 0x037F, 0x037F, 0x037F, 0xE8C4, 0x0B7F, 0x853A, 0xE8E4, 0xE8E4, 0xE8E4, 0xE8E4,   // 0x0330 (816)
+0x4B32, 0x4250, 0xE8E4, 0xFFDF, 0xFFFF, 0xE8C4, 0xE8E4, 0xE8E4, 0x1AB7, 0x1296, 0x0A97, 0x0A96, 0xE8E4, 0x037F, 0x037F, 0xE8E4,   // 0x0340 (832)
+0xE8E4, 0xE8C4, 0xE8E4, 0x035E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7F, 0x0B7E, 0xE105, 0x037F, 0x037F,   // 0x0350 (848)
+0xE8C4, 0xE8C4, 0x037F, 0x853A, 0xE8E4, 0x5353, 0x5332, 0x4B32, 0x4B32, 0x4230, 0xE8C4, 0xFFFF, 0xFFFF, 0xE8E4, 0x0AD8, 0x12D8,   // 0x0360 (864)
+0x12D8, 0x0AD8, 0x0A97, 0x0A96, 0xE8C5, 0x037F, 0x037F, 0xE8E4, 0x0B7E, 0x0B7F, 0x037F, 0x0B5F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0370 (880)
+0x037F, 0x037F, 0x039F, 0x037F, 0x0B5E, 0xE0E5, 0xE105, 0xE0E5, 0xE8E4, 0x0B5F, 0x037F, 0x855A, 0xE8C5, 0xFF1C, 0xCD97, 0xE8C5,   // 0x0380 (896)
+0x4B32, 0x3A2F, 0xE8E4, 0xFFFF, 0xFFFF, 0xE8E4, 0x12F8, 0x131A, 0xE8E4, 0x0A96, 0x0A97, 0x0A96, 0xE8E4, 0x037F, 0x037E, 0xE8E4,   // 0x0390 (912)
+0x037F, 0x037F, 0xE8E4, 0x0B7F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x0B7E, 0xE8C4, 0xE8E4, 0xE8E4,   // 0x03A0 (928)
+0x035E, 0x037F, 0x037F, 0x855A, 0xB5D9, 0xE8E4, 0xF0C4, 0x12D7, 0x4B53, 0x424F, 0xE8E4, 0xE924, 0xFFFF, 0x12D7, 0xE8E4, 0xE8C4,   // 0x03B0 (944)
+0x12D8, 0x1296, 0x0A97, 0x0A96, 0xE8C4, 0xE8E4, 0x037F, 0x037F, 0xE8E4, 0xE8E4, 0x0B7E, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x03C0 (960)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0xADFA, 0x5353, 0x5352, 0x4B53,   // 0x03D0 (976)
+0x4374, 0x4B32, 0x4B52, 0x8456, 0xFFFF, 0x12F8, 0x12F8, 0x12D8, 0x12D8, 0x0A97, 0x0AB7, 0x1A75, 0x0B7F, 0x037F, 0x037F, 0x037F,   // 0x03E0 (992)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x03F0 (1008)
+0x037F, 0x037F, 0x037F, 0x853B, 0xADFA, 0xD6DC, 0xFFFF, 0xFFFF, 0x5C36, 0xAE1A, 0xA5FA, 0x853A, 0xFFFF, 0xB67C, 0x23DB, 0x033A,   // 0x0400 (1024)
+0x0AD8, 0x0A97, 0x0AB7, 0x0A97, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0410 (1040)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0xAE1A, 0xB63A, 0xFFFF, 0xFFFF,   // 0x0420 (1056)
+0xFFDF, 0xEF9E, 0xFFFF, 0xFFFF, 0xFFFF, 0x8D9B, 0x1B5A, 0x1B79, 0x0AD9, 0x0A97, 0x0AD8, 0x0A97, 0x037F, 0x037F, 0x037F, 0x039F,   // 0x0430 (1072)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0440 (1088)
+0x037F, 0x037F, 0x037F, 0x855A, 0x855B, 0xA5D9, 0xB5F8, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x3333, 0x2B14, 0x2AF5,   // 0x0450 (1104)
+0x22B4, 0x12B5, 0x0A97, 0x0A97, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0460 (1120)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x853B, 0x855B, 0x7C74, 0x6BD0, 0x6390,   // 0x0470 (1136)
+0x42EF, 0x8CB4, 0xBDD7, 0xBDD6, 0x6413, 0x1A72, 0x1AB2, 0x1A51, 0x11EF, 0x11EF, 0x0A97, 0x0A97, 0x037E, 0x037F, 0x037F, 0x037F,   // 0x0480 (1152)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0490 (1168)
+0x037F, 0x039F, 0x037F, 0x855A, 0x855A, 0x6BD0, 0x6BD1, 0x5B8F, 0x42CE, 0x5B70, 0x7C31, 0x7C32, 0x2A6E, 0x224F, 0x2270, 0x1230,   // 0x04A0 (1184)
+0x0A10, 0x0A96, 0x0AB6, 0x0A97, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x04B0 (1200)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x855B, 0x855B, 0x8C92, 0x73F1, 0x5B4E,   // 0x04C0 (1216)
+0x52CC, 0x424B, 0x320A, 0x21A8, 0x2188, 0x2167, 0x1126, 0x0907, 0x0908, 0x09AD, 0x2A2C, 0x0AD8, 0x039F, 0x037F, 0x037F, 0x037F,   // 0x04D0 (1232)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x04E0 (1248)
+0x037F, 0x037F, 0x037F, 0x855B, 0x855B, 0x8C51, 0x73AE, 0x73CF, 0x636E, 0x52CC, 0x3A2A, 0x29E9, 0x29A9, 0x2168, 0x1947, 0x1926,   // 0x04F0 (1264)
+0x1906, 0x2124, 0x18E3, 0x031B, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0500 (1280)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x857A, 0x7B8D, 0x31A6, 0x4208,   // 0x0510 (1296)
+0x52AA, 0x5ACC, 0x4A4A, 0x31A7, 0x2966, 0x2946, 0x2125, 0x2104, 0x18E3, 0x1061, 0x3184, 0x5C7A, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0520 (1312)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0530 (1328)
+0x037F, 0x037F, 0x037F, 0x039F, 0x6C99, 0x7B8C, 0x41E7, 0x3186, 0x3186, 0x3165, 0x2103, 0x1082, 0x1062, 0x1081, 0x1061, 0x1082,   // 0x0540 (1344)
+0x10A2, 0x3165, 0x83CD, 0x549C, 0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0550 (1360)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x035F, 0x0BBF, 0x6479, 0x7C52, 0x738D,   // 0x0560 (1376)
+0x630B, 0x5AA9, 0x4A27, 0x39C6, 0x39C6, 0x41E6, 0x5268, 0x62EA, 0x73AE, 0x8474, 0x547B, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F,   // 0x0570 (1392)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0580 (1408)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x13DF, 0x343D, 0x547B, 0x5C9A, 0x6CB8, 0x74B8, 0x74B8, 0x6CB8, 0x649A, 0x547C,   // 0x0590 (1424)
+0x2C1E, 0x0BBF, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05A0 (1440)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x035F,   // 0x05B0 (1456)
+0x035F, 0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x035F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05C0 (1472)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05D0 (1488)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05E0 (1504)
+0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x05F0 (1520)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0600 (1536)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0610 (1552)
+0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0620 (1568)
+0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0630 (1584)
+0x037F, 0x037F, 0x039F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F, 0x037F,   // 0x0640 (1600)
+};

_719/dom1.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: dom1.jpg
+// Time generated: 09.09.2018 15:00:45
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short dom1[0x1900] ={
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0010 (16)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0020 (32)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0030 (48)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0040 (64)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0050 (80)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xF7BE, 0xE71C,   // 0x0060 (96)
+0xDEFB, 0xDEFB, 0xDEFB, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C,   // 0x0070 (112)
+0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C,   // 0x0080 (128)
+0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE71C, 0xE73C, 0xEF5D,   // 0x0090 (144)
+0xF79E, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00A0 (160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xDEFB, 0xC638, 0xCE59, 0xCE79, 0xDEFB,   // 0x00B0 (176)
+0xDEDB, 0xDEDB, 0xD6BA, 0xD6BA, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x00C0 (192)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x00D0 (208)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xCE79, 0xCE79,   // 0x00E0 (224)
+0xCE79, 0xD69A, 0xDEFB, 0xEF7D, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x00F0 (240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xBDF7, 0xD69A, 0xE71C, 0xE73C, 0xE73C, 0xE73C,   // 0x0100 (256)
+0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0110 (272)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0120 (288)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0130 (304)
+0xE73C, 0xDEFB, 0xD69A, 0xCE59, 0xD69A, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0140 (320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xCE79, 0xCE59, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C,   // 0x0150 (336)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0160 (352)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0170 (368)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0180 (384)
+0xEF5D, 0xEF5D, 0xEF7D, 0xE73C, 0xDEDB, 0xC638, 0xD6BA, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xB596, 0xDEDB, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01A0 (416)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01B0 (432)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01C0 (448)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01D0 (464)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xD69A, 0xCE59, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01E0 (480)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xC618, 0xE73C, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x01F0 (496)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0200 (512)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0210 (528)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0220 (544)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xDEDB, 0xC638, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0230 (560)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xC638, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0240 (576)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0250 (592)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0260 (608)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0270 (624)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xDEDB, 0xC638, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0280 (640)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xC638, 0xDEFB, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0290 (656)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02A0 (672)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02B0 (688)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02C0 (704)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xDEDB, 0xCE59, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x02D0 (720)
+0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0xDEDB, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02E0 (736)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x02F0 (752)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0300 (768)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0310 (784)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xCE79, 0xD6BA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0320 (800)
+0xFFFF, 0xFFFF, 0xF79E, 0xCE79, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0330 (816)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0340 (832)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0350 (848)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0360 (864)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE71C, 0xC638, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0370 (880)
+0xFFFF, 0xFFFF, 0xDEFB, 0xD6BA, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0380 (896)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0390 (912)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03A0 (928)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03B0 (944)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xD69A, 0xD69A, 0xFFDF, 0xFFDF, 0xFFFF,   // 0x03C0 (960)
+0xFFFF, 0xF79E, 0xD6BA, 0xE71C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03D0 (976)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03E0 (992)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x03F0 (1008)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0400 (1024)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE71C, 0xCE59, 0xEF5D, 0xFFDF, 0xFFFF,   // 0x0410 (1040)
+0xFFFF, 0xE71C, 0xD6BA, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0420 (1056)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0430 (1072)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0440 (1088)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0450 (1104)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xCE79, 0xDEDB, 0xFFDF, 0xFFDF,   // 0x0460 (1120)
+0xFFFF, 0xDEDB, 0xDEDB, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0470 (1136)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0480 (1152)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0490 (1168)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04A0 (1184)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xD6BA, 0xCE79, 0xF79E, 0xFFDF,   // 0x04B0 (1200)
+0xFFDF, 0xD6BA, 0xDEFB, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04C0 (1216)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04D0 (1232)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04E0 (1248)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x04F0 (1264)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xDEFB, 0xCE59, 0xEF5D, 0xF7BE,   // 0x0500 (1280)
+0xFFDF, 0xD6BA, 0xE71C, 0xF79E, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0510 (1296)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D,   // 0x0520 (1312)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0530 (1328)
+0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D,   // 0x0540 (1344)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xE73C, 0xCE59, 0xE73C, 0xF7BE,   // 0x0550 (1360)
+0xF7BE, 0xD69A, 0xE71C, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0560 (1376)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0570 (1392)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0580 (1408)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0590 (1424)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xE71C, 0xF7BE,   // 0x05A0 (1440)
+0xF7BE, 0xCE79, 0xE73C, 0xEF5D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x05B0 (1456)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x05C0 (1472)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x05D0 (1488)
+0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x05E0 (1504)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x05F0 (1520)
+0xF79E, 0xCE79, 0xE73C, 0xEF5D, 0xEF5D, 0xEF7D, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E,   // 0x0600 (1536)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D,   // 0x0610 (1552)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C,   // 0x0620 (1568)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0630 (1584)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0640 (1600)
+0xF7BE, 0xCE79, 0xE73C, 0xEF5D, 0xE73C, 0xEF5D, 0xEF7D, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0650 (1616)
+0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x0660 (1632)
+0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0670 (1648)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0680 (1664)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0690 (1680)
+0xF7BE, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE,   // 0x06A0 (1696)
+0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E, 0xF79E,   // 0x06B0 (1712)
+0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x06C0 (1728)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x06D0 (1744)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x06E0 (1760)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xF79E, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE,   // 0x06F0 (1776)
+0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF7BE, 0xF79E, 0xF79E, 0xF79E, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D,   // 0x0700 (1792)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0710 (1808)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0720 (1824)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0730 (1840)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xEF7D, 0xEF7D,   // 0x0740 (1856)
+0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF7D, 0xEF5D, 0xEF5D, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0750 (1872)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0760 (1888)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0770 (1904)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0780 (1920)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0790 (1936)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07A0 (1952)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07B0 (1968)
+0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07C0 (1984)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x07D0 (2000)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x07E0 (2016)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73D, 0xE73C,   // 0x07F0 (2032)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0800 (2048)
+0xE73D, 0xE73C, 0xE73D, 0xE73D, 0xEF3C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0810 (2064)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0820 (2080)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0830 (2096)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D,   // 0x0840 (2112)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0850 (2128)
+0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE73D, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0860 (2144)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0870 (2160)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0880 (2176)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE75D, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0890 (2192)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08A0 (2208)
+0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08B0 (2224)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x08C0 (2240)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08D0 (2256)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE75C, 0xE73D, 0xE73C,   // 0x08E0 (2272)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x08F0 (2288)
+0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0900 (2304)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0910 (2320)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0920 (2336)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF3C, 0xE75C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE75C, 0xE73D,   // 0x0930 (2352)
+0xE73D, 0xE75D, 0xEF5D, 0xE75D, 0xE77D, 0xEF7E, 0xEF7E, 0xEF7E, 0xE79E, 0xE79E, 0xE79E, 0xEF9E, 0xE7BE, 0xE7BE, 0xE7BF, 0xE7BF,   // 0x0940 (2368)
+0xE79F, 0xE7BF, 0xE79E, 0xEF3C, 0xE73C, 0xE73D, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0950 (2384)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0960 (2400)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0970 (2416)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF9E, 0xE7DF, 0xE7BF, 0xE7BF, 0xE7BF, 0xE79F, 0xE7BE, 0xE79F,   // 0x0980 (2432)
+0xE79E, 0xE79E, 0xE79E, 0xE77E, 0xDF5D, 0xDF3D, 0xDF1C, 0xDF1C, 0xDEFB, 0xDEDA, 0xE6BA, 0xDE99, 0xDE99, 0xE678, 0xE657, 0xDE37,   // 0x0990 (2448)
+0xE5F6, 0xDDD5, 0xE69A, 0xE77E, 0xEF3D, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x09A0 (2464)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x09B0 (2480)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x09C0 (2496)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xDE58, 0xE554, 0xE573, 0xE552, 0xE531, 0xE4F1, 0xE4D0, 0xE4AF,   // 0x09D0 (2512)
+0xE48E, 0xE46E, 0xE44D, 0xE40C, 0xE3EB, 0xE3AA, 0xE369, 0xEB49, 0xEB28, 0xEB07, 0xEAE7, 0xEAC6, 0xF2A6, 0xF285, 0xF265, 0xF264,   // 0x09E0 (2528)
+0xF243, 0xF1E3, 0xEB49, 0xDEDA, 0xE7BF, 0xEF3C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x09F0 (2544)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0A00 (2560)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0A10 (2576)
+0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xD6BB, 0x934B, 0xE1A0, 0xF1E1, 0xF1C1, 0xF9C1, 0xF9A0, 0xF9A0, 0xF9A0,   // 0x0A20 (2592)
+0xF980, 0xF980, 0xF980, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960, 0xF960,   // 0x0A30 (2608)
+0xF960, 0xF960, 0xF940, 0xE3AB, 0xDF5D, 0xE79E, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0A40 (2624)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0A50 (2640)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0A60 (2656)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0x9D14, 0x528A, 0xA9E3, 0xF940, 0xF980, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9A0,   // 0x0A70 (2672)
+0xF9A0, 0xF9A0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0A80 (2688)
+0xF9E0, 0xF9C0, 0xF9A0, 0xF180, 0xE44E, 0xDF9E, 0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE75C, 0xE73D, 0xE73D, 0xE73C, 0xE73C, 0xE73C,   // 0x0A90 (2704)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0AA0 (2720)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0AB0 (2736)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xCE79, 0x632D, 0x530C, 0x730B, 0xE203, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0AC0 (2752)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0AD0 (2768)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF1A1, 0xDD11, 0xE7BF, 0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C, 0xE73C,   // 0x0AE0 (2784)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0AF0 (2800)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0B00 (2816)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0x8C71, 0x52AA, 0x632C, 0x9514, 0xDD11, 0xF180, 0xF9A0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0B10 (2832)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0B20 (2848)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF1E2, 0xDDB5, 0xE7BF, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73D, 0xE73C,   // 0x0B30 (2864)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0B40 (2880)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0B50 (2896)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xC618, 0x5AEB, 0x5AEB, 0x7BAE, 0xD6DB, 0xE73C, 0xE369, 0xF940, 0xF9C0, 0xF9E0, 0xF9C0,   // 0x0B60 (2912)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0B70 (2928)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF940, 0xEA64, 0xDE57, 0xE7BF, 0xE73C, 0xE73C, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0B80 (2944)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0B90 (2960)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0BA0 (2976)
+0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE71C, 0x8410, 0x5ACB, 0x632C, 0xA534, 0xEF5D, 0xDF5D, 0xD5F6, 0xF223, 0xF960, 0xF9C0, 0xF9C0,   // 0x0BB0 (2992)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0BC0 (3008)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF940, 0xEAE7, 0xDEDA, 0xEF9E, 0xE73D, 0xE75C, 0xE73C, 0xE73D, 0xE73C, 0xE73D,   // 0x0BD0 (3024)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0BE0 (3040)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0BF0 (3056)
+0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xAD75, 0x5ACB, 0x630C, 0x8410, 0xDEFB, 0xE73C, 0xDF1C, 0xDF5D, 0xDC8F, 0xF180, 0xF9A0, 0xF9E0,   // 0x0C00 (3072)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0C10 (3088)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF940, 0xE369, 0xE71C, 0xE79E, 0xEF3C, 0xE73C, 0xE73C, 0xE73C, 0xE73D,   // 0x0C20 (3104)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0C30 (3120)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0C40 (3136)
+0xE73C, 0xE73C, 0xEF5D, 0xDEDB, 0x738E, 0x5AEB, 0x6B4D, 0xBDB7, 0xEF5D, 0xDEFB, 0xE6DB, 0xE75D, 0xD6DA, 0xE328, 0xF960, 0xF9C0,   // 0x0C50 (3152)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0C60 (3168)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF940, 0xDC0D, 0xE75D, 0xE75D, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0C70 (3184)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0C80 (3200)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0C90 (3216)
+0xE73C, 0xE73C, 0xEF7D, 0x9CF3, 0x5ACB, 0x630C, 0x8C71, 0xE73C, 0xE71B, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF7E, 0xDDB4, 0xF203, 0xF960,   // 0x0CA0 (3232)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0CB0 (3248)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF961, 0xE4D0, 0xE77E, 0xE75D, 0xE73C, 0xE73C, 0xE73D,   // 0x0CC0 (3264)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0CD0 (3280)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0CE0 (3296)
+0xE73C, 0xEF5D, 0xCE79, 0x632C, 0x630C, 0x6B6D, 0xC638, 0xE73C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFC, 0xE71C, 0xD75D, 0xDC2D, 0xF180,   // 0x0CF0 (3312)
+0xF9A0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0D00 (3328)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF1C0, 0xDD73, 0xE79E, 0xE75D, 0xE73C, 0xE73D,   // 0x0D10 (3344)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0D20 (3360)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0D30 (3376)
+0xE73C, 0xEF5D, 0x8C51, 0x5AEB, 0x632C, 0x9CD3, 0xEF5D, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF5D, 0xD699, 0xEAE7,   // 0x0D40 (3392)
+0xF960, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0D50 (3408)
+0xF9E0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF980, 0xF202, 0xDE17, 0xEF7E, 0xE75C, 0xE73D,   // 0x0D60 (3424)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0D70 (3440)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0D80 (3456)
+0xEF7D, 0xBDD7, 0x5AEB, 0x630C, 0x73AE, 0xD69A, 0xE73C, 0xDEFB, 0xDEFC, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFC, 0xE6DB, 0xDF7E, 0xDD73,   // 0x0D90 (3472)
+0xF202, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0DA0 (3488)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF960, 0xEA84, 0xDE99, 0xE77D, 0xE73C,   // 0x0DB0 (3504)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0DC0 (3520)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D,   // 0x0DD0 (3536)
+0xDEFB, 0x73AE, 0x5AEB, 0x630C, 0xAD75, 0xEF5D, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF1C, 0xD75D,   // 0x0DE0 (3552)
+0xE3EC, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0,   // 0x0DF0 (3568)
+0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF920, 0xE2E7, 0xE6BA, 0xE75D,   // 0x0E00 (3584)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0E10 (3600)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D,   // 0x0E20 (3616)
+0xCE79, 0x94B2, 0x9492, 0x8C51, 0xD6BA, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFC, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF7D,   // 0x0E30 (3632)
+0xD679, 0xEAA5, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9E0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0,   // 0x0E40 (3648)
+0xF9C0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9C1, 0xF1E1, 0xE9E1, 0xE1E2, 0xD1E2, 0xDB27, 0xE3AB, 0xDE17, 0xE75D,   // 0x0E50 (3664)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0E60 (3680)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0E70 (3696)
+0xEF5D, 0xF79E, 0xF79E, 0xCE79, 0xCE59, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF1C, 0xDF1C, 0xDF1C, 0xE71B, 0xDEFC, 0xDEFB, 0xDEFB,   // 0x0E80 (3712)
+0xDF9E, 0xDD12, 0xF1C1, 0xF980, 0xF9C0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF9C0, 0xF9C0, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9A0, 0xF9C0, 0xF9C1,   // 0x0E90 (3728)
+0xF1E2, 0xEA02, 0xE243, 0xDA84, 0xDAC6, 0xCB08, 0xBB6B, 0xABCD, 0xA40F, 0x9C70, 0x9CB2, 0x8472, 0xCEBB, 0xE7BF, 0xE75D, 0xE73C,   // 0x0EA0 (3744)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0EB0 (3760)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0EC0 (3776)
+0xE73C, 0xE73C, 0xE73C, 0xCE59, 0xCE59, 0xE71C, 0xDEFB, 0xDEFB, 0xDEDB, 0xDE79, 0xDEBA, 0xDEDB, 0xDEFC, 0xDF1B, 0xDEFB, 0xDEFB,   // 0x0ED0 (3792)
+0xE71C, 0xD75D, 0xE3AB, 0xF180, 0xF9A0, 0xF9A0, 0xF9C0, 0xF1C1, 0xF1E2, 0xEA02, 0xE243, 0xDA85, 0xD2E7, 0xCB29, 0xBB8B, 0xB3ED,   // 0x0EE0 (3808)
+0xAC50, 0xACB2, 0xA514, 0x9D55, 0x9D76, 0x9D96, 0x9D97, 0xA5B7, 0xA596, 0xAD96, 0xA576, 0x9CF3, 0xD6BB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0EF0 (3824)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0F00 (3840)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0F10 (3856)
+0xE73C, 0xEF3D, 0xEF5D, 0xCE59, 0xCE59, 0xE73C, 0xDEFB, 0xDF3C, 0xDE37, 0xE2A6, 0xEAA6, 0xE34A, 0xDCB1, 0xDEDA, 0xDF1C, 0xDEFC,   // 0x0F20 (3872)
+0xE6DB, 0xDF5E, 0xD657, 0xD2C7, 0xCAA6, 0xC349, 0xBBAB, 0xB3ED, 0xAC50, 0xA4B1, 0xA513, 0x9D55, 0x9D76, 0x9D97, 0x9D97, 0x9DB7,   // 0x0F30 (3888)
+0xAD96, 0xA596, 0xA575, 0xA555, 0xA555, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA534, 0xA534, 0x9CD3, 0xDEDB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0F40 (3904)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0F50 (3920)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0F60 (3936)
+0xE73C, 0xE73D, 0xEF5D, 0xCE79, 0xC638, 0xE71C, 0xDEFB, 0xDF3D, 0xDE37, 0xF202, 0xF900, 0xF8C0, 0xEAC7, 0xD6BB, 0xE73D, 0xDEFB,   // 0x0F70 (3952)
+0xDEFB, 0xE71B, 0xDF1C, 0x9D14, 0x9D35, 0x9D97, 0x9D96, 0x9D97, 0xA5B7, 0xA5B6, 0xAD96, 0xAD75, 0xAD55, 0xAD34, 0xAD34, 0xAD55,   // 0x0F80 (3968)
+0xAD55, 0xA534, 0xAD55, 0xAD34, 0xAD35, 0xA514, 0x9492, 0x8C51, 0x94B2, 0xA534, 0xA534, 0x9CF3, 0xDEFB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0F90 (3984)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0FA0 (4000)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x0FB0 (4016)
+0xE73C, 0xE73C, 0xEF5D, 0xCE79, 0xC618, 0xE73C, 0xDEFB, 0xDF3D, 0xDE58, 0xEA85, 0xF980, 0xF960, 0xEB48, 0xDEFB, 0xDF3D, 0xDEFB,   // 0x0FC0 (4032)
+0xDEFC, 0xE71B, 0xDEDB, 0x9D14, 0xA534, 0xAD54, 0xAD34, 0xAD34, 0x9CD3, 0x94B2, 0x9492, 0x8C51, 0xA514, 0xAD55, 0xA535, 0x8C72,   // 0x0FD0 (4048)
+0x8430, 0x840F, 0x8C50, 0xA534, 0xB596, 0x8C71, 0x630C, 0x52AA, 0x7BEF, 0xAD55, 0xA514, 0xA514, 0xDEFB, 0xEF5D, 0xE73C, 0xE73C,   // 0x0FE0 (4064)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x0FF0 (4080)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x1000 (4096)
+0xE73C, 0xE73D, 0xEF5D, 0xD69A, 0xBDD7, 0xE73C, 0xDEFB, 0xDF3D, 0xDE79, 0xEAA5, 0xF940, 0xF960, 0xEB49, 0xDEDB, 0xDF3C, 0xDEFB,   // 0x1010 (4112)
+0xDEFB, 0xE71C, 0xD6BB, 0x9CF3, 0xA514, 0xAD55, 0xAD55, 0xA515, 0x6B6D, 0x632C, 0x630C, 0x5AEB, 0x94B2, 0xAD75, 0x9CF3, 0x6B4C,   // 0x1020 (4128)
+0x5AEB, 0x5ACB, 0x738E, 0xA534, 0xB596, 0x8C51, 0x630C, 0x5AEB, 0x8430, 0xAD55, 0x9CF3, 0xAD55, 0xE71C, 0xEF5D, 0xE73C, 0xE73C,   // 0x1030 (4144)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1040 (4160)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x1050 (4176)
+0xE73C, 0xE73C, 0xE73C, 0xD69A, 0xB5B7, 0xE73C, 0xDEFB, 0xDF3C, 0xDE99, 0xE285, 0xF8E0, 0xF900, 0xEB28, 0xDEFC, 0xDF3D, 0xDEFB,   // 0x1060 (4192)
+0xDEFB, 0xE71C, 0xD6BA, 0x9CF3, 0xA514, 0xAD55, 0xA554, 0xA514, 0x632D, 0x630C, 0x632C, 0x632C, 0x9CD2, 0xAD75, 0x9CF3, 0x6B4D,   // 0x1070 (4208)
+0x630C, 0x630C, 0x7BCF, 0xAD55, 0xAD75, 0x8410, 0x5AEB, 0x5AEB, 0x8C71, 0xAD75, 0x9CD3, 0xB5B6, 0xE73C, 0xEF5D, 0xE73C, 0xE73C,   // 0x1080 (4224)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1090 (4240)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x10A0 (4256)
+0xE73C, 0xE73C, 0xE73C, 0xD6BA, 0xB5B6, 0xE73C, 0xDEFB, 0xDF1C, 0xDEFA, 0xDC90, 0xEAC8, 0xEA04, 0xE38B, 0xDEDB, 0xDF3D, 0xDEFB,   // 0x10B0 (4272)
+0xDEFB, 0xE73D, 0xD679, 0x9CF3, 0xA534, 0xAD55, 0xA534, 0xA514, 0x6B4D, 0x632C, 0x632C, 0x6B4D, 0x9CF3, 0xAD55, 0x9CF3, 0x6B4D,   // 0x10C0 (4288)
+0x630B, 0x630C, 0x7BCF, 0xAD75, 0xAD55, 0x73AE, 0x5ACB, 0x632C, 0x94B2, 0xAD75, 0x9CD3, 0xBDD7, 0xE73C, 0xEF5D, 0xE73C, 0xE73C,   // 0x10D0 (4304)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x10E0 (4320)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x10F0 (4336)
+0xE73C, 0xE73C, 0xE75D, 0xDEDB, 0xB5B6, 0xE73C, 0xDEFB, 0xDEFC, 0xDEFC, 0xDF3C, 0xD6BA, 0xDDF6, 0xDDF7, 0xDEFB, 0xDEFC, 0xDEFB,   // 0x1100 (4352)
+0xDEFB, 0xE73C, 0xCE79, 0x9CD3, 0xA514, 0xAD34, 0xAD55, 0xA514, 0x6B4D, 0x632C, 0x630C, 0x634C, 0xA514, 0xAD75, 0x9CF3, 0x632C,   // 0x1110 (4368)
+0x632C, 0x630B, 0x7BCF, 0xAD75, 0xA534, 0x8C51, 0x8430, 0x9492, 0xA534, 0xAD55, 0x94B2, 0xC638, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C,   // 0x1120 (4384)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1130 (4400)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x1140 (4416)
+0xE73C, 0xEF5D, 0xEF7D, 0xDEFB, 0xB596, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDF1C, 0xDF5D, 0xDF7E, 0xDF5D, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x1150 (4432)
+0xDEFB, 0xE73D, 0xCE58, 0x9CF4, 0xA534, 0xA534, 0xAD35, 0x9D13, 0x630C, 0x630C, 0x630C, 0x6B6D, 0xA534, 0xAD55, 0x9CD3, 0x632C,   // 0x1160 (4448)
+0x632C, 0x630C, 0x7BEF, 0xAD55, 0xAD55, 0xAD55, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0x9492, 0xB5B6, 0xE71C, 0xEF7D, 0xEF5D, 0xE73C,   // 0x1170 (4464)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1180 (4480)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D,   // 0x1190 (4496)
+0xEF7D, 0xE73C, 0xD6BA, 0xBDD7, 0xAD75, 0xEF5D, 0xE71C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x11A0 (4512)
+0xDEFB, 0xE73C, 0xC638, 0xA514, 0xA534, 0xA534, 0xAD55, 0xA514, 0x8410, 0x8C51, 0x9492, 0x9CD3, 0xA534, 0xAD55, 0x94B2, 0x632C,   // 0x11B0 (4528)
+0x630C, 0x632C, 0x8410, 0xAD75, 0xAD75, 0xAD55, 0xA534, 0x9CF3, 0x9CD3, 0x9CD3, 0x8C71, 0x9CF3, 0xB596, 0xC638, 0xDEDB, 0xEF5D,   // 0x11C0 (4544)
+0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x11D0 (4560)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xE71C,   // 0x11E0 (4576)
+0xCE79, 0xBDD7, 0xAD75, 0xA514, 0x9CF3, 0xD6BA, 0xE71C, 0xE73C, 0xE73C, 0xE73C, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x11F0 (4592)
+0xDEFB, 0xE73C, 0xC618, 0x9CF3, 0xA534, 0xA534, 0xA534, 0xA534, 0xAD55, 0xAD55, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0x94B2, 0x630C,   // 0x1200 (4608)
+0x630C, 0x5AEB, 0x7BEF, 0xA514, 0x94B2, 0x9492, 0x94B2, 0x94B2, 0x9CD3, 0x9CF3, 0xA514, 0xA534, 0xA534, 0xA534, 0xAD75, 0xC618,   // 0x1210 (4624)
+0xDEDB, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1220 (4640)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xE73C, 0xCE59, 0xB5B6,   // 0x1230 (4656)
+0xAD55, 0xA534, 0xA534, 0xAD55, 0x9CF3, 0xA514, 0xA534, 0xB5B6, 0xC638, 0xD6BA, 0xE71C, 0xEF5D, 0xE73C, 0xE71C, 0xDEFB, 0xDEFB,   // 0x1240 (4672)
+0xDEFB, 0xEF5D, 0xBDF7, 0x9CF3, 0xA534, 0xAD55, 0xA534, 0xA534, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0x8C51, 0x52AA,   // 0x1250 (4688)
+0x632C, 0x6B4D, 0x8410, 0x9CF3, 0x9CD3, 0x9CF3, 0xA514, 0xA534, 0xAD55, 0xAD55, 0xAD75, 0xAD55, 0xAD55, 0xA534, 0xA534, 0xA534,   // 0x1260 (4704)
+0xAD75, 0xBDF7, 0xDEFB, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1270 (4720)
+0xF79E, 0xCE59, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xE73C, 0xCE79, 0xB5B6, 0xAD55, 0xA534,   // 0x1280 (4736)
+0xA534, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xA514, 0xA514, 0x9CF3, 0x9CF3, 0xA514, 0xAD55, 0xB5B6, 0xC638, 0xDEDB, 0xE71C, 0xE73C,   // 0x1290 (4752)
+0xE73C, 0xEF5D, 0xBDD7, 0x9CF3, 0xA534, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA514, 0x9CD3, 0x94B2, 0x9492, 0x94B2, 0x9492, 0x8C51,   // 0x12A0 (4768)
+0x9CD3, 0xA514, 0xA534, 0xAD55, 0xAD55, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55,   // 0x12B0 (4784)
+0xA534, 0xA534, 0xB596, 0xCE59, 0xE73C, 0xEF7D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEDB, 0xF79E,   // 0x12C0 (4800)
+0xF79E, 0xCE79, 0xE73C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF5D, 0xD6BA, 0xBDD7, 0xAD55, 0xA534, 0xA534, 0xAD55,   // 0x12D0 (4816)
+0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA534, 0xA514, 0x9CF3, 0xA514, 0xA514, 0xA534, 0xB5B6,   // 0x12E0 (4832)
+0xCE59, 0xE71C, 0xB5B6, 0xA514, 0xA514, 0x9CF3, 0x9CD3, 0x9492, 0x9492, 0x94B2, 0x9CD3, 0x9CF3, 0xA514, 0xA534, 0xAD55, 0xAD75,   // 0x12F0 (4848)
+0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55, 0xAD55,   // 0x1300 (4864)
+0xAD55, 0xAD55, 0xA534, 0xAD55, 0xBDD7, 0xDEDB, 0xEF7D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1310 (4880)
+0xF7BE, 0xD6BA, 0xE71C, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xE73C, 0xC638, 0xAD75, 0xAD55, 0xAD55, 0xAD75, 0xAD75, 0xAD75,   // 0x1320 (4896)
+0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xAD55, 0xA534, 0xA514,   // 0x1330 (4912)
+0xA514, 0xA514, 0x9492, 0x8C71, 0x9492, 0x94B2, 0x9CF3, 0xA514, 0xA534, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75,   // 0x1340 (4928)
+0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75, 0xAD55, 0xAD75, 0xAD75, 0xAD75,   // 0x1350 (4944)
+0xAD55, 0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xB596, 0xCE79, 0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1360 (4960)
+0xF7BE, 0xD6BA, 0xE71C, 0xEF7D, 0xE73C, 0xEF5D, 0xEF7D, 0xDEDB, 0xBDD7, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75,   // 0x1370 (4976)
+0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB596, 0xB596, 0xB596, 0xB596, 0xAD75,   // 0x1380 (4992)
+0xAD75, 0xAD75, 0xAD55, 0xAD55, 0xAD75, 0xAD75, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xAD75, 0xAD75, 0xAD75,   // 0x1390 (5008)
+0xAD75, 0xB596, 0xB596, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xAD75,   // 0x13A0 (5024)
+0xAD75, 0xAD75, 0xAD75, 0xB596, 0xAD75, 0xAD75, 0xB596, 0xC638, 0xE73C, 0xEF7D, 0xEF5D, 0xEF5D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x13B0 (5040)
+0xFFDF, 0xDEDB, 0xE71C, 0xEF7D, 0xEF7D, 0xEF5D, 0xCE59, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB5B6, 0xB596, 0xB596,   // 0x13C0 (5056)
+0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596,   // 0x13D0 (5072)
+0xB596, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596,   // 0x13E0 (5088)
+0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596,   // 0x13F0 (5104)
+0xB596, 0xB5B6, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xB596, 0xC618, 0xE73C, 0xEF7D, 0xEF7D, 0xE73C, 0xCE59, 0xDEFB, 0xF79E,   // 0x1400 (5120)
+0xFFDF, 0xDEDB, 0xDEFB, 0xF79E, 0xE71C, 0xC618, 0xB596, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1410 (5136)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1420 (5152)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1430 (5168)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6,   // 0x1440 (5184)
+0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xB5B6, 0xBDF7, 0xDEFB, 0xF79E, 0xE71C, 0xCE59, 0xE71C, 0xEF7D,   // 0x1450 (5200)
+0xFFFF, 0xDEFB, 0xDEDB, 0xE71C, 0xBDF7, 0xB5B6, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1460 (5216)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1470 (5232)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1480 (5248)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7,   // 0x1490 (5264)
+0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xBDD7, 0xB5B6, 0xC618, 0xE71C, 0xDEFB, 0xCE59, 0xE73C, 0xEF7D,   // 0x14A0 (5280)
+0xFFFF, 0xEF5D, 0xC618, 0xC618, 0xBDD7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14B0 (5296)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14C0 (5312)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14D0 (5328)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7,   // 0x14E0 (5344)
+0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDF7, 0xBDD7, 0xC638, 0xC638, 0xD69A, 0xEF5D, 0xEF7D,   // 0x14F0 (5360)
+0xFFFF, 0xF7BE, 0xC638, 0xBDF7, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1500 (5376)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1510 (5392)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1520 (5408)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1530 (5424)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xBDD7, 0xBDD7, 0xDEFB, 0xEF5D, 0xEF7D,   // 0x1540 (5440)
+0xFFFF, 0xFFFF, 0xD6BA, 0xBDF7, 0xC638, 0xC618, 0xC618, 0xC638, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1550 (5456)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1560 (5472)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1570 (5488)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618,   // 0x1580 (5504)
+0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xC618, 0xB5B6, 0xC638, 0xE73C, 0xEF5D, 0xF79E,   // 0x1590 (5520)
+0xFFFF, 0xFFFF, 0xEF7D, 0xBDF7, 0xC638, 0xCE59, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15A0 (5536)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15B0 (5552)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15C0 (5568)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x15D0 (5584)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xCE59, 0xC618, 0xB5B6, 0xD69A, 0xEF5D, 0xEF7D, 0xF7BE,   // 0x15E0 (5600)
+0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0xC618, 0xCE79, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x15F0 (5616)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1600 (5632)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1610 (5648)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1620 (5664)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xB5B6, 0xC618, 0xE71C, 0xEF5D, 0xEF7D, 0xFFDF,   // 0x1630 (5680)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xC618, 0xC638, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1640 (5696)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1650 (5712)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1660 (5728)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79,   // 0x1670 (5744)
+0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xCE79, 0xBDD7, 0xBDD7, 0xDEDB, 0xE73C, 0xEF5D, 0xF7BE, 0xFFDF,   // 0x1680 (5760)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xBDF7, 0xCE79, 0xD69A, 0xD69A, 0xD69A, 0xCE79, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x1690 (5776)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16A0 (5792)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16B0 (5808)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16C0 (5824)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xCE79, 0xBDF7, 0xB5B6, 0xD69A, 0xE73C, 0xE73C, 0xEF7D, 0xF7BE, 0xFFFF,   // 0x16D0 (5840)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xBDF7, 0xCE79, 0xD6BA, 0xD6BA, 0xD6BA, 0xD69A, 0xD69A, 0xD6BA, 0xD69A, 0xD69A,   // 0x16E0 (5856)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x16F0 (5872)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x1700 (5888)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD69A,   // 0x1710 (5904)
+0xD69A, 0xD69A, 0xD69A, 0xD69A, 0xD6BA, 0xDEDB, 0xCE79, 0xBDD7, 0xB596, 0xD69A, 0xE73C, 0xE73C, 0xEF7D, 0xF7BE, 0xFFDF, 0xFFFF,   // 0x1720 (5920)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xC618, 0xCE59, 0xD6BA, 0xDEDB, 0xDEDB, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1730 (5936)
+0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1740 (5952)
+0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1750 (5968)
+0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA, 0xD6BA,   // 0x1760 (5984)
+0xD6BA, 0xD6BA, 0xDEDB, 0xDEDB, 0xD6BA, 0xCE59, 0xB5B6, 0xB5B6, 0xD69A, 0xE73C, 0xE73C, 0xEF5D, 0xF79E, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x1770 (6000)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xC638, 0xC638, 0xD69A, 0xDEDB, 0xDEFB, 0xDEFB, 0xDEDB, 0xDEDB,   // 0x1780 (6016)
+0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB,   // 0x1790 (6032)
+0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB,   // 0x17A0 (6048)
+0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEDB, 0xDEFB,   // 0x17B0 (6064)
+0xDEFB, 0xDEFB, 0xDEDB, 0xD69A, 0xC618, 0xB596, 0xBDF7, 0xDEDB, 0xE73C, 0xE73C, 0xEF5D, 0xF79E, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x17C0 (6080)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF79E, 0xD6BA, 0xC618, 0xC638, 0xCE79, 0xD6BA, 0xDEDB, 0xDEFB,   // 0x17D0 (6096)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x17E0 (6112)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB,   // 0x17F0 (6128)
+0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEDB,   // 0x1800 (6144)
+0xD6BA, 0xCE79, 0xBDF7, 0xB5B6, 0xBDD7, 0xCE79, 0xDEFB, 0xE73C, 0xE73C, 0xEF7D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1810 (6160)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xEF5D, 0xD6BA, 0xC638, 0xC618, 0xC618, 0xC638,   // 0x1820 (6176)
+0xCE59, 0xC638, 0xC638, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xC638, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1830 (6192)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59,   // 0x1840 (6208)
+0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xCE59, 0xC638, 0xC618, 0xBDF7,   // 0x1850 (6224)
+0xBDD7, 0xB5B6, 0xC618, 0xCE79, 0xDEFB, 0xE73C, 0xE73C, 0xE73C, 0xEF7D, 0xF79E, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1860 (6240)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF79E, 0xEF5D, 0xDEFB, 0xD6BA, 0xCE79,   // 0x1870 (6256)
+0xCE59, 0xCE59, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x1880 (6272)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638,   // 0x1890 (6288)
+0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xCE59, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xC638, 0xCE59,   // 0x18A0 (6304)
+0xD69A, 0xDEDB, 0xE71C, 0xE73C, 0xE73C, 0xE73C, 0xEF5D, 0xEF7D, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x18B0 (6320)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xF7BE, 0xF7BE, 0xF79E, 0xEF7D, 0xEF7D,   // 0x18C0 (6336)
+0xEF5D, 0xEF5D, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x18D0 (6352)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x18E0 (6368)
+0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C, 0xE73C,   // 0x18F0 (6384)
+0xEF5D, 0xEF5D, 0xE73C, 0xEF5D, 0xEF5D, 0xF79E, 0xF7BE, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1900 (6400)
+};

_719/dtu21.ino

@@ -0,0 +1,101 @@
+void dtu21()
+{ //Set the address of the HTU21D. This detail is hidden at the bototm of page 10 of the datasheet.
+ const int I2C_address = 0x40; // I2C write address. Note that 'const' has been declared. If you try to write to this variable
+ // anywhere else in your code you'll get a compilation error. This prevents you from doing silly things. 
+ 
+ const int TempCode = 0xE3; // A temperature measurement is executed with this command code. See page 11 of datasheet.
+ const int HumidCode = 0xE5; // A humidity measurement is executed with this command code. See page 11 of datasheet.
+ 
+ long Temperature; //Perform our calculation using LONG to prevent overflow at high measuremetn values when using 14bit mode.
+ long Humidity; 
+ 
+ float TemperatureFL; //Variable to store our final calculated temperature measurement
+ float HumidityFL; 
+ 
+ delay(100); // a short delay to let everything stabilise
+ 
+
+ delay(10); //add a small delay to slow things down
+ 
+ RequestMeas(I2C_address, TempCode); //Request the current temperature
+ Temperature = ReadMeas(I2C_address); //read the result
+ 
+ //We must now convert our temp measurement into an actual proper temperature value
+ //According to page 15, the conversion equation is: Temp = -46.85 + 175.72 x TeampMeas / 2^16
+ //Becasue the result will have decimal places in the result we must use a Float datatype.
+// TemperatureFL = (Temperature/65536.0)*175.72-46.85 ; 
+  TemperatureFL = (Temperature/65536.0)*175.72-46.85-1.1 ; 
+ 
+ delay(100); //add a small delay to slow things down
+ 
+ RequestMeas(I2C_address, HumidCode); //Request the current humidity
+ Humidity = ReadMeas(I2C_address); //read the result
+ 
+ //We must now convert our humidity measurement into an actual proper humidity value
+ //According to page 15, the conversion equation is: Humidity = 6 + 125 x TeampMeas / 2^16
+ //Becasue the result will have decimal places in the result we must use a Float datatype.
+ //HumidityFL = -6 + 125*(Humidity/pow(2, 16)); 
+ HumidityFL =(Humidity/65536.0)*125.0-6.0; 
+ 
+ 
+  tdc=TemperatureFL;
+ tdd=abs(TemperatureFL*10-tdc*10);
+  hdc=HumidityFL;
+ hdd=HumidityFL*10-hdc*10;
+ if(hdc>99)
+ {hdc=99;
+ hdd=9;
+ }
+
+  
+ 
+}
+
+void RequestMeas(int Address, int CommandCode)
+{
+ Wire.beginTransmission(Address); // The HTU21D will respond to its address
+ Wire.write(CommandCode); // request the measurement, ie temperature or humidity
+ Wire.endTransmission();
+ return;
+}
+ 
+long ReadMeas(int Address)
+{
+ //A measurement from the HTU21D is returned in 3 consecutive bytes. See page 11 of the datasheet
+ //the order of returend data is: [DATA (Most Sig Byte)], [DATA (Least Sig Byte)], [Checksum]
+ //We will ignore the checksum to save computation time and complexity. Page 14 of the datasheet details how to calculate the checksum
+ 
+ byte DataHIGH; //The location to store the high measurement byte
+ byte DataLOW; //The low measurement byte
+ byte CRC; //If you want to compute the CRC feel free to do so.
+ 
+ long Data; //The temporary memory location we are storing our data in as we receive it from the HTU21D
+ //Each packet of data is only 8bits in length, but if we do a bit shift we can store the 2 packets of
+ //measurement data in a variable. Remember you can only return 1 variable when a function finishes.
+ //Ideally, we'd use an int to store the result, however, at high measurement values in 14bit mode, an int overflows.
+ //To prevent overflow, we must use a single long (32bits). 
+ 
+ Wire.requestFrom(Address, 3); //We are requesting data from the HTU21D and there will be 3x bytes that must be read.
+ while(Wire.available()) // Check for data from the HTU21D
+ {
+ DataHIGH = Wire.read(); // Read high byte
+ DataLOW = Wire.read(); // Read low byte
+ CRC = Wire.read(); // Read the CRC byte
+ } 
+ 
+ //OK, so now we are going to 'pack' our 2x bytes of data measuremetns into a single int so only 1 variable is returned.
+ //To do this, we will use the left bitshift operator '<<'. What this does is push all the bits across to the left.
+ //FUN FACT: performing a left bit shift is equivalent to multiplication by 2 for each shift. The reverse is true for right
+ //bitshift which is equivalent to dividing by 2. This is a far more efficient method to perform multiply or divide by 2.
+ 
+ Data = DataHIGH; //The data sits in the low byte of 'int Data'.
+ //Ie, Data = [00000000][00000000][00000000][8 bits of DataHIGH]
+ //data[1] << 8
+ //Data = Data << 8; //Shift all the bits to the left for 8 bits. The old locations fill with zeros.
+ Data = Data<<8;
+ //Ie, Data = [00000000][00000000][8 bits of DataHIGH][00000000]
+ Data = Data + DataLOW; //Now simply add the low byte of data to the int.
+ //Ie, Data = [00000000][00000000][8 bits of DataHIGH][8 bits of DataLOW]
+ 
+ return Data; //return our measurement.
+}

_719/fileread.ino

@@ -0,0 +1,124 @@
+void readfile()
+{w=0;
+bufer="";
+int a=0,b=0;
+byte st=0;
+int cardSize;
+
+   myGLCD.setColor(22,18,70); 
+
+   myGLCD.fillRoundRect (380,145, 630, 475);
+ myGLCD.setColor(VGA_WHITE); 
+  myGLCD.drawRoundRect (380,145, 630, 475); 
+  
+
+myGLCD.setFont(SmallFont);
+ myGLCD.setColor(255,255,255);
+    myGLCD.setBackColor(0,38,92);
+
+
+
+  myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+     
+
+  clc();
+  
+   myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE);
+
+  sd.chdir("/");
+  delay(100);
+ myFile.open(name, O_READ);
+cardSize=myFile.fileSize();
+// myGLCD.print("cardSize=",10,10);
+// myGLCD.printNumI(cardSize,10,30);
+ st=0;
+ w=0;
+for (int i=0 ; i < cardSize; i = i++)
+{       char ByteRead=myFile.read();  //чтение данных с порта
+            if (ByteRead==char(13))//окончание строки 
+            {  analyzer();   //передача данных на обработку
+             myFile.read();
+                bufer="";
+                st=0;
+              } 
+            else {
+              bufer=bufer+char(ByteRead);
+                  st++;
+                 if(st>28)
+                 {st=0;
+                   analyzer();
+                    bufer="";
+                      }
+ }   ///накопление данных в буфер
+ if (fcl==1)
+ {fcl=0;
+ goto clos;
+ }
+ 
+ }
+ analyzer();   //передача данных на обработку
+clos:
+  myFile.close();
+  
+  myGLCD.setColor(22,18,70); 
+  myGLCD.setBackColor(VGA_WHITE); 
+  myGLCD.print("    pres  exit  to return  ",393,463);
+    myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE); 
+
+}
+
+//**************************************************************************
+
+
+
+
+void analyzer()
+{ myGLCD.setFont(SmallFont);
+  myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE); 
+  
+  w++;
+myGLCD.print(bufer,385,147-12+12*w);
+delay(100);
+boolean b=0;
+if(w>25)
+{w=0;
+  myGLCD.setColor(22,18,70); 
+  myGLCD.setBackColor(VGA_WHITE); 
+  myGLCD.print("   pres touch to continion  ",393,463);
+    myGLCD.setBackColor(22,18,70); 
+  myGLCD.setColor(VGA_WHITE); 
+ while(b<1)
+{delay(200);
+   if (myTouch.dataAvailable()) 
+{  
+   myTouch.read();
+     int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+        if ((x>=380) && (x<=630))  // open
+      { 
+            if ((y>=150) && (y<=470))  // 640, 240,  680, 280); //open
+      
+     { b=2;
+       myGLCD.setColor(22,18,70); 
+
+   myGLCD.fillRoundRect (380,145, 630, 475);
+ myGLCD.setColor(VGA_WHITE); 
+  myGLCD.drawRoundRect (380,145, 630, 475); 
+     }
+      }
+      
+      if ((x<380) || (x>630))  // open
+    {fcl=1;
+      b=2;
+    }
+}
+}
+
+
+}
+}

_719/flr.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: flr.jpg
+// Time generated: 09.09.2015 19:21:28
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short flr[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00D0 (208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001E, 0x18FB, 0x52DA, 0x94DD, 0xBDFF, 0xB5DF, 0xADBF, 0xB5DE, 0xB5DF, 0xADBE, 0xADBE, 0xB5BF, 0xAD9E, 0xAD9E, 0xB5DF, 0xB5DF,   // 0x0110 (272)
+0xB5BF, 0xAD9F, 0xADBE, 0x9D7D, 0xB5DF, 0xADBF, 0xADBF, 0xAD9E, 0xA55E, 0xB5DF, 0xB5DF, 0xA55D, 0xAD7E, 0xAD5D, 0xA55E, 0xA57E,   // 0x0120 (288)
+0xB5BF, 0xADDF, 0xADDF, 0xADBF, 0xADBE, 0xB5BE, 0xB5BE, 0xB5BF, 0xB5DF, 0xB5DE, 0xBDFF, 0xAD9D, 0x6BBC, 0x299C, 0x001E, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31DC,   // 0x0150 (336)
+0x94BD, 0xC65E, 0xCEBD, 0xC69C, 0xCEDD, 0xCEDD, 0xCEBD, 0xC69D, 0xC6BC, 0xC6DC, 0xC6DB, 0xC6BC, 0xCEBC, 0xCEBD, 0xCEBD, 0xCEDD,   // 0x0160 (352)
+0xC6BC, 0xCE9C, 0xCEDD, 0xC69C, 0xCEBD, 0xCEDD, 0xC69C, 0xCEBC, 0xCE7C, 0xCEBC, 0xD6DC, 0xC69B, 0xCEBB, 0xCEBB, 0xCE9B, 0xCEBC,   // 0x0170 (368)
+0xCEBD, 0xC6DD, 0xC6BD, 0xC6BC, 0xCEBC, 0xCE9C, 0xCEBC, 0xCEBC, 0xC6DC, 0xCEDC, 0xD6FD, 0xD71D, 0xD6DC, 0xBE3C, 0x9D3D, 0x425D,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x633C, 0xBE3D,   // 0x01A0 (416)
+0xCEBC, 0xCEBC, 0xCEDD, 0xC69D, 0xC6BD, 0xC6BD, 0xC69D, 0xC6BD, 0xBEBC, 0xBEBB, 0xBEBB, 0xC6BB, 0xC6BC, 0xC69C, 0xC69C, 0xC69C,   // 0x01B0 (432)
+0xC67C, 0xC69C, 0xCEBD, 0xCEDD, 0xBE9D, 0xC6BC, 0xB5F9, 0x9D15, 0x94B3, 0x9491, 0x9CF4, 0xB5D8, 0xCE7A, 0xD6BC, 0xCE9B, 0xC67C,   // 0x01C0 (448)
+0xC69C, 0xBEBD, 0xBEBC, 0xBE9C, 0xC69C, 0xCE7B, 0xC69C, 0xC6BC, 0xBEBD, 0xBEBD, 0xC6BD, 0xCEDD, 0xD71D, 0xD71E, 0xD71D, 0xC65C,   // 0x01D0 (464)
+0x6B7C, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087C, 0x73FC, 0xBE5D, 0xC69B,   // 0x01F0 (496)
+0xBE7C, 0xC69D, 0xBE9D, 0xBE7D, 0xBE9E, 0xBE9E, 0xBE9D, 0xBE9D, 0xBE9B, 0xBEBB, 0xBEBB, 0xBE9C, 0xC69C, 0xC69B, 0xBE7B, 0xBE9B,   // 0x0200 (512)
+0xC6DC, 0xBE9C, 0xBE7C, 0xBE7C, 0xBE5B, 0xB5F9, 0x6A0A, 0xD864, 0xE064, 0xD884, 0xC043, 0x730D, 0xC69B, 0xCE9C, 0xC65B, 0xC69C,   // 0x0210 (528)
+0xBE7C, 0xBEBC, 0xBEBC, 0xBEBC, 0xC69C, 0xC69C, 0xC69C, 0xBE9D, 0xB6BE, 0xB69D, 0xBEBD, 0xBE9D, 0xC69D, 0xCEDD, 0xD71D, 0xD6FD,   // 0x0220 (544)
+0xC67D, 0x73DD, 0x003C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x5B3C, 0xB63C, 0xC6BC, 0xBE9C,   // 0x0240 (576)
+0xBE5C, 0xBE9D, 0xBE9E, 0xB69E, 0xB67D, 0xB67D, 0xB65C, 0xBE7C, 0xBE9C, 0xB6BB, 0xB69C, 0xB69D, 0xBE7C, 0xBE5B, 0xB67B, 0xBEBC,   // 0x0250 (592)
+0xB6BD, 0xB69C, 0xAE7D, 0xAE5B, 0xBE7B, 0x936E, 0xE043, 0xF864, 0xF864, 0xF863, 0xF864, 0xC843, 0x83F0, 0xC63A, 0xC63A, 0xC67B,   // 0x0260 (608)
+0xC69C, 0xBE7B, 0xB67C, 0xB67C, 0xBE7C, 0xBE7C, 0xBE7D, 0xB67D, 0xAE7E, 0xB67E, 0xB6BE, 0xB6BD, 0xBE9D, 0xC6DD, 0xC6DD, 0xC6BC,   // 0x0270 (624)
+0xCEBC, 0xC67D, 0x6B7D, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x52DD, 0xADDC, 0xB67B, 0xBE9C, 0xBE7D,   // 0x0290 (656)
+0xBE7D, 0xB67D, 0xAE7D, 0xAE7D, 0xB69D, 0xAE9D, 0xB65C, 0xBE7B, 0xB67B, 0xB67C, 0xAE7C, 0xADFC, 0x94D5, 0x92AC, 0x79E8, 0x6BD0,   // 0x02A0 (672)
+0x8D78, 0xAE7D, 0xAE7C, 0xA65C, 0x9D35, 0xE0A4, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xC002, 0x9472, 0xC6BB, 0xC69C,   // 0x02B0 (688)
+0xB69D, 0xB67D, 0xB67C, 0xB67D, 0xB67D, 0xB67D, 0xB67E, 0xB65E, 0xB67E, 0xAE7E, 0xAE7D, 0xAE7D, 0xB67D, 0xB67D, 0xBE7D, 0xBE7C,   // 0x02C0 (704)
+0xBE7C, 0xC6BB, 0xADDB, 0x423D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x637B, 0xB61C, 0xBE9D, 0xB67D, 0xB65D,   // 0x02E0 (736)
+0xB65C, 0xB65D, 0xAE5D, 0xA65E, 0xAE7E, 0xAE7D, 0xAE5C, 0xB65A, 0xB65B, 0xB67C, 0xAE1C, 0x626B, 0xC884, 0xF864, 0xF864, 0xD884,   // 0x02F0 (752)
+0xA105, 0x8451, 0xB679, 0xBE79, 0xA533, 0xE063, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF043, 0x8B0D, 0xC69C, 0xB65E,   // 0x0300 (768)
+0xB67E, 0xAE7D, 0xB69C, 0xB67C, 0xAE5D, 0xB67D, 0xB65D, 0xB67D, 0xB67D, 0xAE7D, 0xAE7E, 0xAE7E, 0xAE5D, 0xB65D, 0xB67D, 0xB67D,   // 0x0310 (784)
+0xB65C, 0xBE7B, 0xB63C, 0x5B3C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213B, 0x8CFB, 0xB67D, 0xB69E, 0xAE5D, 0xAE3C,   // 0x0330 (816)
+0xAE5D, 0xAE7D, 0xAE7E, 0xA65E, 0xA65D, 0xA65C, 0xAE7C, 0xB67B, 0xB65A, 0xAE5B, 0x8CD5, 0xC083, 0xF863, 0xF884, 0xF884, 0xF884,   // 0x0340 (832)
+0xF864, 0xC822, 0x942E, 0xE716, 0xAD11, 0xD863, 0xF863, 0xF884, 0xF864, 0xF863, 0xF864, 0xF883, 0xF864, 0xA8A5, 0xB61A, 0xB67D,   // 0x0350 (848)
+0xAE7D, 0xB67D, 0xBE9C, 0xBE7B, 0xB65D, 0xB65D, 0xB65D, 0xB69D, 0xAE7D, 0xAE7D, 0xAE5D, 0xAE7D, 0xAE9D, 0xAE7D, 0xAE5D, 0xAE5C,   // 0x0360 (864)
+0xB65C, 0xB65C, 0xBE7B, 0x8CDB, 0x18DB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x3A1B, 0xA5BB, 0xAE7D, 0xA65D, 0xAE5D, 0xAE5D,   // 0x0380 (896)
+0xA61C, 0xA63C, 0xA63D, 0x9E3D, 0xA65D, 0xA65C, 0xAE7D, 0xAE7D, 0xAE9D, 0xAE7D, 0x7A6B, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864,   // 0x0390 (912)
+0xF884, 0xF864, 0xC905, 0xCE32, 0x9C6D, 0xD863, 0xF884, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF864, 0xC8A5, 0xB5F8, 0xB67D,   // 0x03A0 (928)
+0xB67D, 0xB67D, 0xBE9C, 0xBE5A, 0x9D78, 0x8473, 0x8C95, 0x8C94, 0x8CB5, 0x8CD6, 0xA61B, 0xAE7E, 0xAE5D, 0xAE5D, 0xA63D, 0xAE5D,   // 0x03B0 (944)
+0xAE3C, 0xAE3C, 0xB65B, 0xA59B, 0x39FC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ABC, 0xA5FC, 0xAE7D, 0x9E3D, 0xA63D, 0xA63D,   // 0x03D0 (976)
+0xA63C, 0xA65D, 0xA65D, 0x9E5D, 0xA65C, 0xA63B, 0xAE5B, 0xAE9D, 0xA67D, 0xA67C, 0x8AAB, 0xF864, 0xF864, 0xF884, 0xF884, 0xF884,   // 0x03E0 (992)
+0xF884, 0xF884, 0xF843, 0xA268, 0x944D, 0xE064, 0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xF864, 0xF863, 0xC084, 0x94F2, 0xB67D,   // 0x03F0 (1008)
+0xAE7E, 0xB69D, 0xBE7A, 0x8451, 0x7947, 0xB8A4, 0xE064, 0xE064, 0xE064, 0xB8A4, 0x89C9, 0x7BB0, 0xA61C, 0xAE5E, 0xA65D, 0xAE5D,   // 0x0400 (1024)
+0xAE3D, 0xAE3D, 0xAE5C, 0xADFC, 0x5B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBE, 0xAE5D, 0xAE9E, 0xA67E, 0xA65E, 0xA61C,   // 0x0420 (1056)
+0xA61C, 0xA63C, 0x9E3D, 0x9E5D, 0xA65C, 0xA61A, 0xAE3B, 0xAE7D, 0xAE7D, 0xA65C, 0x8A4A, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864,   // 0x0430 (1072)
+0xF884, 0xF863, 0xF883, 0xE884, 0x7A68, 0xD8A4, 0xF863, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xB802, 0x8C91, 0xB67C,   // 0x0440 (1088)
+0xB69D, 0xAE1A, 0x826A, 0xA0C4, 0xF864, 0xF864, 0xF864, 0xF884, 0xF863, 0xF884, 0xF864, 0xE063, 0x8209, 0x9579, 0xA65D, 0xA65D,   // 0x0450 (1104)
+0xA65D, 0xA63D, 0xAE3C, 0xAE3C, 0x635D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x741E, 0xAE5C, 0xAEBE, 0xA69E, 0xA65E, 0xA63D,   // 0x0470 (1136)
+0xA61C, 0x9DFC, 0x961C, 0x9E3D, 0x9E3C, 0xA61A, 0xA63A, 0xAE5D, 0xA65C, 0xAE5B, 0x83EE, 0xE063, 0xF884, 0xF884, 0xF884, 0xF884,   // 0x0480 (1152)
+0xF884, 0xF884, 0xF884, 0xF864, 0x7883, 0xD884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xB802, 0x9CD1, 0xB67C,   // 0x0490 (1168)
+0x9536, 0xB0E6, 0xF043, 0xF864, 0xF884, 0xF864, 0xF863, 0xF863, 0xF883, 0xF864, 0xF884, 0xF864, 0xF043, 0x7168, 0x9E1B, 0xA63E,   // 0x04A0 (1184)
+0xA63D, 0xA61D, 0xAE3C, 0xA5FC, 0x5B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xA63C, 0xAEDF, 0xA67E, 0xA65E, 0xA65D,   // 0x04C0 (1216)
+0xA65D, 0x9E1C, 0x9E1C, 0x9E3D, 0x95DA, 0xBCB5, 0xBCB4, 0xADD8, 0xB65B, 0xC6B8, 0xCE93, 0xA884, 0xF864, 0xF864, 0xF884, 0xF864,   // 0x04D0 (1232)
+0xF864, 0xF863, 0xF884, 0xF864, 0xC884, 0xE084, 0xF863, 0xF884, 0xF863, 0xF883, 0xF884, 0xF884, 0xF863, 0xC002, 0xAD30, 0xBE17,   // 0x04E0 (1248)
+0x9002, 0xF843, 0xF884, 0xF884, 0xF863, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xF863, 0xF864, 0xF883, 0xE823, 0x732F, 0x9E1D,   // 0x04F0 (1264)
+0x9E3E, 0x9E3D, 0xA61C, 0x9DBB, 0x5B3D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0xADFD, 0xAE7E, 0xAE7E, 0xA65D, 0xA67E,   // 0x0510 (1296)
+0xA63D, 0xA63D, 0xA5FC, 0x7C33, 0xCA6B, 0xF884, 0xF884, 0xE987, 0xEACA, 0xFB4B, 0xED6E, 0x8A88, 0xE843, 0xF884, 0xF864, 0xF884,   // 0x0520 (1312)
+0xF884, 0xF884, 0xF884, 0xF884, 0xC084, 0xA884, 0xF884, 0xF884, 0xF863, 0xF884, 0xF863, 0xF884, 0xF863, 0xC8A4, 0x8C6E, 0x8A69,   // 0x0530 (1328)
+0xF843, 0xF864, 0xF884, 0xF864, 0xF884, 0xF884, 0xF883, 0xF884, 0xF863, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xA0E6, 0x95BB,   // 0x0540 (1344)
+0x961D, 0x961D, 0x9E1C, 0x9DDC, 0x5AFD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x635E, 0xA5FD, 0xAE3E, 0xA65E, 0xA65E, 0xA65D,   // 0x0560 (1376)
+0xA67E, 0xA5DB, 0x8A4A, 0xE043, 0xF863, 0xF884, 0xF883, 0xF884, 0xF884, 0xF863, 0xF843, 0xD904, 0xA883, 0xF864, 0xF883, 0xF884,   // 0x0570 (1392)
+0xF864, 0xF864, 0xF884, 0xF884, 0xF084, 0xC064, 0xF883, 0xF884, 0xF864, 0xF863, 0xF883, 0xF864, 0xF864, 0x90E5, 0x6187, 0xE863,   // 0x0580 (1408)
+0xF864, 0xF864, 0xF884, 0xF884, 0xF863, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF863, 0xB0A4, 0x7CD6,   // 0x0590 (1424)
+0x961D, 0x8DFD, 0x961C, 0x9DBB, 0x52FD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x635D, 0xA5DD, 0xA61E, 0xA63E, 0x9E3D, 0x9E5D,   // 0x05B0 (1456)
+0x9DFB, 0x9926, 0xF843, 0xF863, 0xF884, 0xF864, 0xF884, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xD863, 0xD884, 0xF884, 0xF863,   // 0x05C0 (1472)
+0xF883, 0xF864, 0xF863, 0xF884, 0xF864, 0xC084, 0xF884, 0xF863, 0xF884, 0xF864, 0xF884, 0xF884, 0xF064, 0x78C4, 0xE864, 0xF864,   // 0x05D0 (1488)
+0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xF863, 0xF843, 0xB0C5, 0x7CF8,   // 0x05E0 (1504)
+0x8E1E, 0x8DFD, 0x961C, 0x95BB, 0x52DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0x9DBD, 0x9E1E, 0x9E1E, 0x9E3E, 0x963D,   // 0x0600 (1536)
+0x7433, 0xC149, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xD864, 0xF064, 0xF884,   // 0x0610 (1552)
+0xF864, 0xF883, 0xF863, 0xF864, 0xF884, 0xE844, 0xF863, 0xF844, 0xF863, 0xF884, 0xF863, 0xF864, 0xA884, 0xD883, 0xF864, 0xF863,   // 0x0620 (1568)
+0xE084, 0xC884, 0xF884, 0xF863, 0xF864, 0xF884, 0xF884, 0xF883, 0xF884, 0xF884, 0xF863, 0xF863, 0xF8A5, 0xF928, 0x8967, 0x8DBB,   // 0x0630 (1584)
+0x85FD, 0x85FD, 0x8DFC, 0x8D9B, 0x52DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533D, 0x959D, 0x95DD, 0x95DD, 0x95FD, 0x8DFD,   // 0x0650 (1616)
+0x5B71, 0xD312, 0xF842, 0xF884, 0xF863, 0xF864, 0xF864, 0xF883, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xF864, 0xB883, 0xB883,   // 0x0660 (1632)
+0xF884, 0xF863, 0xF863, 0xF843, 0xF803, 0xF844, 0xF8E4, 0xF125, 0xE884, 0xE803, 0xF844, 0xF884, 0xA884, 0xF884, 0xF864, 0xB884,   // 0x0670 (1648)
+0x98A5, 0xD084, 0xF884, 0xF884, 0xF883, 0xF863, 0xF884, 0xF864, 0xF884, 0xF863, 0xF864, 0xF864, 0xE24E, 0x5A2D, 0x7432, 0x8DDB,   // 0x0680 (1664)
+0x85DC, 0x85DC, 0x8DDC, 0x8D7B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x8D9D, 0x8DDD, 0x8DBD, 0x8DDD, 0x8DDD,   // 0x06A0 (1696)
+0x6370, 0x9C16, 0xFACD, 0xF843, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xF064, 0xB083, 0xB083, 0xF064, 0xA883,   // 0x06B0 (1712)
+0xD884, 0xF884, 0xF823, 0xF0C4, 0xF348, 0xF5AB, 0xF6ED, 0xF70D, 0xEE8C, 0xCC88, 0xB1E5, 0x9023, 0xC864, 0xF864, 0xB084, 0x98A4,   // 0x06C0 (1728)
+0xF884, 0xF864, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF843, 0xE885, 0x8A2A, 0x7473, 0x8DDA, 0x85DA,   // 0x06D0 (1744)
+0x85BB, 0x85BC, 0x85BB, 0x8D5B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4AFD, 0x857C, 0x85DD, 0x85BC, 0x85BD, 0x85DD,   // 0x06F0 (1776)
+0x8559, 0x7106, 0xFA4B, 0xF8A5, 0xF884, 0xF884, 0xF863, 0xF883, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xB063, 0xA063, 0xF863,   // 0x0700 (1792)
+0xB063, 0xE003, 0xF247, 0xF6AC, 0xFFEE, 0xFFCE, 0xFF8E, 0xFFAE, 0xF76D, 0xF7AD, 0xEFAD, 0x94C9, 0x9084, 0xC024, 0xA8A5, 0xF863,   // 0x0710 (1808)
+0xF884, 0xF864, 0xF864, 0xF884, 0xF864, 0xF864, 0xF883, 0xF864, 0xF863, 0xE085, 0x7A2A, 0x6B4F, 0x8D99, 0x95DB, 0x85DB, 0x859B,   // 0x0720 (1824)
+0x859B, 0x7D9C, 0x859B, 0x853B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x857C, 0x85DC, 0x7D9C, 0x85DC, 0x85DD,   // 0x0740 (1856)
+0x85BE, 0x7C12, 0xB802, 0xF844, 0xF884, 0xF883, 0xF864, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF863, 0xF884, 0xD863, 0xA083,   // 0x0750 (1872)
+0xC003, 0x8AE7, 0xFF8E, 0xFFCE, 0xBD8A, 0xF72C, 0xFF8E, 0xFFEE, 0x8C09, 0x8C08, 0xFFEE, 0xFFEE, 0xADC9, 0x60C5, 0xF044, 0xF864,   // 0x0760 (1888)
+0xF883, 0xF884, 0xF064, 0xC084, 0xA0C5, 0x70C4, 0x60C5, 0x60C5, 0x58A4, 0x6B6E, 0x7D7A, 0x85BC, 0x85BB, 0x85BB, 0x7D9B, 0x859B,   // 0x0770 (1904)
+0x859B, 0x7D9C, 0x859B, 0x853B, 0x4A9D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D5C, 0x85BD, 0x7D9C, 0x7DBD, 0x7DBD,   // 0x0790 (1936)
+0x7DBD, 0x859C, 0x7C53, 0x7925, 0xD043, 0xF843, 0xF843, 0xF883, 0xF864, 0xF863, 0xF863, 0xF884, 0xF884, 0xF884, 0xF863, 0xB043,   // 0x07A0 (1952)
+0x89C6, 0xF76D, 0xFFEE, 0xC5AA, 0x3185, 0xEF2D, 0xFFAE, 0xFFCE, 0x9428, 0xAD09, 0xFFCE, 0xFF8D, 0xFFEE, 0x9CE9, 0x9844, 0xF863,   // 0x07B0 (1968)
+0xD884, 0x88C4, 0xB885, 0xA8A4, 0xD884, 0xE084, 0xE884, 0xE884, 0xE884, 0xA147, 0x91C9, 0x62ED, 0x6C11, 0x8D57, 0x8579, 0x857B,   // 0x07C0 (1984)
+0x7D7B, 0x7D7C, 0x7D7B, 0x853C, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D7C, 0x859D, 0x759D, 0x7DDD, 0x759D,   // 0x07E0 (2016)
+0x7DBC, 0x859B, 0x9577, 0x9532, 0x948E, 0x9BCB, 0xA247, 0xC0E4, 0xC0A3, 0xF083, 0xF864, 0xF863, 0xF864, 0xF863, 0xF864, 0xE043,   // 0x07F0 (2032)
+0xB56A, 0xFFEE, 0xFFAE, 0xD64B, 0xC5AA, 0xFFAE, 0xFF6E, 0xFF6D, 0xFF8D, 0xFFAE, 0xFF6D, 0xFF6D, 0xFF8E, 0xF78D, 0x61E5, 0x9864,   // 0x0800 (2048)
+0xA884, 0xE864, 0xF884, 0xF863, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xF863, 0xF064, 0xC8A4, 0x91E9, 0x6B91, 0x7D1C,   // 0x0810 (2064)
+0x755E, 0x6D5D, 0x7D7C, 0x7D1B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ADD, 0x755D, 0x7D9E, 0x7DBF, 0x7DBE, 0x759D,   // 0x0830 (2096)
+0x7D7C, 0x859A, 0x9576, 0x848F, 0x8C0B, 0x94AC, 0x8C0A, 0x6A65, 0x4984, 0x58A3, 0x68A3, 0x78A2, 0xB083, 0xF064, 0xF844, 0xC125,   // 0x0840 (2112)
+0xE70C, 0xFFAE, 0xFF8D, 0xFF8E, 0xFFCE, 0xFF6E, 0xFF8E, 0xFF8E, 0xFFEE, 0xE70C, 0xB52A, 0xFFAD, 0xFF6E, 0xFFCD, 0x7B66, 0xD044,   // 0x0850 (2128)
+0xF864, 0xF064, 0xE864, 0xE884, 0xF884, 0xF864, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xC063, 0x6392,   // 0x0860 (2144)
+0x6D7F, 0x655D, 0x7DBD, 0x74FB, 0x3A7C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x323C, 0x64BB, 0x6D5D, 0x6D7E, 0x75BE, 0x75DE,   // 0x0880 (2176)
+0x7D9C, 0x74B4, 0x6269, 0xA8A4, 0xE864, 0xE843, 0xE864, 0xE864, 0xE864, 0xE884, 0xE884, 0xB884, 0x9883, 0x9884, 0xB823, 0x8A26,   // 0x0890 (2192)
+0xF7AD, 0xFF8D, 0xFF6D, 0xFF8D, 0xFFCD, 0xFFAD, 0xFF6C, 0xEF4D, 0xCDCB, 0xB289, 0xBCAA, 0xFFCE, 0xFF6E, 0xFFEC, 0x83E6, 0xA824,   // 0x08A0 (2208)
+0x80C4, 0xB085, 0xB885, 0xB085, 0xE064, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF863, 0xF864, 0xF863, 0xC063,   // 0x08B0 (2224)
+0x63B2, 0x5D7C, 0x655A, 0x6498, 0x321B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x323C, 0x547B, 0x5CFC, 0x5D1D, 0x6D5D, 0x6D9C,   // 0x08D0 (2256)
+0x6C95, 0x8083, 0xF063, 0xF864, 0xF884, 0xF884, 0xF863, 0xF884, 0xF864, 0xF884, 0xE084, 0xB083, 0xB863, 0xA083, 0x612A, 0x4228,   // 0x08E0 (2272)
+0xF74C, 0xFF8E, 0xF74C, 0xCCAA, 0xC4CB, 0xC64F, 0xCE72, 0x9CD1, 0xCA2C, 0xD1AC, 0xD60B, 0xFFCE, 0xFF6D, 0xF7CD, 0x9265, 0xB044,   // 0x08F0 (2288)
+0xE863, 0xF864, 0xF863, 0xF863, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF864, 0xF863, 0xF863, 0xF884, 0xF864, 0xF884, 0xF864,   // 0x0900 (2304)
+0x9863, 0x6D19, 0x5CF8, 0x5BD4, 0x29DB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x327C, 0x5C9B, 0x5CFC, 0x54DC, 0x54DC, 0x5C55,   // 0x0920 (2336)
+0x80A3, 0xF843, 0xF884, 0xF864, 0xF863, 0xF863, 0xF884, 0xF884, 0xF064, 0xA0A4, 0x90C4, 0x90A3, 0x90A3, 0x90A3, 0x6127, 0x20E6,   // 0x0930 (2352)
+0xCE2A, 0xFFCE, 0xFFCE, 0xEDCC, 0xD1AC, 0xBB0F, 0xB2EF, 0xAA0A, 0xD1EC, 0xA209, 0xDEEC, 0xFF8D, 0xFFEE, 0xEE6A, 0xF884, 0xF844,   // 0x0940 (2368)
+0xF884, 0xF864, 0xF884, 0xF863, 0xF864, 0xF884, 0xF863, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864,   // 0x0950 (2384)
+0xF023, 0x82AD, 0x5C97, 0x4BF7, 0x29DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DD, 0x5CFC, 0x5D1C, 0x54DB, 0x64FA, 0x5926,   // 0x0970 (2416)
+0xF843, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xE883, 0xF884, 0xF864, 0xF864, 0xF864, 0xF863, 0x9023,   // 0x0980 (2432)
+0x62E5, 0xFFED, 0xFF8E, 0xFFCD, 0xC3AB, 0xD16B, 0xBBCD, 0xE653, 0x8BAC, 0x6AC5, 0xFFED, 0xFF8D, 0xF7ED, 0xBB27, 0xD023, 0xE084,   // 0x0990 (2448)
+0xE864, 0xF084, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF883, 0xF864, 0xF863, 0xF883, 0xF864,   // 0x09A0 (2464)
+0xF863, 0xB107, 0x5C15, 0x5C16, 0x327C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x653C, 0x5D7B, 0x551A, 0x634F, 0xD023,   // 0x09C0 (2496)
+0xF864, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF883, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xD884, 0x90C5,   // 0x09D0 (2512)
+0x2908, 0x9CE9, 0xFFED, 0xFFCE, 0xE72C, 0x6286, 0x7B6B, 0x9C2E, 0x7328, 0xCE6A, 0xFFEE, 0xFFEE, 0xE488, 0xB064, 0xB0A4, 0xB084,   // 0x09E0 (2528)
+0xB884, 0x9883, 0xA0C4, 0xE883, 0xF863, 0xF864, 0xF884, 0xF883, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF864, 0xF863,   // 0x09F0 (2544)
+0xF864, 0xB0E5, 0x6391, 0x6CB8, 0x53B9, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B5E, 0x6D9D, 0x65BD, 0x5CFA, 0x8106, 0xF884,   // 0x0A10 (2576)
+0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF863, 0xF884, 0xF864, 0xE084, 0x98A4, 0x98A4, 0xB8C6,   // 0x0A20 (2592)
+0x61AC, 0x38A4, 0x9407, 0xEF8C, 0xFFEE, 0xFFED, 0xB569, 0xA528, 0xEF2C, 0xFFEE, 0xF76C, 0xAC28, 0xB064, 0xB863, 0xB083, 0xE863,   // 0x0A30 (2608)
+0xF863, 0xF864, 0xC883, 0x88A4, 0x9883, 0xE884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF864, 0xF884, 0xF883, 0xF884, 0xF864, 0xF864,   // 0x0A40 (2624)
+0xF864, 0x90E6, 0x63B3, 0x6CDA, 0x537B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B3D, 0x6DBD, 0x6DFF, 0x64B8, 0x8373, 0xF148,   // 0x0A60 (2656)
+0xF863, 0xF863, 0xF883, 0xF864, 0xF864, 0xF863, 0xF884, 0xF864, 0xF884, 0xF864, 0xF063, 0xA0E4, 0x88A4, 0xD083, 0xE084, 0x90A3,   // 0x0A70 (2672)
+0xB083, 0xF064, 0xD823, 0x81C4, 0x9C68, 0xC649, 0xDF2C, 0xE72C, 0xC68A, 0xC488, 0xE965, 0xE823, 0xE864, 0xA0A4, 0x90A3, 0xB0A4,   // 0x0A80 (2688)
+0x90A4, 0xE084, 0xF863, 0xF864, 0x98A3, 0x68A4, 0xB884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF863,   // 0x0A90 (2704)
+0xD065, 0x6229, 0x6458, 0x751B, 0x5BBB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x85DE, 0x75DE, 0x5457, 0x8436, 0xF1A9,   // 0x0AB0 (2736)
+0xF863, 0xF863, 0xF884, 0xF884, 0xF863, 0xF863, 0xF884, 0xF884, 0xF843, 0xB8A4, 0x838F, 0x6227, 0xE864, 0xE884, 0x80A3, 0xD883,   // 0x0AC0 (2752)
+0xF884, 0xF884, 0xF064, 0xD824, 0xD024, 0xA0A3, 0x8904, 0xA105, 0x80C3, 0x8043, 0xF043, 0xF863, 0xF884, 0xF864, 0xF864, 0xF864,   // 0x0AD0 (2768)
+0xE883, 0xF084, 0xF884, 0xF884, 0xF864, 0xF084, 0xA0A4, 0x90A4, 0xC0A4, 0xF864, 0xF064, 0xF844, 0xF844, 0xF844, 0xF863, 0xC884,   // 0x0AE0 (2784)
+0x5944, 0x6435, 0x64DC, 0x751A, 0x5B9B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B3D, 0x8DDD, 0x861E, 0x6CF9, 0x7435, 0xE331,   // 0x0B00 (2816)
+0xF843, 0xF863, 0xF864, 0xF884, 0xF863, 0xF884, 0xF863, 0xE023, 0x8AAC, 0xA61A, 0x8BCF, 0xE883, 0xF864, 0x98A4, 0xE884, 0xF884,   // 0x0B10 (2832)
+0xF884, 0xF884, 0xC084, 0xD084, 0xF863, 0xF863, 0xD063, 0xA863, 0xF844, 0xE084, 0x60A2, 0xB063, 0xF863, 0xF884, 0xF883, 0xF884,   // 0x0B20 (2848)
+0xF884, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF864, 0xE864, 0x88A4, 0x6143, 0xA388, 0x8BCE, 0x8AEB, 0x8248, 0x7A6A, 0x6A8C,   // 0x0B30 (2864)
+0x6C35, 0x6D7D, 0x74FA, 0x74FB, 0x429C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85BD, 0x8DFE, 0x861E, 0x628B, 0xF928,   // 0x0B50 (2896)
+0xF884, 0xF884, 0xF864, 0xF863, 0xF884, 0xF843, 0xB0C5, 0x7BF2, 0xAEBC, 0xA513, 0xE043, 0xF863, 0xB083, 0xB8A3, 0xF864, 0xF864,   // 0x0B60 (2912)
+0xF884, 0xF884, 0x80A3, 0xD884, 0xF863, 0xF884, 0xF864, 0x90A4, 0xE084, 0xF863, 0xD883, 0x48A3, 0xB883, 0xF884, 0xF884, 0xF864,   // 0x0B70 (2928)
+0xF884, 0xF884, 0xF884, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0x9922, 0xAD0A, 0xAE37, 0x9E3B, 0x8D58, 0x8519, 0x757C,   // 0x0B80 (2944)
+0x75BE, 0x75DE, 0x75DC, 0x7D7B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533D, 0x8DBD, 0x8E1F, 0x8E1F, 0x7D18, 0x8862,   // 0x0BA0 (2976)
+0xF843, 0xF864, 0xF864, 0xF863, 0xE064, 0x7A27, 0x9599, 0xAEBD, 0xAE18, 0xC043, 0xF863, 0xF884, 0xD084, 0xF883, 0xF863, 0xF864,   // 0x0BB0 (2992)
+0xF864, 0xE064, 0x88A3, 0xF864, 0xF883, 0xF884, 0xF884, 0xC884, 0xD0A4, 0xF864, 0xF884, 0xE064, 0x58C3, 0xB084, 0xF863, 0xF864,   // 0x0BC0 (3008)
+0xF864, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF883, 0xF863, 0xF863, 0xF863, 0x80E5, 0x8D74, 0x967E, 0x963E, 0x8E3D, 0x861C,   // 0x0BD0 (3024)
+0x75FB, 0x75FC, 0x861C, 0x85BB, 0x4B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533C, 0x8DDD, 0x8E3F, 0x8E1F, 0x865F, 0x6C94,   // 0x0BF0 (3056)
+0x8146, 0x9905, 0xA105, 0x9167, 0x842F, 0xA659, 0xAEDE, 0xB6BD, 0x9229, 0xF843, 0xF884, 0xF863, 0xF864, 0xF884, 0xF863, 0xF884,   // 0x0C00 (3072)
+0xF864, 0xC063, 0x78A3, 0xF884, 0xF884, 0xF863, 0xF884, 0xB884, 0x80A3, 0xF863, 0xF884, 0xF864, 0xC083, 0x3985, 0xC0A4, 0xF863,   // 0x0C10 (3088)
+0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF864, 0xF884, 0xF863, 0x78E4, 0x6CD5, 0x967F, 0x965E, 0x863C,   // 0x0C20 (3104)
+0x861C, 0x861D, 0x8E3D, 0x8DFC, 0x535D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85FC, 0x8E5E, 0x8E1E, 0x8E3E, 0x861C,   // 0x0C40 (3136)
+0x7DBA, 0x7538, 0x8599, 0x95DA, 0x9E59, 0xA6BC, 0xAEBE, 0x9D34, 0xC843, 0xF884, 0xF864, 0xF884, 0xF863, 0xF863, 0xF864, 0xF884,   // 0x0C50 (3152)
+0xF884, 0xC863, 0x80A3, 0xF864, 0xF884, 0xF863, 0xF884, 0xD8A4, 0x88A4, 0xF864, 0xF884, 0xF884, 0xF863, 0x9125, 0x8B6A, 0xC0A4,   // 0x0C60 (3168)
+0xF863, 0xF864, 0xF884, 0xF864, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xD023, 0x7C73, 0x9E7D, 0x963D, 0x8E3E,   // 0x0C70 (3184)
+0x8E3F, 0x863F, 0x8E3E, 0x963D, 0x5B9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42FC, 0x7DDB, 0x863D, 0x85FD, 0x861D, 0x8E1C,   // 0x0C90 (3216)
+0x85DC, 0x863E, 0xA69F, 0x9E7D, 0x9E5A, 0x9E5C, 0xAE9C, 0x81A7, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864,   // 0x0CA0 (3232)
+0xF884, 0xC863, 0x80A3, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xE864, 0xF863, 0xF864, 0xF863, 0xF884, 0xC863, 0x94B1, 0x9D97,   // 0x0CB0 (3248)
+0xC906, 0xF843, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xF883, 0xF864, 0xF883, 0xF884, 0xF843, 0x8C31, 0x965D, 0x961D, 0x965F,   // 0x0CC0 (3264)
+0x963F, 0x8E1F, 0x965F, 0x9E5E, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x757B, 0x7DDC, 0x7DDD, 0x861D, 0x8E1D,   // 0x0CE0 (3296)
+0x8E5D, 0xA69F, 0xA6BF, 0xAEBD, 0xA65D, 0xAEBF, 0x8D77, 0xC864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884,   // 0x0CF0 (3312)
+0xF863, 0xC863, 0x80A3, 0xF864, 0xF863, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF864, 0xF884, 0xF884, 0xF863, 0x88E5, 0xBEBD,   // 0x0D00 (3328)
+0xA5FA, 0xAA4B, 0xF043, 0xF863, 0xF884, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF042, 0x8411, 0x969C, 0x969D, 0x967E,   // 0x0D10 (3344)
+0x965F, 0x963F, 0x9E7F, 0xA69F, 0x63FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x755B, 0x7DDC, 0x7DFE, 0x8E3E, 0x965E,   // 0x0D30 (3376)
+0x8E7D, 0xA6FF, 0xAF3F, 0xAEBE, 0xAEDF, 0xAEDF, 0x7B4E, 0xE843, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF883,   // 0x0D40 (3392)
+0xF884, 0xB883, 0x78A3, 0xF864, 0xF884, 0xF884, 0xF864, 0xF864, 0xF884, 0xF863, 0xF884, 0xF884, 0xF884, 0xF863, 0xB863, 0xA619,   // 0x0D50 (3408)
+0xA63A, 0x9DD9, 0xACD1, 0xC106, 0xF843, 0xF864, 0xF884, 0xF864, 0xF863, 0xF884, 0xF864, 0xA063, 0x8577, 0x96BD, 0x96BD, 0x969E,   // 0x0D60 (3424)
+0x9E7F, 0x9E9F, 0xA6BF, 0xAE9E, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x7D5C, 0x7DBC, 0x7DDD, 0x8E1D, 0x963D,   // 0x0D80 (3456)
+0x9E9E, 0x9EDD, 0xA6DD, 0xA6FD, 0xA6DE, 0xA6DE, 0x828A, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884,   // 0x0D90 (3472)
+0xF864, 0x60A3, 0x78A3, 0xF864, 0xF884, 0xF884, 0xF864, 0xF884, 0xF864, 0xF864, 0xF883, 0xF884, 0xF884, 0xF884, 0xE023, 0x8C31,   // 0x0DA0 (3488)
+0xA69C, 0xB6BC, 0xBEFD, 0x9D79, 0x8B0C, 0xC126, 0xF063, 0xF043, 0xE843, 0xE843, 0xE023, 0x7B6F, 0x969D, 0x96BE, 0x9EDE, 0x9E9E,   // 0x0DB0 (3504)
+0x9E9F, 0x9E9F, 0xA6BE, 0xB6BD, 0x6BFE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x859C, 0x85BC, 0x7DBC, 0x85FD, 0x8DFC,   // 0x0DD0 (3536)
+0x967D, 0x8E5B, 0x8E7A, 0x9EBB, 0xA6DD, 0x9E7C, 0x79C8, 0xF863, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF864, 0xF864, 0xF864,   // 0x0DE0 (3552)
+0xF863, 0x8185, 0x7A25, 0xF043, 0xF863, 0xF884, 0xF883, 0xF863, 0xF863, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF843, 0x8B4D,   // 0x0DF0 (3568)
+0xB6DE, 0xAEBD, 0xAEBE, 0xAEBE, 0xA69D, 0x9E1B, 0x8452, 0x7B8E, 0x7B6D, 0x7BCF, 0x7C52, 0x8E5B, 0x969D, 0xA6FF, 0x9EDE, 0xA6DF,   // 0x0E00 (3584)
+0x9E9E, 0x9E7F, 0xAEBE, 0xBEFE, 0x73FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x535D, 0x8DDC, 0x8DFD, 0x85DD, 0x95FD, 0x95FD,   // 0x0E20 (3616)
+0x8E1C, 0x967C, 0x969C, 0x9E9C, 0x9E7C, 0x963B, 0x7208, 0xF863, 0xF864, 0xF863, 0xF864, 0xF884, 0xF884, 0xF884, 0xF863, 0xF884,   // 0x0E30 (3632)
+0xF843, 0xA347, 0xB4A7, 0xD843, 0xF864, 0xF864, 0xF884, 0xF864, 0xF884, 0xF863, 0xF863, 0xF884, 0xF884, 0xF864, 0xF864, 0x7A8B,   // 0x0E40 (3648)
+0xAE9D, 0xA6BE, 0xA69E, 0x9EBE, 0xA69D, 0xAEBE, 0xB6DE, 0xB6DE, 0xAE9D, 0xA69D, 0xA69E, 0x9E9E, 0x9EBE, 0xA6FF, 0xA6FF, 0xAEBE,   // 0x0E50 (3664)
+0x9E9E, 0x9E7E, 0xA6BE, 0xC71E, 0x741E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x63BD, 0x9E5E, 0x9E7E, 0x9E5E, 0xA65E, 0xA65E,   // 0x0E70 (3696)
+0xAEBF, 0xA69D, 0x9EBD, 0xA67E, 0x9E5D, 0xA69E, 0x7A8B, 0xF843, 0xF884, 0xF884, 0xF864, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884,   // 0x0E80 (3712)
+0xC823, 0xB4A7, 0xD587, 0xC843, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF863, 0xF863, 0xF864, 0xF884, 0xF863, 0x82CB,   // 0x0E90 (3728)
+0xAEBE, 0xAEBE, 0xA6BE, 0xA69E, 0xA69E, 0xAEDE, 0xA6DE, 0xA6BE, 0xA6BD, 0x9E9E, 0xAEBE, 0xAEFF, 0xA6DD, 0xA6FE, 0xAEDE, 0xA6BE,   // 0x0EA0 (3744)
+0xA6BE, 0x9E7E, 0x9E5E, 0xBEDE, 0x7C5E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xA6BE, 0xA6FF, 0xAEDF, 0xAEFF, 0xAEFF,   // 0x0EC0 (3776)
+0xA6DE, 0xAEFF, 0xAF1F, 0xA69E, 0xAEBF, 0xA69E, 0x84D4, 0xC023, 0xF8C5, 0xF8C5, 0xF884, 0xF884, 0xF884, 0xF884, 0xF864, 0xF843,   // 0x0ED0 (3792)
+0xA1A6, 0xD524, 0xB4A5, 0x6862, 0xF884, 0xF885, 0xF863, 0xF883, 0xF883, 0xF884, 0xF884, 0xF884, 0xF884, 0xF884, 0xF843, 0x938C,   // 0x0EE0 (3808)
+0xAEBD, 0xAEDE, 0xA69D, 0xA69E, 0xA6BF, 0x9E9E, 0x9E7D, 0xA6BE, 0xA69D, 0xAEDE, 0xAEDE, 0xBF1F, 0xAEDD, 0xAEDD, 0xB71E, 0xAEFE,   // 0x0EF0 (3824)
+0x9EBD, 0x967D, 0x9E7E, 0xBEDE, 0x8CBE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xAEDF, 0xAF1F, 0xAEDF, 0xAF3E, 0xAF1D,   // 0x0F10 (3856)
+0xAF1E, 0xA6FE, 0xAF3E, 0xA6DE, 0xA6DE, 0xAEFE, 0xAEFD, 0x7A4A, 0xF823, 0xF8A5, 0xF884, 0xF884, 0xF884, 0xF864, 0xF863, 0xB043,   // 0x0F20 (3872)
+0xA48A, 0xC505, 0xD5E8, 0x7C09, 0x9863, 0xF907, 0xF906, 0xF843, 0xF864, 0xF864, 0xF864, 0xF864, 0xF884, 0xF884, 0xD822, 0xA4D0,   // 0x0F30 (3888)
+0xB6BC, 0xB6FD, 0xAEDD, 0xAEDE, 0xA6BE, 0xA6BE, 0xA6BE, 0xA6BE, 0xAEBD, 0xB6DE, 0xBEDE, 0xB6DD, 0xB6FD, 0xAEFD, 0xAEFE, 0xAEDF,   // 0x0F40 (3904)
+0x9E7F, 0x969F, 0x9E9F, 0xBEDE, 0x8C9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x741E, 0xB6FD, 0xB73F, 0xAEFF, 0xAF3E, 0xAF3D,   // 0x0F60 (3936)
+0xAF3D, 0xAF3D, 0xAEFD, 0x9E7D, 0xAF1E, 0xA6FE, 0xAF1E, 0x95F7, 0x7187, 0xD843, 0xF843, 0xF884, 0xF883, 0xF843, 0xC063, 0xA4B2,   // 0x0F70 (3952)
+0xB5F1, 0xB58B, 0xD68D, 0xBE0C, 0x5AAA, 0x9883, 0xF9CA, 0xF1CA, 0xF8C5, 0xF843, 0xF884, 0xF884, 0xF884, 0xF843, 0x99A9, 0xB638,   // 0x0F80 (3968)
+0xA69C, 0xA6BE, 0xAEBF, 0xAEDF, 0xAEDE, 0xAEDE, 0xAEDD, 0xAEFE, 0xA6DE, 0xAEBD, 0xBEDD, 0xB6DC, 0xAEFD, 0xAEFE, 0xA6DF, 0x965D,   // 0x0F90 (3984)
+0x967E, 0x9E9F, 0xA69E, 0xBEFE, 0x7C3E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xC6DE, 0xBF1E, 0xAEDD, 0xAF1E, 0xAF3D,   // 0x0FB0 (4016)
+0xA71C, 0xAF5C, 0xA6BC, 0xA69D, 0x84F4, 0x8516, 0xAEFE, 0xA6FC, 0xA699, 0x73CF, 0x8166, 0xD884, 0xD884, 0x8988, 0x8D15, 0xB6DD,   // 0x0FC0 (4032)
+0xB6B9, 0xA5D0, 0xAE0D, 0xC68D, 0x9CC7, 0x52A7, 0xA063, 0xF989, 0xF28D, 0xF24C, 0xF927, 0xF864, 0xF843, 0x88E4, 0x95BA, 0xAEDE,   // 0x0FD0 (4048)
+0xAEBE, 0xAEDE, 0xAEBE, 0xB6FF, 0xB6DF, 0xB6DE, 0xB6FF, 0xA6BE, 0x9E9E, 0xAEBE, 0xB6BC, 0xB6FE, 0xAEFF, 0xA69E, 0x9E9E, 0x965E,   // 0x0FE0 (4064)
+0x9E7E, 0xA69E, 0xB6BD, 0xCF1E, 0x8CBF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B9D, 0xBE7C, 0xBEFD, 0xB71D, 0xB73E, 0xAF1D,   // 0x1000 (4096)
+0xAF3D, 0xB73D, 0xA67C, 0xAEBE, 0x6BAD, 0x7C63, 0x8D33, 0xAEBB, 0xAF5D, 0xB73D, 0xAEBB, 0x84F4, 0x84B4, 0xB69C, 0xB71E, 0xB6DE,   // 0x1010 (4112)
+0xBF1C, 0xA633, 0x7CE8, 0xB6AD, 0x8D26, 0x7464, 0x52C8, 0xA022, 0xE823, 0xE084, 0xE884, 0xE043, 0x9167, 0xA63B, 0xAEDF, 0xB6FF,   // 0x1020 (4128)
+0xB6DE, 0xAEFD, 0xA6DF, 0xAE9E, 0xA65C, 0x8D16, 0x9DD9, 0xA6BE, 0xA6BE, 0xAEFE, 0xAEFE, 0xA69E, 0x9E5D, 0x9E9D, 0x9E9E, 0xA6BF,   // 0x1030 (4144)
+0xAEBE, 0xBEFE, 0xC6FD, 0xD73D, 0x847E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1C, 0xB63C, 0xC73E, 0xBF5F, 0xAEFD, 0xB71E,   // 0x1050 (4176)
+0xB75E, 0xB73D, 0xA6DB, 0xA6DD, 0x844D, 0xBEA2, 0xAEA3, 0x8CEA, 0x9DD7, 0xB73E, 0xBF3F, 0xB71F, 0xB73E, 0xB73E, 0xBF3E, 0xB71D,   // 0x1060 (4192)
+0xBF1B, 0xB6D6, 0x754B, 0x8DEB, 0x7525, 0x64A3, 0x4307, 0x0326, 0x8C70, 0x9D55, 0x73F0, 0x8C93, 0xAEBD, 0xAEDE, 0xAEBE, 0xB6FF,   // 0x1070 (4208)
+0xB6DD, 0xA61A, 0x84D4, 0x740E, 0x6BA7, 0x31A3, 0x5B6E, 0xA67D, 0xAEDD, 0xA6BE, 0x9E7E, 0x9E7E, 0xAEBF, 0xA69E, 0xA6BE, 0xAEBE,   // 0x1080 (4224)
+0xB6DD, 0xBEBC, 0xD73E, 0xC6BD, 0x5B7D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31DB, 0xAE1C, 0xCF5D, 0xC73E, 0xB6FD, 0xBF3E,   // 0x10A0 (4256)
+0xBF5E, 0xBF3E, 0xB71D, 0xAF1C, 0x8C8D, 0xD6C2, 0xB6A4, 0xC744, 0xA5C3, 0x7C6E, 0xA61B, 0xBF1E, 0xC73E, 0xC75E, 0xBF3E, 0xBF1E,   // 0x10B0 (4272)
+0xB75C, 0xBF59, 0x8E2F, 0x6D48, 0x7DA8, 0x6CE7, 0x22C6, 0x04C7, 0xB6D9, 0xB73C, 0xB75E, 0xB75F, 0xB71E, 0xAEDE, 0xB71F, 0x9DB8,   // 0x10C0 (4288)
+0x740E, 0x7446, 0x9D83, 0x9583, 0x9DC3, 0x9563, 0x5B0D, 0xB6BD, 0xB6FD, 0xAEDD, 0xA6BE, 0xA6BE, 0xA6BE, 0xA6BD, 0xB6DE, 0xB6FE,   // 0x10D0 (4304)
+0xB6DE, 0xC71D, 0xD75D, 0xBE7D, 0x427D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085B, 0x951D, 0xCF3E, 0xC73E, 0xCF7F, 0xBF5E,   // 0x10F0 (4336)
+0xBF3E, 0xBF5E, 0xBF5E, 0xBF5D, 0x7C2C, 0xF7A7, 0xAE24, 0xBEE4, 0xC744, 0xBEE3, 0x7CA5, 0x8CB4, 0xCEFD, 0xC73F, 0xBF3F, 0xBF1F,   // 0x1100 (4352)
+0xC75D, 0xBF5B, 0xA6B3, 0x6D48, 0x964B, 0x6CC8, 0x2BA8, 0x350C, 0xCF1B, 0xB75C, 0xB75D, 0xB73E, 0xBF5E, 0xBEBD, 0x8CF2, 0x9528,   // 0x1110 (4368)
+0xBEC8, 0xB667, 0x9DA8, 0xA5E5, 0xCF65, 0x9DC3, 0x5B0D, 0xB6DD, 0xAEFD, 0xAEDE, 0xAEBF, 0xA69D, 0xAEBD, 0xAEDD, 0xC73E, 0xBF1E,   // 0x1120 (4384)
+0xCF3E, 0xD75F, 0xDF9F, 0xAD9E, 0x10BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBC, 0xCEFD, 0xD77F, 0xCF7F, 0xC75F,   // 0x1140 (4416)
+0xC75F, 0xC75F, 0xC77F, 0xC77E, 0x7C0B, 0xFFE7, 0xD6C5, 0xA644, 0xBF04, 0xBF04, 0xC744, 0xA602, 0x7C0B, 0xCF1E, 0xC75F, 0xCF5F,   // 0x1150 (4432)
+0xC75E, 0xC75C, 0xBF57, 0x8DEC, 0x8DEA, 0x5C27, 0x2C4A, 0x4D0E, 0xDF3D, 0xBF5D, 0xB71E, 0xBF1E, 0xBE17, 0x9CC7, 0xB686, 0xBF08,   // 0x1160 (4448)
+0xA589, 0x9D67, 0xBEAA, 0xBF05, 0xD789, 0x9DA5, 0x52EB, 0xAEBC, 0xAEFE, 0xA6BE, 0x9E9E, 0xAE9D, 0xBF1E, 0xCF9F, 0xCF3D, 0xCF5E,   // 0x1170 (4464)
+0xD77E, 0xDF9E, 0xE7BE, 0x847E, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FB, 0xB5FE, 0xE7BF, 0xD79F, 0xCF9F,   // 0x1190 (4496)
+0xD77F, 0xCF7F, 0xCF7E, 0xCF7F, 0x8C6D, 0xFFC7, 0xF7A6, 0xADE3, 0xB6A4, 0xBF04, 0xBEE4, 0xC744, 0xB6C3, 0x6BC8, 0xBE5A, 0xCF5F,   // 0x11A0 (4512)
+0xCF5E, 0xD79E, 0xCF99, 0xA66F, 0x8DCB, 0x42E6, 0x0C88, 0x85B3, 0xCF7E, 0xCF7E, 0xBF1E, 0xBF1E, 0xCE88, 0xBEA3, 0xA605, 0x8D04,   // 0x11B0 (4528)
+0xB664, 0xBF25, 0xBEE5, 0xBEE4, 0xDF8B, 0x9D84, 0x6BCF, 0xC77D, 0xB73E, 0xB6FE, 0xBF3E, 0xC75E, 0xC73D, 0xCF5D, 0xD77E, 0xD77E,   // 0x11C0 (4544)
+0xDF7E, 0xF7FF, 0xBE3E, 0x215E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x4A9C, 0xBE7E, 0xE7DF, 0xDFBF,   // 0x11E0 (4576)
+0xDFBF, 0xD7BF, 0xD7BF, 0xD79F, 0x7C0F, 0xC626, 0xFFE6, 0xDF01, 0x9DA4, 0xBF04, 0xB704, 0xBEE4, 0xC744, 0x9DE3, 0x5304, 0xADF9,   // 0x11F0 (4592)
+0xCF7F, 0xD79E, 0xD7BA, 0xB6F2, 0x95ED, 0x3266, 0x04A8, 0xCF3B, 0xD79F, 0xD79F, 0xBE75, 0xE768, 0xBE23, 0x8D24, 0x9D84, 0xBF04,   // 0x1200 (4608)
+0xBF24, 0xB704, 0xB703, 0xBF05, 0xE7AB, 0x8D03, 0x84B3, 0xCFBE, 0xCFBF, 0xCF9E, 0xCF7D, 0xD77E, 0xCF5D, 0xDF9E, 0xE7DF, 0xE7BE,   // 0x1210 (4624)
+0xF7FF, 0xD71E, 0x52DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x425B, 0xB61D, 0xEFDF,   // 0x1230 (4656)
+0xEFFF, 0xE7DF, 0xDFBF, 0xDFDF, 0x8C91, 0xADA5, 0xE727, 0xFFE0, 0xCE62, 0x9DC3, 0xC724, 0xBEE4, 0xBEE4, 0xBF04, 0x9543, 0x7C85,   // 0x1240 (4672)
+0xC71C, 0xCF7D, 0xCFBB, 0xB6F3, 0x8D2E, 0x1AA6, 0x1428, 0xD79D, 0xD77E, 0xADAB, 0xFFE0, 0xE722, 0x7C23, 0xAE44, 0xC724, 0xBF04,   // 0x1250 (4688)
+0xBF24, 0xBF04, 0xBF03, 0xD74A, 0xD788, 0x6C03, 0xADF7, 0xDFDF, 0xDFDF, 0xDFDF, 0xDFBE, 0xDFBE, 0xDF9E, 0xE7DF, 0xEFFF, 0xF7FF,   // 0x1260 (4704)
+0xC69E, 0x4A9D, 0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x31DD, 0x849C,   // 0x1280 (4736)
+0xC67D, 0xE7BF, 0xEFFE, 0xDF9F, 0x9D54, 0xAE63, 0xB606, 0xBE22, 0xE741, 0xB603, 0xAE44, 0xC724, 0xBF04, 0xBF04, 0x9DA4, 0xAE63,   // 0x1290 (4752)
+0x950D, 0xCF7B, 0xCF79, 0xBF35, 0x8CEE, 0x02C5, 0x4C6B, 0xD79C, 0xADCE, 0xFFC0, 0xE6E1, 0x9D23, 0xBEE5, 0xCF64, 0xC744, 0xB704,   // 0x12A0 (4768)
+0xAE64, 0x9DE3, 0xA5E6, 0xC64B, 0xADE2, 0x52A5, 0xDF7D, 0xEFDF, 0xE7DF, 0xE7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xE79E, 0xA55E,   // 0x12B0 (4784)
+0x39FE, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109D,   // 0x12D0 (4816)
+0x4A5C, 0x7C3A, 0xADDA, 0xD71D, 0xB5F8, 0x8D63, 0xC765, 0xAE44, 0x9D83, 0xADC3, 0x8CE4, 0xA604, 0xBF24, 0xC704, 0xAE44, 0xAE24,   // 0x12E0 (4832)
+0xAE23, 0xB637, 0xCF3B, 0xC719, 0x6BD0, 0x0324, 0x5C51, 0xCEB8, 0xE742, 0xDEC1, 0xA5A3, 0xBF24, 0xB685, 0x8D45, 0x7C64, 0x8443,   // 0x12F0 (4848)
+0x9CE2, 0xBDA3, 0xDECA, 0xFFA3, 0xC600, 0x8C30, 0xF7DF, 0xF7FE, 0xF7FF, 0xEFDF, 0xF7FF, 0xE77E, 0xC69C, 0xA55D, 0x5B3D, 0x18BE,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001E, 0x005C, 0x299C, 0x5B1E, 0x6B9E, 0x6B9F, 0x6BBF, 0x6B9F, 0x73DF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6B9F, 0x6B9F, 0x637E,   // 0x1330 (4912)
+0x6B9E, 0x6BBF, 0x5B1E, 0x5B1D, 0x217D, 0x001F, 0x109D, 0x635E, 0x5B1E, 0x637F, 0x6B7F, 0x739F, 0x6B7F, 0x637F, 0x635E, 0x6B7F,   // 0x1340 (4928)
+0x6B7F, 0x73BF, 0x73BF, 0x73DF, 0x739F, 0x6B9F, 0x6B9F, 0x739F, 0x739F, 0x73BF, 0x73BF, 0x52DE, 0x31DD, 0x10BD, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1460 (5216)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1470 (5232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14B0 (5296)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14C0 (5312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1510 (5392)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1520 (5408)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1530 (5424)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1550 (5456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1560 (5472)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1570 (5488)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1580 (5504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x109F, 0x085F,   // 0x15B0 (5552)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15C0 (5568)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15D0 (5584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15F0 (5616)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x1600 (5632)
+0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F,   // 0x1610 (5648)
+0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1620 (5664)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1640 (5696)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x211F, 0xFFFF, 0x001F, 0x001F,   // 0x1650 (5712)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x1660 (5728)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1670 (5744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1690 (5776)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x16A0 (5792)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x16B0 (5808)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16C0 (5824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16E0 (5856)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x213F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x16F0 (5872)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x1700 (5888)
+0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1710 (5904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0x001F, 0xFFFF, 0x001F, 0x001F,   // 0x1740 (5952)
+0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0xFFFF,   // 0x1750 (5968)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1790 (6032)
+0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_719/fotos.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: fotos.jpg
+// Time generated: 24.03.2014 12:47:16
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short fotos[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00D0 (208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001E, 0x18FB, 0x52DA, 0x94DD, 0xBDFF, 0xB5DF, 0xADBF, 0xB5FE, 0xB5DF, 0xADBE, 0xADBE, 0xB5BF, 0xAD9E, 0xAD9E, 0xB5BF, 0xB5DF,   // 0x0110 (272)
+0xB5DF, 0xAD9E, 0xADBE, 0xA55D, 0xB5DF, 0xADBF, 0xADBF, 0xADBE, 0xA55E, 0xB5DF, 0xB5DF, 0xA57E, 0xA57E, 0xAD7E, 0xA55E, 0xA57E,   // 0x0120 (288)
+0xB5BF, 0xADDF, 0xADDF, 0xADBF, 0xADBE, 0xB5BE, 0xB5BE, 0xB5BF, 0xB5DF, 0xB5BE, 0xBDFF, 0xAD9E, 0x6BBC, 0x297C, 0x001E, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31DC,   // 0x0150 (336)
+0x94BD, 0xC65E, 0xCEBD, 0xC69C, 0xCEDD, 0xCEDD, 0xCEBD, 0xC6BC, 0xC6BC, 0xC6DB, 0xC6DC, 0xC6BC, 0xCEBC, 0xCEBC, 0xCEBC, 0xCEBC,   // 0x0160 (352)
+0xC69C, 0xCE9C, 0xCEBD, 0xC69C, 0xCEBD, 0xCEDD, 0xC69C, 0xCEDD, 0xC69C, 0xCEBC, 0xCEDC, 0xC69B, 0xCE9B, 0xCEBB, 0xCE9B, 0xCEBC,   // 0x0170 (368)
+0xCEBD, 0xC6DD, 0xC6BD, 0xC6BC, 0xCEBC, 0xCE9C, 0xCEBC, 0xCEBC, 0xC6DC, 0xCEDC, 0xD6FD, 0xD6FD, 0xD6DC, 0xBE3C, 0x9D3D, 0x425D,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x633C, 0xBE3D,   // 0x01A0 (416)
+0xCEBC, 0xCEBC, 0xCEDD, 0xC6BD, 0xC6BD, 0xBEBD, 0xC69D, 0xC6BD, 0xBEBC, 0xBEBA, 0xBEBB, 0xC6BB, 0xC6BC, 0xC69C, 0xC69C, 0xC69C,   // 0x01B0 (432)
+0xC69C, 0xC69C, 0xCEBD, 0xCEDD, 0xC69C, 0xC6BC, 0xBE5B, 0xC6BC, 0xC69C, 0xC6BB, 0xD6FB, 0xCEBB, 0xC69B, 0xCEBC, 0xCE9C, 0xC69C,   // 0x01C0 (448)
+0xC69D, 0xBEBD, 0xBEBC, 0xBEBC, 0xC69C, 0xCE9C, 0xC69C, 0xC6BC, 0xBEBD, 0xC6BD, 0xCEBD, 0xCEFD, 0xD71D, 0xD71E, 0xD71D, 0xC65D,   // 0x01D0 (464)
+0x6B5C, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087C, 0x73DC, 0xBE5D, 0xC69B,   // 0x01F0 (496)
+0xBE7C, 0xC69D, 0xBE9D, 0xBE7D, 0xBE9E, 0xBE9E, 0xBE9D, 0xBE9D, 0xBE9B, 0xBEBB, 0xB6BB, 0xBE9C, 0xC6BC, 0xC69C, 0xBE7B, 0xC6BB,   // 0x0200 (512)
+0xCEDB, 0xC6BB, 0xC69B, 0xC67C, 0xBE5B, 0xBE7B, 0xC67B, 0xC67B, 0xC69A, 0xD71B, 0xDF7C, 0xCEDB, 0xC69B, 0xCE9C, 0xC65B, 0xC67C,   // 0x0210 (528)
+0xBE7C, 0xBEBC, 0xBEBC, 0xBEBC, 0xC69C, 0xC69C, 0xC69D, 0xBEBD, 0xB6BE, 0xB69D, 0xBEBD, 0xBEBD, 0xC69D, 0xCEDD, 0xD71D, 0xD6FD,   // 0x0220 (544)
+0xC67D, 0x73DD, 0x003D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x635C, 0xB63C, 0xC6BC, 0xBE9C,   // 0x0240 (576)
+0xBE5C, 0xBE9D, 0xBE9E, 0xB69E, 0xB67D, 0xB65D, 0xB65C, 0xBE7C, 0xBE9C, 0xB6BB, 0xB69C, 0xB69D, 0xBE7C, 0xBE5B, 0xBE7A, 0xCEFA,   // 0x0250 (592)
+0xDF5B, 0xD73B, 0xC69A, 0xBE59, 0xC67A, 0xCE9A, 0xD6FC, 0xCE9A, 0xCE99, 0xDF5A, 0xEFDB, 0xD6FA, 0xC67A, 0xC65B, 0xC63A, 0xC67B,   // 0x0260 (608)
+0xC69B, 0xBE9B, 0xB69B, 0xB69C, 0xBE7C, 0xBE7C, 0xBE7D, 0xB67D, 0xAE7E, 0xB67E, 0xB6BE, 0xB6BD, 0xBE9D, 0xC6BD, 0xC6DD, 0xC6BC,   // 0x0270 (624)
+0xCEBC, 0xC67C, 0x6B7E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ABD, 0xADDC, 0xB67B, 0xBE9C, 0xBE7D,   // 0x0290 (656)
+0xBE7D, 0xB67D, 0xAE7D, 0xAE7D, 0xAE9D, 0xB69D, 0xB65C, 0xBE5B, 0xB67B, 0xB67B, 0xB67D, 0xB65E, 0xBE7E, 0xBE5B, 0xBE58, 0xD6F9,   // 0x02A0 (672)
+0xE7BA, 0xE79A, 0xDF19, 0xC657, 0xC637, 0xD6D9, 0xEF7B, 0xE719, 0xE718, 0xEF78, 0xEF79, 0xD71A, 0xC679, 0xBE58, 0xCEBA, 0xDEDB,   // 0x02B0 (688)
+0xD6FB, 0xC69B, 0xBE7B, 0xB65C, 0xB67C, 0xBE7D, 0xBE7E, 0xB65E, 0xAE7E, 0xAE7E, 0xAE7D, 0xAE7D, 0xAE7D, 0xB67D, 0xBE9C, 0xBE7C,   // 0x02C0 (704)
+0xBE7C, 0xC6BB, 0xADDC, 0x423D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001C, 0x635C, 0xB61C, 0xBE9C, 0xB65D, 0xB65D,   // 0x02E0 (736)
+0xB65C, 0xB67D, 0xAE5D, 0xA65D, 0xAE7D, 0xAE9D, 0xAE7B, 0xB63A, 0xB65B, 0xB67C, 0xB65D, 0xB63E, 0xBE5D, 0xC69B, 0xCEB9, 0xDF38,   // 0x02F0 (752)
+0xEFD8, 0xEF98, 0xE757, 0xD6B6, 0xCE75, 0xE717, 0xF798, 0xEF57, 0xEF36, 0xEF36, 0xEF37, 0xDEF8, 0xC677, 0xCE78, 0xDF1A, 0xEF5A,   // 0x0300 (768)
+0xE75B, 0xCEBA, 0xBE9A, 0xB65B, 0xB63C, 0xB65D, 0xB65D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE5D, 0xB65D, 0xB67D, 0xB67D,   // 0x0310 (784)
+0xB65C, 0xBE7B, 0xB63C, 0x5B3C, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213B, 0x8CFB, 0xB67D, 0xB69E, 0xAE5D, 0xAE5C,   // 0x0330 (816)
+0xAE5D, 0xAE7D, 0xAE7E, 0xA67E, 0xA67D, 0xA65C, 0xAE5A, 0xB65A, 0xB659, 0xB63A, 0xB61B, 0xB61C, 0xC65C, 0xD6DB, 0xE779, 0xE775,   // 0x0340 (832)
+0xF7B6, 0xF795, 0xEF75, 0xEF36, 0xE6F5, 0xFF56, 0xFF56, 0xF734, 0xEF34, 0xEEF4, 0xEF15, 0xDEF6, 0xCE75, 0xDED6, 0xF779, 0xF778,   // 0x0350 (848)
+0xEF58, 0xDEF9, 0xCE9A, 0xBE5B, 0xB65D, 0xB65D, 0xB65D, 0xB67D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE7D, 0xAE5D, 0xAE5C,   // 0x0360 (864)
+0xAE5C, 0xB65C, 0xBE7B, 0x8CDB, 0x18DB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x3A1B, 0xA5BB, 0xAE7C, 0xA65D, 0xA65D, 0xAE5D,   // 0x0380 (896)
+0xA61C, 0xA63C, 0xA63D, 0x9E3D, 0xA65D, 0xA65B, 0xB69B, 0xCF1C, 0xCEFA, 0xBE78, 0xB638, 0xB5F9, 0xC638, 0xDED9, 0xFFB9, 0xF774,   // 0x0390 (912)
+0xF7B4, 0xF773, 0xF774, 0xFF75, 0xFF35, 0xFF75, 0xFF54, 0xF6F2, 0xF6F3, 0xF6D3, 0xF6D4, 0xE6D5, 0xDEB4, 0xEF35, 0xFF96, 0xF775,   // 0x03A0 (928)
+0xEF35, 0xEF38, 0xCE99, 0xBE3A, 0xB63B, 0xB63B, 0xAE3B, 0xB65C, 0xAE7C, 0xAE5D, 0xAE5D, 0xAE5D, 0xAE5D, 0xAE5D, 0xA63D, 0xAE5C,   // 0x03B0 (944)
+0xAE3C, 0xAE3C, 0xB65B, 0xA59B, 0x3A1C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4ABC, 0xA5FC, 0xAE7D, 0x9E3D, 0xA63D, 0xA63D,   // 0x03D0 (976)
+0xA63D, 0xA65D, 0xA65D, 0x9E5D, 0xA65C, 0xA63B, 0xB67A, 0xD71C, 0xE77B, 0xD738, 0xCEB7, 0xC637, 0xC5F5, 0xD694, 0xFF96, 0xF773,   // 0x03E0 (992)
+0xFF93, 0xFF73, 0xFF54, 0xFF74, 0xFF54, 0xFF53, 0xFF33, 0xF6B2, 0xF6B2, 0xF6B2, 0xF6B3, 0xEED4, 0xEF14, 0xFF95, 0xFFB4, 0xF753,   // 0x03F0 (1008)
+0xF754, 0xEF57, 0xCE76, 0xBE17, 0xBE59, 0xBE7A, 0xB65A, 0xAE5A, 0xAE7C, 0xAE5C, 0xAE5D, 0xAE5D, 0xA65D, 0xAE5E, 0xA65D, 0xAE5D,   // 0x0400 (1024)
+0xAE5D, 0xAE3D, 0xB65C, 0xADFC, 0x5B1D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBD, 0xAE3D, 0xA67D, 0xA65E, 0xA65E, 0xA61C,   // 0x0420 (1056)
+0x9E1C, 0xA63C, 0x9E3D, 0x9E5D, 0xA65C, 0xA61A, 0xB639, 0xD6FB, 0xEF9A, 0xEF97, 0xE736, 0xDEB5, 0xD653, 0xDEB2, 0xFF94, 0xFF72,   // 0x0430 (1072)
+0xFF72, 0xFF33, 0xFF53, 0xFF33, 0xFF53, 0xFF32, 0xFF32, 0xF6B1, 0xF691, 0xFED2, 0xEE91, 0xF6D3, 0xFF54, 0xFF93, 0xFF92, 0xF731,   // 0x0440 (1088)
+0xFF73, 0xE715, 0xC654, 0xC676, 0xD6F9, 0xD75B, 0xC6B9, 0xAE5A, 0xAE5C, 0xAE3C, 0xAE3C, 0xA63C, 0xA63D, 0xA65D, 0xA65D, 0xA65D,   // 0x0450 (1104)
+0xA65D, 0xA63D, 0xAE5C, 0xAE3C, 0x5B5D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x73FE, 0xAE5C, 0xAE9E, 0xA69E, 0xA65E, 0xA61D,   // 0x0470 (1136)
+0xA61C, 0x9DFC, 0x961C, 0x9E3D, 0x9E3C, 0xA61A, 0xADF8, 0xC678, 0xE717, 0xEF75, 0xEF54, 0xEF35, 0xEEF3, 0xEEF2, 0xFF72, 0xFF51,   // 0x0480 (1152)
+0xFF32, 0xFF13, 0xFF13, 0xFF12, 0xFF31, 0xFF10, 0xFF31, 0xF6B1, 0xF671, 0xFED1, 0xEE6F, 0xF6D1, 0xFF33, 0xFF51, 0xFF51, 0xFF31,   // 0x0490 (1168)
+0xF752, 0xDED2, 0xCE73, 0xD715, 0xE798, 0xEFDA, 0xC6D8, 0xA619, 0x9DFB, 0x9DFB, 0xA61C, 0xA61C, 0xA61C, 0xA61D, 0x9E3D, 0xA63D,   // 0x04A0 (1184)
+0xA63D, 0xA63D, 0xA63C, 0xA5DB, 0x52FD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xA63D, 0xAEBE, 0xA67E, 0xA65E, 0xA65D,   // 0x04C0 (1216)
+0xA65D, 0x9DFC, 0x9E1D, 0x9E3D, 0x95FB, 0xA61B, 0xADF8, 0xBE16, 0xDED5, 0xEF53, 0xEF32, 0xF753, 0xFF53, 0xFF31, 0xFF31, 0xFF31,   // 0x04D0 (1232)
+0xFED1, 0xFED2, 0xFED2, 0xFF11, 0xFF10, 0xFF0F, 0xFF30, 0xFED1, 0xEE50, 0xFEB0, 0xF66E, 0xFED1, 0xFF12, 0xFF10, 0xFF10, 0xFF31,   // 0x04E0 (1248)
+0xF731, 0xE732, 0xDF33, 0xEFB6, 0xEFB6, 0xE797, 0xBE96, 0xA5D8, 0xA5FB, 0x9DFB, 0x9DFB, 0xA5FB, 0xA61C, 0x9E1C, 0x9E1D, 0x9E1D,   // 0x04F0 (1264)
+0x9E3E, 0x9E3D, 0xA61C, 0x9DBB, 0x5B3D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0xA5FD, 0xAE7E, 0xA67E, 0xA65D, 0xA67E,   // 0x0510 (1296)
+0xA65D, 0xA63D, 0xA61D, 0xA61D, 0x9DFC, 0xA5FB, 0xAE18, 0xBDF3, 0xDE93, 0xFF53, 0xF711, 0xF711, 0xF6F0, 0xFF10, 0xFF30, 0xFF31,   // 0x0520 (1312)
+0xFEB0, 0xFEB1, 0xF691, 0xFED1, 0xFED0, 0xFEEF, 0xFEEF, 0xFEAF, 0xF64F, 0xFEB0, 0xEE4E, 0xFEB0, 0xFED0, 0xFEF0, 0xFF10, 0xFF31,   // 0x0530 (1328)
+0xFF31, 0xF771, 0xF792, 0xF7B3, 0xF7D4, 0xD715, 0xB614, 0xADD6, 0xA5F8, 0xA618, 0xA618, 0x9DFA, 0x9E1C, 0x9DFD, 0x9DDD, 0x961D,   // 0x0540 (1344)
+0x961D, 0x961D, 0x9E1C, 0x9DDB, 0x5AFD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637E, 0xA5FD, 0xAE3E, 0xA65E, 0xA65E, 0x9E5D,   // 0x0560 (1376)
+0xA67E, 0xAE7E, 0xAE3E, 0xAE1D, 0xAE3C, 0xAE3A, 0xBE78, 0xD674, 0xEED3, 0xFF32, 0xFF10, 0xF6EF, 0xF6CE, 0xFEEE, 0xFEEF, 0xFEF0,   // 0x0570 (1392)
+0xFE8F, 0xF670, 0xFE91, 0xFE90, 0xFE8F, 0xFE8F, 0xFE8E, 0xFE90, 0xEE2E, 0xFE91, 0xEE2E, 0xFE8F, 0xFE8F, 0xFEEF, 0xFEEF, 0xF6D0,   // 0x0580 (1408)
+0xFF51, 0xFF70, 0xFF8F, 0xEF6F, 0xF772, 0xCE72, 0xBDF4, 0xC656, 0xC697, 0xC6F9, 0xB6DA, 0x9E1A, 0x95DB, 0x9DDC, 0x9DDD, 0x95FD,   // 0x0590 (1424)
+0x8DFD, 0x8DFD, 0x961C, 0x9DBB, 0x52FD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x635E, 0xA5DD, 0xA63E, 0xA63E, 0x9E5E, 0x9E5D,   // 0x05B0 (1456)
+0xA65D, 0xA63D, 0xAE5C, 0xAE3B, 0xAE39, 0xB637, 0xCEB5, 0xEF14, 0xFF31, 0xFF2F, 0xF6EE, 0xFF0E, 0xFEEE, 0xFEED, 0xFEAD, 0xFEAE,   // 0x05C0 (1472)
+0xF66E, 0xEDED, 0xFE90, 0xFE6F, 0xFE4F, 0xF64F, 0xF66F, 0xF670, 0xE5EE, 0xFE71, 0xEDCE, 0xF64E, 0xFE8E, 0xFE8D, 0xFEAD, 0xFF10,   // 0x05D0 (1488)
+0xFF0F, 0xFF2F, 0xFF4E, 0xF72E, 0xEF10, 0xD630, 0xDE73, 0xE715, 0xEF76, 0xE79A, 0xBEDA, 0x9E1B, 0x95BB, 0x95BC, 0x9DDC, 0x95DD,   // 0x05E0 (1504)
+0x8E1E, 0x8DFD, 0x961C, 0x95BB, 0x52DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B5D, 0x9DBD, 0x9E1E, 0x9E1E, 0x9E3D, 0x963D,   // 0x0600 (1536)
+0x961C, 0x961B, 0xAE9B, 0xC6DA, 0xC6D7, 0xC693, 0xD6B2, 0xF731, 0xFF4F, 0xFF2D, 0xFF0D, 0xFEEE, 0xFECD, 0xFECD, 0xFEAD, 0xFE8D,   // 0x0610 (1552)
+0xF62C, 0xEDAC, 0xEDCD, 0xF62F, 0xEDEE, 0xEE2F, 0xF671, 0xDDEF, 0xDDF0, 0xDDAF, 0xDDAE, 0xEE4F, 0xF66E, 0xFEAE, 0xFECD, 0xFEEE,   // 0x0620 (1568)
+0xFECE, 0xFECE, 0xFF0E, 0xFF4F, 0xF70F, 0xE6B0, 0xF6F2, 0xF731, 0xF752, 0xD6D5, 0xA5F7, 0x95B9, 0x959B, 0x95BB, 0x95BB, 0x8DDC,   // 0x0630 (1584)
+0x85FD, 0x85FD, 0x8DFC, 0x8D9B, 0x52DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x533D, 0x95BD, 0x95FD, 0x95FE, 0x961D, 0x8E1D,   // 0x0650 (1616)
+0x8E1C, 0x961B, 0xA679, 0xCF39, 0xDF77, 0xE753, 0xF750, 0xFF2F, 0xFF2D, 0xFF2C, 0xFF0D, 0xFEEE, 0xFE8D, 0xFE6D, 0xFE6D, 0xFE6C,   // 0x0660 (1632)
+0xFDEB, 0xE56B, 0xDD4C, 0xEDCF, 0xD54E, 0xCD2E, 0xD590, 0xA46C, 0xB4CF, 0x93EB, 0xA44C, 0xCD6E, 0xE5CE, 0xF66E, 0xFECE, 0xFE8D,   // 0x0670 (1648)
+0xFECD, 0xFECD, 0xFF2D, 0xFF2E, 0xFF2E, 0xF70F, 0xFF30, 0xFF0F, 0xF70F, 0xCE71, 0xA5D3, 0x9575, 0x9597, 0x95B8, 0x8DB8, 0x8DDB,   // 0x0680 (1664)
+0x85DC, 0x85DC, 0x8DDC, 0x8D5B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x8D9D, 0x8DDD, 0x8DBD, 0x8DDD, 0x8DDD,   // 0x06A0 (1696)
+0x8DFD, 0x8DFB, 0x95F7, 0xBE95, 0xDF34, 0xEF51, 0xFF4F, 0xFF2D, 0xFF0C, 0xFF0C, 0xFEED, 0xFECE, 0xFE6D, 0xFE2C, 0xFDEB, 0xFE2C,   // 0x06B0 (1712)
+0xFE0D, 0xE52C, 0xC48B, 0xBC6C, 0xA40B, 0x9BCB, 0x9BED, 0x7B2A, 0x7B4B, 0x62C9, 0x6AE8, 0x8B8A, 0x9BE9, 0xCD6B, 0xFE8E, 0xFE8D,   // 0x06C0 (1728)
+0xFECD, 0xFEED, 0xFF2D, 0xFEEC, 0xFF0C, 0xFF2E, 0xFF0E, 0xFF0D, 0xFF0D, 0xDEB0, 0xC652, 0xB653, 0xBEB6, 0xBEB8, 0xA659, 0x8DD9,   // 0x06D0 (1744)
+0x7DBB, 0x7DBC, 0x85BB, 0x8D5B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4AFD, 0x857C, 0x85DD, 0x85BC, 0x85BD, 0x85DD,   // 0x06F0 (1776)
+0x85DD, 0x85DC, 0x8DD7, 0xB634, 0xD6D2, 0xE6EF, 0xF6ED, 0xFF0C, 0xFF0B, 0xFECB, 0xFE8C, 0xFE8D, 0xFE4C, 0xFDEB, 0xF5AA, 0xFDEC,   // 0x0700 (1792)
+0xFDEE, 0xDD2E, 0x9B69, 0x7AA7, 0x7AA9, 0x72EA, 0x72EB, 0x6AEB, 0x62EB, 0x62CA, 0x62EA, 0x6AE9, 0x6265, 0x8BA7, 0xD56C, 0xF66E,   // 0x0710 (1808)
+0xFECD, 0xFECC, 0xFECB, 0xF6CB, 0xFEEB, 0xFF0C, 0xFEEB, 0xFEEC, 0xFF0C, 0xEEEE, 0xDEAF, 0xE733, 0xEFB7, 0xDF99, 0xB699, 0x8DB8,   // 0x0720 (1824)
+0x7D7A, 0x7D9C, 0x859B, 0x853B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4AFD, 0x857C, 0x85DC, 0x7D9C, 0x85BD, 0x7DBD,   // 0x0740 (1856)
+0x85BD, 0x8DDD, 0x95B9, 0xB636, 0xD6D3, 0xE6CF, 0xEEAB, 0xFEEB, 0xFEEC, 0xFECC, 0xFE6C, 0xF62B, 0xF5EA, 0xFDCA, 0xF58A, 0xED6B,   // 0x0750 (1872)
+0xDD0C, 0xB40B, 0x7A88, 0x6A69, 0x6A8B, 0x6AEB, 0x6B0C, 0x630C, 0x5AEC, 0x632D, 0x6B4C, 0x630B, 0x62A8, 0x6265, 0x8346, 0xCD6C,   // 0x0760 (1888)
+0xEE2D, 0xF64B, 0xF669, 0xFEC9, 0xFEE9, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEB, 0xFEEC, 0xF70D, 0xF72F, 0xE712, 0xC674, 0x9DB5, 0x8557,   // 0x0770 (1904)
+0x7D7A, 0x7D9C, 0x859B, 0x851B, 0x4A9D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D7C, 0x85BD, 0x7D9C, 0x7DBD, 0x7DBD,   // 0x0790 (1936)
+0x7DBD, 0x857C, 0x9578, 0xADB5, 0xCE73, 0xE6D0, 0xE68B, 0xF6A9, 0xFECB, 0xFECB, 0xFE8B, 0xFE0A, 0xEDA8, 0xED68, 0xE549, 0xDD4B,   // 0x07A0 (1952)
+0xBC4A, 0x82C8, 0x6248, 0x6ACB, 0x5A8B, 0x5AAB, 0x62EC, 0x5AEC, 0x5AEC, 0x6B6C, 0x630B, 0x6AEB, 0x6ACA, 0x5A46, 0x59E3, 0xAC4A,   // 0x07B0 (1968)
+0xDD6C, 0xEDEB, 0xF629, 0xFE89, 0xFEA8, 0xFEA8, 0xFEC8, 0xFEEA, 0xFEEB, 0xFF0A, 0xFF0B, 0xEECD, 0xD650, 0xADB2, 0x8D36, 0x857A,   // 0x07C0 (1984)
+0x7D5B, 0x7D7C, 0x7D7C, 0x853B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7D7C, 0x7DBD, 0x7D9D, 0x7DDD, 0x759D,   // 0x07E0 (2016)
+0x7D9C, 0x859B, 0x9578, 0x9D53, 0xB5B0, 0xD68F, 0xEEAC, 0xF689, 0xFEC9, 0xFE89, 0xFEAA, 0xFE4A, 0xF5C8, 0xE547, 0xDD08, 0xD52B,   // 0x07F0 (2032)
+0xABEA, 0x5A05, 0x6269, 0x5A6A, 0x528B, 0x52AA, 0x52EB, 0x632D, 0x632C, 0x7BAD, 0x732B, 0x6B2B, 0x6AEA, 0x5A68, 0x5A05, 0x9BA9,   // 0x0800 (2048)
+0xD50C, 0xEDAB, 0xFDE9, 0xFE28, 0xFE47, 0xFE87, 0xFEA7, 0xFEC9, 0xFEE9, 0xFEEA, 0xF6CA, 0xDE2C, 0xC5EF, 0xA574, 0x8518, 0x7D3C,   // 0x0810 (2064)
+0x755E, 0x6D5D, 0x7D7C, 0x7D1B, 0x4ABD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DD, 0x755C, 0x7DBE, 0x7DBF, 0x7DDE, 0x759D,   // 0x0830 (2096)
+0x7D9C, 0x859A, 0x9596, 0xA572, 0xAD8E, 0xD64D, 0xF6ED, 0xF6A9, 0xFE88, 0xFE88, 0xFE68, 0xFE28, 0xF5C8, 0xED89, 0xDD2A, 0xBC49,   // 0x0840 (2112)
+0x82E7, 0x6268, 0x5229, 0x4A6A, 0x4ACB, 0x4ACA, 0x4ACB, 0x5B0C, 0x632D, 0x7B6D, 0x9450, 0x732C, 0x6AEB, 0x5A89, 0x5A47, 0x61E4,   // 0x0850 (2128)
+0xB429, 0xE54B, 0xFDA9, 0xFDC8, 0xFE27, 0xFE46, 0xFE87, 0xFEA8, 0xFEC8, 0xF6E9, 0xEEAA, 0xDE4C, 0xC610, 0x9D75, 0x7D1B, 0x757E,   // 0x0860 (2144)
+0x6D7E, 0x655D, 0x759C, 0x74FB, 0x427C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x323C, 0x64BC, 0x6D5D, 0x6D7E, 0x75BE, 0x75BE,   // 0x0880 (2176)
+0x7D9C, 0x8599, 0x9DF6, 0xBE54, 0xCE90, 0xE6EE, 0xF70C, 0xF6C8, 0xFE67, 0xFE67, 0xFE27, 0xFDE7, 0xF587, 0xF589, 0xE56C, 0xA3A8,   // 0x0890 (2192)
+0x6A45, 0x5A69, 0x4A29, 0x426A, 0x428A, 0x4289, 0x4249, 0x424A, 0x4A6B, 0x5A8B, 0x83EF, 0x8C30, 0x734C, 0x62EB, 0x5226, 0x59C3,   // 0x08A0 (2208)
+0xB42A, 0xDD0A, 0xED28, 0xFD67, 0xFDC7, 0xFE06, 0xFE67, 0xFE88, 0xF6A8, 0xEEA8, 0xEECA, 0xE6AE, 0xB5F0, 0x8D55, 0x755C, 0x657E,   // 0x08B0 (2224)
+0x5D7E, 0x5D7D, 0x6D7B, 0x6499, 0x321C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x2A1C, 0x547B, 0x5CFC, 0x5D1C, 0x655D, 0x6D7D,   // 0x08D0 (2256)
+0x7DBC, 0x961B, 0xBEF9, 0xDF57, 0xE731, 0xEEEC, 0xF6A9, 0xFEA7, 0xFE86, 0xFE46, 0xFE47, 0xFDC7, 0xF527, 0xE4E8, 0xDCCA, 0x9B27,   // 0x08E0 (2272)
+0x61E5, 0x49E7, 0x4209, 0x424A, 0x3A6A, 0x3A49, 0x3A29, 0x3A0A, 0x39E9, 0x39A8, 0x524A, 0x8410, 0x738D, 0x5ACA, 0x4A07, 0x5A05,   // 0x08F0 (2288)
+0x9B88, 0xCCC9, 0xE508, 0xF527, 0xFDA7, 0xFE07, 0xFE47, 0xFE88, 0xF6A8, 0xEEA7, 0xF70A, 0xD66B, 0xA58C, 0x8D54, 0x757C, 0x5D5E,   // 0x0900 (2304)
+0x557E, 0x555C, 0x54F9, 0x5438, 0x29DC, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x325C, 0x5C9B, 0x5CFC, 0x54DC, 0x5CFC, 0x5CFB,   // 0x0920 (2336)
+0x651A, 0x7D9A, 0xA657, 0xC692, 0xDEAD, 0xF6EA, 0xF686, 0xFE65, 0xFE45, 0xFE45, 0xFDE5, 0xFD86, 0xF527, 0xE4C8, 0xD469, 0x92C5,   // 0x0930 (2352)
+0x5163, 0x49C7, 0x41E9, 0x3A2A, 0x3A4A, 0x3229, 0x31E8, 0x31C8, 0x39C9, 0x41E9, 0x31A8, 0x6B4D, 0x738D, 0x4A49, 0x41C6, 0x4963,   // 0x0940 (2368)
+0x61C1, 0xBC47, 0xE4E7, 0xED06, 0xFD86, 0xFDE7, 0xFE27, 0xFE67, 0xF687, 0xEE86, 0xF6E8, 0xF74C, 0xD6CF, 0x95D3, 0x6539, 0x553C,   // 0x0950 (2384)
+0x44FB, 0x44DB, 0x4CB9, 0x4C18, 0x29BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DD, 0x64FC, 0x5D1C, 0x54DB, 0x54FB, 0x5CFB,   // 0x0970 (2416)
+0x5CFA, 0x5CD7, 0x74F2, 0x9D4D, 0xCE0A, 0xF687, 0xFE45, 0xFE24, 0xFE24, 0xFE24, 0xFDC4, 0xFD65, 0xF526, 0xECC6, 0xDCA8, 0xB3A7,   // 0x0980 (2432)
+0x6A24, 0x4985, 0x3987, 0x31E9, 0x3A2A, 0x3209, 0x31C8, 0x31C8, 0x39E9, 0x39A8, 0x39C7, 0x6B4C, 0x736C, 0x5249, 0x4145, 0x4122,   // 0x0990 (2448)
+0x7A64, 0xC467, 0xE506, 0xF526, 0xFDA6, 0xFDE6, 0xFE25, 0xFE65, 0xFE85, 0xFEA5, 0xFEC7, 0xF6E9, 0xEF4F, 0xAE54, 0x5C96, 0x449A,   // 0x09A0 (2464)
+0x44FB, 0x44BB, 0x4CBA, 0x5458, 0x325B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x431D, 0x653C, 0x5D7C, 0x551B, 0x5D1C, 0x5D1C,   // 0x09C0 (2496)
+0x5D1C, 0x64FA, 0x74F4, 0xA56F, 0xD5CA, 0xE5C4, 0xF603, 0xFE23, 0xFE43, 0xFE03, 0xFDC3, 0xFD85, 0xF504, 0xE484, 0xE4A6, 0xCC68,   // 0x09D0 (2512)
+0x8AC5, 0x49A4, 0x41A7, 0x31C9, 0x31EA, 0x31E9, 0x31C7, 0x31A6, 0x3185, 0x39E7, 0x4A28, 0x6309, 0x4A46, 0x49C7, 0x4945, 0x4902,   // 0x09E0 (2528)
+0x8265, 0xD468, 0xE4E6, 0xFD25, 0xFD84, 0xFDE4, 0xFE03, 0xFE22, 0xFE42, 0xFE84, 0xF644, 0xDDC4, 0xBD87, 0x8CEE, 0x5C95, 0x54DB,   // 0x09F0 (2544)
+0x4CDC, 0x44BC, 0x549C, 0x64FA, 0x53BA, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B5E, 0x6D9D, 0x65BD, 0x5D5C, 0x5D3C, 0x5D1B,   // 0x0A10 (2576)
+0x5D1C, 0x5D3B, 0x7556, 0xA5F2, 0xC5EB, 0xDDE5, 0xFE23, 0xFDC1, 0xF5A0, 0xF5C0, 0xF560, 0xFD42, 0xFD23, 0xF4E4, 0xEC85, 0xBB83,   // 0x0A20 (2592)
+0x6140, 0x40E2, 0x3925, 0x2967, 0x2988, 0x31A8, 0x3A08, 0x31C7, 0x3185, 0x3966, 0x5288, 0x5AE9, 0x39E5, 0x2903, 0x3103, 0x5921,   // 0x0A30 (2608)
+0xAB46, 0xD406, 0xE444, 0xF4A3, 0xFD23, 0xFDA1, 0xFDC0, 0xFDA0, 0xFDC0, 0xFE02, 0xF603, 0xCD23, 0x9C86, 0x7CCF, 0x64F7, 0x4CBA,   // 0x0A40 (2624)
+0x4CBC, 0x4CDD, 0x54BC, 0x6CDA, 0x537B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x6DBD, 0x6DDF, 0x659E, 0x655D, 0x651C,   // 0x0A60 (2656)
+0x653C, 0x5D3B, 0x6536, 0x7D51, 0xA5AB, 0xD626, 0xF623, 0xFE01, 0xFDE0, 0xFE00, 0xFDC0, 0xFD61, 0xFCE1, 0xFCA2, 0xE421, 0xC3A2,   // 0x0A70 (2672)
+0x79C0, 0x2800, 0x1000, 0x0843, 0x1084, 0x20C4, 0x2125, 0x10C3, 0x2145, 0x41A6, 0x3966, 0x18E3, 0x1081, 0x0000, 0x1000, 0x6180,   // 0x0A80 (2688)
+0xBB63, 0xCB42, 0xDB41, 0xEC21, 0xFD01, 0xFDC0, 0xFE00, 0xFDC0, 0xF560, 0xFDC1, 0xF624, 0xCD66, 0x948A, 0x7492, 0x6519, 0x5D1C,   // 0x0A90 (2704)
+0x54FD, 0x551D, 0x5CDD, 0x753B, 0x5BBB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x7DBD, 0x75DE, 0x6D9F, 0x655D, 0x651B,   // 0x0AB0 (2736)
+0x653B, 0x6538, 0x7575, 0x95D1, 0xBE2C, 0xE647, 0xF603, 0xFE00, 0xFDE0, 0xFE00, 0xFE00, 0xFDA1, 0xFD41, 0xF4A0, 0xEC40, 0xDC02,   // 0x0AC0 (2752)
+0xAAC2, 0x4880, 0x1000, 0x0800, 0x0000, 0x0000, 0x1062, 0x0001, 0x10A3, 0x1861, 0x28A2, 0x0800, 0x0000, 0x0800, 0x2000, 0x8A40,   // 0x0AD0 (2768)
+0xCB60, 0xDB61, 0xEB81, 0xEC01, 0xF4A0, 0xF580, 0xFE00, 0xFDE0, 0xF560, 0xED60, 0xE5A3, 0xCD89, 0x9D30, 0x8536, 0x6D5B, 0x5D3D,   // 0x0AE0 (2784)
+0x551D, 0x5D3E, 0x651D, 0x753B, 0x5BBB, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x85BD, 0x7DFE, 0x75DE, 0x6DBD, 0x6D9C,   // 0x0B00 (2816)
+0x7579, 0x8597, 0xA5D2, 0xC62F, 0xDE4B, 0xEE47, 0xF624, 0xF5E1, 0xF600, 0xFE41, 0xFDE0, 0xFD80, 0xFD80, 0xFD00, 0xFCA0, 0xE3E0,   // 0x0B10 (2832)
+0xAAA0, 0x6100, 0x3040, 0x1800, 0x1000, 0x0801, 0x0000, 0x0800, 0x0800, 0x1820, 0x2881, 0x1000, 0x1800, 0x3000, 0x6960, 0xC362,   // 0x0B20 (2848)
+0xEC21, 0xEBA0, 0xF3E0, 0xFC81, 0xF4E1, 0xF560, 0xF5E0, 0xFE00, 0xF600, 0xE5A1, 0xDDA3, 0xC5AB, 0xA572, 0x8D58, 0x755C, 0x655E,   // 0x0B30 (2864)
+0x657E, 0x659E, 0x6D7D, 0x751C, 0x429C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85BD, 0x8DFE, 0x861E, 0x7E1E, 0x7E1E,   // 0x0B50 (2896)
+0x7DFA, 0x95F8, 0xB634, 0xCE50, 0xD62C, 0xDE29, 0xE606, 0xEDE3, 0xEDC0, 0xEDE0, 0xFE01, 0xFDC1, 0xFDA0, 0xFD40, 0xFD00, 0xFC61,   // 0x0B60 (2912)
+0xD381, 0xAB02, 0x8242, 0x3820, 0x2820, 0x1800, 0x0800, 0x1000, 0x1820, 0x2000, 0x2800, 0x3020, 0x4060, 0x68E0, 0xAAC4, 0xE3E3,   // 0x0B70 (2928)
+0xF400, 0xEBC0, 0xF420, 0xFCC1, 0xFD41, 0xF5A0, 0xEDA0, 0xF5E0, 0xF642, 0xEE23, 0xE626, 0xC5EC, 0xA592, 0x8D77, 0x859C, 0x75BD,   // 0x0B80 (2944)
+0x75BE, 0x75DE, 0x7DDD, 0x7D5B, 0x42DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x531D, 0x8DBD, 0x8E1F, 0x8E1F, 0x863F, 0x865F,   // 0x0BA0 (2976)
+0x861C, 0x8DFA, 0xA5F8, 0xADF5, 0xB5F2, 0xB60E, 0xC5E9, 0xD605, 0xE602, 0xF5E0, 0xFE01, 0xFDE2, 0xFD80, 0xF540, 0xF520, 0xFCE2,   // 0x0BB0 (2992)
+0xFCA2, 0xE3E3, 0xD3C3, 0xAAC1, 0x81C0, 0x5100, 0x3020, 0x2820, 0x3840, 0x6100, 0x7180, 0x9221, 0xA282, 0xAA01, 0xBA81, 0xE381,   // 0x0BC0 (3008)
+0xFC61, 0xFC40, 0xFC60, 0xFCE0, 0xFD60, 0xFDC0, 0xFDE0, 0xF5E1, 0xEE03, 0xEE45, 0xDE88, 0xC64D, 0xA612, 0x95F6, 0x8DFA, 0x7E1C,   // 0x0BD0 (3024)
+0x7DFC, 0x75FC, 0x861C, 0x85BC, 0x4AFD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x531D, 0x8DDD, 0x963F, 0x8E1F, 0x863F, 0x863E,   // 0x0BF0 (3056)
+0x861D, 0x85DA, 0x8DB9, 0x9DD8, 0x9DF5, 0xA5F0, 0xB5EB, 0xD606, 0xF664, 0xFE43, 0xF5C2, 0xF583, 0xF582, 0xFD81, 0xF540, 0xFD00,   // 0x0C00 (3072)
+0xFCC1, 0xF440, 0xD340, 0xD360, 0xBAC0, 0xB365, 0x7A00, 0xA2E6, 0x8A02, 0xBB25, 0xC344, 0xC321, 0xD3A2, 0xD301, 0xC280, 0xDB60,   // 0x0C10 (3088)
+0xF420, 0xFC80, 0xFCA0, 0xFCE0, 0xFD40, 0xFDC0, 0xFE00, 0xEDE2, 0xE605, 0xD628, 0xCE6C, 0xBE51, 0xAE35, 0x9617, 0x8DFA, 0x861C,   // 0x0C20 (3104)
+0x861C, 0x861D, 0x8E3D, 0x8DFC, 0x535D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1C, 0x85FC, 0x8E5D, 0x8E1E, 0x861D, 0x861C,   // 0x0C40 (3136)
+0x85FC, 0x85FC, 0x8E1D, 0x961B, 0x9E36, 0xA650, 0xBE2B, 0xE627, 0xEE04, 0xEDC3, 0xEDC4, 0xEDA6, 0xF5C5, 0xFDC2, 0xFDA0, 0xFD80,   // 0x0C50 (3152)
+0xFD41, 0xF460, 0xF3C0, 0xE380, 0xE3E3, 0xD384, 0xBAE2, 0xD3E6, 0xBAE1, 0xE404, 0xE3C2, 0xDB80, 0xEBC1, 0xE380, 0xCAE0, 0xE3C0,   // 0x0C60 (3168)
+0xFCC0, 0xFCC0, 0xF4A0, 0xFCA0, 0xFCE0, 0xFD60, 0xF581, 0xDDC3, 0xD5E8, 0xC5EE, 0xB615, 0xAE38, 0xA63A, 0x961A, 0x8DFB, 0x8E1E,   // 0x0C70 (3184)
+0x8E3F, 0x863F, 0x8E3F, 0x963D, 0x5B9D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42FC, 0x7DDB, 0x863D, 0x85FD, 0x861D, 0x861C,   // 0x0C90 (3216)
+0x85DC, 0x8E3D, 0x9EBF, 0x9E9D, 0x9E57, 0xB651, 0xCE6D, 0xE629, 0xD5A5, 0xCD85, 0xDDC7, 0xDD87, 0xDD64, 0xED81, 0xFE02, 0xED80,   // 0x0CA0 (3232)
+0xF540, 0xFCC0, 0xFC60, 0xFC21, 0xE3A0, 0xDB81, 0xD321, 0xDB82, 0xCB00, 0xF463, 0xE3C0, 0xEBE0, 0xEC00, 0xF421, 0xEBE0, 0xE3E0,   // 0x0CB0 (3248)
+0xF4C0, 0xF4E0, 0xF4C0, 0xF4A0, 0xF4A0, 0xF500, 0xEDA3, 0xDDE8, 0xC60D, 0xB5F4, 0xADDA, 0xA61C, 0x9E5D, 0x963C, 0x8E1D, 0x965F,   // 0x0CC0 (3264)
+0x965F, 0x8E3F, 0x965F, 0x9E3E, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42BC, 0x757B, 0x7DDC, 0x7DDD, 0x861D, 0x8E3D,   // 0x0CE0 (3296)
+0x963E, 0x9E9F, 0xA6BF, 0xB6BD, 0xBE99, 0xB632, 0xCE2E, 0xCE2B, 0xB588, 0xA549, 0xAD67, 0xBD45, 0xE647, 0xEE03, 0xE5A2, 0xDD22,   // 0x0CF0 (3312)
+0xE502, 0xF502, 0xF4A1, 0xF4A1, 0xF461, 0xDBA0, 0xDB40, 0xEBC2, 0xDB40, 0xF481, 0xE460, 0xF480, 0xEC60, 0xF440, 0xEC20, 0xE440,   // 0x0D00 (3328)
+0xF4E0, 0xFD42, 0xF500, 0xF4A0, 0xECC0, 0xE4E1, 0xE5A5, 0xD60C, 0xBE32, 0xA618, 0x9E1C, 0x9E5D, 0x9E9D, 0x969C, 0x969D, 0x967E,   // 0x0D10 (3344)
+0x965F, 0x963F, 0x965F, 0xA69F, 0x63FE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x755B, 0x7DDC, 0x7DFE, 0x8E1E, 0x965E,   // 0x0D30 (3376)
+0x8E7D, 0xA6FF, 0xAF3F, 0xAEBC, 0xB678, 0xC695, 0xBE71, 0xAE0C, 0x8507, 0x3B01, 0x3AC0, 0xAD85, 0xE688, 0xE626, 0xBC82, 0x8280,   // 0x0D40 (3392)
+0xD4A1, 0xED22, 0xECC1, 0xECC0, 0xFD01, 0xE3C0, 0xDB40, 0xE340, 0xD300, 0xF480, 0xECA0, 0xEC80, 0xFD01, 0xEC60, 0xE420, 0xF4C1,   // 0x0D50 (3408)
+0xECE1, 0xF542, 0xED22, 0xF523, 0xED23, 0xDCE2, 0xCD25, 0xCE2F, 0xBE56, 0xA63A, 0x9E7D, 0x9EBE, 0x96BE, 0x96BD, 0x96BD, 0x967E,   // 0x0D60 (3424)
+0x9E7F, 0x9E9F, 0xA6BF, 0xAE9D, 0x63DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x42DC, 0x7D5B, 0x7DBC, 0x7DDD, 0x861D, 0x963D,   // 0x0D80 (3456)
+0x9EBD, 0x9EDD, 0xA6DD, 0xAF1D, 0xAEDA, 0xAEB7, 0x9E93, 0x4CA7, 0x12C0, 0x12C0, 0x3B41, 0xC6A9, 0xCE6A, 0x6260, 0x40C0, 0x9B40,   // 0x0D90 (3472)
+0xE524, 0xDCE0, 0xF560, 0xFDA0, 0xF521, 0xD360, 0xD340, 0xE381, 0xCB00, 0xF4A0, 0xF500, 0xF4C0, 0xFD00, 0xEC80, 0xF4C0, 0xECA0,   // 0x0DA0 (3488)
+0xF543, 0xED44, 0xEDC6, 0xE565, 0xD4A3, 0xD503, 0xCD66, 0xC5CE, 0xBE17, 0xA65A, 0x9E7D, 0x96BE, 0x96BD, 0x96BE, 0x9EDE, 0xA6BF,   // 0x0DB0 (3504)
+0xA6BF, 0xA6BE, 0xAEDE, 0xB6BD, 0x6BFE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4B1D, 0x857C, 0x85BC, 0x7DBC, 0x85DC, 0x8E1C,   // 0x0DD0 (3536)
+0x965D, 0x8E7B, 0x8E7A, 0x96BB, 0xA71B, 0x8636, 0x3409, 0x0300, 0x0320, 0x1B80, 0x6D45, 0xB66B, 0x6BC2, 0x2920, 0x3900, 0xBC22,   // 0x0DE0 (3552)
+0xF585, 0xED41, 0xED40, 0xFE01, 0xFDA2, 0xCB80, 0xBAC0, 0xDB80, 0xCB20, 0xE440, 0xFD62, 0xF4E0, 0xFD21, 0xFCC0, 0xFCE0, 0xECE0,   // 0x0DF0 (3568)
+0xF564, 0xE586, 0xDDC8, 0xE60B, 0xD58A, 0xCD27, 0xC548, 0xBD8E, 0xBE16, 0xB69B, 0x9E7C, 0x8E5C, 0x969D, 0x9EDF, 0xA6DF, 0xAEFF,   // 0x0E00 (3584)
+0xAEDF, 0xA6BD, 0xB6FD, 0xBEFD, 0x741E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x535D, 0x8DDC, 0x8DFD, 0x85DD, 0x95FD, 0x95FD,   // 0x0E20 (3616)
+0x8DFC, 0x965C, 0x96BC, 0x9F1C, 0x8698, 0x344C, 0x02C3, 0x0320, 0x02C0, 0x23C2, 0x8609, 0x74C8, 0x0940, 0x1100, 0x49A0, 0xC464,   // 0x0E30 (3632)
+0xE4E3, 0xE520, 0xFE23, 0xFE43, 0xED63, 0xBB20, 0xC340, 0xCB60, 0xC300, 0xE420, 0xFCE1, 0xFD02, 0xFD62, 0xF4E0, 0xFD41, 0xF520,   // 0x0E40 (3648)
+0xE543, 0xD587, 0xD60C, 0xE672, 0xDE53, 0xCDCF, 0xC5AD, 0xBDAF, 0xBE34, 0xBEBA, 0xAEDD, 0x9E9D, 0x9EBE, 0xA6FF, 0xA6DF, 0xAEDF,   // 0x0E50 (3664)
+0xB6FF, 0xAEDD, 0xBF1D, 0xC71D, 0x741E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x63BE, 0x9E5E, 0x9E7E, 0x9E5E, 0xA65E, 0xA65E,   // 0x0E70 (3696)
+0xAEBF, 0xA69E, 0x9EDD, 0xAF9D, 0x6DF3, 0x0B45, 0x02A0, 0x02C0, 0x02C0, 0x12E0, 0x4424, 0x43A4, 0x0120, 0x00E0, 0x3180, 0xBC45,   // 0x0E80 (3712)
+0xDCC3, 0xE541, 0xF603, 0xD582, 0xBC60, 0xBBA0, 0xBB20, 0xBB00, 0xD3A0, 0xDC00, 0xFD43, 0xE4A0, 0xF563, 0xF501, 0xDC80, 0xFDC4,   // 0x0E90 (3728)
+0xE564, 0xC567, 0xD670, 0xCE76, 0xCE99, 0xD6B8, 0xCE95, 0xBE13, 0xBE54, 0xBEBA, 0xBEFE, 0xAF1F, 0xA6DE, 0xA6FE, 0xAEFE, 0xAEBE,   // 0x0EA0 (3744)
+0xBF1F, 0xB6BD, 0xA65A, 0xCF1E, 0x845E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xA6BE, 0xA6FF, 0xA6DF, 0xAEFF, 0xAEFF,   // 0x0EC0 (3776)
+0xAEDE, 0xAEFF, 0xB75F, 0x96B9, 0x3C4A, 0x02C0, 0x0B20, 0x1B42, 0x1301, 0x12A1, 0x3366, 0x64EE, 0x8DB2, 0x9DD3, 0x94CC, 0xBC87,   // 0x0ED0 (3792)
+0xBC01, 0xDD23, 0xDDC4, 0xA4C3, 0x7B20, 0xBBE0, 0xC380, 0xC340, 0xC380, 0xDC20, 0xF563, 0xE503, 0xDD03, 0xE4E3, 0xDCA3, 0xED85,   // 0x0EE0 (3808)
+0xE5C8, 0xCDCB, 0xC671, 0xBEB8, 0xC71D, 0xC6FC, 0xBE99, 0xBEB9, 0xBEFA, 0xB69B, 0xB6DE, 0xBF1F, 0xAEDD, 0xAEDD, 0xB71E, 0xB6FE,   // 0x0EF0 (3824)
+0xAE7D, 0x9DDA, 0x9DD9, 0xD71E, 0x8C9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BFE, 0xAEDE, 0xAF1F, 0xAEDF, 0xAF1E, 0xAF1E,   // 0x0F10 (3856)
+0xAF1E, 0xA6FE, 0xB75E, 0x85F5, 0x1B66, 0x02C0, 0x1321, 0x1B02, 0x43E7, 0x756F, 0x9676, 0xAEFA, 0xB71B, 0xBF3A, 0xCED5, 0xCDAE,   // 0x0F20 (3872)
+0xB465, 0xC504, 0xD608, 0xADA9, 0x8C23, 0xAC00, 0xBBC0, 0xC3A2, 0xCC04, 0xD484, 0xD4C4, 0xE5A8, 0xCD06, 0xCCE6, 0xCCE6, 0xE5A9,   // 0x0F30 (3888)
+0xE60B, 0xE730, 0xD775, 0xC73B, 0xAEBD, 0xAEDD, 0xBF1D, 0xB6FD, 0xAEFD, 0xBEFE, 0xBEDE, 0xB6DD, 0xB6FD, 0xAEFC, 0xB71E, 0xCF7F,   // 0x0F40 (3904)
+0x8D79, 0x6413, 0xBEBD, 0xD73E, 0x8C7E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x741E, 0xB6DD, 0xB73F, 0xB6FF, 0xAF1E, 0xAF3D,   // 0x0F60 (3936)
+0xAF3D, 0xAF3D, 0xB75C, 0x64F1, 0x12C6, 0x12C4, 0x2346, 0x652E, 0x9E96, 0xAF19, 0xB75C, 0xB73D, 0xB71D, 0xBF1C, 0xCEFA, 0xCE55,   // 0x0F70 (3952)
+0xBDAE, 0xB58A, 0xD6AD, 0xC62C, 0x9C85, 0x9BE1, 0xBC84, 0xABC5, 0xBC48, 0xBCC9, 0xCDAC, 0xD5EE, 0xE691, 0xD60F, 0xCDAD, 0xC5AC,   // 0x0F80 (3968)
+0x7BA3, 0x4AC3, 0x53A7, 0x9DF5, 0xC75D, 0xC73F, 0xB6FE, 0xAEFE, 0xAEDE, 0xB6DE, 0xBEDD, 0xB6DC, 0xB6FC, 0xC73E, 0xCF7F, 0x7D16,   // 0x0F90 (3984)
+0x32CE, 0x8D58, 0xD75F, 0xD71D, 0x7C1E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x637D, 0xBEDD, 0xBF1E, 0xAEDD, 0xAF1E, 0xAF3D,   // 0x0FB0 (4016)
+0xA71C, 0xB75C, 0xAF1A, 0x544F, 0x2B09, 0x5CAF, 0x8614, 0xAF39, 0xB75B, 0xBF3C, 0xBF1E, 0xB71E, 0xB6FE, 0xBEFE, 0xC71C, 0xC6DA,   // 0x0FC0 (4032)
+0xB675, 0x9DAD, 0xAE0C, 0xC68D, 0x94C5, 0x9463, 0xACE7, 0x93E7, 0xD5F1, 0xCE33, 0xD6B5, 0xD695, 0xE718, 0xD6D6, 0xC673, 0xB631,   // 0x0FD0 (4048)
+0x63C6, 0x0960, 0x00E0, 0x1923, 0x430B, 0xA67B, 0xCF7F, 0xB6FE, 0xB71E, 0xBF1D, 0xBEDC, 0xC71D, 0xD7BF, 0x9E39, 0x32AC, 0x19C9,   // 0x0FE0 (4064)
+0x74D5, 0xC71E, 0xCF1D, 0xD73D, 0x8CBF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B9D, 0xB67C, 0xBEFD, 0xB71D, 0xB73E, 0xAF1D,   // 0x1000 (4096)
+0xAF5D, 0xB75D, 0x8E37, 0x6D32, 0x85D5, 0xA6D9, 0xB73A, 0xB77B, 0xB75D, 0xB73D, 0xB73E, 0xB71E, 0xB71E, 0xBF1E, 0xBF3D, 0xBF3C,   // 0x1010 (4112)
+0xBF19, 0xA631, 0x74E9, 0xB6AD, 0x8D26, 0x7C83, 0x8485, 0x94EB, 0xD6F7, 0xCEFA, 0xC6FA, 0xC6FB, 0xC6FC, 0xC71A, 0xCF3A, 0xB6B6,   // 0x1020 (4128)
+0x850D, 0x5C28, 0x1A02, 0x00A0, 0x0060, 0x21C6, 0x8D96, 0xCF7E, 0xC75E, 0xC75E, 0xD7BF, 0xBEFC, 0x6CB3, 0x1967, 0x08E5, 0x6C73,   // 0x1030 (4144)
+0xC71E, 0xCF5F, 0xCF1D, 0xD71D, 0x847E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1C, 0xB65C, 0xC73E, 0xBF5F, 0xAEFD, 0xB71E,   // 0x1050 (4176)
+0xB73E, 0xB73D, 0x9E99, 0x9E58, 0xB71B, 0xBF5C, 0xB75C, 0xB73C, 0xB71D, 0xB73E, 0xBF3F, 0xB73E, 0xB71E, 0xB73E, 0xB73D, 0xBF3D,   // 0x1060 (4192)
+0xBF5B, 0xAED5, 0x7D4B, 0x8DEA, 0x7D46, 0x64A3, 0x4B82, 0x958F, 0xBF19, 0xBF3C, 0xB6FD, 0xB71F, 0xB6DE, 0xB6FD, 0xC77D, 0xB6F9,   // 0x1070 (4208)
+0xA654, 0x74CD, 0x644A, 0x3B26, 0x11A2, 0x0101, 0x19E5, 0x6C8F, 0x95D6, 0x8514, 0x6431, 0x328A, 0x0882, 0x0083, 0x6432, 0xC75E,   // 0x1080 (4224)
+0xC75E, 0xC6DD, 0xD73E, 0xC6BD, 0x635D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x31BA, 0xAE1C, 0xCF5D, 0xC73E, 0xB6FD, 0xBF3E,   // 0x10A0 (4256)
+0xBF7E, 0xBF3D, 0xB71C, 0xB71C, 0xBF5D, 0xB73D, 0xB71C, 0xB73D, 0xBF5E, 0xBF3F, 0xBF1F, 0xBF1E, 0xBF1E, 0xBF3E, 0xB73E, 0xBF1E,   // 0x10B0 (4272)
+0xBF3C, 0xBF59, 0x8E30, 0x6D47, 0x7DC8, 0x5CA4, 0x22A0, 0x9E33, 0xBF5A, 0xB75C, 0xB75E, 0xB75F, 0xB73F, 0xB73E, 0xBF3D, 0xBF3B,   // 0x10C0 (4288)
+0xBF39, 0x8DD1, 0x7D4E, 0x5C4A, 0x4346, 0x3B27, 0x2243, 0x2A85, 0x2A85, 0x11C5, 0x0924, 0x0020, 0x0062, 0x53B0, 0xBF1D, 0xCF5F,   // 0x10D0 (4304)
+0xC73E, 0xCF1E, 0xD75D, 0xBE7C, 0x427D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085B, 0x951D, 0xCF3E, 0xC73E, 0xCF7F, 0xBF5E,   // 0x10F0 (4336)
+0xBF3E, 0xBF5E, 0xBF5E, 0xC77E, 0xBF5E, 0xBF7E, 0xBF5E, 0xB73E, 0xBF3E, 0xBF1F, 0xBF1F, 0xBF1E, 0xC73F, 0xC73F, 0xBF3F, 0xC73F,   // 0x1100 (4352)
+0xBF5E, 0xBF7B, 0xA6B3, 0x6D48, 0x8E4A, 0x5465, 0x2AE3, 0xBF39, 0xC75C, 0xB75C, 0xBF9D, 0xBF5E, 0xBF5E, 0xBF5F, 0xBF5E, 0xC77E,   // 0x1110 (4368)
+0xC77C, 0xBF5A, 0x9E13, 0x648C, 0x53E9, 0x4366, 0x3305, 0x1201, 0x0100, 0x00A0, 0x0041, 0x19A7, 0x74B3, 0xBEFC, 0xD79F, 0xCF5E,   // 0x1120 (4384)
+0xCF5E, 0xD75E, 0xDF9E, 0xAD9E, 0x10BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x6BBC, 0xCF1D, 0xD77F, 0xCF7F, 0xC75E,   // 0x1140 (4416)
+0xC75F, 0xC75F, 0xC77F, 0xC75E, 0xC73E, 0xC77F, 0xC79F, 0xC77F, 0xC75F, 0xCF3F, 0xCF3F, 0xC73E, 0xCF3F, 0xCF5F, 0xCF5F, 0xCF5F,   // 0x1150 (4432)
+0xC75E, 0xC77C, 0xBF57, 0x85CB, 0x8DEA, 0x4BE5, 0x53E8, 0xCF9C, 0xC75D, 0xC77D, 0xC77D, 0xC75D, 0xBF3D, 0xC73F, 0xC73F, 0xC73F,   // 0x1160 (4448)
+0xC73E, 0xCF9E, 0xBF1B, 0xAEB8, 0x9E75, 0x8DB2, 0x8DB2, 0x8592, 0x7D11, 0x7D12, 0x7CF3, 0x95D7, 0xCF5D, 0xD7DF, 0xCF3D, 0xCF5E,   // 0x1170 (4464)
+0xD77E, 0xDF9E, 0xE7BE, 0x847E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FB, 0xB5FD, 0xE7BF, 0xD79F, 0xCF9F,   // 0x1190 (4496)
+0xD77F, 0xCF7F, 0xCF7F, 0xCF7F, 0xCF7F, 0xCF9F, 0xCF9F, 0xCF7F, 0xCF7F, 0xCF7F, 0xD77F, 0xD77F, 0xCF7F, 0xD77F, 0xD77F, 0xCF7F,   // 0x11A0 (4512)
+0xCF5E, 0xD79E, 0xCF99, 0x9E4E, 0x8DCB, 0x3B23, 0x5C2B, 0xD7BD, 0xCF5E, 0xCF9E, 0xCF5D, 0xCF7E, 0xC73D, 0xC73E, 0xC73F, 0xC71F,   // 0x11B0 (4528)
+0xCF5F, 0xCF7F, 0xCF7F, 0xD7DF, 0xCFDD, 0xCFDD, 0xCFDD, 0xCFDD, 0xCFDE, 0xD7FF, 0xDFFF, 0xD77E, 0xC73D, 0xCF5D, 0xD77F, 0xD77E,   // 0x11C0 (4544)
+0xDF7E, 0xF7FF, 0xBE5E, 0x215D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x4A9C, 0xBE5E, 0xE7DF, 0xDFBF,   // 0x11E0 (4576)
+0xDFBF, 0xDFBF, 0xD79F, 0xD79F, 0xDFBF, 0xDFBF, 0xD79F, 0xD7BF, 0xD7BF, 0xD7BF, 0xD7BF, 0xD79F, 0xD79F, 0xD79F, 0xCF7F, 0xCF7F,   // 0x11F0 (4592)
+0xCF7F, 0xD7BE, 0xD7BA, 0xB6D1, 0x95ED, 0x3B04, 0x5BEB, 0xDFBE, 0xD79F, 0xD7BF, 0xCF9E, 0xCFBE, 0xCF9E, 0xCF9E, 0xCF9E, 0xCF7E,   // 0x1200 (4608)
+0xCF9F, 0xCF9F, 0xCF9F, 0xCF9E, 0xCFBD, 0xD7DE, 0xCFDE, 0xCFBE, 0xD7BF, 0xD7BE, 0xCF7D, 0xD77E, 0xCF5D, 0xDF9E, 0xE7DF, 0xE7BF,   // 0x1210 (4624)
+0xEFFF, 0xD71E, 0x52DD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x425B, 0xB61D, 0xEFDF,   // 0x1230 (4656)
+0xEFFF, 0xE7BF, 0xE7BF, 0xDFBF, 0xDFBF, 0xDFBF, 0xDFBF, 0xDFDF, 0xDFFF, 0xDFDE, 0xD7BF, 0xD7BF, 0xD7DF, 0xD7DF, 0xD7BF, 0xD7BF,   // 0x1240 (4672)
+0xD7BE, 0xCF7D, 0xCFBA, 0xB6F3, 0x8DCE, 0x4347, 0x53CC, 0xD79D, 0xD7BE, 0xD7BF, 0xCFDF, 0xD7DF, 0xD7FE, 0xD7FD, 0xD7DD, 0xD7DE,   // 0x1250 (4688)
+0xD7BE, 0xD7DF, 0xD7DF, 0xD7DE, 0xD7DE, 0xD7DD, 0xD7DE, 0xD7DF, 0xDFDF, 0xDFDF, 0xDFBE, 0xDFBE, 0xDF9E, 0xE7BF, 0xF7FF, 0xFFFF,   // 0x1260 (4704)
+0xC69E, 0x4A9D, 0x005E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x31BD, 0x849C,   // 0x1280 (4736)
+0xC69D, 0xE7BE, 0xEFFE, 0xDF9E, 0xDF9E, 0xE7BE, 0xEFFF, 0xE7DF, 0xE7FE, 0xE7FD, 0xDFDE, 0xDFBF, 0xDFDF, 0xDFDF, 0xDFDF, 0xDFDE,   // 0x1290 (4752)
+0xDFDE, 0xCF7B, 0xCF79, 0xBF35, 0x8DCE, 0x3B25, 0x644B, 0xD79C, 0xD77D, 0xD79F, 0xDFDF, 0xDFFF, 0xE7FF, 0xE7FE, 0xE7FD, 0xE7FE,   // 0x12A0 (4768)
+0xE7FF, 0xE7FF, 0xE7FF, 0xE7FF, 0xE7FE, 0xE7FE, 0xE7FF, 0xE7DF, 0xE7DF, 0xE7DF, 0xEFFF, 0xF7FF, 0xF7FF, 0xF7FF, 0xE7BE, 0xA55E,   // 0x12B0 (4784)
+0x39FE, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x089D,   // 0x12D0 (4816)
+0x4A5C, 0x7C3B, 0xADDA, 0xD71D, 0xE79E, 0xEFDF, 0xF7FF, 0xEFFE, 0xEFFE, 0xEFFD, 0xEFFE, 0xEFDF, 0xEFFF, 0xE7DF, 0xE7BF, 0xE7BE,   // 0x12E0 (4832)
+0xDFDD, 0xDFBD, 0xCF3B, 0xC718, 0x7473, 0x1990, 0x4B12, 0xD79C, 0xCF3D, 0xDF7F, 0xE7BF, 0xEFFF, 0xEFFF, 0xEFDE, 0xEFDE, 0xEFDF,   // 0x12F0 (4848)
+0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7FF, 0xF7DE, 0xF7DF, 0xF7FF, 0xF7FF, 0xEFDF, 0xF7FF, 0xE77E, 0xC67D, 0xA55D, 0x633D, 0x10BE,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001E, 0x005C, 0x299C, 0x5B1E, 0x6B9F, 0x6B9F, 0x6BBF, 0x6B9F, 0x73DF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6BBF, 0x6B9F, 0x6B9F, 0x637F,   // 0x1330 (4912)
+0x6B9F, 0x6BBF, 0x5B1E, 0x531D, 0x215C, 0x001F, 0x109D, 0x5B3E, 0x5B3E, 0x635F, 0x6B7F, 0x6B9F, 0x6B9F, 0x6B7F, 0x637E, 0x6B7F,   // 0x1340 (4928)
+0x6B7F, 0x73BF, 0x73BF, 0x73BF, 0x73BF, 0x6B9F, 0x6B9F, 0x6B9F, 0x73BF, 0x739F, 0x73BF, 0x52DE, 0x31DD, 0x10BD, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1460 (5216)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1470 (5232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14B0 (5296)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14C0 (5312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4A5F, 0x107F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x20FF, 0x4A5F, 0x4A7F, 0x52BF, 0x52BF, 0x421F, 0x001F, 0x001F, 0x001F,   // 0x1510 (5392)
+0x001F, 0x001F, 0x001F, 0x003F, 0x4A7F, 0x423F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0x319F,   // 0x1520 (5408)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1530 (5424)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1550 (5456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B9F, 0xFFFF, 0xFFFF, 0xD69F, 0xD6BF, 0x9CDF, 0x001F, 0x001F, 0x001F,   // 0x1560 (5472)
+0x001F, 0x001F, 0x001F, 0x18DF, 0xFFFF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xF7DF, 0x317F,   // 0x1570 (5488)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1580 (5504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0x9CDF, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x41FF,   // 0x15B0 (5552)
+0x4A3F, 0x319F, 0x001F, 0x18BF, 0xFFFF, 0xF79F, 0x423F, 0x001F, 0x001F, 0x39FF, 0x423F, 0x39FF, 0x001F, 0x001F, 0xB5BF, 0x213F,   // 0x15C0 (5568)
+0x001F, 0x319F, 0x423F, 0x4A5F, 0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15D0 (5584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15F0 (5616)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xBDDF, 0x39FF, 0x39FF, 0x295F, 0x003F, 0x633F, 0xFFFF,   // 0x1600 (5632)
+0xE73F, 0xF7DF, 0x297F, 0x109F, 0xFFFF, 0xFFFF, 0xDEFF, 0x001F, 0x31BF, 0xFFFF, 0xE71F, 0xFFFF, 0x4A5F, 0x003F, 0x001F, 0x001F,   // 0x1610 (5648)
+0x295F, 0xEF5F, 0xEF7F, 0xE71F, 0x421F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1620 (5664)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1640 (5696)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xFFBF, 0xE75F, 0xEF3F, 0x9D1F, 0x295F, 0xFFFF, 0xC61F,   // 0x1650 (5712)
+0x001F, 0xFFFF, 0xF79F, 0x003F, 0xFFFF, 0xF79F, 0x001F, 0x003F, 0xFFFF, 0xFFFF, 0x001F, 0xE75F, 0xFFFF, 0x211F, 0x001F, 0x001F,   // 0x1660 (5728)
+0xE75F, 0xFFFF, 0x4A7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1670 (5744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1690 (5776)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xA4FF, 0x001F, 0x001F, 0x001F, 0x421F, 0xFFFF, 0xCE5F,   // 0x16A0 (5792)
+0x109F, 0xFFFF, 0xDEFF, 0x083F, 0xFFFF, 0xF79F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0xEF7F, 0xFFFF, 0x18FF, 0x001F, 0x001F,   // 0x16B0 (5808)
+0xAD7F, 0xF7DF, 0xFFFF, 0x6B5F, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16C0 (5824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16E0 (5856)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x633F, 0xFFFF, 0xA55F, 0x001F, 0x001F, 0x001F, 0x41FF, 0xFFFF, 0xCE5F,   // 0x16F0 (5872)
+0x087F, 0xFFFF, 0xE71F, 0x003F, 0xFFFF, 0xF79F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0x001F, 0xEF7F, 0xFFFF, 0x211F, 0x001F, 0x001F,   // 0x1700 (5888)
+0x001F, 0xA53F, 0xF7BF, 0xFFFF, 0x529F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1710 (5904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6B3F, 0xFFFF, 0xAD5F, 0x001F, 0x001F, 0x001F, 0x39BF, 0xE75F, 0xD6BF,   // 0x1740 (5952)
+0x319F, 0xFFFF, 0xC61F, 0x003F, 0xE71F, 0xFFBF, 0x211F, 0x001F, 0xDEFF, 0xFFFF, 0x211F, 0xF79F, 0xE73F, 0x18DF, 0x001F, 0x001F,   // 0x1750 (5968)
+0x18DF, 0x109F, 0xC65F, 0xEF5F, 0x421F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1F, 0xEF3F, 0x94BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x211F, 0xEF5F,   // 0x1790 (6032)
+0xF7BF, 0xC63F, 0x001F, 0x001F, 0x001F, 0xE75F, 0xF79F, 0x001F, 0x001F, 0xE71F, 0xF7BF, 0xEF5F, 0x003F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0xCE5F, 0xFFDF, 0xEF7F, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_719/instellingen.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: instellingen.jpg
+// Time generated: 12.04.2014 22:15:03
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short instellingen[0x1900] ={
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x0010 (16)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0020 (32)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0030 (48)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010,   // 0x0040 (64)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0050 (80)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0060 (96)
+0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0070 (112)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0080 (128)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011,   // 0x0090 (144)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00A0 (160)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00B0 (176)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0011,   // 0x00C0 (192)
+0x0012, 0x0012, 0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012,   // 0x00D0 (208)
+0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00E0 (224)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x00F0 (240)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0100 (256)
+0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0812, 0x0812, 0x0812, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012,   // 0x0110 (272)
+0x0012, 0x0812, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012,   // 0x0120 (288)
+0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0012, 0x0011, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x0130 (304)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0140 (320)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0150 (336)
+0x0011, 0x0012, 0x0812, 0x0012, 0x0012, 0x0812, 0x0813, 0x0812, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813,   // 0x0160 (352)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813,   // 0x0170 (368)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0812, 0x0812, 0x0812, 0x0812, 0x0012, 0x0012, 0x0011, 0x0811, 0x0011, 0x0011, 0x0011,   // 0x0180 (384)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0190 (400)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x01A0 (416)
+0x0012, 0x294F, 0x3991, 0x62D4, 0x7BB6, 0x8417, 0x9CB9, 0xA53A, 0xB57A, 0xBDDB, 0xC61C, 0xCE3C, 0xCE5C, 0xD67C, 0xD69D, 0xCE7C,   // 0x01B0 (432)
+0xCE5C, 0xCE3C, 0xCE5C, 0xCE7C, 0xCE5C, 0xCE3C, 0xCE5C, 0xCE5C, 0xCE3C, 0xCE3C, 0xCE3C, 0xCE5C, 0xCE5C, 0xCE3C, 0xCE5C, 0xCE7C,   // 0x01C0 (448)
+0xCE7C, 0xCE5C, 0xCE3C, 0xCE5C, 0xC61C, 0xBDBB, 0xB57A, 0xAD3A, 0x9478, 0x83F7, 0x6315, 0x5AB4, 0x39B1, 0x18EA, 0x0011, 0x0012,   // 0x01D0 (464)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x01E0 (480)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012,   // 0x01F0 (496)
+0x0812, 0x5293, 0x7BB6, 0x9CF9, 0xAD7B, 0xC61B, 0xCE5C, 0xD67C, 0xDEBD, 0xDEFD, 0xE73E, 0xEF5E, 0xEF5E, 0xEF5E, 0xEF7E, 0xF79F,   // 0x0200 (512)
+0xF79F, 0xEF9E, 0xF7BF, 0xFFDF, 0xF7BF, 0xF79E, 0xF79F, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7BF, 0xF7DF,   // 0x0210 (528)
+0xF79F, 0xF79F, 0xF79F, 0xF79F, 0xEF7E, 0xE73E, 0xE71E, 0xE71E, 0xD69D, 0xB5BB, 0xA4F9, 0x9478, 0x62F5, 0x3191, 0x0811, 0x0011,   // 0x0220 (544)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0230 (560)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012,   // 0x0240 (576)
+0x6B35, 0x9CB9, 0x6B56, 0x39B0, 0x294B, 0x292A, 0x2129, 0x292A, 0x292A, 0x292A, 0x294A, 0x294A, 0x292A, 0x292A, 0x292A, 0x292A,   // 0x0250 (592)
+0x292A, 0x292A, 0x294B, 0x294A, 0x292A, 0x292A, 0x294A, 0x294A, 0x294A, 0x292A, 0x292A, 0x294A, 0x292A, 0x292A, 0x292A, 0x294A,   // 0x0260 (608)
+0x292A, 0x292A, 0x294A, 0x294B, 0x292A, 0x292A, 0x292A, 0x2109, 0x20C8, 0x20E9, 0x18E8, 0x18E9, 0x292C, 0x39B1, 0x4A33, 0x210D,   // 0x0270 (624)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0280 (640)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0811, 0x0012, 0x0812, 0x83F7,   // 0x0290 (656)
+0x7396, 0x316D, 0x294B, 0x316C, 0x41F1, 0x4A33, 0x4A33, 0x4A32, 0x5A95, 0x5253, 0x5274, 0x4A53, 0x5274, 0x4A53, 0x4A53, 0x4A33,   // 0x02A0 (672)
+0x5275, 0x5275, 0x4A33, 0x4A32, 0x4A33, 0x5253, 0x5253, 0x4A33, 0x5254, 0x5254, 0x5253, 0x4A32, 0x5254, 0x5254, 0x4A33, 0x4A33,   // 0x02B0 (688)
+0x5254, 0x5295, 0x4A53, 0x4A33, 0x5254, 0x5274, 0x4A33, 0x4A33, 0x4A33, 0x4A33, 0x39B0, 0x398F, 0x292B, 0x18E8, 0x18E9, 0x3150,   // 0x02C0 (704)
+0x2950, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x02D0 (720)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0012, 0x0812, 0x9478, 0x5294,   // 0x02E0 (736)
+0x294C, 0x316D, 0x39B0, 0x62F6, 0x7BB7, 0x83D7, 0x7BD7, 0x83F7, 0x8C38, 0x9498, 0x7BD7, 0x83D8, 0x8C38, 0x8C78, 0x83F8, 0x83F8,   // 0x02F0 (752)
+0x8C38, 0x8C38, 0x7BB7, 0x7BD7, 0x8C78, 0x9479, 0x83D8, 0x83F7, 0x9498, 0x8C58, 0x83D8, 0x7BD7, 0x8418, 0x9479, 0x8C38, 0x83F8,   // 0x0300 (768)
+0x8C58, 0x8C38, 0x7BB7, 0x7BB7, 0x8C58, 0x9499, 0x83D7, 0x7377, 0x9478, 0x8C18, 0x7376, 0x5AD4, 0x5AD4, 0x39B1, 0x2109, 0x10A6,   // 0x0310 (784)
+0x210C, 0x292F, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0320 (800)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0812, 0x62F5, 0x9438, 0x294C,   // 0x0330 (816)
+0x39AF, 0x5AB5, 0x83F7, 0x9498, 0x9CB9, 0x9CDA, 0xA51A, 0xAD5A, 0x9CD9, 0x9CB9, 0x9CD9, 0x9CD9, 0xA4F9, 0xA51A, 0x9CB9, 0xA4F9,   // 0x0340 (832)
+0x9CB9, 0xA4F9, 0xAD5A, 0xA4FA, 0x9CD9, 0x9CD9, 0xA4F9, 0xA4FA, 0x9CD9, 0x9CD9, 0xA4F9, 0xA51A, 0x9CD9, 0xA4FA, 0xA4F9, 0x9CB9,   // 0x0350 (848)
+0x9CD9, 0xA4F9, 0xAD5A, 0xA51A, 0x9CD9, 0x9CB9, 0xA51A, 0xA4F9, 0x9CB9, 0x9CD9, 0x9CD9, 0x9479, 0x83F8, 0x7396, 0x5274, 0x296E,   // 0x0360 (864)
+0x18E9, 0x39D2, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0370 (880)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x5AD4, 0x8417, 0x6B15, 0x398F,   // 0x0380 (896)
+0x4A13, 0x7356, 0x9498, 0x9CD9, 0x8C18, 0x9CD9, 0x9CB9, 0x9CD9, 0x9479, 0x9CB9, 0xA51A, 0xA51A, 0x8C39, 0x8C58, 0xA4FA, 0xA53A,   // 0x0390 (912)
+0x8C38, 0x9479, 0x9CB9, 0xA51A, 0x9499, 0x9478, 0x9CDA, 0x9CB9, 0x9478, 0x9479, 0x9CD9, 0x9CD9, 0x9479, 0x8C38, 0xA4F9, 0xA51A,   // 0x03A0 (928)
+0x9479, 0x8418, 0x9CB9, 0xA4FA, 0x9CB9, 0x8418, 0x9CDA, 0xA4F9, 0x9499, 0x8C38, 0x9CB9, 0x9499, 0x9478, 0x6B56, 0x6B56, 0x4A33,   // 0x03B0 (944)
+0x292C, 0x296F, 0x3191, 0x0812, 0x0012, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x03C0 (960)
+0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x7B97, 0xA519, 0x4A13, 0x41F1,   // 0x03D0 (976)
+0x7BB7, 0x9499, 0x9498, 0x9CB9, 0xA51A, 0x9478, 0xA4FA, 0x9CD9, 0x9CB9, 0x9CDA, 0x9CD9, 0x9CB9, 0x9CB9, 0x9CD9, 0x9CB9, 0x9499,   // 0x03E0 (992)
+0x9CD9, 0x9CD9, 0x9CD9, 0x9CB9, 0x9C99, 0x9CB9, 0x9CF9, 0x9CD9, 0xA4F9, 0x9CB9, 0x9499, 0x9499, 0xA4FA, 0x9CB9, 0x9479, 0x9CD9,   // 0x03F0 (1008)
+0x9CD9, 0xA4FA, 0x9CD9, 0x9CD9, 0x9499, 0x9CD9, 0x9CB9, 0x9CD9, 0x9499, 0x9CB9, 0x9CD9, 0x9CD9, 0x9498, 0x94B8, 0x8417, 0x7356,   // 0x0400 (1024)
+0x39B0, 0x292C, 0x5AB4, 0x292F, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0410 (1040)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x83D7, 0xBDBB, 0x39CF, 0x4A33,   // 0x0420 (1056)
+0x7BB7, 0x9458, 0x7B97, 0x83F8, 0x9CF9, 0x9CB9, 0x7BB7, 0x8C38, 0x9479, 0x9479, 0x7BB7, 0x8C38, 0x9CD9, 0x9CB9, 0x83D8, 0x8C18,   // 0x0430 (1072)
+0x9CD9, 0x9499, 0x83F8, 0x8C38, 0x9479, 0x9499, 0x8418, 0x83F8, 0x9479, 0x9499, 0x83F8, 0x7BB7, 0x9499, 0x9499, 0x83F8, 0x83F8,   // 0x0440 (1088)
+0x9479, 0x9458, 0x83D7, 0x7BB7, 0x9499, 0x9C99, 0x8C18, 0x7BB7, 0x9CD9, 0x9479, 0x83F8, 0x7397, 0x9478, 0x9499, 0x83F7, 0x62B5,   // 0x0450 (1104)
+0x4A13, 0x316E, 0x7376, 0x41D2, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0460 (1120)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x8C58, 0xCE5C, 0x4A12, 0x5274,   // 0x0470 (1136)
+0x8C58, 0x83F8, 0x9CB9, 0x9479, 0x8C38, 0x8C38, 0x9CB9, 0x9478, 0x9458, 0x9479, 0x9CB9, 0x9458, 0x8C38, 0x9459, 0x9479, 0x9478,   // 0x0480 (1152)
+0x8C58, 0x8C58, 0x8C59, 0x8418, 0x9499, 0x9CD9, 0x8C38, 0x8C58, 0x9479, 0x8C58, 0x9479, 0x9C99, 0x8C38, 0x9458, 0x9499, 0x9479,   // 0x0490 (1168)
+0x9458, 0x8C39, 0x9499, 0x9458, 0x8C58, 0x8C38, 0x9499, 0x9459, 0x8C18, 0x9479, 0x9499, 0x9479, 0x8C58, 0x8C18, 0x8C18, 0x7BF7,   // 0x04A0 (1184)
+0x5254, 0x31B0, 0x9478, 0x5273, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x04B0 (1200)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0xAD3A, 0xCE7D, 0x4A33, 0x62D5,   // 0x04C0 (1216)
+0x6315, 0x7BD7, 0x9478, 0x8C18, 0x7376, 0x7BD7, 0x8C38, 0x9458, 0x6B56, 0x7BB7, 0x8C38, 0x8C38, 0x7357, 0x83F8, 0x8C38, 0x7BD7,   // 0x04D0 (1232)
+0x7356, 0x7BB7, 0x8C38, 0x8417, 0xB5BB, 0xC63C, 0x9CB9, 0x8C38, 0x7377, 0x6B16, 0xB59B, 0xE71E, 0x9479, 0x6B36, 0x8418, 0x8C58,   // 0x04E0 (1248)
+0x7B97, 0x6B36, 0x8C38, 0x9479, 0x7BB7, 0x6B56, 0x8C38, 0x8C59, 0x83F8, 0x6B36, 0x8418, 0x8C38, 0x8418, 0x6B16, 0x83D7, 0x83F8,   // 0x04F0 (1264)
+0x5A94, 0x398F, 0xA559, 0x6B55, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0500 (1280)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0xAD3A, 0xDEFD, 0x4A33, 0x5A95,   // 0x0510 (1296)
+0x83D7, 0x8C58, 0x83F8, 0x8418, 0x8C58, 0x8C18, 0x83F8, 0x7BB7, 0x8418, 0x83F8, 0x7BD7, 0x8418, 0x83F8, 0x7BB7, 0xA51A, 0xC63C,   // 0x0520 (1312)
+0x9479, 0x7BB7, 0x8418, 0x7377, 0xC61C, 0xFFDF, 0xAD5A, 0x7377, 0x7BD7, 0x8C18, 0xD67C, 0xFFFF, 0xB59B, 0x7BB7, 0x83D7, 0x7BB7,   // 0x0530 (1328)
+0x8C38, 0xA4DA, 0x9C99, 0x83D7, 0x8C38, 0x8418, 0x8C38, 0x83F8, 0x83F8, 0x83F7, 0x7BD8, 0x83F7, 0x83F7, 0x8C38, 0x83F8, 0x7BD7,   // 0x0540 (1344)
+0x5274, 0x4A33, 0xB59B, 0x7BB7, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0550 (1360)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xBDBA, 0xDEFD, 0x39F0, 0x5295,   // 0x0560 (1376)
+0x7397, 0x7B97, 0x62D6, 0x7377, 0x7BD7, 0x7BB7, 0x62F6, 0x7397, 0x83F8, 0x83F8, 0x62D5, 0x6B36, 0x83F8, 0x6B36, 0xA4FA, 0xF7BF,   // 0x0570 (1392)
+0xCE3C, 0x7BB7, 0x5A95, 0x6316, 0xD67C, 0xFFFF, 0xBDDB, 0x7376, 0x6B16, 0xAD1A, 0xFFBF, 0xFFFF, 0xBDBB, 0x6B36, 0x6316, 0x5A75,   // 0x0580 (1408)
+0xB59B, 0xF7BF, 0x9CD9, 0x5A95, 0x83F7, 0x7BB7, 0x7356, 0x5A95, 0x83D7, 0x8418, 0x7357, 0x62D5, 0x83F8, 0x83D7, 0x6B16, 0x5A95,   // 0x0590 (1424)
+0x5AB5, 0x4A33, 0xC61C, 0x8C58, 0x0012, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x05A0 (1440)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0012, 0x0813, 0xC61C, 0xF7BF, 0x4A33, 0x5275,   // 0x05B0 (1456)
+0x7BB7, 0x7B97, 0x7377, 0x7B97, 0x7BB7, 0x7B97, 0x7377, 0x7B97, 0x7356, 0x7357, 0x7377, 0x7357, 0x7397, 0x6B36, 0x9CDA, 0xEF5E,   // 0x05C0 (1472)
+0xFFDF, 0xAD3A, 0x62F6, 0x7397, 0xD69D, 0xFFFF, 0xEF5E, 0x8418, 0x62F6, 0xC61C, 0xFFFF, 0xFFFF, 0xC61C, 0x62F5, 0x62F5, 0x9CD9,   // 0x05D0 (1488)
+0xF7BF, 0xEF5E, 0xA4FA, 0x6B37, 0x7377, 0x7B97, 0x7356, 0x7356, 0x7357, 0x7376, 0x7377, 0x7BB7, 0x6B36, 0x7397, 0x7B97, 0x7377,   // 0x05E0 (1504)
+0x5274, 0x41F1, 0xD69C, 0x9CD9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x05F0 (1520)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xBDDB, 0xE73E, 0x4A32, 0x5AB5,   // 0x0600 (1536)
+0x5274, 0x62D6, 0x7BB7, 0x7BB7, 0x5274, 0x6B16, 0x7376, 0x7377, 0x5274, 0xBDFB, 0xD6BC, 0x7377, 0x4A52, 0x5A95, 0x9479, 0xE71E,   // 0x0610 (1552)
+0xFFFF, 0xEF7F, 0x8C58, 0x83F8, 0xDEDD, 0xFFFF, 0xFFFF, 0xB5BB, 0xAD7A, 0xFFDF, 0xFFFF, 0xFFFF, 0xCE3C, 0x5274, 0x83D8, 0xF7BF,   // 0x0620 (1568)
+0xFFFF, 0xEF5E, 0x9498, 0x6B16, 0x5AB6, 0x5253, 0x8C18, 0xAD5A, 0x62D6, 0x5273, 0x7376, 0x7357, 0x6B36, 0x5274, 0x7397, 0x6B36,   // 0x0630 (1584)
+0x5253, 0x41D0, 0xD69C, 0xA4F9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0640 (1600)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0x0813, 0xD69D, 0xF7BF, 0x4211, 0x4A52,   // 0x0650 (1616)
+0x6B16, 0x62F6, 0x6B56, 0x6B56, 0x62F5, 0x6B16, 0x7357, 0x6B16, 0x5A95, 0xCE5C, 0xFFDF, 0xDEFD, 0x7B97, 0x5253, 0x9458, 0xEF5E,   // 0x0660 (1632)
+0xF7BF, 0xFFFF, 0xDEFE, 0xDEBD, 0xFFFF, 0xF79F, 0xF79F, 0xF79F, 0xF79F, 0xFFDF, 0xFFBF, 0xFFDF, 0xEF5E, 0xCE5C, 0xDEDD, 0xFFDF,   // 0x0670 (1648)
+0xFFFF, 0xD69D, 0x83D7, 0x5AB5, 0x62D5, 0x9CB9, 0xEF7E, 0xD67C, 0x5274, 0x6B36, 0x6B16, 0x6B36, 0x62F6, 0x6B57, 0x62F6, 0x6B16,   // 0x0680 (1664)
+0x4A33, 0x4211, 0xD69D, 0xA519, 0x0813, 0x0813, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0690 (1680)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0x0813, 0xD69D, 0xEF5F, 0x41CF, 0x4A31,   // 0x06A0 (1696)
+0x6B36, 0x62F5, 0x4A32, 0x5A95, 0x7356, 0x62F6, 0x4A31, 0x5294, 0x5AB5, 0x9CB9, 0xEF7E, 0xFFFF, 0xE73D, 0x9479, 0x83F8, 0xDEFD,   // 0x06B0 (1712)
+0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xEF7E, 0xF79F, 0xF7BF, 0xFFFF, 0xFFDF, 0xF7BF, 0xFFFF, 0xFFFF, 0xEF7E, 0xF7BF, 0xFFFF, 0xF7BF,   // 0x06C0 (1728)
+0xFFFF, 0xDEDD, 0x62D6, 0x5253, 0xBDBB, 0xF7BF, 0xF79F, 0xAD5A, 0x5274, 0x6B57, 0x5A95, 0x4A31, 0x62F5, 0x6B36, 0x5A95, 0x4A11,   // 0x06D0 (1744)
+0x5253, 0x5253, 0xD69D, 0xA4F9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x06E0 (1760)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0812, 0x0813, 0xCE7C, 0xF79E, 0x4A32, 0x4A31,   // 0x06F0 (1776)
+0x5A95, 0x5AB6, 0x5AD5, 0x5A95, 0x5AB5, 0x5273, 0x5A94, 0x5274, 0x5274, 0x7376, 0xDEBD, 0xFFFF, 0xF7BF, 0xE71E, 0xDEFE, 0xF79F,   // 0x0700 (1792)
+0xF79E, 0xF7BF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xEF7E, 0xF7BF,   // 0x0710 (1808)
+0xFFDF, 0xEF5E, 0xBDFC, 0xCE7C, 0xFFBF, 0xFFFF, 0xE71E, 0x7BB7, 0x5273, 0x5274, 0x5AB6, 0x5A94, 0x5274, 0x62D5, 0x62F6, 0x5274,   // 0x0720 (1824)
+0x4A32, 0x4211, 0xD69D, 0x9CF9, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0730 (1840)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xDEDD, 0xF7BF, 0x4A11, 0x4A11,   // 0x0740 (1856)
+0x41F0, 0x5252, 0x5AB5, 0x5253, 0x9CD9, 0xBDFB, 0x9499, 0x5A94, 0x39CE, 0x41EF, 0xC61C, 0xF79F, 0xF77E, 0xFFDF, 0xF79F, 0xF79F,   // 0x0750 (1872)
+0xFFFF, 0xF7BF, 0xE71D, 0xC61C, 0x9C99, 0x8418, 0x83F8, 0x7397, 0x62D6, 0x6B36, 0x9479, 0xAD3A, 0xDEDD, 0xF79F, 0xF79F, 0xFFFF,   // 0x0760 (1888)
+0xF7BF, 0xEF7E, 0xF7BF, 0xF79F, 0xF79F, 0xFFFF, 0xC5FC, 0x5253, 0x4A32, 0x39CE, 0x5273, 0x6B36, 0x5AB5, 0x4A11, 0x5274, 0x62D5,   // 0x0770 (1904)
+0x41F0, 0x39AE, 0xD6BD, 0x9CD9, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x0780 (1920)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0012, 0x0813, 0x0813, 0xD69D, 0xFFFF, 0x41F0, 0x41F0,   // 0x0790 (1936)
+0x5253, 0x5273, 0x5AB5, 0x4A31, 0x7B97, 0xE71D, 0xEF7E, 0xD67C, 0x9478, 0x4A32, 0xB57A, 0xF79F, 0xEF7E, 0xEF7F, 0xF7BF, 0xEF7E,   // 0x07A0 (1952)
+0xBDDC, 0x8C38, 0x62F6, 0x5A94, 0x5A94, 0x5253, 0x4A52, 0x4A11, 0x4A32, 0x5253, 0x41F0, 0x7357, 0xE73E, 0xF77F, 0xDEDD, 0xCE5C,   // 0x07B0 (1968)
+0xDEFD, 0xFFDF, 0xF77E, 0xEF5E, 0xEF5E, 0xEF5E, 0x8C58, 0x39AE, 0x5253, 0x8417, 0xCE3C, 0xC63C, 0x8C38, 0x4A52, 0x5273, 0x5A74,   // 0x07C0 (1984)
+0x41F0, 0x4A11, 0xC63C, 0x9CD9, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x07D0 (2000)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0833, 0xDEDD, 0xEF7F, 0x318C, 0x39CF,   // 0x07E0 (2016)
+0x5273, 0x5253, 0x39CE, 0x4A31, 0x4A32, 0xAD7B, 0xEF5E, 0xEF7F, 0xDF1E, 0xD69D, 0xDEBD, 0xEF5E, 0xF79F, 0xDEFD, 0xB59B, 0x7377,   // 0x07F0 (2032)
+0x5253, 0x4A52, 0x39CE, 0x39CE, 0x4A32, 0x4A32, 0x41EF, 0x41CF, 0x5253, 0x4A53, 0x39CE, 0x7B97, 0xF79E, 0xF7BF, 0x9CDA, 0x4A10,   // 0x0800 (2048)
+0x7B97, 0xBDFC, 0xE71D, 0xF7BF, 0xE73E, 0xDEFD, 0xC5FC, 0x9499, 0xCE5C, 0xE6FE, 0xF79E, 0xCE5C, 0x5A95, 0x5273, 0x4A31, 0x318D,   // 0x0810 (2064)
+0x4210, 0x41F0, 0xCE5C, 0x9478, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0820 (2080)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xD6BD, 0xF7BF, 0x41F0, 0x39CE,   // 0x0830 (2096)
+0x4A32, 0x4A31, 0x4A52, 0x4A31, 0x4210, 0x5274, 0xCE3C, 0xEF5E, 0xE73E, 0xEF5E, 0xEF7E, 0xEF7E, 0xCE7C, 0x8C38, 0x5274, 0x4A31,   // 0x0840 (2112)
+0x4210, 0x4A11, 0x4A31, 0x4A32, 0x4A32, 0x4A31, 0x4A11, 0x4A10, 0x4A32, 0x41F0, 0x5253, 0xAD1A, 0xEF5E, 0xDEDD, 0x83F8, 0x39CF,   // 0x0850 (2128)
+0x4210, 0x5253, 0x8C38, 0xD6BD, 0xEF5E, 0xDEDD, 0xEF5E, 0xE73E, 0xEF7F, 0xEF5E, 0xD69D, 0x7BB7, 0x41F0, 0x4A31, 0x4A31, 0x4A52,   // 0x0860 (2144)
+0x41F0, 0x41CF, 0xCE7C, 0x8C17, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0870 (2160)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xD69C, 0xF7BF, 0x41CF, 0x39AE,   // 0x0880 (2176)
+0x31AD, 0x41EF, 0x41F0, 0x41EF, 0x294A, 0x318C, 0x8418, 0xD67C, 0xDEDD, 0xDEDD, 0xE71E, 0xBDFC, 0x5273, 0x41EF, 0x41EF, 0x4210,   // 0x0890 (2192)
+0x318D, 0x39CE, 0x5252, 0x5252, 0x39AD, 0x39CE, 0x4A32, 0x4A32, 0x39CE, 0x318C, 0x6B56, 0xDEBD, 0xEF5E, 0xB59B, 0x5274, 0x4210,   // 0x08A0 (2208)
+0x39AD, 0x316C, 0x4A11, 0x6B16, 0xC5FC, 0xE73E, 0xD6BD, 0xDEDD, 0xD6BD, 0xDEFD, 0x9CD9, 0x41CF, 0x41F0, 0x398D, 0x4210, 0x4A32,   // 0x08B0 (2224)
+0x318D, 0x294B, 0xCE7C, 0x83D7, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x08C0 (2240)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0814, 0xCE5C, 0xFFDF, 0x39AE, 0x318D,   // 0x08D0 (2256)
+0x5274, 0xB57B, 0xB57A, 0x9CB9, 0x7356, 0x5253, 0x7377, 0xC63C, 0xDEDD, 0xCE7C, 0xA4F9, 0x5274, 0x39CE, 0x39CF, 0x4A10, 0x41EF,   // 0x08E0 (2272)
+0x4A11, 0x4A11, 0x4210, 0x4210, 0x4A10, 0x4210, 0x4A10, 0x41F0, 0x41F0, 0x41F0, 0x83D8, 0xDEFD, 0xDEDD, 0x8C58, 0x39CE, 0x41CF,   // 0x08F0 (2288)
+0x4210, 0x4A11, 0x39CE, 0x39AE, 0x5A95, 0xAD7A, 0xDEBD, 0xD69C, 0xD6BD, 0xB59B, 0x4A11, 0x296B, 0x39AD, 0x41CE, 0x4A32, 0x4A32,   // 0x0900 (2304)
+0x39AE, 0x39AE, 0xBDDB, 0x7B96, 0x0813, 0x0812, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0910 (2320)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xD6BD, 0xFFFF, 0x18E6, 0x2108,   // 0x0920 (2336)
+0x39AD, 0x9CD9, 0xEF5E, 0xD69D, 0xD6BD, 0xC5FC, 0xC61C, 0xC63C, 0xC5FC, 0xDEFD, 0x9458, 0x39AD, 0x39CE, 0x41F0, 0x316B, 0x398D,   // 0x0930 (2352)
+0x4A11, 0x4A11, 0x318D, 0x318D, 0x4A11, 0x4A31, 0x318D, 0x318D, 0x41F0, 0x5273, 0xAD3A, 0xD69D, 0xBDBB, 0x62F6, 0x2929, 0x318C,   // 0x0940 (2368)
+0x4A11, 0x4A10, 0x39AD, 0x296A, 0x39CE, 0x5274, 0xB57A, 0xDEDD, 0xCE3C, 0xB59B, 0x83D7, 0x8C18, 0xA4FA, 0xAD5A, 0xBDDC, 0x9C99,   // 0x0950 (2384)
+0x296B, 0x318C, 0xB59B, 0x7356, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0960 (2400)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xD69D, 0xFFFF, 0x2109, 0x18C6,   // 0x0970 (2416)
+0x2109, 0x316B, 0x83F7, 0xCE7C, 0xD67C, 0xCE5C, 0xD67D, 0xC61C, 0xC63C, 0xCE7C, 0xB59B, 0x7BB7, 0x41CF, 0x39AE, 0x41CE, 0x41CF,   // 0x0980 (2432)
+0x41CF, 0x41CF, 0x41CF, 0x39CE, 0x39CE, 0x39AD, 0x318C, 0x318B, 0x294A, 0x5A95, 0xC63C, 0xD6BD, 0x9478, 0x39CF, 0x39AE, 0x41EF,   // 0x0990 (2448)
+0x41EF, 0x41F0, 0x39CE, 0x39CE, 0x39CE, 0x39AD, 0x5274, 0xB59B, 0xCE5C, 0xCE3C, 0xC61C, 0xCE7C, 0xDEFD, 0xDEBD, 0xC61B, 0x5253,   // 0x09A0 (2464)
+0x18E7, 0x2929, 0xB59A, 0x6B35, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x09B0 (2480)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xCE5D, 0xFFDF, 0x316B, 0x18C6,   // 0x09C0 (2496)
+0x1063, 0x10A4, 0x294A, 0x83D7, 0xB59B, 0xB57A, 0xB55A, 0xAD5A, 0xA51A, 0xB59B, 0xC61C, 0xC5FB, 0x8C38, 0x4A11, 0x39CE, 0x41F0,   // 0x09D0 (2512)
+0x316B, 0x318C, 0x39AE, 0x41CF, 0x4211, 0x5273, 0x7357, 0x83D8, 0x7397, 0x94B9, 0xC61C, 0xBDFB, 0x5274, 0x2107, 0x41EF, 0x4210,   // 0x09E0 (2528)
+0x318C, 0x296A, 0x4210, 0x4211, 0x318D, 0x2929, 0x39CE, 0x6B36, 0xBDBB, 0xBDBB, 0xB59B, 0xBD9B, 0xB5BB, 0x9479, 0x39AD, 0x20E8,   // 0x09F0 (2544)
+0x10A4, 0x10A5, 0xBDBB, 0x62D4, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x0A00 (2560)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xCE5C, 0xFFFF, 0x294A, 0x18A5,   // 0x0A10 (2576)
+0x1085, 0x18A5, 0x1063, 0x18C5, 0x7377, 0xA53A, 0xBDDB, 0x7376, 0x31AD, 0x5253, 0xAD7A, 0xBDBB, 0xBDBB, 0x9458, 0x5252, 0x318D,   // 0x0A20 (2592)
+0x316B, 0x39AD, 0x4210, 0x7337, 0x9458, 0x9CB9, 0xAD5A, 0xC5FB, 0xBDDB, 0xB59B, 0xBDDC, 0xBDBB, 0x7356, 0x41F0, 0x39CF, 0x39AE,   // 0x0A30 (2608)
+0x39CE, 0x39AD, 0x41CF, 0x39AE, 0x318C, 0x316B, 0x2929, 0x39AD, 0x7357, 0xAD5A, 0xA51A, 0xA4FA, 0x8C38, 0x39CE, 0x18A5, 0x2109,   // 0x0A40 (2624)
+0x18A5, 0x2909, 0xAD5A, 0x5AB4, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0A50 (2640)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0x0813, 0xD6BD, 0xFFFF, 0x18E7, 0x2109,   // 0x0A60 (2656)
+0x318D, 0x41F0, 0x39CE, 0x4210, 0x8C38, 0x9CD9, 0x8C58, 0x39AE, 0x18C6, 0x2107, 0x39AD, 0x8C18, 0xA4FA, 0xAD3A, 0x9459, 0x5252,   // 0x0A70 (2672)
+0x39AD, 0x4210, 0x83F8, 0xA51A, 0xA4FA, 0xAD3A, 0xAD3A, 0x9CB9, 0x9CDA, 0xA4F9, 0xA4FA, 0xA4FA, 0xA4F9, 0x83D7, 0x4210, 0x2128,   // 0x0A80 (2688)
+0x314A, 0x39AD, 0x20E7, 0x1085, 0x316B, 0x316C, 0x10A5, 0x0842, 0x39CE, 0x9458, 0xA4F9, 0x9479, 0x4A11, 0x0041, 0x0863, 0x0021,   // 0x0A90 (2704)
+0x10A4, 0x2129, 0xA4FA, 0x5273, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0AA0 (2720)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0x0813, 0xD67C, 0xFFFF, 0x41F0, 0x6B36,   // 0x0AB0 (2736)
+0x8C38, 0x9478, 0x9479, 0x9CF9, 0x9499, 0x9CD9, 0x5AB5, 0x2929, 0x20E7, 0x18C6, 0x18A5, 0x316B, 0x7377, 0x9CD9, 0x9CB9, 0x83F7,   // 0x0AC0 (2752)
+0x62D5, 0x7357, 0x9CBA, 0x9499, 0x8C18, 0x8C58, 0x9479, 0x8C38, 0x9479, 0x9478, 0x8C18, 0x8C58, 0x9499, 0x9479, 0x7B97, 0x41F0,   // 0x0AD0 (2768)
+0x20E8, 0x18E7, 0x20E7, 0x20E7, 0x2129, 0x2909, 0x20E8, 0x18C6, 0x2108, 0x62B6, 0x9CB9, 0x8C38, 0x7B97, 0x5294, 0x4A52, 0x4210,   // 0x0AE0 (2784)
+0x318D, 0x294B, 0xA51A, 0x4A13, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0AF0 (2800)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0812, 0x0813, 0xD69C, 0xFFDF, 0x39AE, 0x5253,   // 0x0B00 (2816)
+0xA53A, 0x9C99, 0x9CD9, 0x9479, 0x83F8, 0x9479, 0x41CF, 0x2108, 0x0862, 0x10A5, 0x2929, 0x18E7, 0x18C7, 0x5274, 0x8C39, 0x8418,   // 0x0B10 (2832)
+0x8C58, 0x9479, 0x83F7, 0x7BD8, 0x8C38, 0x83F8, 0x83F8, 0x8C38, 0x8C38, 0x83F8, 0x8418, 0x8C58, 0x8C38, 0x8C38, 0x9479, 0x7BB7,   // 0x0B20 (2848)
+0x39CE, 0x18A5, 0x2929, 0x316C, 0x18C6, 0x0883, 0x294A, 0x2929, 0x18C6, 0x316C, 0x9479, 0x8418, 0x9CD9, 0xAD7A, 0xAD3A, 0xA4F9,   // 0x0B30 (2864)
+0x7377, 0x41F0, 0x9499, 0x5253, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0B40 (2880)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xDEBD, 0xFFDF, 0x2109, 0x18C6,   // 0x0B50 (2896)
+0x39CE, 0x5AB5, 0x7BB8, 0x7BB7, 0x8C38, 0x6B16, 0x314B, 0x2108, 0x18C6, 0x18E7, 0x2108, 0x2108, 0x1084, 0x18E7, 0x5253, 0x7BD7,   // 0x0B60 (2912)
+0x83D7, 0x83D7, 0x7BB7, 0x7B97, 0x7B97, 0x7BB7, 0x7BD7, 0x7BB7, 0x7BD7, 0x83F8, 0x7BB7, 0x83F7, 0x7BB8, 0x7BD7, 0x7BB7, 0x83F7,   // 0x0B70 (2928)
+0x5AB5, 0x2929, 0x2108, 0x2929, 0x20E7, 0x18E7, 0x2929, 0x2109, 0x18E7, 0x294A, 0x6B17, 0x83F7, 0x7BB7, 0x83D7, 0x9499, 0x7B97,   // 0x0B80 (2944)
+0x41F0, 0x316C, 0x8C58, 0x41F2, 0x0813, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0B90 (2960)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xD69C, 0xFFFF, 0x18C6, 0x10A5,   // 0x0BA0 (2976)
+0x18C7, 0x2949, 0x41F0, 0x7337, 0x7BB7, 0x5253, 0x18A5, 0x18C6, 0x296B, 0x2929, 0x18A5, 0x18C5, 0x292A, 0x18C5, 0x41EF, 0x7397,   // 0x0BB0 (2992)
+0x7397, 0x6B36, 0x7357, 0x7B97, 0x7377, 0x7377, 0x7377, 0x7B97, 0x7BB7, 0x7377, 0x7377, 0x7376, 0x7B97, 0x7377, 0x7397, 0x7BB7,   // 0x0BC0 (3008)
+0x7377, 0x4A32, 0x18C6, 0x1084, 0x294A, 0x314B, 0x18E7, 0x1084, 0x2108, 0x2929, 0x5253, 0x7B97, 0x7BB7, 0x6B36, 0x41EF, 0x2128,   // 0x0BD0 (3024)
+0x10A5, 0x2109, 0x94B8, 0x39B1, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0BE0 (3040)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xCE5C, 0xFFFF, 0x20E8, 0x0863,   // 0x0BF0 (3056)
+0x18A6, 0x0863, 0x39CE, 0x62F5, 0x7377, 0x39CF, 0x18C6, 0x20E7, 0x2929, 0x2928, 0x20E7, 0x2109, 0x20E7, 0x292A, 0x5274, 0x6B56,   // 0x0C00 (3072)
+0x62F6, 0x62F6, 0x62F6, 0x6B36, 0x6B36, 0x62F6, 0x5A94, 0x4A32, 0x5253, 0x5A95, 0x62F6, 0x6B36, 0x7357, 0x62F6, 0x6B36, 0x6B36,   // 0x0C10 (3088)
+0x6B56, 0x5A94, 0x2109, 0x18E7, 0x292A, 0x2929, 0x2108, 0x18E7, 0x2108, 0x2108, 0x39CE, 0x7357, 0x6B16, 0x4A10, 0x10A4, 0x0021,   // 0x0C20 (3104)
+0x10A5, 0x2109, 0x8C37, 0x41D2, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0C30 (3120)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0x0813, 0xD69C, 0xFFBF, 0x314B, 0x2129,   // 0x0C40 (3136)
+0x41EF, 0x5A75, 0x6B56, 0x5AB5, 0x6B36, 0x318C, 0x294A, 0x294A, 0x1084, 0x18E7, 0x294A, 0x314B, 0x0863, 0x2929, 0x5A95, 0x6B16,   // 0x0C50 (3152)
+0x62D5, 0x62D5, 0x5AB5, 0x5AD5, 0x5A95, 0x5273, 0x4A52, 0x4A52, 0x5273, 0x5273, 0x5253, 0x5AB5, 0x62D6, 0x62D5, 0x5A95, 0x5AB5,   // 0x0C60 (3168)
+0x6316, 0x5A94, 0x318C, 0x2108, 0x18C5, 0x1083, 0x2929, 0x2929, 0x18C6, 0x0863, 0x316B, 0x6B16, 0x5AD5, 0x5294, 0x5273, 0x39CE,   // 0x0C70 (3184)
+0x20C7, 0x18A5, 0x8417, 0x3190, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0C80 (3200)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0813, 0x0813, 0xDEDD, 0xF7BF, 0x41F1, 0x5A94,   // 0x0C90 (3216)
+0x7BD7, 0x8C59, 0x6B56, 0x5A95, 0x5AD5, 0x314B, 0x2108, 0x2929, 0x18C7, 0x2108, 0x2129, 0x2129, 0x18C6, 0x318C, 0x5294, 0x5A95,   // 0x0CA0 (3232)
+0x5A94, 0x5A94, 0x5274, 0x5A94, 0x5274, 0x5273, 0x7BB8, 0xBDFB, 0xBDBB, 0x7BD7, 0x5A75, 0x5274, 0x5294, 0x5A95, 0x5A94, 0x5274,   // 0x0CB0 (3248)
+0x5A95, 0x5274, 0x4210, 0x318C, 0x2949, 0x2108, 0x398D, 0x296B, 0x294A, 0x18C6, 0x398D, 0x5AB5, 0x5274, 0x6B36, 0x9499, 0x6B56,   // 0x0CC0 (3264)
+0x4A32, 0x31AD, 0x83D7, 0x398F, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0CD0 (3280)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xCE7C, 0xEF5E, 0x4A12, 0x4A32,   // 0x0CE0 (3296)
+0x5274, 0x5273, 0x5274, 0x5274, 0x5294, 0x2928, 0x1084, 0x2107, 0x318C, 0x314A, 0x18C6, 0x18E7, 0x2929, 0x41EF, 0x5274, 0x5274,   // 0x0CF0 (3312)
+0x5253, 0x5273, 0x5253, 0x5253, 0x5A95, 0x7BB7, 0xA51A, 0xCE5C, 0xCE5C, 0xA51A, 0x83F7, 0x5A95, 0x4A32, 0x5273, 0x5274, 0x4A52,   // 0x0D00 (3328)
+0x5273, 0x5274, 0x5274, 0x5A95, 0x5252, 0x5253, 0x5274, 0x4A32, 0x4A31, 0x4A32, 0x4A32, 0x5253, 0x5273, 0x5253, 0x5254, 0x62D5,   // 0x0D10 (3344)
+0x5A95, 0x41F0, 0x83F7, 0x39B0, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0D20 (3360)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0x0813, 0xCE7C, 0xF79F, 0x294A, 0x18E7,   // 0x0D30 (3376)
+0x294B, 0x39AE, 0x41EF, 0x4A11, 0x5253, 0x2929, 0x18C6, 0x2108, 0x294A, 0x292A, 0x20E8, 0x2129, 0x18C6, 0x41CF, 0x5273, 0x4A32,   // 0x0D40 (3392)
+0x4A52, 0x4A32, 0x4A52, 0x4A31, 0x5A95, 0x9CDA, 0x8C58, 0x5A74, 0x5A95, 0x8418, 0x9478, 0x62D6, 0x4A11, 0x4A32, 0x4A31, 0x4A52,   // 0x0D50 (3408)
+0x4A32, 0x4A32, 0x5252, 0x5273, 0x4A53, 0x5274, 0x5252, 0x5253, 0x5253, 0x5253, 0x5273, 0x4A31, 0x4A52, 0x5253, 0x41CF, 0x398D,   // 0x0D60 (3424)
+0x2129, 0x18E7, 0x83F8, 0x398F, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0D70 (3440)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x0813, 0xCE7C, 0xFFFF, 0x292A, 0x1084,   // 0x0D80 (3456)
+0x2929, 0x0884, 0x316B, 0x41CF, 0x4A31, 0x294A, 0x294A, 0x294A, 0x10A5, 0x2107, 0x316C, 0x314A, 0x1084, 0x294A, 0x4A11, 0x4210,   // 0x0D90 (3472)
+0x4210, 0x4210, 0x4210, 0x41F0, 0x5273, 0x8C58, 0x9499, 0x62D6, 0x62D5, 0x9479, 0x8C58, 0x5274, 0x4210, 0x4A11, 0x4210, 0x4A11,   // 0x0DA0 (3488)
+0x4A11, 0x41F0, 0x39AE, 0x316C, 0x318C, 0x316B, 0x39AD, 0x39AE, 0x39AD, 0x318C, 0x39CE, 0x4210, 0x39CE, 0x318C, 0x2108, 0x316B,   // 0x0DB0 (3504)
+0x0863, 0x18C6, 0x83F7, 0x318E, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010,   // 0x0DC0 (3520)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0812, 0x0813, 0xC61C, 0xFFDF, 0x2909, 0x1084,   // 0x0DD0 (3536)
+0x7BB7, 0x39CE, 0x39CF, 0x39CE, 0x83D7, 0x316C, 0x20E8, 0x2909, 0x18C6, 0x2108, 0x294A, 0x294A, 0x18C6, 0x2107, 0x39CF, 0x4A10,   // 0x0DE0 (3552)
+0x41EF, 0x41EF, 0x41EF, 0x41EF, 0x4210, 0x5AB5, 0x9478, 0xB5BB, 0xB59B, 0x9498, 0x62F6, 0x41EF, 0x41CF, 0x4210, 0x41CF, 0x41CF,   // 0x0DF0 (3568)
+0x41EF, 0x39CE, 0x2929, 0x10A5, 0x18C6, 0x18A5, 0x20E7, 0x18E7, 0x18C6, 0x18C6, 0x316C, 0x6B16, 0x39AD, 0x296A, 0x316D, 0x83D7,   // 0x0E00 (3584)
+0x0842, 0x18C5, 0x8C18, 0x39AE, 0x0813, 0x0812, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x0E10 (3600)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0xCE5C, 0xF7BF, 0x18E7, 0x2929,   // 0x0E20 (3616)
+0xCE7C, 0x7BB7, 0x318C, 0x62F6, 0xE73E, 0x41F0, 0x1083, 0x18C6, 0x7B77, 0x41EF, 0x18A5, 0x20E7, 0x294A, 0x294A, 0x39AD, 0x41CF,   // 0x0E30 (3632)
+0x39AE, 0x39CE, 0x39CE, 0x39AE, 0x39AD, 0x39CF, 0x5253, 0x6B16, 0x62D5, 0x5273, 0x41F0, 0x39AD, 0x39CE, 0x41CF, 0x39CE, 0x39CE,   // 0x0E40 (3648)
+0x39CF, 0x318C, 0x18E7, 0x10A4, 0x20E7, 0x2108, 0x18C7, 0x318C, 0x4A32, 0x0863, 0x39AD, 0xBDFB, 0x62D5, 0x398D, 0x7BB7, 0xCE7D,   // 0x0E50 (3664)
+0x0864, 0x20E8, 0x83F7, 0x318E, 0x0834, 0x0813, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0E60 (3680)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0xC63C, 0xEF7E, 0x2108, 0x5233,   // 0x0E70 (3696)
+0xE71E, 0x6B16, 0x296B, 0xAD7A, 0xFFFF, 0x4A11, 0x0020, 0x41F0, 0xF79F, 0x5252, 0x1084, 0x10A5, 0x2109, 0x318D, 0x39AE, 0x39AD,   // 0x0E80 (3712)
+0x318C, 0x318C, 0x39AE, 0x318D, 0x39AD, 0x39AD, 0x318C, 0x318B, 0x316C, 0x318C, 0x398D, 0x398D, 0x398D, 0x39AD, 0x39AC, 0x39AD,   // 0x0E90 (3728)
+0x39AD, 0x294A, 0x18E6, 0x2108, 0x294A, 0x18E7, 0x18C6, 0x5253, 0xD67C, 0x18C6, 0x294A, 0xDEBD, 0xA4FA, 0x292A, 0x9CD9, 0xC63C,   // 0x0EA0 (3744)
+0x398D, 0x292A, 0x8C58, 0x39D0, 0x0814, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0EB0 (3760)
+0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0xBDBB, 0xD69C, 0x4A13, 0x8418,   // 0x0EC0 (3776)
+0xDEDD, 0xA51A, 0x8C38, 0xCE7C, 0xF79F, 0x5274, 0x41CF, 0xBDFB, 0xEF5E, 0x39AE, 0x10A5, 0x398D, 0x62F6, 0x4210, 0x294B, 0x318C,   // 0x0ED0 (3792)
+0x318C, 0x316C, 0x316C, 0x318C, 0x316C, 0x318C, 0x316C, 0x316C, 0x318C, 0x316B, 0x316B, 0x316C, 0x318B, 0x316B, 0x318C, 0x318D,   // 0x0EE0 (3808)
+0x2929, 0x18C5, 0x2108, 0x39AE, 0x5A95, 0x5253, 0x10A4, 0x4A11, 0xFFFF, 0x7B97, 0x39AD, 0xDEFE, 0xCE5C, 0x7357, 0xC61C, 0xCE5C,   // 0x0EF0 (3824)
+0x7BD7, 0x5253, 0x83F7, 0x41D1, 0x1034, 0x0813, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x0F00 (3840)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0813, 0xA51A, 0xCE5C, 0x7BB6, 0xB57B,   // 0x0F10 (3856)
+0xD69D, 0xD6BD, 0xE71E, 0xDEFD, 0xDEDD, 0x9CB9, 0xC5FC, 0xDEFD, 0xCE5C, 0x318B, 0x294A, 0xA51A, 0xAD7A, 0x41EF, 0x2109, 0x20E7,   // 0x0F20 (3872)
+0x292A, 0x316B, 0x294B, 0x316C, 0x294A, 0x294A, 0x316B, 0x294B, 0x316B, 0x316B, 0x316B, 0x316B, 0x316B, 0x294A, 0x316B, 0x314A,   // 0x0F30 (3888)
+0x2108, 0x2109, 0x18E7, 0x18E7, 0x7BB7, 0xE73E, 0x39CF, 0x39CE, 0xF7BF, 0xD67D, 0xA4D9, 0xDEDD, 0xE6FE, 0xDEDD, 0xD69D, 0xD67D,   // 0x0F40 (3904)
+0xAD5A, 0x7B97, 0x8C18, 0x41D1, 0x0834, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x0F50 (3920)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0813, 0x9478, 0xC61C, 0x7357, 0xA4F9,   // 0x0F60 (3936)
+0xC61C, 0xCE5C, 0xCE5D, 0xD69D, 0xCE7C, 0xD6BD, 0xD69D, 0xD69C, 0xC61C, 0x5274, 0x9CD9, 0xF79F, 0x6B16, 0x18C6, 0x0862, 0x2128,   // 0x0F70 (3952)
+0x294A, 0x2929, 0x2129, 0x294A, 0x294A, 0x2929, 0x2929, 0x294A, 0x292A, 0x2929, 0x2129, 0x2929, 0x294A, 0x2929, 0x2109, 0x18E7,   // 0x0F80 (3968)
+0x316B, 0x5A74, 0x4A11, 0x18C6, 0x318D, 0xEF9E, 0xD69C, 0x8C38, 0xDEDD, 0xDEBD, 0xE71D, 0xD69C, 0xD69D, 0xD69D, 0xCE5C, 0xC61B,   // 0x0F90 (3984)
+0x9CF9, 0x6B36, 0x9478, 0x4A12, 0x0834, 0x0814, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x0FA0 (4000)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0812, 0x7BB6, 0xAD5A, 0x6B15, 0x9CD9,   // 0x0FB0 (4016)
+0xC61C, 0xD67D, 0xCE3C, 0xD69D, 0xC61C, 0xC61C, 0xC61B, 0xC5FB, 0xCE5C, 0xD6BD, 0xCE7C, 0xDEDD, 0x39CE, 0x18C5, 0x318C, 0x83F8,   // 0x0FC0 (4032)
+0x49F0, 0x18A6, 0x20E7, 0x2108, 0x2929, 0x2108, 0x2108, 0x2929, 0x2929, 0x2108, 0x2929, 0x2929, 0x20E8, 0x2108, 0x18E7, 0x18C6,   // 0x0FD0 (4048)
+0x2129, 0x7336, 0xDEFD, 0x5274, 0x4A31, 0xAD3A, 0xE73E, 0xEF5E, 0xD69D, 0xD6BD, 0xD67D, 0xCE5C, 0xCE5C, 0xCE7D, 0xCE5C, 0xC63C,   // 0x0FE0 (4064)
+0x9CF9, 0x62F5, 0x9CD9, 0x5AB5, 0x0814, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x0FF0 (4080)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x62F5, 0x9CB8, 0x5AB4, 0x7396,   // 0x1000 (4096)
+0x9CD9, 0xA4FA, 0xAD7A, 0xB5BB, 0xC61C, 0xC63C, 0xC61C, 0xBDDB, 0xBDBB, 0xBDFC, 0xBDDB, 0xBDFC, 0x5274, 0x62F6, 0xD6BD, 0xB57B,   // 0x1010 (4112)
+0x316B, 0x1084, 0x2108, 0x18C6, 0x18A6, 0x2108, 0x20E8, 0x20E7, 0x20E7, 0x20E7, 0x2929, 0x2109, 0x18A6, 0x18E6, 0x294B, 0x2929,   // 0x1020 (4128)
+0x0863, 0x316C, 0xBDDB, 0xE73E, 0xC61C, 0xBDBB, 0xCE7C, 0xCE5C, 0xCE5C, 0xD69D, 0xD6BD, 0xCE5C, 0xBDDB, 0xA53A, 0xA4FA, 0x9CB9,   // 0x1030 (4144)
+0x7BB7, 0x6B15, 0xA519, 0x62F5, 0x0835, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x1040 (4160)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0811, 0x0812, 0x4A33, 0x7BD7, 0x41D1, 0x39D0,   // 0x1050 (4176)
+0x5254, 0x5AB5, 0x62D5, 0x6B36, 0x83F7, 0x9499, 0xAD3A, 0xBDDB, 0xB57A, 0xAD5A, 0xB59B, 0xAD5A, 0xBDFB, 0xCE5C, 0xC61C, 0x4A10,   // 0x1060 (4192)
+0x0862, 0x2108, 0x318C, 0x2108, 0x18E7, 0x18C7, 0x18E7, 0x18C6, 0x18C6, 0x18E7, 0x18C6, 0x18C7, 0x18C5, 0x2107, 0x4A32, 0x5274,   // 0x1070 (4208)
+0x318B, 0x2108, 0x62B5, 0xE71E, 0xCE3C, 0xCE5C, 0xD67D, 0xC63C, 0xCE7C, 0xB59B, 0xA4FA, 0x8C38, 0x7377, 0x62F5, 0x5A95, 0x5274,   // 0x1080 (4224)
+0x4A32, 0x5A75, 0xC5FB, 0x7BD7, 0x0834, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010,   // 0x1090 (4240)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x39B1, 0x6315, 0x316E, 0x41F1,   // 0x10A0 (4256)
+0x4A54, 0x5295, 0x5295, 0x5A95, 0x4A32, 0x5253, 0x62D5, 0x83F8, 0xA4FA, 0xB5BB, 0xAD3A, 0xA51A, 0xAD5A, 0xA51A, 0x9499, 0x41EF,   // 0x10B0 (4272)
+0x39AD, 0x62D6, 0x5253, 0x316C, 0x316B, 0x2929, 0x20E7, 0x18C7, 0x18C6, 0x18A5, 0x18A5, 0x10A4, 0x2108, 0x2929, 0x4A32, 0xCE7D,   // 0x10C0 (4288)
+0xBDBB, 0x7376, 0x7377, 0xCE7C, 0xC61C, 0xC5FB, 0xC63C, 0xBDFB, 0x9CB9, 0x6B56, 0x5253, 0x5253, 0x5A95, 0x6B16, 0x62F6, 0x5A95,   // 0x10D0 (4304)
+0x4A32, 0x7356, 0xDEBD, 0xA4F9, 0x0814, 0x0833, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011,   // 0x10E0 (4320)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x210C, 0x5254, 0x4A13, 0x39AF,   // 0x10F0 (4336)
+0x5294, 0x6B56, 0x6B56, 0x7377, 0x7376, 0x6B16, 0x5273, 0x4210, 0x62F6, 0x8C58, 0xAD3A, 0x9CD9, 0x9CD9, 0xA4FA, 0x83F8, 0x7BB7,   // 0x1100 (4352)
+0xAD5A, 0xAD3A, 0x318D, 0x18C5, 0x2929, 0x292A, 0x2108, 0x2108, 0x18C6, 0x1084, 0x1084, 0x1063, 0x18C6, 0x18E7, 0x2108, 0x5253,   // 0x1110 (4368)
+0xBDFC, 0xCE5C, 0xC63C, 0xB57A, 0xBDBB, 0xBDFB, 0xA51A, 0x62F6, 0x5253, 0x5AB5, 0x6B36, 0x7B97, 0x7BB7, 0x7B97, 0x7376, 0x5AB5,   // 0x1120 (4384)
+0x5A95, 0xCE3C, 0xDEDD, 0xC61C, 0x0814, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1130 (4400)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0811, 0x294E, 0x5AB4, 0x316D,   // 0x1140 (4416)
+0x41F2, 0x5274, 0x6315, 0x6B15, 0x6B16, 0x6B36, 0x7397, 0x62F6, 0x4210, 0x4A11, 0x83D7, 0x9CB9, 0x9479, 0x9499, 0x9CD9, 0xA51A,   // 0x1150 (4432)
+0x9458, 0x39AE, 0x2108, 0x296B, 0x294A, 0x314B, 0x316B, 0x2929, 0x18C6, 0x1084, 0x0863, 0x18A5, 0x292A, 0x314B, 0x2128, 0x39CE,   // 0x1160 (4448)
+0x8C58, 0xAD5A, 0xAD3A, 0xAD5A, 0xB57B, 0xA4FA, 0x62D5, 0x4A31, 0x7377, 0x7B97, 0x7BB7, 0x7377, 0x6B36, 0x6B36, 0x5AB5, 0x5273,   // 0x1170 (4464)
+0x83F8, 0xFFFF, 0xEF7E, 0x83F7, 0x0813, 0x0813, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1180 (4480)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x3191, 0x3990,   // 0x1190 (4496)
+0x39B0, 0x39D0, 0x4A12, 0x62D5, 0x62D5, 0x62B6, 0x62D5, 0x62D5, 0x62D5, 0x4A11, 0x4211, 0x7B96, 0x9479, 0x83F8, 0x83F8, 0x9479,   // 0x11A0 (4512)
+0x5AB5, 0x318D, 0x41CF, 0x5253, 0x4210, 0x294A, 0x2129, 0x316B, 0x2108, 0x1084, 0x0020, 0x18A5, 0x5A95, 0x8C18, 0x5A95, 0x5274,   // 0x11B0 (4528)
+0x7BB7, 0xA519, 0xA4FA, 0xB57B, 0x9479, 0x5252, 0x4A11, 0x7397, 0x7376, 0x7376, 0x6B16, 0x62F6, 0x62F5, 0x5A95, 0x5A95, 0x7BD7,   // 0x11C0 (4544)
+0xDEFD, 0xFFFF, 0xC61B, 0x0814, 0x0813, 0x0812, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x11D0 (4560)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0812, 0x3191,   // 0x11E0 (4576)
+0x41F2, 0x39B0, 0x41D1, 0x4A12, 0x4A33, 0x5274, 0x5274, 0x4A32, 0x5A95, 0x5274, 0x318D, 0x41EF, 0x6B36, 0x7377, 0x6B56, 0x7377,   // 0x11F0 (4592)
+0x7377, 0x83F7, 0x8C38, 0x5A95, 0x318C, 0x2108, 0x18E7, 0x20E7, 0x2929, 0x18C5, 0x0000, 0x0000, 0x18C6, 0x5A95, 0x8418, 0x8C58,   // 0x1200 (4608)
+0x8C38, 0x83F8, 0x9479, 0x83F8, 0x4A52, 0x41CF, 0x62F6, 0x6316, 0x5AB5, 0x5A74, 0x62D6, 0x5A95, 0x5AB5, 0x6B56, 0xA4FA, 0xFFFF,   // 0x1210 (4624)
+0xFFFF, 0xFFFF, 0x0834, 0x0813, 0x0813, 0x0012, 0x0811, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1220 (4640)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0812,   // 0x1230 (4656)
+0x0812, 0x4213, 0x4A53, 0x4A13, 0x5254, 0x5AD5, 0x5AD5, 0x6B36, 0x6B16, 0x62D5, 0x6B36, 0x4A33, 0x62F6, 0x8C58, 0x8C58, 0x83D7,   // 0x1240 (4672)
+0x8C18, 0x8C58, 0x6B36, 0x4211, 0x39AE, 0x41F0, 0x41F0, 0x41EF, 0x41CF, 0x41CF, 0x316C, 0x294A, 0x294A, 0x41F0, 0x8418, 0x8C58,   // 0x1250 (4688)
+0x9478, 0x9CB9, 0x9499, 0x7BB7, 0x5253, 0x7BB7, 0x83F7, 0x7BB7, 0x7397, 0x6B56, 0x7BB7, 0x8418, 0x9478, 0xD69D, 0xFFFF, 0xFFFF,   // 0x1260 (4704)
+0xFFFF, 0x0814, 0x0813, 0x0813, 0x0812, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1270 (4720)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012,   // 0x1280 (4736)
+0x0012, 0x0812, 0x41F2, 0x6B15, 0x8C37, 0xA519, 0xC5FB, 0xCE9C, 0xDEDD, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1290 (4752)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x12A0 (4768)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7BF, 0xF7BF, 0xF79E, 0xE73E, 0xEF9E, 0xEF5E, 0xE6FE, 0xEF5E, 0x0814,   // 0x12B0 (4784)
+0x0813, 0x0813, 0x0012, 0x0812, 0x0812, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x12C0 (4800)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x12D0 (4816)
+0x0812, 0x0812, 0x0812, 0x0813, 0x5253, 0x7376, 0x8C37, 0xA4FA, 0xB55B, 0xBDDB, 0xBDDB, 0xD69D, 0xD69C, 0xD69D, 0xDEDD, 0xDEBD,   // 0x12E0 (4832)
+0xD67C, 0xCE5C, 0xD69D, 0xD69C, 0xCE5C, 0xD67D, 0xCE5C, 0xCE3C, 0xCE7C, 0xC63C, 0xC61C, 0xCE5C, 0xCE5C, 0xD69C, 0xCE3C, 0xC61B,   // 0x12F0 (4848)
+0xC61C, 0xCE5C, 0xC61C, 0xBDDB, 0xC63C, 0xC5FC, 0xBDDB, 0xC5FB, 0xBD9B, 0xB5BB, 0xB5BB, 0xBDDB, 0xAD5A, 0x1014, 0x0814, 0x0814,   // 0x1300 (4864)
+0x0813, 0x0813, 0x0812, 0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1310 (4880)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1320 (4896)
+0x0011, 0x0012, 0x0011, 0x0012, 0x0012, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0814, 0x0833, 0x0814, 0x0814, 0x0834, 0x0814,   // 0x1330 (4912)
+0x0834, 0x0814, 0x0814, 0x0815, 0x0834, 0x0814, 0x0834, 0x0834, 0x0834, 0x0814, 0x0814, 0x0834, 0x0814, 0x0815, 0x0814, 0x0814,   // 0x1340 (4928)
+0x0814, 0x1015, 0x1015, 0x0814, 0x1034, 0x0814, 0x1015, 0x0814, 0x0834, 0x0814, 0x0814, 0x0814, 0x0833, 0x0813, 0x0833, 0x0813,   // 0x1350 (4944)
+0x0812, 0x0012, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1360 (4960)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1370 (4976)
+0x0011, 0x0011, 0x0012, 0x0011, 0x0812, 0x0812, 0x0012, 0x0012, 0x0812, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813,   // 0x1380 (4992)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0814, 0x0813,   // 0x1390 (5008)
+0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0813, 0x0812, 0x0812, 0x0012,   // 0x13A0 (5024)
+0x0812, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x13B0 (5040)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011,   // 0x13C0 (5056)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0012, 0x0012, 0x0812, 0x0812, 0x0812, 0x0812, 0x0812, 0x0812,   // 0x13D0 (5072)
+0x0012, 0x0012, 0x0012, 0x0812, 0x0012, 0x0012, 0x0012, 0x0813, 0x0812, 0x0813, 0x0813, 0x0012, 0x0813, 0x0812, 0x0812, 0x0813,   // 0x13E0 (5088)
+0x0812, 0x0813, 0x0812, 0x0812, 0x0812, 0x0813, 0x0812, 0x0812, 0x0012, 0x0812, 0x0812, 0x0812, 0x0812, 0x0012, 0x0012, 0x0011,   // 0x13F0 (5104)
+0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1400 (5120)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1410 (5136)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0012, 0x0011, 0x0012,   // 0x1420 (5152)
+0x0012, 0x0011, 0x0012, 0x0012, 0x0011, 0x0812, 0x0011, 0x0011, 0x0012, 0x0012, 0x0011, 0x0012, 0x0811, 0x0811, 0x0011, 0x0012,   // 0x1430 (5168)
+0x0011, 0x0012, 0x0011, 0x0011, 0x0012, 0x0811, 0x0012, 0x0012, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0012, 0x0011, 0x0011,   // 0x1440 (5184)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1450 (5200)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1460 (5216)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1470 (5232)
+0x0011, 0x0011, 0x0011, 0x0811, 0x0012, 0x0010, 0x0011, 0x0011, 0x0011, 0x0811, 0x0011, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011,   // 0x1480 (5248)
+0x0011, 0x0012, 0x0011, 0x0012, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1490 (5264)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14A0 (5280)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x14B0 (5296)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14C0 (5312)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0xCE5D, 0x0011, 0x0011, 0xCE5D, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14D0 (5328)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14E0 (5344)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x14F0 (5360)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0xFFFF, 0x0010, 0x0010,   // 0x1500 (5376)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0xFFFF, 0x000D, 0x0011, 0x0011, 0x0011,   // 0x1510 (5392)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1520 (5408)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x1530 (5424)
+0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1540 (5440)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0x0011,   // 0x1550 (5456)
+0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0xFFFF, 0x084D, 0x0010, 0x0010, 0x0011,   // 0x1560 (5472)
+0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010,   // 0x1570 (5488)
+0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011,   // 0x1580 (5504)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1590 (5520)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0010, 0x0010,   // 0x15A0 (5536)
+0xFFFF, 0xFFFF, 0xFFFF, 0x080E, 0x0011, 0x0011, 0x0010, 0xFFFF, 0xFFFF, 0x000F, 0x210F, 0xFFFF, 0xFFFF, 0x000E, 0x0010, 0x0011,   // 0x15B0 (5552)
+0xFFFF, 0xFFFF, 0x0010, 0x0010, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0xFFFF,   // 0x15C0 (5568)
+0xFFFF, 0x0011, 0x0011, 0x0011, 0x082D, 0xFFFF, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x080D, 0xFFFF, 0xFFFF, 0x0010, 0x0011, 0x0011,   // 0x15D0 (5584)
+0xFFFF, 0xFFFF, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x15E0 (5600)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0010, 0x0011,   // 0x15F0 (5616)
+0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0010, 0x0011, 0xFFFF,   // 0x1600 (5632)
+0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x1610 (5648)
+0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010,   // 0x1620 (5664)
+0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1630 (5680)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011,   // 0x1640 (5696)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0xFFFF, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011, 0xFFFF,   // 0x1650 (5712)
+0xFFFF, 0xFFFF, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011,   // 0x1660 (5728)
+0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0xF77E, 0x0010, 0x0010, 0x0011,   // 0x1670 (5744)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1680 (5760)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0x0011,   // 0x1690 (5776)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0010, 0xFFFF,   // 0x16A0 (5792)
+0x080D, 0x0011, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x16B0 (5808)
+0x0010, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x16C0 (5824)
+0xFFFF, 0x0010, 0x0010, 0xFFFF, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x16D0 (5840)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0xFFFF, 0x000F, 0x0011, 0x0010,   // 0x16E0 (5856)
+0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0010, 0x0011, 0xFFFF,   // 0x16F0 (5872)
+0x082D, 0x0010, 0x0010, 0x0011, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x1700 (5888)
+0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1710 (5904)
+0xFFFF, 0x0011, 0x0010, 0xFFFF, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1720 (5920)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0xFFFF, 0xFFFF, 0xFFFF, 0x0010, 0x0011,   // 0x1730 (5936)
+0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0xFFFF, 0x000E, 0x0011, 0x0010, 0x0011, 0xFFFF, 0xFFFF, 0x0010, 0x0011,   // 0x1740 (5952)
+0xFFFF, 0xFFFF, 0xFFFF, 0x000F, 0x0010, 0xFFFF, 0x0010, 0x0010, 0xFFFF, 0x0010, 0x0011, 0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0010,   // 0x1750 (5968)
+0x0011, 0xFFFF, 0x0011, 0x0010, 0x000E, 0xFFFF, 0xFFFF, 0xFFFF, 0x0011, 0x0010, 0x000F, 0xFFFF, 0xFFFF, 0xFFFF, 0x0011, 0x0011,   // 0x1760 (5984)
+0xFFFF, 0x0011, 0x0011, 0xFFFF, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1770 (6000)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1780 (6016)
+0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1790 (6032)
+0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x17A0 (6048)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x000D, 0xC5FD, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010,   // 0x17B0 (6064)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x17C0 (6080)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x17D0 (6096)
+0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x17E0 (6112)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x17F0 (6128)
+0x0011, 0x0011, 0x0011, 0x0010, 0x002D, 0xFFFF, 0xFFFF, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x1800 (6144)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1810 (6160)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x1820 (6176)
+0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011,   // 0x1830 (6192)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010,   // 0x1840 (6208)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011,   // 0x1850 (6224)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1860 (6240)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1870 (6256)
+0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011,   // 0x1880 (6272)
+0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0010,   // 0x1890 (6288)
+0x0010, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x18A0 (6304)
+0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x18B0 (6320)
+0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x18C0 (6336)
+0x0011, 0x0010, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x18D0 (6352)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011, 0x0011, 0x0011,   // 0x18E0 (6368)
+0x0011, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0010, 0x0011,   // 0x18F0 (6384)
+0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0010, 0x0010, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011, 0x0011,   // 0x1900 (6400)
+};

_719/internet.ino

@@ -0,0 +1,295 @@
+void internet()
+{ //Serial2.setTimeout(5000);
+  char* name;
+  char* name1;
+  boolean bad = 0;
+  int i;
+   char c7 ;
+  char c8 ;
+  //  esp8266();
+  //doo:
+    while(Serial2.available()) {
+   
+    c8=Serial2.read();
+    //c7=Serial2.peek();
+    // Serial.print(String(c8));
+    delay(2);
+ 
+ }
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0, 172, 238);
+  myGLCD.setFont(BigFont);
+  // myGLCD.fillScr(VGA_BLUE);
+
+  digitalWrite(18, LOW);
+  delay(3000);
+  digitalWrite(18, HIGH);//reset WIFI
+  myGLCD.print(" openweather " , 280, 457);
+delay(3000);
+ // myGLCD.print("   connecting    " , 280, 457);
+  //***************************
+ while(Serial2.available()) {
+if (Serial2.find("hi"))
+    {     
+    myGLCD.print("WiFi connected" ,280, 457);  
+    }
+}
+ //**************************************
+ Serial2.print("7");//проверка подключения к точке доступа если ответ больше 0 то подключились
+delay(1000);
+//myGLCD.print("  read server  " ,280, 457);  
+//***************************
+ i=0;
+while (i<900)
+     {
+ i++;
+ if(Serial2.available()) {
+   if (Serial2.find("IP"))
+    {Serial2.read();
+     // myGLCD.print("  NTP  " ,280, 457);  
+      int ip1 = Serial2.parseInt();
+
+      int ip2 = Serial2.parseInt();
+
+      int ip3 = Serial2.parseInt();
+
+      int ip4 = Serial2.parseInt();
+
+      // Serial1.read();
+      String data1 = "IP:" +  String(ip1) + "." + String(ip2) + "." + String(ip3) + "." + String(ip4) + "   ";
+      // String data1;
+      //  data1 += ip1;
+      //  data1 += ".";
+      //   data1 += ip2;
+      //   data1 += ".";
+      //   data1 += ip3;
+      //   data1 += ".";
+      //   data1 += ip4;
+      //    data1 += "    "
+      myGLCD.print(data1 , 240, 457);
+    }
+   // myGLCD.print("available" , 240, 457);
+    
+    //  myGLCD.print(String(c2) ,520, 457);
+
+  }
+   
+                           
+      if(i>0)delay (10); 
+     }
+//**************************************
+  Serial2.print("1");//проверка подключения к точке доступа если ответ больше 0 то подключились
+  delay(1000);
+  //***************************
+  myGLCD.print("      read server    " , 240, 457);
+  i = 0;
+  //while (i<900)
+  //   {
+  // i++;
+  // if(Serial2.available()) {
+  //                          i=0;
+  //                             if (Serial2.find("1+"))
+  //                           {myGLCD.print("   read server    " ,280, 457);
+  //                            i=1000;
+  //                             }
+
+  //                          }
+  //    if(i>0)delay (10);
+  //    }
+  //**************************************
+  //****************************SD**********************
+  sd.chdir("/");
+  delay (100);
+
+  sd.chdir("progn");
+  delay (100);
+  if (sd.exists("prognoz.txt"))
+  { name = "prognoz1.txt";
+    name1 = "prognoz.txt";
+  }//установка раб директории
+  else
+  { name = "prognoz.txt";
+    name1 = "prognoz1.txt";
+  }
+
+  //  myFile.remove();
+  delay (50);
+  myFile.open(name, O_RDWR | O_CREAT | O_AT_END);
+  delay (50);
+
+  //******************************************************
+
+  i = 0; //счетчик времени
+  int n = 1; // счетчик символов
+  int st = 0;
+  char c ;
+  //Serial2.setTimeout(2000);
+  i = 0;
+  myGLCD.print("    read inform      " , 280, 457);
+  while (i < 600) {
+    if (Serial2.available()) {
+
+      c = Serial2.read();
+
+      myFile.print(c);
+
+      i = 0;
+    }//gotov
+    if (i > 0)delay (10);
+    i++;
+
+
+  }//while
+
+  delay (500);
+//  myGLCD.print("   read inform 2      " , 280, 457);
+  i = 0;
+  while (i < 600) {
+    if (Serial2.available()) {
+
+      c = Serial2.read();
+
+      myFile.print(c);
+
+      i = 0;
+    }//gotov
+    if (i > 0)delay (10);
+    i++;
+
+  }//while
+
+
+
+
+  myGLCD.print("                         ", 118, 457);
+  myGLCD.print("   end read inform     " , 280, 457);
+  int cardSize = myFile.fileSize();
+  //myGLCD.printNumI(st ,150, 230);
+  // myGLCD.printNumI(i ,180, 230);
+  myFile.close();
+  delay (1000);
+  myGLCD.print("                         ", 118, 457);
+  myGLCD.print("     verifying         " , 280, 457);
+  delay (1000);
+  myGLCD.print("                         ", 118, 457);
+  myGLCD.print("file size=" , 280, 457);
+  myGLCD.printNumI(cardSize, 280 + 160, 457);
+  //************proverka file **********************************************
+
+  sd.chdir("/");//установка раб директории
+  delay (1000);
+  sd.chdir("progn");
+  delay (100);
+  myFile.open(name, O_READ);
+  char symbol;
+  i = 0;
+  char token[] = "weatherdata";
+  n = 1;
+  while (  n < 8000) //размер считанного с сайта файла проверяем на наличае в конце </weatherdata>
+  { symbol = myFile.read();
+    if (n > 1000)
+    { if (symbol == token[i])
+      { i = i + 1;
+      }
+      else
+      {
+        i = 0;
+      }
+    }
+    if (i > 9) {
+      break;
+    }
+    n = n + 1;
+  }
+  if (cardSize > 5000) //измерение размера файла если размер больше то считали  все
+  { if (i > 9) { // если есть в конце </weatherdata>
+      wifi = 0;
+      myGLCD.print("   good file W=  " , 280, 457);
+      myGLCD.printNumI(i, 280 + 256, 457);
+      wifih = t.hour; // час обновления данных
+      wifim = t.min; // минуты
+    }
+    else// // если нет в конце </weatherdata> то error
+    { myGLCD.print("    bad file  W=   " , 280, 457);
+      myGLCD.printNumI(i, 280 + 256, 457);
+      wifi = 9;
+      bad = 1;
+    }
+
+  }
+  else//размер меньше то считали не все error
+  { myGLCD.print("      bad file          " , 280, 457);
+    wifi = 9;
+    bad = 1;
+  }
+  myFile.close();
+  delay (1000);
+  sd.chdir("/");//установка раб директории
+  delay (1000);
+  sd.chdir("progn");
+  delay (100);
+  if (bad == 1)
+  { if (sd.exists("Err.txt"))
+    { myFile.open("Err.txt", O_RDWR | O_CREAT | O_AT_END);
+      delay (100);
+      myFile.remove();
+    }
+    delay (100);
+    sd.rename(name, "Err.txt");
+    delay (100);
+
+  }
+  else {
+    myFile.open(name1, O_RDWR | O_CREAT | O_AT_END);
+    delay (100);
+    myFile.remove();
+  }
+
+
+  sd.chdir("/");
+  delay (2000);
+  // myGLCD.print(" end read inform " ,260, 460);
+  myGLCD.print("                          ", 250, 457);
+  clc();
+  digitalWrite(65, LOW);
+  /*   return;
+
+
+
+
+
+  //****Для отладки***************************
+
+
+
+  while(1)
+  {
+    if (myTouch.dataAvailable())
+
+      {
+        myTouch.read();
+       int x=myTouch.getX();
+       int y=myTouch.getY();
+
+           if ((x>=0) && (x<=799))  // Upper row
+        {
+
+          if ((y>=10) && (y<=479))  // яркость
+            {
+               menu();
+            }
+        }
+      }//touch
+   sec=rtc_clock.get_seconds();
+  if (sec==0)
+  {
+  delay(800);
+  clc();
+  }
+
+  }//while
+   // dbgSerial.println(json);
+    //***********************************************************************************
+    */
+}
+//***********************************************

_719/intime.ino

@@ -0,0 +1,299 @@
+void intime()
+{
+  char c7 ;
+  char c8 ;
+  int i = 0;
+  int h1, m1, s1, day1, month1, year1;
+  int cl1 = 0;
+  int save = 0;
+  int x, y;
+  int x1 = 170;
+  int y1 = 200;
+  //doo:
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0, 172, 238);
+  myGLCD.setFont(BigFont);
+
+
+  while (Serial2.available()) { //очистка порта
+
+    c8 = Serial2.read();
+    //c7=Serial2.peek();
+    //Serial.print(String(c8));
+    delay(2);
+
+  }
+
+  digitalWrite(18, LOW);
+  delay(3000);
+  // Serial2.flush();
+  digitalWrite(18, HIGH);//reset WIFI
+  myGLCD.print("     NTP      " , 280, 457);
+
+  delay(3000);
+  //myGLCD.print("   connecting    " ,280, 457);
+  //delay(500);
+  //***************************
+
+
+
+  //****************************************************************************
+  i = 0;
+  while (Serial2.available()) {
+    if (Serial2.find("hi"))
+    {
+      myGLCD.print("WiFi connected" , 280, 457);
+    }
+  }
+
+  //**************************************
+  Serial2.print("7");//проверка подключения к точке доступа если ответ больше 0 то подключились
+  delay(1000);
+  myGLCD.print("  read server  " , 280, 457);
+  //***************************
+  i = 0;
+  while (i < 600)
+  {
+    i++;
+    if (Serial2.available()) {
+      if (Serial2.find("IP"))
+      { Serial2.read();
+
+        int ip1 = Serial2.parseInt();
+
+        int ip2 = Serial2.parseInt();
+
+        int ip3 = Serial2.parseInt();
+
+        int ip4 = Serial2.parseInt();
+
+        // Serial2.read();
+        String data1 = "IP:" +  String(ip1) + "." + String(ip2) + "." + String(ip3) + "." + String(ip4) + "   ";
+        // String data1;
+        //  data1 += ip1;
+        //  data1 += ".";
+        //   data1 += ip2;
+        //   data1 += ".";
+        //   data1 += ip3;
+        //   data1 += ".";
+        //   data1 += ip4;
+        //    data1 += "    "
+        myGLCD.print(data1 , 240, 457);
+      }
+      Serial2.print("2");//проверка подключения к точке доступа если ответ больше 0 то подключились
+      delay(1000);
+      if (Serial2.find("2+"))
+      { myGLCD.print("     read ntp   " , 240, 457);
+        cl1 = 1;
+        i=601;
+        myGLCD.setColor(155, 155, 155);
+        myGLCD.fillRect(160, 140, 660, 390); //тень
+        myGLCD.setColor(0, 0, 155);
+        myGLCD.fillRect(150, 130, 650, 380); //поле
+        myGLCD.setColor(VGA_WHITE);
+        myGLCD.drawRect(160, 140, 640, 370); //обводка
+
+        myGLCD.drawRect(190, 320, 370, 360); //YES
+        myGLCD.drawRect(430, 320, 610, 360); //NO
+        myGLCD.setBackColor(0, 0, 155); //фон цифр
+        myGLCD.print("YES" , 255, 335);
+        myGLCD.print("NO" , 500, 335);
+        myGLCD.print("Set NTP Time" , 300, 140);
+        h1 = Serial2.parseInt();
+        m1 = Serial2.parseInt();
+        s1 = Serial2.parseInt();
+        day1 = Serial2.parseInt();
+        month1 = Serial2.parseInt() * (-1);
+        year1 = Serial2.parseInt() * (-1);
+        //myGLCD.print("   end read NTP   " , 280, 457);
+        if ( year1 == 1970)
+        {
+          Serial2.print("2");
+          delay(1000);
+
+          if (Serial2.find("2+"))
+          {
+            myGLCD.print("    read NTP2    " , 280, 457);
+            delay(1000);
+            h1 = Serial2.parseInt();
+            m1 = Serial2.parseInt();
+            s1 = Serial2.parseInt();
+            day1 = Serial2.parseInt();
+            month1 = Serial2.parseInt() * (-1);
+            year1 = Serial2.parseInt() * (-1);
+          }
+        }
+
+      }
+
+    }
+
+
+    if (i > 0)delay (10);
+  }
+
+  //**************************************
+  if (cl1 == 1 )
+  { myGLCD.setBackColor(0, 0, 155); //фон цифр
+    //***********************************************************************************************************
+    while (1)
+    { t = rtc.getTime();
+      //***********  T  O  U  C  H  ********************
+      if (myTouch.dataAvailable())
+      { //myGLCD.fillScr(0, 0, 0);
+        myTouch.read();
+        x = myTouch.getX();
+        y = myTouch.getY();
+        // Serial.print("xt=");
+        // Serial.println(xt);
+        //  Serial.print("yt=");
+        //  Serial.println(yt);
+        myGLCD.drawPixel(x, y);
+
+        if ((y >= 320) && (y <= 360))
+        { if ((x >= 200) && (x <= 350)) // Upper row
+          { myGLCD.setColor(100, 255, 100);
+            myGLCD.drawRect(190, 320, 370, 360); //YES
+            myGLCD.setFont(BigFont);
+            myGLCD.print("YES" , 255, 335); //The time is set
+            save = 1;
+
+          }
+          if ((x >= 450) && (x = 600)) // Upper row
+          { myGLCD.setColor(255, 50, 0);
+            myGLCD.drawRect(430, 320, 610, 360); //NO
+            myGLCD.setFont(BigFont);
+            myGLCD.print("NO" , 500, 335); //time is not set
+            save = 2;
+          }
+        }
+
+      }
+
+
+
+      if (t.sec != oldsec)
+      { oldsec = t.sec;
+        myGLCD.setFont(BigFont);
+        String data =  String(day1) + "/" + String(month1) + "/" + String(year1);
+        myGLCD.print(data , 330, 175);
+        myGLCD.setFont( SevenSegNumFont);
+        s1++;
+        if (s1 > 59) {
+          s1 = 0;
+          m1++;
+          if (m1 > 59) {
+            h1++;
+            m1 = 0;
+            if (h1 > 23)h1 = 0;
+          }
+        }
+
+        int clockCenterX = 270;
+        int clockCenterY = 220;
+        if (h1 < 10)
+        {
+          myGLCD.printNumI(0, clockCenterX, clockCenterY - 20);
+          myGLCD.printNumI(h1, clockCenterX + 32, clockCenterY - 20);
+        }
+        else
+        {
+          myGLCD.printNumI(h1, clockCenterX, clockCenterY - 20);
+        }
+        myGLCD.print(":", clockCenterX + 64, clockCenterY - 20);
+        if (m1 < 10)
+        {
+          myGLCD.printNumI(0, clockCenterX + 96, clockCenterY - 20);
+          myGLCD.printNumI(m1, clockCenterX + 128, clockCenterY - 20);
+        }
+        else
+        {
+          myGLCD.printNumI(m1, clockCenterX + 96, clockCenterY - 20);
+        }
+        myGLCD.print(":", clockCenterX + 160, clockCenterY - 20);
+        if (s1 < 10)
+        {
+          myGLCD.printNumI(0, clockCenterX + 96 * 2, clockCenterY - 20);
+          myGLCD.printNumI(s1, clockCenterX + 96 * 2 + 32, clockCenterY - 20);
+        }
+        else
+        {
+          myGLCD.printNumI(s1, clockCenterX + 96 * 2, clockCenterY - 20);
+        }
+        if (save == 2)
+        { myGLCD.setFont(BigFont);
+          myGLCD.setColor(0, 0, 155);
+          myGLCD.fillRect(170, 280, 630, 368); //поле
+          myGLCD.setColor(255, 50, 0);
+          myGLCD.print("The time is not set" , 250, 310);
+          delay(3000);
+          return;
+        }
+        if (save == 1)
+        { myGLCD.setFont(BigFont);
+          rtc.setTime(h1, m1, s1);    // Set the time to 12:00:00 (24hr format)
+          rtc.setDate(day1, month1, year1); // Set the date to January 1st, 2014
+          dow = calcDOW(day1, month1, year1);
+          rtc.setDOW(dow);
+          myGLCD.setColor(0, 0, 155);
+          myGLCD.fillRect(170, 280, 630, 368); //поле
+          myGLCD.setColor(100, 255, 100);
+          myGLCD.print("The time is set" , 280, 310);
+          delay(3000);
+          return;
+        }
+      }
+      delay(500);
+    }
+
+  }
+
+}
+//****************************************************************
+void vrem()
+{ //t19:05d29/0915/
+  // peredacha vremeni drugim ds1307
+  min1 = t.min;
+  hour1 = t.hour;
+
+  Serial.print("t");
+
+
+
+  if (hour1 > 9)
+  {
+    Serial.print(hour1);
+  }
+  else
+  { Serial.print("0");
+    Serial.print(hour1);
+  }
+  Serial.print(":");
+  if (min1 > 9)
+  {
+    Serial.print(min1);
+  }
+  else
+  { Serial.print("0");
+    Serial.print(min1);
+  }
+  Serial.print("d");
+  if (date > 9)
+  { Serial.print(date);
+  }
+  else
+  { Serial.print("0");
+    Serial.print(date);
+  }
+  Serial.print("/");
+  if (mon > 9)
+  { Serial.print(mon);
+  }
+  else
+  { Serial.print("0");
+    Serial.print(mon);
+  }
+  Serial.print(t.year - 2000);
+  Serial.print("/");
+}
+

_719/ints.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: ints.jpg
+// Time generated: 14.09.2015 16:54:26
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short ints[0x1900] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0080 (128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00B0 (176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087F,   // 0x00C0 (192)
+0x295D, 0x315A, 0x3196, 0x20D1, 0x10AF, 0x090F, 0x0150, 0x0170, 0x0150, 0x0150, 0x090F, 0x08EF, 0x18B0, 0x2934, 0x2939, 0x211C,   // 0x00D0 (208)
+0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213D, 0x3177, 0x18D0,   // 0x0110 (272)
+0x008D, 0x0170, 0x0212, 0x0315, 0x03F8, 0x049A, 0x04FC, 0x053D, 0x053D, 0x04DB, 0x04BB, 0x045A, 0x0397, 0x02B4, 0x01D1, 0x00EE,   // 0x0120 (288)
+0x18EF, 0x3175, 0x39DB, 0x109F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0130 (304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x31BC, 0x2952, 0x006C, 0x012E, 0x0272,   // 0x0160 (352)
+0x0355, 0x03D7, 0x0418, 0x0439, 0x049A, 0x04DC, 0x053D, 0x05BE, 0x05DF, 0x051D, 0x04FC, 0x04DC, 0x04DB, 0x049A, 0x0479, 0x03D7,   // 0x0170 (368)
+0x0315, 0x01D1, 0x008D, 0x18D0, 0x39BA, 0x10DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01A0 (416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x319C, 0x2152, 0x004A, 0x014E, 0x0292, 0x02F4, 0x0334,   // 0x01B0 (432)
+0x0335, 0x0376, 0x03B7, 0x03D8, 0x057D, 0x063F, 0x0E3F, 0x0E5F, 0x0E3F, 0x0DBE, 0x04FC, 0x04BB, 0x049A, 0x0459, 0x0418, 0x1437,   // 0x01C0 (448)
+0x0BD6, 0x0396, 0x02F5, 0x01F2, 0x006E, 0x08AF, 0x31DA, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01D0 (464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x211F, 0x39D6, 0x002A, 0x00EC, 0x0210, 0x0272, 0x0292, 0x02B3, 0x02D4,   // 0x0200 (512)
+0x0315, 0x0356, 0x0397, 0x03B7, 0x049A, 0x05FE, 0x0E3F, 0x0E5F, 0x163F, 0x0E5F, 0x061F, 0x04DB, 0x045A, 0x0419, 0x2477, 0x7576,   // 0x0210 (528)
+0x8595, 0x95D5, 0x9DD1, 0xB5A8, 0x8C6C, 0x4A4C, 0x104B, 0x20F2, 0x31BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0220 (544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0240 (576)
+0x39BE, 0x6AB9, 0x001F, 0x001F, 0x001F, 0x001F, 0x39FE, 0x18AE, 0x002A, 0x016E, 0x01EF, 0x0210, 0x0231, 0x0251, 0x0293, 0x02B3,   // 0x0250 (592)
+0x02F4, 0x0335, 0x0376, 0x03B7, 0x03B8, 0x059E, 0x0E3F, 0x0E3F, 0x163F, 0x0E3F, 0x0DFF, 0x04BB, 0x0459, 0x0419, 0x03B7, 0x0376,   // 0x0260 (608)
+0x0356, 0x1395, 0x3BD2, 0x8CE7, 0xE662, 0xFFC4, 0xEE06, 0xB3C6, 0x7249, 0x5A59, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0270 (624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x107F,   // 0x0290 (656)
+0xD3A8, 0xD3EA, 0x211F, 0x001F, 0x001F, 0x423B, 0x000B, 0x008A, 0x016E, 0x018E, 0x01AF, 0x01D0, 0x0211, 0x0231, 0x0272, 0x0293,   // 0x02A0 (672)
+0x02B4, 0x02B4, 0x0316, 0x0377, 0x0397, 0x055D, 0x065F, 0x0E3F, 0x0E3F, 0x0E3F, 0x059E, 0x045A, 0x0419, 0x03F8, 0x03B7, 0x0376,   // 0x02B0 (688)
+0x0355, 0x0314, 0x02B3, 0x0212, 0x118A, 0xB444, 0xFEE5, 0xFF65, 0xFEE4, 0xF544, 0xC40E, 0x5ABD, 0x087F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x72F9,   // 0x02E0 (736)
+0xFB40, 0xFBC2, 0xDE7A, 0x73BF, 0x4239, 0x0008, 0x00AA, 0x012D, 0x012D, 0x016E, 0x018E, 0x01AF, 0x01F0, 0x0231, 0x0211, 0x0252,   // 0x02F0 (752)
+0x2333, 0x6495, 0xADB4, 0x33F5, 0x0357, 0x055D, 0x063F, 0x063F, 0x061F, 0x063F, 0x061F, 0x047A, 0x03D8, 0x03B7, 0x0397, 0x0356,   // 0x0300 (768)
+0x0335, 0x0B13, 0x12D1, 0x1270, 0x11EE, 0x59C7, 0xFC04, 0xFD25, 0xFEE6, 0xFF05, 0xFD83, 0xFC85, 0xBC96, 0x423F, 0x001F, 0x001F,   // 0x0310 (784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18DF, 0xE408,   // 0x0330 (816)
+0xFB80, 0xFB80, 0xF4EA, 0x6354, 0x0007, 0x008A, 0x00CC, 0x00EC, 0x010D, 0x012E, 0x016E, 0x018E, 0x01D0, 0x01B0, 0x3312, 0xADB4,   // 0x0340 (832)
+0xFF56, 0xFE91, 0x7B0A, 0x02B3, 0x0419, 0x05FF, 0x05FF, 0x05FF, 0x061F, 0x059E, 0x05FE, 0x04DB, 0x03D8, 0x0397, 0x0376, 0x0315,   // 0x0350 (848)
+0x02F4, 0x22F1, 0x6B2C, 0xB3E8, 0xF568, 0xFDA7, 0xFCA4, 0xFBA3, 0xFC26, 0xFEEF, 0xFF2E, 0xFD66, 0xFC43, 0xED71, 0x529F, 0x003F,   // 0x0360 (864)
+0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x83DD, 0xFBA0,   // 0x0380 (896)
+0xFBA0, 0xFBC0, 0xFBA0, 0x6963, 0x0029, 0x006B, 0x006B, 0x008B, 0x00CC, 0x010D, 0x010D, 0x012E, 0x016F, 0x7BF1, 0xFE92, 0xFE70,   // 0x0390 (912)
+0xFD4D, 0x41E9, 0x01CF, 0x02D3, 0x055C, 0x05BE, 0x05DF, 0x05DE, 0x057D, 0x049B, 0x051C, 0x049A, 0x03F7, 0x0355, 0x0335, 0x03F7,   // 0x03A0 (928)
+0x0375, 0x0293, 0x0272, 0x1251, 0x532E, 0xACCD, 0xFEAD, 0xFEEC, 0xFD45, 0xFBE4, 0xFECE, 0xFF96, 0xFDCB, 0xFC23, 0xF5D1, 0x94DF,   // 0x03B0 (944)
+0x9BB3, 0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xDD94, 0xFB60,   // 0x03D0 (976)
+0xFB60, 0xF320, 0xEAC0, 0xEA60, 0x5905, 0x212B, 0x5AAD, 0xA40D, 0xBC8D, 0xBC8E, 0xA44F, 0x736F, 0xB38A, 0xFD0A, 0xFC47, 0xFBC5,   // 0x03E0 (992)
+0xB225, 0x018D, 0x02B1, 0x03F6, 0x057C, 0x059D, 0x055C, 0x049A, 0x0439, 0x0439, 0x04BA, 0x0397, 0x0335, 0x0396, 0x0458, 0x053B,   // 0x03F0 (1008)
+0x051A, 0x0458, 0x02F3, 0x0251, 0x01D0, 0x014C, 0x31AA, 0xB44A, 0xFF6D, 0xFEEA, 0xFCC3, 0xFF49, 0xFFF7, 0xFDEE, 0xFC04, 0xEE77,   // 0x0400 (1024)
+0xC50F, 0xBCB4, 0x297F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x425F, 0xECEC, 0xF2C0,   // 0x0420 (1056)
+0xEAA0, 0xDA40, 0xD1C0, 0xDA01, 0xF385, 0xF4EB, 0xFD6B, 0xFDAC, 0xFDAD, 0xFDCD, 0xFE0E, 0xFD09, 0xFB84, 0xFB43, 0xFB42, 0xFAC1,   // 0x0430 (1072)
+0x4A09, 0x0372, 0x03F5, 0x04F9, 0x053B, 0x057D, 0x049A, 0x0459, 0x049A, 0x03F8, 0x04FB, 0x051B, 0x04BA, 0x053B, 0x055B, 0x051A,   // 0x0440 (1088)
+0x04F9, 0x051A, 0x03B6, 0x0210, 0x01EF, 0x01AE, 0x014C, 0x00C9, 0x59E6, 0xE5E8, 0xFF69, 0xFE23, 0xFF87, 0xFFD3, 0xFDAD, 0xFCA9,   // 0x0450 (1104)
+0xBDB3, 0xEE67, 0xCE1D, 0x10BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x73BF, 0xDC0A, 0xD9E0,   // 0x0470 (1136)
+0xD1A0, 0xC960, 0xE200, 0xFB02, 0xFB42, 0xFB42, 0xFB84, 0xFBC5, 0xFC06, 0xFC67, 0xFC67, 0xFB43, 0xFB22, 0xFB22, 0xFB41, 0xD241,   // 0x0480 (1152)
+0x0A0B, 0x0392, 0x0456, 0x04D9, 0x053B, 0x055B, 0x055C, 0x055B, 0x04BA, 0x0499, 0x051B, 0x055B, 0x055B, 0x051A, 0x04FA, 0x04FA,   // 0x0490 (1168)
+0x04D9, 0x04D9, 0x0355, 0x0210, 0x01EF, 0x01AF, 0x018E, 0x012B, 0x00AA, 0x18A7, 0xBC65, 0xFF46, 0xFF22, 0xFF47, 0xFF4F, 0xFD4A,   // 0x04A0 (1184)
+0xDC8A, 0xDEA7, 0xF6B2, 0xB5BF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x847F, 0xD329, 0xC0E0,   // 0x04C0 (1216)
+0xC120, 0xEA20, 0xFAC0, 0xFAC0, 0xFAA0, 0xFAC0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE1, 0xFB21, 0xFB01, 0xFB20, 0xB1A1,   // 0x04D0 (1232)
+0x022D, 0x03D4, 0x0477, 0x04FA, 0x051A, 0x051B, 0x053B, 0x053B, 0x053B, 0x053B, 0x053B, 0x051A, 0x051A, 0x04FA, 0x04D9, 0x04D9,   // 0x04E0 (1248)
+0x04B9, 0x0498, 0x0458, 0x03B5, 0x01CF, 0x018E, 0x018E, 0x01AE, 0x00EB, 0x00A9, 0x094B, 0xB427, 0xFEE4, 0xFEC2, 0xFF27, 0xFE6C,   // 0x04F0 (1264)
+0xFCA9, 0xEE65, 0xF6A9, 0xE6DC, 0x4A9F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA53F, 0xBAA9, 0xC0E0,   // 0x0510 (1296)
+0xE260, 0xF280, 0xEA60, 0xF2C0, 0xF2E0, 0xEAE0, 0xEAA0, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFAE0, 0xFAE0, 0xFB00, 0xB100,   // 0x0520 (1312)
+0x70A4, 0x0B92, 0x0498, 0x04D9, 0x04FA, 0x04FA, 0x04FA, 0x051A, 0x051A, 0x051A, 0x051A, 0x04FA, 0x04DA, 0x04D9, 0x04B9, 0x04B9,   // 0x0530 (1328)
+0x0498, 0x0478, 0x0478, 0x0458, 0x0355, 0x01CF, 0x01D0, 0x0375, 0x0251, 0x0250, 0x0291, 0x09ED, 0xD446, 0xFE63, 0xFE82, 0xFEC7,   // 0x0540 (1344)
+0xFD29, 0xFE27, 0xFE85, 0xDE16, 0xB5DE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xADBF, 0xCB49, 0xEA80,   // 0x0560 (1376)
+0xF2E0, 0xEAC0, 0xEA80, 0xEAA0, 0xF2E0, 0xF2E0, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2A0, 0xF2C0, 0xF2E0, 0xFAE0, 0xFAE0, 0xFAE0, 0xB120,   // 0x0570 (1392)
+0xA040, 0x9163, 0x1BD4, 0x04DA, 0x051A, 0x051A, 0x04FA, 0x04D9, 0x04D9, 0x04D9, 0x04D9, 0x04D9, 0x04B9, 0x04B9, 0x0498, 0x0478,   // 0x0580 (1408)
+0x0478, 0x0458, 0x0437, 0x0437, 0x0437, 0x0395, 0x0355, 0x03B6, 0x0396, 0x0355, 0x02F3, 0x0231, 0x3A4C, 0xFCE5, 0xFE22, 0xFE64,   // 0x0590 (1424)
+0xFDC5, 0xFE06, 0xFEA6, 0xDDB0, 0xDEFD, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA51B, 0xE322, 0xFB20,   // 0x05B0 (1456)
+0xF300, 0xF2E0, 0xEB00, 0xF300, 0xEAC0, 0xEAA0, 0xEAC0, 0xEAC0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2E0, 0xC1A0,   // 0x05C0 (1472)
+0xA8E0, 0xC120, 0xB1C2, 0x72CA, 0x22CF, 0x0330, 0x03B3, 0x04B9, 0x04B9, 0x04B9, 0x04B9, 0x04B9, 0x0498, 0x0498, 0x0478, 0x0478,   // 0x05D0 (1488)
+0x0478, 0x0438, 0x0438, 0x03F7, 0x03D6, 0x03B7, 0x03B6, 0x0375, 0x0375, 0x0335, 0x0314, 0x0292, 0x01EF, 0xAB68, 0xFD64, 0xFE03,   // 0x05E0 (1504)
+0xFDC3, 0xFE05, 0xFE46, 0xED2A, 0xCE9A, 0x7BDE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10DF, 0xDC2A, 0xFB60, 0xF340,   // 0x0600 (1536)
+0xEAC0, 0xEB40, 0xFBC1, 0xF320, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xF2A0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2E0, 0xDA20,   // 0x0610 (1552)
+0xB940, 0xC1C0, 0xD9E0, 0xEA40, 0xD1E0, 0x4860, 0x10E4, 0x0457, 0x0498, 0x0498, 0x0498, 0x0478, 0x0478, 0x0458, 0x0458, 0x0437,   // 0x0620 (1568)
+0x0395, 0x03D6, 0x0395, 0x03F6, 0x03D6, 0x03B6, 0x0375, 0x0375, 0x0355, 0x0314, 0x02F4, 0x32D0, 0x0211, 0x62AA, 0xFCE5, 0xFDA3,   // 0x0630 (1584)
+0xFD83, 0xFD84, 0xFDE6, 0xF4C8, 0xC638, 0xAD7D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7B18, 0xF380, 0xF360, 0xEA80,   // 0x0650 (1616)
+0xE2A0, 0xF401, 0xEB81, 0xE280, 0xEAA0, 0xEAA0, 0xEA80, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAC0, 0xFB00, 0xEA80,   // 0x0660 (1632)
+0xC9A0, 0xDA00, 0xE220, 0xEAA0, 0xFC48, 0xFDF0, 0x8CD1, 0x03B5, 0x0437, 0x0457, 0x0478, 0x0478, 0x0458, 0x0458, 0x0437, 0x03F6,   // 0x0670 (1648)
+0x0251, 0x0231, 0x0210, 0x02F4, 0x03B6, 0x0375, 0x0375, 0x0355, 0x0334, 0x02F4, 0x02D5, 0x4208, 0x9349, 0x3A2C, 0xFC46, 0xFDC4,   // 0x0680 (1664)
+0xFDC3, 0xFD04, 0xFD66, 0xFCA7, 0xC5B5, 0xDEFD, 0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0690 (1680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0xE406, 0xF361, 0xE280, 0xE240,   // 0x06A0 (1696)
+0xEB41, 0xF3E1, 0xE2A0, 0xEA80, 0xF2E0, 0xF2E0, 0xEAC0, 0xEAA0, 0xEAC0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB00, 0xFB40, 0xF300,   // 0x06B0 (1712)
+0xD200, 0xE2C2, 0xF4AB, 0xFEF5, 0xF779, 0x740E, 0x0A4D, 0x0373, 0x03D6, 0x0437, 0x0457, 0x0354, 0x02D3, 0x0375, 0x0417, 0x0418,   // 0x06C0 (1728)
+0x02F3, 0x01F0, 0x01F0, 0x01CF, 0x02B2, 0x0396, 0x0355, 0x0315, 0x0314, 0x02F4, 0x02D4, 0x0948, 0xE423, 0xC407, 0xEC07, 0xFDA5,   // 0x06D0 (1744)
+0xFEA4, 0xFCE5, 0xFD05, 0xFC86, 0xC553, 0xD6FC, 0x39FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x06E0 (1760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6AB9, 0xEB80, 0xE2A0, 0xE260, 0xEAA0,   // 0x06F0 (1776)
+0xEBA1, 0xEB01, 0xEA80, 0xF300, 0xF320, 0xF2E0, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB00, 0xFB41, 0xFB61, 0xFB82,   // 0x0700 (1792)
+0xF3A5, 0xFDD2, 0xFF37, 0xCDD2, 0x29E8, 0x01AA, 0x02D0, 0x0352, 0x03B5, 0x03F7, 0x03F7, 0x0272, 0x0210, 0x0210, 0x02B3, 0x0355,   // 0x0710 (1808)
+0x02B2, 0x01AF, 0x01CF, 0x01AE, 0x01F0, 0x0355, 0x0335, 0x0314, 0x02F4, 0x02D4, 0x02B4, 0x010A, 0xB363, 0xFE26, 0xFC06, 0xFD26,   // 0x0720 (1824)
+0xFF85, 0xFD05, 0xFCA5, 0xFC65, 0xD50F, 0xD658, 0x6B3E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0730 (1840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xAB6E, 0xE240, 0xDA20, 0xEAC0, 0xEB00,   // 0x0740 (1856)
+0xEB61, 0xEA80, 0xEB00, 0xFB60, 0xF300, 0xEAA0, 0xF2A0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB20, 0xFB40, 0xFB62, 0xFBA3, 0xFBC3,   // 0x0750 (1872)
+0xFC04, 0xFD0B, 0xAC8F, 0x0926, 0x01AA, 0x024E, 0x02D0, 0x0353, 0x03B6, 0x03D6, 0x03F7, 0x02F3, 0x01F0, 0x0210, 0x01CF, 0x01CF,   // 0x0760 (1888)
+0x01CF, 0x01AF, 0x018F, 0x018E, 0x0251, 0x02F4, 0x0314, 0x02F4, 0x02D4, 0x0293, 0x0272, 0x006A, 0x8263, 0xFF06, 0xFC67, 0xFD06,   // 0x0770 (1904)
+0xFFE5, 0xFD45, 0xFC46, 0xFC65, 0xDCCD, 0xD530, 0xBD7A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0780 (1920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0xCB09, 0xA8A0, 0xDA00, 0xF340, 0xF320,   // 0x0790 (1936)
+0xEAC0, 0xE280, 0xF360, 0xFB60, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2C0, 0xFAE0, 0xFB20, 0xFB41, 0xFB82, 0xFBA3, 0xFBE4, 0xFC04,   // 0x07A0 (1952)
+0xFC25, 0xFC66, 0x4A07, 0x018B, 0x024D, 0x02B0, 0x0333, 0x0375, 0x0396, 0x03B6, 0x03D6, 0x02B3, 0x01AE, 0x01CF, 0x01AF, 0x01AE,   // 0x07B0 (1968)
+0x018F, 0x018E, 0x016E, 0x016E, 0x018E, 0x01F0, 0x02D4, 0x02D4, 0x02B4, 0x0190, 0x004C, 0x00CB, 0x7A23, 0xFF66, 0xFD06, 0xFD06,   // 0x07C0 (1984)
+0xFFE6, 0xFE46, 0xFC06, 0xFC46, 0xE4CA, 0xE4EA, 0xEE56, 0x631F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x07D0 (2000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x215F, 0x7A6C, 0x6062, 0xFB20, 0xF360, 0xEAA0,   // 0x07E0 (2016)
+0xE280, 0xEAC0, 0xF3E1, 0xEB00, 0xEA80, 0xF2C0, 0xEAC0, 0xFAC0, 0xFB00, 0xFB20, 0xFB41, 0xFB82, 0xFBA3, 0xFBE4, 0xFC05, 0xFC26,   // 0x07F0 (2032)
+0xFC66, 0xFCC7, 0xA3A9, 0x01ED, 0x02B0, 0x0313, 0x0354, 0x0375, 0x0395, 0x0396, 0x0396, 0x0334, 0x01CF, 0x018E, 0x018E, 0x018E,   // 0x0800 (2048)
+0x016E, 0x016E, 0x014D, 0x012D, 0x014D, 0x0293, 0x02D4, 0x02B3, 0x0293, 0x0273, 0x014F, 0x012D, 0x7A43, 0xFF46, 0xFD67, 0xFD06,   // 0x0810 (2064)
+0xFFE6, 0xFEC6, 0xFBE6, 0xFC26, 0xF506, 0xFD45, 0xE5F4, 0xC65E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0820 (2080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x213F, 0x8457, 0xA982, 0xFBC0, 0xF300, 0xE280,   // 0x0830 (2096)
+0xEA80, 0xEB21, 0xF3C1, 0xE2A0, 0xEAA0, 0xF2C0, 0xFAC0, 0xFB00, 0xFB21, 0xFB61, 0xFBA3, 0xFBC3, 0xFC04, 0xFC25, 0xFC66, 0xFC86,   // 0x0840 (2112)
+0xFCC8, 0xFCE8, 0xE4A9, 0x126E, 0x02D2, 0x0334, 0x0355, 0x0375, 0x0375, 0x0375, 0x0355, 0x0376, 0x02F3, 0x018E, 0x014E, 0x014E,   // 0x0850 (2128)
+0x014D, 0x012D, 0x010D, 0x012D, 0x00EC, 0x016E, 0x02B3, 0x0293, 0x0232, 0x0211, 0x0232, 0x016E, 0x8AA4, 0xFF26, 0xFD86, 0xFD47,   // 0x0860 (2144)
+0xFFA6, 0xFF07, 0xFBE6, 0xFC07, 0xFD46, 0xFDA5, 0xD553, 0xD6BD, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0870 (2160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39FF, 0x93D3, 0xDAA0, 0xF3C1, 0xE280, 0xEAC0,   // 0x0880 (2176)
+0xEA80, 0xEB81, 0xEB21, 0xEA80, 0xF2C0, 0xFAE0, 0xFB00, 0xFB21, 0xFB61, 0xF362, 0xEB22, 0xEB43, 0xE344, 0xF384, 0xEBE5, 0xD3C6,   // 0x0890 (2192)
+0xDC27, 0xFCE8, 0xFD8A, 0x32EF, 0x02B2, 0x0314, 0x0355, 0x0335, 0x0335, 0x0335, 0x0335, 0x0335, 0x0354, 0x02F4, 0x0272, 0x014E,   // 0x08A0 (2208)
+0x010C, 0x010C, 0x010C, 0x010C, 0x00EC, 0x00CB, 0x018E, 0x01AF, 0x010C, 0x216C, 0x01CF, 0x014E, 0xB3A5, 0xFEE6, 0xFD86, 0xFD67,   // 0x08B0 (2224)
+0xFF67, 0xFF27, 0xFC66, 0xFC27, 0xFDC6, 0xFDC6, 0xC511, 0xC63B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x08C0 (2240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x3A1F, 0xA3B0, 0xEB60, 0xEB21, 0xE280, 0xF2E0,   // 0x08D0 (2256)
+0xEAC0, 0xEB61, 0xE2A0, 0xEAA0, 0xF2A0, 0xEAA0, 0xF2C0, 0xF2C0, 0xD200, 0xB120, 0xA900, 0xA900, 0xB120, 0x9920, 0x20E3, 0x00A5,   // 0x08E0 (2272)
+0x08E5, 0x3964, 0x9AA4, 0x326C, 0x0292, 0x02F4, 0x0314, 0x0314, 0x0315, 0x0314, 0x0315, 0x0314, 0x02F4, 0x0315, 0x01CF, 0x00EC,   // 0x08F0 (2288)
+0x00EC, 0x010C, 0x00EB, 0x00CB, 0x00CB, 0x00CB, 0x00AB, 0x008A, 0x006A, 0x5188, 0x3A2B, 0x014F, 0xD466, 0xFE67, 0xFD46, 0xFE07,   // 0x0900 (2304)
+0xFF27, 0xFF27, 0xFD07, 0xFC26, 0xFEC7, 0xFD85, 0xB4B1, 0xBE1A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0910 (2320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4A5F, 0xBBCD, 0xEB60, 0xDA00, 0xE280, 0xF300,   // 0x0920 (2336)
+0xEAE0, 0xEAE1, 0xE280, 0xE280, 0xEA80, 0xEAA0, 0xF2C0, 0xD1E0, 0xA900, 0xA900, 0xA920, 0xA920, 0xC160, 0x5943, 0x0109, 0x014A,   // 0x0930 (2352)
+0x016A, 0x016A, 0x012A, 0x01CD, 0x0292, 0x02D3, 0x02D4, 0x02F4, 0x02F4, 0x02D4, 0x02F4, 0x02F4, 0x02D4, 0x02B3, 0x010C, 0x00EB,   // 0x0940 (2368)
+0x00CB, 0x00CB, 0x00CB, 0x00AB, 0x00AB, 0x00AB, 0x008A, 0x008A, 0x0069, 0x4988, 0x9329, 0x016E, 0xED06, 0xFDE6, 0xFD06, 0xFE67,   // 0x0950 (2384)
+0xFEC7, 0xFF07, 0xFD46, 0xFC67, 0xFFA6, 0xF526, 0xACB1, 0xBDFA, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0960 (2400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5B1F, 0xD42C, 0xE280, 0xC0E0, 0xEAA0, 0xF320,   // 0x0970 (2416)
+0xF320, 0xE280, 0xE280, 0xEA80, 0xE2A0, 0xEAA0, 0xE260, 0xB120, 0xB940, 0xB140, 0xB140, 0xB960, 0xD1E0, 0x69E5, 0x014B, 0x01AC,   // 0x0980 (2432)
+0x01CD, 0x01CE, 0x020E, 0x022F, 0x0271, 0x02B3, 0x02B3, 0x02B3, 0x02B3, 0x02B3, 0x02B4, 0x02B3, 0x02B3, 0x0293, 0x00EC, 0x00AB,   // 0x0990 (2448)
+0x00CB, 0x00CB, 0x00AB, 0x00AA, 0x008A, 0x008A, 0x008A, 0x0069, 0x0029, 0x31AC, 0xDBE7, 0x628B, 0xFD46, 0xFD46, 0xFD06, 0xFEA7,   // 0x09A0 (2464)
+0xFEA7, 0xFEE7, 0xFD06, 0xFD26, 0xFFC7, 0xE446, 0x9C92, 0xC61A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x09B0 (2480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x6BBF, 0xD40B, 0xD160, 0xC100, 0xEAE0, 0xEAC0,   // 0x09C0 (2496)
+0xFB80, 0xE2A0, 0xE280, 0xEA80, 0xEA80, 0xEAC0, 0xC9E0, 0xB960, 0xB980, 0xB980, 0xB980, 0xC1A0, 0xDA00, 0xD2C2, 0x118C, 0x01CF,   // 0x09D0 (2512)
+0x0210, 0x0210, 0x0230, 0x0231, 0x0272, 0x0293, 0x0293, 0x0293, 0x0293, 0x0293, 0x0293, 0x0293, 0x0273, 0x0293, 0x0211, 0x018F,   // 0x09E0 (2528)
+0x008A, 0x008A, 0x008A, 0x008A, 0x0089, 0x0069, 0x0069, 0x0069, 0x008B, 0x21EE, 0xF4C6, 0xF486, 0xFCE6, 0xFCC6, 0xFD66, 0xFEA7,   // 0x09F0 (2544)
+0xFE87, 0xFEA7, 0xFC87, 0xFEA7, 0xFF86, 0xC3E8, 0x94F4, 0xC63A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A00 (2560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x843F, 0xD3EC, 0xC8E0, 0xC960, 0xF300, 0xE260,   // 0x0A10 (2576)
+0xEB40, 0xEB41, 0xE260, 0xEA80, 0xEAA0, 0xEAA0, 0xC9E0, 0xC180, 0xC1A0, 0xC1A0, 0xC9C0, 0xC9C0, 0xDA20, 0xFB00, 0xBAA3, 0x11EF,   // 0x0A20 (2592)
+0x0212, 0x0212, 0x0232, 0x0252, 0x0252, 0x0252, 0x0252, 0x0253, 0x0253, 0x0254, 0x0253, 0x0233, 0x0233, 0x0253, 0x0273, 0x010C,   // 0x0A30 (2608)
+0x006A, 0x006A, 0x0089, 0x0069, 0x0069, 0x0049, 0x0049, 0x010D, 0x0191, 0x19AE, 0xF5A6, 0xFD46, 0xFC46, 0xFC66, 0xFDE7, 0xFE87,   // 0x0A40 (2624)
+0xFE87, 0xFE47, 0xFCC6, 0xFFC7, 0xFEE6, 0xBBCA, 0xA555, 0xCE5B, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0A50 (2640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94FF, 0xC40D, 0xB820, 0xD1C0, 0xF320, 0xE280,   // 0x0A60 (2656)
+0xE2A0, 0xF381, 0xEAA0, 0xEA80, 0xE2A0, 0xEAA0, 0xD1E0, 0xC9C0, 0xC9E0, 0xD1E0, 0xD200, 0xD1E0, 0xDA40, 0xFAE0, 0xFB00, 0xCAE3,   // 0x0A70 (2672)
+0x2A0E, 0x0212, 0x0213, 0x0232, 0x0232, 0x0212, 0x0234, 0x1A50, 0x6ACB, 0x9B2A, 0xAB8A, 0x93AD, 0x530F, 0x01F1, 0x0233, 0x018F,   // 0x0A80 (2688)
+0x0089, 0x0069, 0x0049, 0x0049, 0x0048, 0x0048, 0x0028, 0x006A, 0x0150, 0x218D, 0xF5A5, 0xFE26, 0xFC06, 0xFCA6, 0xFE46, 0xFE67,   // 0x0A90 (2704)
+0xFE67, 0xFDA6, 0xFE07, 0xFFE7, 0xFDE5, 0xA3CB, 0xAD97, 0xD67C, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AA0 (2720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94FF, 0xBC71, 0xA800, 0xD9E0, 0xF340, 0xE260,   // 0x0AB0 (2736)
+0xE260, 0xEB00, 0xEB21, 0xE280, 0xEAA0, 0xEAA0, 0xDA00, 0xD1E0, 0xD200, 0xDA20, 0xDA20, 0xDA20, 0xE240, 0xFAE0, 0xFB00, 0xFB00,   // 0x0AC0 (2752)
+0xF301, 0x7269, 0x1A10, 0x01F2, 0x0A11, 0x3A4E, 0x9AC8, 0xEB64, 0xFBC4, 0xFC06, 0xFC26, 0xFCEA, 0xFE0F, 0xBCCE, 0x216C, 0x008A,   // 0x0AD0 (2768)
+0x0069, 0x0049, 0x0048, 0x0048, 0x0048, 0x0028, 0x0027, 0x00AB, 0x0150, 0x318C, 0xFD85, 0xFF26, 0xFC26, 0xFD27, 0xFE27, 0xFE27,   // 0x0AE0 (2784)
+0xFE27, 0xFDA6, 0xFF87, 0xFFE7, 0xEC86, 0x83CE, 0xBDF8, 0xCE7D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0AF0 (2800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94BF, 0xC575, 0xA800, 0xDA00, 0xEB00, 0xE240,   // 0x0B00 (2816)
+0xE280, 0xE280, 0xEB00, 0xEAC0, 0xEA80, 0xEAA0, 0xE260, 0xDA00, 0xDA20, 0xDA40, 0xE260, 0xE260, 0xE240, 0xFAE0, 0xFAE0, 0xFAE0,   // 0x0B10 (2832)
+0xFB00, 0xFB20, 0xEB01, 0xD303, 0xE303, 0xFB41, 0xFB61, 0xFB63, 0xFB62, 0xFB82, 0xFBA2, 0xFBC3, 0xFCEB, 0xFEF3, 0xC4AE, 0x0027,   // 0x0B20 (2848)
+0x0048, 0x0048, 0x0048, 0x0048, 0x0027, 0x0027, 0x0006, 0x00ED, 0x0110, 0x49CB, 0xFD85, 0xFF26, 0xFCA6, 0xFDA6, 0xFE07, 0xFDE7,   // 0x0B30 (2864)
+0xFDC7, 0xFEC7, 0xFFE7, 0xFF67, 0xD407, 0x8C71, 0xCE38, 0xB59D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B40 (2880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7BDF, 0xCE18, 0xA821, 0xD1C0, 0xE2E0, 0xDA20,   // 0x0B50 (2896)
+0xEAA0, 0xE280, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xEAA0, 0xE240, 0xE240, 0xE260, 0xEA80, 0xEAA0, 0xEA80, 0xE240, 0xE260, 0xFB40,   // 0x0B60 (2912)
+0xFB00, 0xFB20, 0xFB20, 0xFB20, 0xFB41, 0xFB41, 0xFB41, 0xFB61, 0xFB81, 0xFB82, 0xFB01, 0xFAA0, 0xE384, 0xE468, 0x9B47, 0x0027,   // 0x0B70 (2928)
+0x0028, 0x0028, 0x0028, 0x0027, 0x0027, 0x0006, 0x0008, 0x010F, 0x00CF, 0x8A89, 0xFDA5, 0xFEE6, 0xFD66, 0xFDA6, 0xFE68, 0xFDC7,   // 0x0B80 (2944)
+0xFE67, 0xFFA7, 0xFFE6, 0xFE06, 0xB388, 0x94F4, 0xD69A, 0x841E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0B90 (2960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5AFF, 0xD6DB, 0x9904, 0xC920, 0xE2E1, 0xD9E0,   // 0x0BA0 (2976)
+0xEAE0, 0xE2A0, 0xEA80, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xEA80, 0xEA60, 0xEA80, 0xEAA0, 0xF2C0, 0xFAC0, 0xEAA0, 0xA0C0, 0xB980,   // 0x0BB0 (2992)
+0xEA80, 0xFAE0, 0xFB40, 0xFB41, 0xFB61, 0xFB81, 0xFB61, 0xF321, 0xEB01, 0xEA40, 0xD1C0, 0x6901, 0x1042, 0x0822, 0x0003, 0x0026,   // 0x0BC0 (3008)
+0x0027, 0x0027, 0x0027, 0x0007, 0x0028, 0x008C, 0x312B, 0x296D, 0x00CE, 0xDBA6, 0xFD85, 0xFEA6, 0xFDA6, 0xFE09, 0xFEEC, 0xFDC6,   // 0x0BD0 (3024)
+0xFF27, 0xFF46, 0xFF47, 0xF4A6, 0x836B, 0xAD76, 0xDEDB, 0x423F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0BE0 (3040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0xDF1D, 0x9B0C, 0xB820, 0xD261, 0xC960,   // 0x0BF0 (3056)
+0xF300, 0xEAA0, 0xE280, 0xEA80, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xF2A0, 0xF2A0, 0xF2C0, 0xFAE0, 0xFAE0, 0xFB00, 0xC9E0, 0x8820,   // 0x0C00 (3072)
+0x9880, 0xA8E0, 0xC180, 0xC9E1, 0xD1E0, 0xD1E0, 0xC9A0, 0xC940, 0xD960, 0xA961, 0x30A2, 0x0003, 0x0004, 0x0004, 0x0005, 0x0006,   // 0x0C10 (3088)
+0x0006, 0x0006, 0x0027, 0x0006, 0x0028, 0x006A, 0xB348, 0x190C, 0x51CB, 0xFC65, 0xFDA5, 0xFE66, 0xFD65, 0xFF90, 0xFE6D, 0xFE66,   // 0x0C20 (3104)
+0xFEC7, 0xFEE6, 0xFE26, 0xE406, 0x8430, 0xBDD7, 0xD6DC, 0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C30 (3120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xC65E, 0xACD3, 0xA800, 0xD201, 0xC0E0,   // 0x0C40 (3136)
+0xF320, 0xEAE0, 0xE280, 0xEA80, 0xEAA0, 0xEAA0, 0xEAA0, 0xEAA0, 0xEAC0, 0xF2C0, 0xFB00, 0xFB00, 0xFB20, 0xFB20, 0xFB40, 0xB960,   // 0x0C50 (3152)
+0x9880, 0xA8A0, 0xA8C0, 0xB0C0, 0xB8E0, 0xC100, 0xC920, 0xB160, 0x6901, 0x0885, 0x0025, 0x0004, 0x0024, 0x0005, 0x0005, 0x0006,   // 0x0C60 (3168)
+0x0006, 0x0006, 0x0006, 0x0027, 0x006E, 0x7A27, 0xDBC5, 0x18CC, 0xDBC6, 0xFCA5, 0xFDA6, 0xFDC6, 0xFEC9, 0xFFF8, 0xFE4A, 0xFE46,   // 0x0C70 (3184)
+0xFE46, 0xFEA6, 0xFD06, 0xAB47, 0x8C93, 0xCE59, 0xB57E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0C80 (3200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x9CFE, 0xC679, 0x9104, 0xC080, 0xB8C0,   // 0x0C90 (3216)
+0xE280, 0xF360, 0xE280, 0xEA80, 0xEA80, 0xEAA0, 0xEA80, 0xEAA0, 0xF2A0, 0xF2C0, 0xF2E0, 0xFB00, 0xFB20, 0xFB21, 0xFB41, 0xFB21,   // 0x0CA0 (3232)
+0xA9A1, 0x7040, 0x78A0, 0x80C0, 0x80E0, 0x58C1, 0x3081, 0x0864, 0x0066, 0x0088, 0x0005, 0x0004, 0x0005, 0x0006, 0x0006, 0x0006,   // 0x0CB0 (3248)
+0x0006, 0x0006, 0x0005, 0x002B, 0x498C, 0xFC64, 0x9266, 0x9287, 0xFC65, 0xFCC5, 0xFD05, 0xFE65, 0xFFF3, 0xFF96, 0xFDC6, 0xFDE7,   // 0x0CC0 (3264)
+0xFE26, 0xFDC7, 0xF425, 0x7B6C, 0xAD55, 0xD6BA, 0x633F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0CD0 (3280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x4A7F, 0xDF1C, 0x932D, 0xA800, 0xB8E0,   // 0x0CE0 (3296)
+0xC980, 0xF380, 0xE281, 0xEA80, 0xEAA0, 0xEA80, 0xEA80, 0xEAA0, 0xEAA0, 0xF2C0, 0xF2C0, 0xF2E0, 0xFAE0, 0xFB21, 0xFB20, 0xFB40,   // 0x0CF0 (3312)
+0xF320, 0x79A2, 0x0004, 0x0004, 0x0004, 0x0005, 0x0006, 0x0068, 0x0089, 0x0048, 0x0004, 0x0004, 0x0005, 0x0006, 0x0006, 0x0006,   // 0x0D00 (3328)
+0x0006, 0x0005, 0x0006, 0x392A, 0xEBE5, 0xFC24, 0xC325, 0xFC25, 0xFC45, 0xFC45, 0xFD65, 0xFFCC, 0xFFFA, 0xFEAE, 0xFD45, 0xFDA7,   // 0x0D10 (3344)
+0xFDC7, 0xFCE6, 0xAB46, 0x7C11, 0xBDD6, 0xDEFC, 0x211F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D20 (3360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x087F, 0xD6BD, 0xAD96, 0x9062, 0xB8A0,   // 0x0D30 (3376)
+0xC180, 0xC9E1, 0xE341, 0xD1E0, 0xEB00, 0xE280, 0xEAA0, 0xEAC0, 0xEAA0, 0xF2C0, 0xF2C0, 0xFAC0, 0xF2E0, 0xFAE0, 0xFB00, 0xFB20,   // 0x0D40 (3392)
+0xFB41, 0xFB60, 0xBA63, 0x30A6, 0x0008, 0x0008, 0x0008, 0x0029, 0x008B, 0x008B, 0x006B, 0x004A, 0x0048, 0x0005, 0x0005, 0x0005,   // 0x0D50 (3408)
+0x0005, 0x0006, 0x5145, 0xEBC5, 0xFC04, 0xFC04, 0xFC24, 0xFC25, 0xFC05, 0xFCE5, 0xFF68, 0xFFF4, 0xFFF6, 0xFD88, 0xFD06, 0xFD46,   // 0x0D60 (3424)
+0xFD26, 0xEC05, 0x732B, 0x9CF4, 0xCE79, 0x9CDE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0D70 (3440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x8C5E, 0xD6DB, 0x8AAB, 0xA800,   // 0x0D80 (3456)
+0xC1C0, 0xB980, 0xC9C1, 0xD241, 0xD1E0, 0xEA80, 0xEAA0, 0xEAE0, 0xF2A0, 0xF2C0, 0xF2C0, 0xF2E0, 0xFAE0, 0xFAE0, 0xFAE0, 0xFB00,   // 0x0D90 (3472)
+0xFB00, 0xFB21, 0xFB60, 0xF341, 0x9204, 0x2889, 0x000B, 0x000C, 0x006D, 0x008D, 0x008E, 0x008F, 0x004A, 0x0007, 0x0006, 0x0005,   // 0x0DA0 (3488)
+0x1065, 0x8A44, 0xFC04, 0xFC04, 0xFBE4, 0xFC04, 0xFC05, 0xFBE5, 0xFCE4, 0xFF67, 0xFFD1, 0xFFF4, 0xFF0F, 0xFC65, 0xFCC6, 0xFCE6,   // 0x0DB0 (3504)
+0xFC86, 0x9307, 0x7C30, 0xB5B6, 0xDEFC, 0x41FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0DC0 (3520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x297F, 0xE71C, 0xA576, 0x8882,   // 0x0DD0 (3536)
+0xB840, 0xCA60, 0xB8C0, 0xC140, 0xC180, 0xD1E0, 0xEAA0, 0xEB20, 0xF2E0, 0xF2A0, 0xF2E0, 0xF2E0, 0xFAC0, 0xFAE0, 0xFB00, 0xFB00,   // 0x0DE0 (3552)
+0xFB00, 0xFB00, 0xFB00, 0xFB21, 0xFB80, 0xF322, 0xAA64, 0x5948, 0x188C, 0x006E, 0x004E, 0x002E, 0x004D, 0x088D, 0x30EB, 0x8A25,   // 0x0DF0 (3568)
+0xE384, 0xFC24, 0xFC04, 0xFBC3, 0xFBE4, 0xFC05, 0xFC04, 0xFD65, 0xFF48, 0xFFAF, 0xFFD1, 0xFFF1, 0xFD47, 0xFC46, 0xFC86, 0xFCA7,   // 0x0E00 (3584)
+0xCBA5, 0x630C, 0xA514, 0xCE79, 0xA53E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E10 (3600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x9CDE, 0xCEDA, 0x8B4D,   // 0x0E20 (3616)
+0xA800, 0xB880, 0xCA60, 0xB080, 0xC180, 0xC140, 0xE240, 0xEB00, 0xF360, 0xF2C0, 0xF2E0, 0xF2E0, 0xF2C0, 0xFAE0, 0xFB00, 0xFB00,   // 0x0E30 (3632)
+0xFB00, 0xFB00, 0xFB20, 0xFB21, 0xFB41, 0xFB61, 0xFB81, 0xFBA1, 0xF342, 0xDB04, 0xC2E4, 0xC2E5, 0xCAE5, 0xE344, 0xFBC3, 0xFC03,   // 0x0E40 (3648)
+0xFBE4, 0xFBC3, 0xFB62, 0xFB41, 0xFB42, 0xFC04, 0xFDE5, 0xFF49, 0xFF6D, 0xFF8E, 0xFFD0, 0xFEAA, 0xFC45, 0xFC46, 0xFC87, 0xEC25,   // 0x0E50 (3664)
+0x5A48, 0x8C72, 0xBDD7, 0xDEFB, 0x319F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0E60 (3680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0xDEFC, 0xADD7,   // 0x0E70 (3696)
+0x7945, 0xB000, 0xB060, 0xB940, 0xB900, 0xC200, 0xC940, 0xE280, 0xD240, 0xEAC0, 0xF2C0, 0xFB00, 0xFAC0, 0xFAC0, 0xFB00, 0xFB00,   // 0x0E80 (3712)
+0xFB00, 0xFB00, 0xFB20, 0xFB20, 0xFB20, 0xFB41, 0xFB61, 0xFB61, 0xFB81, 0xFB81, 0xFBA2, 0xFBC1, 0xFBC2, 0xFBC3, 0xFBC3, 0xFB83,   // 0x0E90 (3728)
+0xFB01, 0xFAC0, 0xFAA0, 0xFB01, 0xFC63, 0xFE25, 0xFF08, 0xFF0B, 0xFF2C, 0xFF8D, 0xFF4C, 0xFCC6, 0xFC26, 0xFC66, 0xFC86, 0x7A65,   // 0x0EA0 (3744)
+0x6BAF, 0xAD55, 0xD699, 0x94BE, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0EB0 (3760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x94DE, 0xD6BA,   // 0x0EC0 (3776)
+0x9492, 0x8841, 0xB800, 0xB000, 0xB000, 0xC180, 0xC200, 0xC900, 0xD220, 0xC1C0, 0xC9A0, 0xE200, 0xFB00, 0xFAE0, 0xFAE0, 0xFB00,   // 0x0ED0 (3792)
+0xFB20, 0xFB00, 0xFB20, 0xFB20, 0xFB20, 0xFB20, 0xFB21, 0xFB41, 0xFB62, 0xFB61, 0xFB62, 0xFB82, 0xFB82, 0xFB21, 0xEA60, 0xEA20,   // 0x0EE0 (3808)
+0xF220, 0xFA80, 0xFB81, 0xFD22, 0xFE23, 0xFE65, 0xFEA8, 0xFEE9, 0xFF2B, 0xFF4A, 0xFD26, 0xFC25, 0xFC66, 0xFCA7, 0xA2E4, 0x52EC,   // 0x0EF0 (3824)
+0x9D13, 0xC618, 0xD6BD, 0x18FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F00 (3840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BF, 0xD6BD,   // 0x0F10 (3856)
+0xC679, 0x7B8E, 0x9000, 0xB800, 0xB000, 0xB000, 0xC1C0, 0xB940, 0xC0E0, 0xCA20, 0xCA60, 0xC160, 0xC920, 0xF280, 0xFB00, 0xFAE0,   // 0x0F20 (3872)
+0xEA60, 0xF2E0, 0xFB20, 0xFB40, 0xFB61, 0xFB40, 0xFB40, 0xFB40, 0xFB21, 0xFB40, 0xFB40, 0xFB01, 0xEA40, 0xD9A0, 0xE1A0, 0xEA40,   // 0x0F30 (3888)
+0xF340, 0xFC60, 0xFD81, 0xFDC2, 0xFDE2, 0xFE23, 0xFE65, 0xFEA8, 0xFF08, 0xFD86, 0xFC05, 0xFC46, 0xFCA6, 0xBB44, 0x4A4A, 0x94B2,   // 0x0F40 (3904)
+0xBDD7, 0xDEFB, 0x527F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0F50 (3920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x52BF,   // 0x0F60 (3936)
+0xDEFB, 0xBE18, 0x6AAA, 0x9800, 0xB800, 0xB000, 0xB000, 0xB900, 0xB060, 0xB840, 0xB940, 0xCAC0, 0xC220, 0xB8C0, 0xC900, 0xE220,   // 0x0F70 (3952)
+0xE220, 0xD1A0, 0xC900, 0xC900, 0xD160, 0xE200, 0xEA80, 0xF2A1, 0xEA80, 0xE200, 0xD9A0, 0xD140, 0xD180, 0xE240, 0xEB20, 0xF400,   // 0x0F80 (3968)
+0xFCA0, 0xFCE0, 0xFD21, 0xFD81, 0xFDC2, 0xFDE3, 0xFE44, 0xFE85, 0xFD45, 0xFC05, 0xFC25, 0xFC86, 0xCB84, 0x4A08, 0x8451, 0xB576,   // 0x0F90 (3984)
+0xD6BA, 0x8C9E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FA0 (4000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FB0 (4016)
+0x947E, 0xDEBA, 0xADD7, 0x6248, 0x9800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB040, 0xC1A0, 0xC240, 0xB100, 0xB020,   // 0x0FC0 (4032)
+0xB860, 0xC0C0, 0xC920, 0xC900, 0xB880, 0xB000, 0xB000, 0xB840, 0xB8A0, 0xB8E0, 0xC960, 0xD200, 0xDA80, 0xE320, 0xEB80, 0xF3E0,   // 0x0FD0 (4048)
+0xF440, 0xFCA0, 0xFD01, 0xFD41, 0xFD82, 0xFDE3, 0xFE04, 0xFCA3, 0xFC05, 0xFC25, 0xFC86, 0xCB84, 0x4A08, 0x7C11, 0xAD55, 0xD699,   // 0x0FE0 (4064)
+0xBDFE, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0FF0 (4080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1000 (4096)
+0x085F, 0xB5DD, 0xD67A, 0xA576, 0x6228, 0x9800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB8C0, 0xB880,   // 0x1010 (4112)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB840, 0xB8A0, 0xC0E0, 0xC160, 0xC9C0, 0xDA40, 0xDAA0, 0xE320, 0xEB80,   // 0x1020 (4128)
+0xF400, 0xFC60, 0xFCC0, 0xFD21, 0xFD82, 0xFD42, 0xFBE2, 0xFB83, 0xFC04, 0xFC66, 0xCB64, 0x41E7, 0x7BF0, 0xA534, 0xCE59, 0xCE7D,   // 0x1030 (4144)
+0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1040 (4160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1050 (4176)
+0x001F, 0x20FF, 0xC65D, 0xCE79, 0xA575, 0x628A, 0x8000, 0xB800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000,   // 0x1060 (4192)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB820, 0xB840, 0xB8A0, 0xC120, 0xC980, 0xD200, 0xDA80, 0xE2E0, 0xEB60,   // 0x1070 (4208)
+0xF3C0, 0xFC20, 0xFCC0, 0xFCE0, 0xFC21, 0xFB21, 0xFB62, 0xFBC3, 0xFC23, 0xAB04, 0x4A28, 0x7BF0, 0xA514, 0xC638, 0xDEDC, 0x39DF,   // 0x1080 (4224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1090 (4240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10A0 (4256)
+0x001F, 0x001F, 0x317F, 0xD69C, 0xCE59, 0xA595, 0x6B6D, 0x68A2, 0xA800, 0xC000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000,   // 0x10B0 (4272)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB020, 0xB820, 0xB860, 0xC0C0, 0xC140, 0xD1A0, 0xD220, 0xDAA0, 0xEB20,   // 0x10C0 (4288)
+0xF3A0, 0xF3E0, 0xFB60, 0xFAC0, 0xFAA0, 0xFB01, 0xFB82, 0xEB62, 0x8223, 0x528A, 0x8431, 0xA514, 0xC639, 0xD6BC, 0x421F, 0x001F,   // 0x10D0 (4304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10E0 (4320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x10F0 (4336)
+0x001F, 0x001F, 0x001F, 0x317F, 0xCE7D, 0xCE79, 0xB5B6, 0x7C51, 0x59C7, 0x7820, 0xB000, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000,   // 0x1100 (4352)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB020, 0xB040, 0xB880, 0xC0E0, 0xC960, 0xD1E0, 0xDA60, 0xE2A0,   // 0x1110 (4368)
+0xE260, 0xEA20, 0xF220, 0xFA60, 0xFAC0, 0xFB00, 0xBA81, 0x59E6, 0x5B0D, 0x8C71, 0xAD55, 0xCE39, 0xDEDC, 0x421F, 0x001F, 0x001F,   // 0x1120 (4384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1130 (4400)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1140 (4416)
+0x001F, 0x001F, 0x001F, 0x001F, 0x211F, 0xB5BD, 0xD69A, 0xBDD7, 0x9D14, 0x6B8E, 0x5145, 0x7800, 0xA800, 0xC000, 0xB800, 0xB000,   // 0x1150 (4432)
+0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB020, 0xB040, 0xB860, 0xB8A0, 0xC100, 0xC940, 0xD160, 0xD960,   // 0x1160 (4448)
+0xE180, 0xE9E0, 0xFA40, 0xFA60, 0xC220, 0x69C3, 0x528A, 0x73F0, 0x94B2, 0xB596, 0xCE79, 0xCE5D, 0x31BF, 0x001F, 0x001F, 0x001F,   // 0x1170 (4464)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1180 (4480)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1190 (4496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x8C7E, 0xDEFB, 0xC638, 0xB576, 0x94D3, 0x636D, 0x51A6, 0x6881, 0x8800, 0xB000,   // 0x11A0 (4512)
+0xB800, 0xB800, 0xB800, 0xB800, 0xB000, 0xB000, 0xB000, 0xB000, 0xB000, 0xB820, 0xB840, 0xB840, 0xC080, 0xC8C0, 0xD920, 0xE160,   // 0x11B0 (4528)
+0xE180, 0xD180, 0x9940, 0x61C4, 0x4A69, 0x6BAE, 0x8C72, 0xA514, 0xBDD7, 0xDEDB, 0xAD9D, 0x20FF, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11C0 (4544)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11D0 (4560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x11E0 (4576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5ADF, 0xCE7C, 0xD6BA, 0xBDF7, 0xAD55, 0x94D3, 0x6BCF, 0x526A, 0x4944,   // 0x11F0 (4592)
+0x6082, 0x7800, 0x8800, 0x9800, 0xA800, 0xB000, 0xB800, 0xB800, 0xB800, 0xB820, 0xB820, 0xB020, 0xA040, 0xA060, 0x90A0, 0x8102,   // 0x1200 (4608)
+0x5943, 0x49C7, 0x52EC, 0x6BCF, 0x8C71, 0x9CF3, 0xB596, 0xCE59, 0xDEFC, 0x841E, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1210 (4624)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1220 (4640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1230 (4656)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BF, 0x843F, 0xDEFC, 0xD69A, 0xC618, 0xAD75, 0x9D13, 0x8C92,   // 0x1240 (4672)
+0x73EF, 0x5B2C, 0x4A49, 0x39A7, 0x4145, 0x4104, 0x48A3, 0x5062, 0x4883, 0x48A3, 0x48E3, 0x3925, 0x39A7, 0x4208, 0x4AAB, 0x636E,   // 0x1250 (4688)
+0x73CF, 0x8450, 0x9492, 0x9D14, 0xB5B6, 0xCE38, 0xDEFB, 0xB5BD, 0x39DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1260 (4704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1270 (4720)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1280 (4736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295F, 0x841F, 0xCE5D, 0xDEDB, 0xCE59, 0xBDD7,   // 0x1290 (4752)
+0xAD75, 0xA535, 0x9CF3, 0x94B2, 0x8C92, 0x8450, 0x7C10, 0x73F0, 0x73CF, 0x7410, 0x7C30, 0x8451, 0x8C71, 0x9492, 0x9CD2, 0x9CF3,   // 0x12A0 (4768)
+0xA534, 0xB596, 0xC618, 0xCE79, 0xDEFB, 0xBE1E, 0x529F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12B0 (4784)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12C0 (4800)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x12D0 (4816)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x089F, 0x52DF, 0xA51E, 0xCE7C,   // 0x12E0 (4832)
+0xDEFB, 0xD69A, 0xC659, 0xC618, 0xBDD7, 0xB5B6, 0xB595, 0xB576, 0xAD75, 0xAD75, 0xB596, 0xB596, 0xBDD7, 0xBDF8, 0xC618, 0xCE7A,   // 0x12F0 (4848)
+0xD6BA, 0xDEFC, 0xC61D, 0x9CDE, 0x421F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1300 (4864)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1310 (4880)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1320 (4896)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10BF,   // 0x1330 (4912)
+0x529F, 0x7BDE, 0xA4FE, 0xC65D, 0xDEFC, 0xDEFC, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFB, 0xDEFC, 0xCE7D, 0xAD5E, 0x949E,   // 0x1340 (4928)
+0x6B7F, 0x39DF, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1350 (4944)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1360 (4960)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1370 (4976)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1380 (4992)
+0x001F, 0x001F, 0x001F, 0x18DF, 0x319F, 0x421F, 0x52BF, 0x62FF, 0x7BDF, 0x73BF, 0x527F, 0x41FF, 0x39DF, 0x18FF, 0x001F, 0x001F,   // 0x1390 (5008)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13A0 (5024)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13B0 (5040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13C0 (5056)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13D0 (5072)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13E0 (5088)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x13F0 (5104)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1400 (5120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1410 (5136)
+0x001F, 0x001F, 0x001F, 0x41FF, 0x41FF, 0x089F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1420 (5152)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1430 (5168)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1440 (5184)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1450 (5200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1460 (5216)
+0x001F, 0x001F, 0x001F, 0xFFDF, 0xFFFF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7BFF,   // 0x1470 (5232)
+0x6B9F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1480 (5248)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x109F, 0x7BFF, 0x7BFF,   // 0x1490 (5264)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14A0 (5280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14B0 (5296)
+0x001F, 0x001F, 0x41FF, 0xFFFF, 0xCE7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xB57F, 0xFFFF,   // 0x14C0 (5312)
+0x4A7F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14D0 (5328)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xAD7F, 0xFFFF, 0x41FF,   // 0x14E0 (5344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x14F0 (5360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1500 (5376)
+0x001F, 0x001F, 0x6B7F, 0xFFDF, 0xA4FF, 0x001F, 0x947F, 0xBDFF, 0xA4FF, 0xDEFE, 0xDEFF, 0x62FF, 0x001F, 0x947F, 0xEF7F, 0xFFFF,   // 0x1510 (5392)
+0xCE9F, 0x089F, 0x3A1F, 0xD67F, 0xFFDF, 0xCE7F, 0x4A7F, 0x001F, 0x001F, 0x9CFF, 0xBDFF, 0x527F, 0xF77F, 0x62FF, 0x947F, 0xBDFF,   // 0x1520 (5408)
+0xA4FF, 0xE6FF, 0xDEFF, 0x5AFF, 0x001F, 0x001F, 0x7C1F, 0xF77F, 0xFFFF, 0xA4FF, 0x299F, 0x001F, 0x947F, 0xEF7F, 0xFFFF, 0xCE7F,   // 0x1530 (5424)
+0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1540 (5440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1550 (5456)
+0x001F, 0x001F, 0xB57F, 0xFFFF, 0x6B9F, 0x001F, 0xF77F, 0xFFFF, 0xDEFF, 0x8C7F, 0xFFDF, 0xDEFF, 0x001F, 0xB57F, 0xFFFF, 0xEF7F,   // 0x1560 (5472)
+0xC5FF, 0x20FF, 0xEF7F, 0xF77F, 0x9CFF, 0xE6FF, 0xFFFF, 0x089F, 0x109F, 0xFFDF, 0xFFFF, 0xFFDF, 0xBDFF, 0x109F, 0xEF7F, 0xFFFF,   // 0x1570 (5488)
+0xDEFF, 0x9D1F, 0xFFFF, 0xE6FF, 0x001F, 0x737F, 0xFFFF, 0xDEFF, 0x9CFF, 0xFFFF, 0xB57F, 0x001F, 0xBDFF, 0xFFFF, 0xEF7F, 0xBDFF,   // 0x1580 (5504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1590 (5520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15A0 (5536)
+0x001F, 0x001F, 0xE6FF, 0xFFDF, 0x299F, 0x20FF, 0xFFDF, 0xFFFF, 0x191F, 0x20FF, 0xFFFF, 0xD67F, 0x001F, 0x421F, 0xFFFF, 0xAD7F,   // 0x15B0 (5552)
+0x001F, 0x631F, 0xFFDF, 0xB57F, 0x41FF, 0x9CFF, 0xFFDF, 0x62FF, 0x39FF, 0xFFFF, 0xEF7F, 0x317F, 0x001F, 0x191F, 0xFFDF, 0xF77F,   // 0x15C0 (5568)
+0x109F, 0x211F, 0xFFDF, 0xBDFF, 0x001F, 0xCE7F, 0xFFDF, 0x62FF, 0x41FF, 0xDEFF, 0xFFFF, 0x001F, 0x527F, 0xFFFF, 0xB57F, 0x001F,   // 0x15D0 (5584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15E0 (5600)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x15F0 (5616)
+0x001F, 0x109F, 0xFFFE, 0xFFFF, 0x001F, 0x529F, 0xFFFF, 0xAD7F, 0x001F, 0x4A7F, 0xFFDF, 0xB57F, 0x001F, 0x7BFF, 0xFFFF, 0x7BFF,   // 0x1600 (5632)
+0x001F, 0xAD7F, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFDF, 0xFFFF, 0x737F, 0x7BFF, 0xFFFF, 0xA4FF, 0x001F, 0x001F, 0x5AFF, 0xFFFF, 0xAD7F,   // 0x1610 (5648)
+0x001F, 0x62FF, 0xFFFF, 0x9CFF, 0x001F, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0x001F, 0x7BFF, 0xFFFF, 0x737F, 0x001F,   // 0x1620 (5664)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1630 (5680)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1640 (5696)
+0x001F, 0x41FF, 0xFFFF, 0xC5FF, 0x001F, 0x7BFF, 0xFFFF, 0x6B9F, 0x001F, 0x7BFF, 0xFFFF, 0x737F, 0x001F, 0xAD7F, 0xFFFF, 0x41FF,   // 0x1650 (5712)
+0x001F, 0x947F, 0xFFFF, 0x4A7F, 0x109F, 0x6B9F, 0x739F, 0x089F, 0xAD9F, 0xFFFF, 0x4A9F, 0x001F, 0x001F, 0x8C7F, 0xFFDF, 0x6B9F,   // 0x1660 (5728)
+0x001F, 0x8C7F, 0xFFFF, 0x737F, 0x001F, 0xE6FF, 0xEF7F, 0x001F, 0x297F, 0x83FF, 0x3A1F, 0x001F, 0xBDFF, 0xFFFF, 0x39FF, 0x001F,   // 0x1670 (5744)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1680 (5760)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1690 (5776)
+0x001F, 0x83FF, 0xFFFF, 0x8C7F, 0x001F, 0xBDFF, 0xFFFF, 0x39FF, 0x001F, 0xBDFF, 0xFFFF, 0x39FF, 0x001F, 0xBDFF, 0xFFDF, 0xCE9F,   // 0x16A0 (5792)
+0x317F, 0x191F, 0xFFFF, 0xF77F, 0xDEFF, 0xFFDF, 0x9CFF, 0x001F, 0xE6FF, 0xFFFF, 0x109F, 0x001F, 0x001F, 0xBDFF, 0xFFFF, 0x297F,   // 0x16B0 (5808)
+0x001F, 0xBDFF, 0xFFFF, 0x299F, 0x001F, 0x7BFF, 0xFFFF, 0xE6FF, 0xFFFF, 0xFFFF, 0x5AFF, 0x001F, 0xBDFF, 0xFFFF, 0xCE7F, 0x317F,   // 0x16C0 (5824)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16D0 (5840)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x16E0 (5856)
+0x001F, 0x7BFF, 0xBDFF, 0x4A9F, 0x001F, 0xAD7F, 0xC5FF, 0x001F, 0x001F, 0xBDFF, 0xC5FF, 0x001F, 0x001F, 0x41FF, 0xAD9F, 0xBDFF,   // 0x16F0 (5872)
+0x109F, 0x001F, 0x20FF, 0x8C7F, 0xBDFF, 0x737F, 0x109F, 0x001F, 0xBE1F, 0xB57F, 0x001F, 0x001F, 0x001F, 0xC5FF, 0xC5DF, 0x001F,   // 0x1700 (5888)
+0x001F, 0xBDFF, 0xBDFF, 0x001F, 0x001F, 0x001F, 0x4A7F, 0xB57F, 0x9CFF, 0x4A7F, 0x001F, 0x001F, 0x41FF, 0xB57F, 0xBDFF, 0x089F,   // 0x1710 (5904)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1720 (5920)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1730 (5936)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1740 (5952)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1750 (5968)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1760 (5984)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1770 (6000)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1780 (6016)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1790 (6032)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17A0 (6048)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17B0 (6064)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17C0 (6080)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17D0 (6096)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17E0 (6112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x17F0 (6128)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1800 (6144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1810 (6160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1820 (6176)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1830 (6192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1840 (6208)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1850 (6224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1860 (6240)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1870 (6256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1880 (6272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1890 (6288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18A0 (6304)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18B0 (6320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18C0 (6336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18D0 (6352)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18E0 (6368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x18F0 (6384)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x1900 (6400)
+};

_719/jar.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: jar.jpg
+// Time generated: 12.04.2014 23:41:47
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short jar[0x384] ={
+0x012E, 0x014F, 0x014E, 0x09EF, 0x0A10, 0x1A31, 0x2A31, 0x2231, 0x1A70, 0x1A53, 0x2230, 0x1A51, 0x1A71, 0x2252, 0x2252, 0x2251,   // 0x0010 (16)
+0x2251, 0x2252, 0x1A52, 0x1A50, 0x1A32, 0x2251, 0x2251, 0x2231, 0x2251, 0x2A92, 0x22B2, 0x3AB4, 0x3B13, 0x3AF4, 0x092D, 0x014D,   // 0x0020 (32)
+0x0150, 0x0150, 0x11F0, 0x19F0, 0x1A12, 0x1A51, 0x1A32, 0x21F3, 0x1A12, 0x1A31, 0x29F1, 0x2232, 0x1230, 0xFFDF, 0x2251, 0x19F0,   // 0x0030 (48)
+0x2211, 0x2230, 0x2211, 0x1A31, 0x1A11, 0x1A30, 0x29F2, 0x2273, 0x22D2, 0x3AF3, 0x42F3, 0x4353, 0x010B, 0x010C, 0x014E, 0x014F,   // 0x0040 (64)
+0x016F, 0x19D1, 0x11EF, 0x11F1, 0x19F0, 0x19F0, 0x19F1, 0x1211, 0x11EF, 0x1211, 0x11F1, 0xFFFF, 0x11D1, 0x1A12, 0x19B1, 0x21F2,   // 0x0050 (80)
+0x11F1, 0x11F1, 0x19F2, 0x11D2, 0x2231, 0x1A31, 0x3293, 0x3AB4, 0x42F3, 0x4354, 0x010A, 0x010B, 0x012C, 0x094F, 0xFFFF, 0x098F,   // 0x0060 (96)
+0x0991, 0x09B1, 0x09B0, 0x1190, 0x11B2, 0x01B0, 0x09CF, 0x11B1, 0x1190, 0xFFFF, 0x01B0, 0x11B0, 0x09D0, 0x01B0, 0x11B0, 0x09B0,   // 0x0070 (112)
+0x09D0, 0x11D0, 0x0A11, 0x1A0F, 0xFFFF, 0x32B3, 0x4334, 0x4B13, 0x00CA, 0x014C, 0x012C, 0x090E, 0xEFDE, 0xFFFF, 0x1190, 0x0170,   // 0x0080 (128)
+0x01B0, 0x01D0, 0x014F, 0x01B0, 0x0990, 0x0970, 0x0990, 0xF7FF, 0x0991, 0x0190, 0x01CF, 0x01CF, 0x0191, 0x0170, 0x0990, 0x018F,   // 0x0090 (144)
+0x09AF, 0xFFFF, 0xFFFF, 0x2A92, 0x3312, 0x4B33, 0x00EB, 0x00EB, 0x012D, 0x010E, 0x018D, 0xFFDF, 0xFFFF, 0x096E, 0x096F, 0x0150,   // 0x00A0 (160)
+0x098F, 0x0151, 0x0190, 0x0170, 0x01AF, 0x016E, 0x094F, 0x018F, 0x0150, 0x094E, 0x0150, 0x0170, 0x0151, 0x0170, 0xFFFF, 0xFFDF,   // 0x00B0 (176)
+0x2212, 0x32B3, 0x3AF2, 0x3B35, 0x00C9, 0x010B, 0x00CB, 0x012F, 0x016E, 0x016F, 0xFFFF, 0xFFFF, 0x0170, 0x0171, 0x016F, 0x014F,   // 0x00C0 (192)
+0xF7FF, 0xFFDF, 0xFFFF, 0xFFDF, 0xFFFF, 0xF7FF, 0x094E, 0x0190, 0x0150, 0x01AF, 0x016F, 0xFFFF, 0xFFDF, 0x11D1, 0x1210, 0x2A92,   // 0x00D0 (208)
+0x32B2, 0x4313, 0x010A, 0x00EA, 0x010C, 0x014D, 0x012D, 0x0170, 0x0150, 0xFFFE, 0xFFFF, 0x016F, 0x014E, 0xF7FF, 0xE77F, 0xFFFF,   // 0x00E0 (224)
+0xFFFF, 0xFFFF, 0xFFFF, 0xE7DF, 0xFFFF, 0xFFFF, 0x094E, 0x016F, 0x014E, 0xFFFF, 0x018F, 0x09B1, 0x1230, 0x2A73, 0x32F3, 0x4314,   // 0x00F0 (240)
+0x010A, 0x010A, 0x00ED, 0x014B, 0x014F, 0x0150, 0x014E, 0x0170, 0x016F, 0x014E, 0xFFDF, 0xE7DF, 0xFFFF, 0x014F, 0x0190, 0x0150,   // 0x0100 (256)
+0x018E, 0xFFBF, 0xFFFF, 0xE7BF, 0xFFFF, 0x0170, 0x016F, 0x0190, 0x098F, 0x01D1, 0x2212, 0x2272, 0x3B13, 0x42F3, 0x00EB, 0x00EA,   // 0x0110 (272)
+0x094D, 0x012C, 0x0150, 0x014F, 0x018F, 0x016F, 0x014F, 0xFFFF, 0xE7DF, 0xFFFF, 0x0970, 0x016F, 0x014E, 0x0150, 0x016F, 0x096F,   // 0x0120 (288)
+0x014E, 0xFFFF, 0xE7DF, 0xFFFF, 0x014F, 0x0910, 0x0990, 0x0991, 0x1A30, 0x2292, 0x32F2, 0x4333, 0x00EB, 0x00EB, 0x00EC, 0x012D,   // 0x0130 (304)
+0x014F, 0x016E, 0x0170, 0x0151, 0xF7FF, 0xEFFF, 0xF7FF, 0x014F, 0x014E, 0x016F, 0x016F, 0x016F, 0x012F, 0x0191, 0x0170, 0x018D,   // 0x0140 (320)
+0xFFFF, 0xE7DF, 0xFFFF, 0x018F, 0x016F, 0x09D1, 0x19F2, 0x2A92, 0x3AD3, 0x4314, 0x00CA, 0x010B, 0x010D, 0x012C, 0x014E, 0x016E,   // 0x0150 (336)
+0x016F, 0x096E, 0xFFFF, 0xFFFE, 0x016E, 0x016F, 0x018F, 0x0930, 0x0171, 0x016E, 0x094F, 0x014F, 0x0150, 0x012F, 0x016E, 0xFFFF,   // 0x0160 (352)
+0xFFFF, 0x0170, 0x01B1, 0x09AF, 0x1A30, 0x3294, 0x3AB3, 0x3B35, 0x08CA, 0x00EB, 0x010C, 0x016D, 0x014F, 0x0150, 0x014F, 0xFFFF,   // 0x0170 (368)
+0xEFBF, 0xFFFF, 0x0192, 0x014E, 0x014F, 0x0170, 0x0130, 0x014F, 0x016F, 0x014F, 0x0170, 0x0190, 0x0170, 0xF7DF, 0xEFDF, 0xFFFF,   // 0x0180 (384)
+0x098E, 0x09D0, 0x2212, 0x2253, 0x3B14, 0x4333, 0x00EA, 0x012B, 0x010C, 0x012B, 0x014D, 0x012F, 0x014F, 0xFFFF, 0xFFFF, 0x094E,   // 0x0190 (400)
+0x016E, 0x0151, 0x014F, 0x016E, 0x0151, 0x0170, 0x018E, 0x0150, 0x0150, 0x016F, 0x0131, 0x014F, 0xFFDF, 0xFFFE, 0x018F, 0x09D0,   // 0x01A0 (416)
+0x1A10, 0x2A70, 0x32D3, 0x3B53, 0x010A, 0x00AB, 0xC679, 0xDF1B, 0xF77D, 0xEFFE, 0x0950, 0xFFDF, 0xFFFF, 0x016F, 0x016F, 0x018F,   // 0x01B0 (432)
+0x014F, 0x0150, 0x012F, 0x016F, 0x016F, 0x1150, 0x014F, 0x014E, 0x018E, 0x014D, 0xFFFF, 0xFFDF, 0x0971, 0xF7FF, 0xE7FF, 0xFFFF,   // 0x01C0 (448)
+0xFFFF, 0x4312, 0x00CA, 0x010A, 0x010E, 0x012E, 0x014F, 0x0150, 0x0170, 0xFFFF, 0xFFFE, 0x016F, 0x0150, 0x0150, 0x014F, 0x016F,   // 0x01D0 (464)
+0x0190, 0x014F, 0x0150, 0x0150, 0x016F, 0x096F, 0x0152, 0x0190, 0xFFFF, 0xFFFF, 0x018F, 0x11B0, 0x21F0, 0x3252, 0x3AD3, 0x4352,   // 0x01E0 (480)
+0x0108, 0x00EC, 0x010D, 0x010E, 0x014E, 0x014F, 0x094F, 0xFFFF, 0xE7DE, 0x0170, 0x0170, 0x014E, 0x096F, 0x014F, 0x0170, 0x0150,   // 0x01F0 (496)
+0x018E, 0x0170, 0x0170, 0x096F, 0x014F, 0x016E, 0xE7DE, 0xFFFF, 0x0170, 0x09D1, 0x21D1, 0x2A93, 0x3AF4, 0x42F4, 0x00EA, 0x010B,   // 0x0200 (512)
+0x00ED, 0x012C, 0x016E, 0x016F, 0x014D, 0x0970, 0xE7DF, 0xFFDF, 0x0150, 0x0150, 0x012F, 0x098E, 0x014F, 0x0170, 0x0170, 0x0150,   // 0x0210 (528)
+0x0150, 0x016F, 0x0150, 0xFFFF, 0xEFBF, 0x0150, 0x018F, 0x01B1, 0x2211, 0x2A91, 0x32F2, 0x4334, 0x00CA, 0x010B, 0x012C, 0x010C,   // 0x0220 (544)
+0x012E, 0x0170, 0x018E, 0x0170, 0xFFFF, 0xEFBF, 0xF7FF, 0x01B1, 0x0130, 0x014F, 0x018E, 0x018F, 0x016E, 0x018E, 0x0150, 0x016F,   // 0x0230 (560)
+0xFFFF, 0xE7BF, 0xFFFF, 0x0150, 0x016F, 0x09F1, 0x1A31, 0x2A92, 0x32F4, 0x4334, 0x00CA, 0x00EA, 0x012B, 0x012E, 0x112F, 0x012F,   // 0x0240 (576)
+0x018F, 0x016E, 0x014E, 0xFFFF, 0xE7DF, 0xFFFF, 0x016E, 0x0191, 0x016F, 0x014F, 0x0152, 0x014F, 0x096E, 0xFFFE, 0xDFFF, 0xF7FF,   // 0x0250 (592)
+0x018F, 0x016F, 0x0970, 0x09B1, 0x2211, 0x2292, 0x32F3, 0x4B14, 0x00EA, 0x010A, 0x010C, 0x012D, 0x012E, 0x014E, 0x094F, 0x0150,   // 0x0260 (608)
+0x018E, 0x0131, 0xFFFF, 0xEFBF, 0xFFFF, 0xFFFF, 0x094F, 0x0151, 0x016F, 0xF7DF, 0xEFDF, 0xE7BF, 0xF7FF, 0x0970, 0x014F, 0x092F,   // 0x0270 (624)
+0x018F, 0x09B0, 0x19F1, 0x2AB1, 0x3312, 0x42F4, 0x00CA, 0x010B, 0x012C, 0x012D, 0x016E, 0x0150, 0x0151, 0x016E, 0xFFFF, 0x0931,   // 0x0280 (640)
+0x0150, 0xFFFF, 0xFFFF, 0xE7FF, 0xFFDF, 0xFFDF, 0xFFFF, 0xDFFF, 0xFFFD, 0x094F, 0x016F, 0x014D, 0xFFFF, 0xF7FF, 0x0190, 0x01D0,   // 0x0290 (656)
+0x2212, 0x2A73, 0x3AD4, 0x4B15, 0x00EA, 0x00EB, 0x012C, 0x012D, 0x012F, 0x0170, 0x014E, 0xF7FF, 0xFFFF, 0x092F, 0x016F, 0x0170,   // 0x02A0 (672)
+0x018E, 0xFFFF, 0xFFDF, 0xF7FE, 0xFFFF, 0xFFFE, 0x0150, 0x0190, 0x014F, 0x0170, 0x016E, 0xFFFF, 0x096F, 0x09D1, 0x1A10, 0x2A72,   // 0x02B0 (688)
+0x3AD3, 0x4333, 0x00EA, 0x012B, 0x010C, 0x014D, 0x012E, 0x094D, 0xF7FF, 0xFFFF, 0x016E, 0x0151, 0x014F, 0x018F, 0x014F, 0x014F,   // 0x02C0 (704)
+0x0150, 0x016F, 0x014F, 0x016F, 0x0170, 0x014F, 0x0950, 0x0170, 0x016F, 0x0150, 0xFFFF, 0x11B0, 0x1A30, 0x2A72, 0x3AD3, 0x3B33,   // 0x02D0 (720)
+0x010A, 0x00EA, 0x010C, 0x012C, 0xEF5D, 0xF7BF, 0x014F, 0x016F, 0x014F, 0x016F, 0x0170, 0x014F, 0x0170, 0x016E, 0x014E, 0xFFDF,   // 0x02E0 (736)
+0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0xFFFF, 0xFFFE, 0x1A11, 0x2270, 0x3AD4, 0x3B13, 0x0109, 0x00EA,   // 0x02F0 (752)
+0x010C, 0xD6DA, 0xE73D, 0x014F, 0x016F, 0x014F, 0x0150, 0x014E, 0x012E, 0x016F, 0x012F, 0x0150, 0x014E, 0xF7DD, 0x014F, 0x014F,   // 0x0300 (768)
+0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x014F, 0x016E, 0xFFFF, 0xF7DF, 0x2252, 0x32B1, 0x3AF3, 0x00CA, 0x00EB, 0x010C, 0x010D,   // 0x0310 (784)
+0x012D, 0x010D, 0x012F, 0x014D, 0x012D, 0x016F, 0x014F, 0x014D, 0x012D, 0x014F, 0x012D, 0xEF5C, 0x014E, 0x014E, 0x014E, 0x014E,   // 0x0320 (800)
+0x014E, 0x014E, 0x014E, 0x014E, 0x012E, 0x0930, 0xF7FF, 0x11F2, 0x2A52, 0x2AD4, 0x00CA, 0x00CB, 0x010B, 0x010B, 0x010C, 0x014C,   // 0x0330 (816)
+0x014D, 0x012E, 0x012E, 0x012D, 0x012C, 0x012B, 0x016E, 0x010E, 0x012E, 0xDEFC, 0x012D, 0x012D, 0x012D, 0x012D, 0x012D, 0x012D,   // 0x0340 (832)
+0x012D, 0x012D, 0x014D, 0x014D, 0x014F, 0x01AF, 0x1210, 0x2250, 0x00E9, 0x00EB, 0x010A, 0x010B, 0x010C, 0x012C, 0x012C, 0x010D,   // 0x0350 (848)
+0x010D, 0x012D, 0x012D, 0x012D, 0x010D, 0x012C, 0x012C, 0xCE9B, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C,   // 0x0360 (864)
+0x012D, 0x014D, 0x016D, 0x014F, 0x09D1, 0x1A11, 0x08C9, 0x010B, 0x00EB, 0x00EB, 0x010C, 0x00EC, 0x012D, 0x012C, 0x010D, 0x010B,   // 0x0370 (880)
+0x012D, 0x010B, 0x012B, 0x014B, 0x010F, 0x10CA, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010C, 0x010D, 0x012C,   // 0x0380 (896)
+0x10EB, 0x016E, 0x0130, 0x018F, };

_719/kalen.ino

@@ -0,0 +1,297 @@
+
+void kalendar(int days,  int mon, word years)
+//void kalen()
+{
+  char* strm[] = {"JAN","FEBR","MARCH","APRIL","MAY","JUNE","JULY","AUG","SEPT","OCT","NOV","DEC"};
+   char* strw[] = {"MO","TU","WE","TH","FR","SA","SU"};
+ int mon1;
+//  int days;
+  int dmax;
+word years1;
+  byte dow;
+
+  
+//***************************************************************************************** 
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(80, 35, 632, 420);
+  myGLCD.setColor(255,114,0);
+ myGLCD.fillRoundRect(80, 35, 632, 87);
+ 
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+    myGLCD.setColor(255, 255, 255);
+ myGLCD.setFont( Ubuntubold);
+ myGLCD.print(strm[mon-1], 250, 50);
+ myGLCD.printNumI(years, 420, 50);
+ myGLCD.setColor(0, 0, 100);
+ dmax=validmax(days, mon, years);
+ for(int i=0;i<7;i++)//вывод дней недели
+ {
+  if (i>4)
+ {myGLCD.setColor(255, 0, 0); //вывод красным выходных дней
+ }
+   myGLCD.print(strw[i], 104+i*72, 89);
+ }
+  myGLCD.setBackColor( VGA_TRANSPARENT);
+    myGLCD.setColor(0, 0, 255);
+ days=1;
+ int yk=0;
+ dow=calcDOW1(days, mon, years);
+ 
+ for (days=1;days<dmax+1;days++)//вывод чисел календаря
+ {
+ 
+  if (mon==t.mon)// текущая дата
+  {
+   if ( years==t.year)
+   {
+     if ( days==t.date)
+   {
+    //   myGLCD.setColor(200, 200, 200);
+ // myGLCD.fillRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+  
+    if (dow>5)
+ {
+    myGLCD.setColor(250, 198, 239);
+  myGLCD.fillRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+   myGLCD.setColor(255, 0, 0);
+  myGLCD.drawRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+ 
+ }
+ else
+ {
+     myGLCD.setColor(182, 217, 252);
+  myGLCD.fillRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+   myGLCD.setColor(0, 0, 255); 
+     myGLCD.drawRoundRect((dow-1)*72+95, yk*50+125, (dow-1)*72+160, yk*50+170);
+ }
+
+  
+    //  myGLCD.printNumI(days, (dow-1)*72+104, yk*50+135);
+   }
+   }
+  }  
+   
+     
+  if (dow>5)
+ {myGLCD.setColor(255, 0, 0); 
+ }
+ else
+ {
+   myGLCD.setColor(0, 0, 255); 
+ }
+   myGLCD.printNumI(days, (dow-1)*72+104, yk*50+135);//вывод чисел календаря
+   
+ 
+
+
+
+  
+   if (dow>6)
+   {dow=0;
+   yk=yk+1;
+   }
+
+   dow=dow+1;
+ }  
+ 
+ 
+  days=1;
+  if (mon==12)
+  {mon1=1;
+    years1=years+1;
+  }
+  else
+  {
+  mon1=mon+1;
+   years1=years;
+  }
+ dow=calcDOW1(days, mon1, years1); 
+ myGLCD.setColor(100, 100, 100); //*********************************
+ for (days=1;dow<8;days++)
+ {
+ myGLCD.printNumI(days, (dow-1)*72+104, yk*50+135); 
+  dow=dow+1;
+ }
+
+if (mon==1)
+  {mon1=12;
+    years1=years-1;
+  }
+  else
+  {
+  mon1=mon-1;
+  years1=years;
+  }
+dmax=validmax(days, mon1, years1);
+days=dmax;
+ dow=calcDOW1(days, mon1, years1); 
+ if(dow<7)
+ {
+ myGLCD.setColor(100, 100, 100); //*************************
+ for (days=dmax;dow>0;days--)
+ {
+ myGLCD.printNumI(days, (dow-1)*72+104, 135); 
+  dow=dow-1;
+ }
+ }
+}
+
+//******************************kalendar*******************************************************************
+void  kalendarset()  
+{
+  
+
+
+ int  days=t.date;
+int  mon=t.mon;
+ word years=t.year;  
+  
+ kalendar(days, mon, years); 
+
+ 
+// myButtons.setButtonColors(VGA_WHITE,VGA_AQUA,VGA_WHITE,VGA_YELLOW,VGA_RED);
+//   myGLCD.setFont(BigFont);
+//    myButtons.setSymbolFont(Dingbats1_XL);
+ drawButkal();
+
+
+ while(1)
+ {
+ if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+     int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+      if ((y>=390) && (y<=390+30))  // Upper row
+      {
+        
+        if ((x>= 588) && (x<= 588+30))  //X
+             {waitForIt( 588, 390, 588+30, 390+30);
+             return;
+           }
+      } 
+        
+       if ((y>=40) && (y<=40+30))  // Upper row
+      {
+        
+        if ((x>= 588) && (x<= 588+30))  //+
+             {waitForIt( 588, 40, 588+30, 40+30);    
+              mon=mon+1;
+              if (mon>12)
+                 {mon=1;
+                 }
+                   kalendar(days, mon, years);
+                    drawButkal();
+             }
+              if ((x>= 90) && (x<= 90+30))  //-
+             {waitForIt( 90, 40, 90+30, 40+30);  
+              mon=mon-1;
+               if (mon<1)
+               {mon=12;
+                }
+               kalendar(days, mon, years); 
+                drawButkal();
+             }
+       if ((x>= 545) && (x<= 545+30))  //>
+             {waitForIt( 545, 40, 545+30, 40+30);         
+               years=years+1;
+            if (years>2099)
+                {years=2000;
+                }
+               kalendar(days, mon, years);
+               drawButkal();
+             }
+        if ((x>= 135) && (x<= 135+30))  //<
+             {waitForIt( 135, 40, 135+30, 40+30);  
+              years=years-1;
+            if (years<2000)
+              {years=2099;
+              }
+                 kalendar(days, mon, years);
+                      drawButkal();
+             }
+
+     
+      
+      }
+      } 
+   
+
+ sec=t.sec;
+if (sec==0)
+{
+delay(800);
+clc();
+} 
+ 
+ 
+ }
+
+}
+
+byte validmax(byte d, byte m, word y)
+{
+  byte mArr[12] = {31,0,31,30,31,30,31,31,30,31,30,31};
+  byte dmax;
+  
+  if (m==2)
+  {
+    if ((y % 4)==0)
+    {
+      dmax=29;
+    }
+    else
+    {
+      dmax=28;
+    }
+  }
+  else
+  {
+    dmax=mArr[m-1];
+  }
+  
+  return dmax;
+}
+
+
+
+
+byte calcDOW1(byte d, byte m, int y)
+{
+  int dow;
+  byte mArr[12] = {6,2,2,5,0,3,5,1,4,6,2,4};
+  
+  dow = (y % 100);
+  dow = dow*1.25;
+  dow += d;
+  dow += mArr[m-1];
+  if (((y % 4)==0) && (m<3))
+    dow -= 1;
+  while (dow>7)
+    dow -= 7;
+    
+  return dow;
+}
+
+
+
+void drawButkal()// календарь на месяц 
+{
+myGLCD.setColor(255, 255, 255);
+   myGLCD.drawBitmap (588, 390, 30, 30, xf);
+    myGLCD.drawRoundRect (588, 390, 588+30, 390+30);//X
+    
+ myGLCD.drawBitmap (588, 40, 30, 30, ad);
+     myGLCD.drawRoundRect ( 588, 40,  618, 70); //+   
+
+ myGLCD.drawBitmap (90, 40, 30, 30, mi); 
+     myGLCD.drawRoundRect (  90, 40,  120, 70); //-
+
+ myGLCD.drawBitmap (545, 40, 30, 30, pr);
+     myGLCD.drawRoundRect ( 545, 40, 545+30, 40+30);//>
+
+ myGLCD.drawBitmap (135, 40, 30, 30, le);
+     myGLCD.drawRoundRect (  135, 40,  135+30, 40+30);//<
+}    

_719/klok.c

@@ -0,0 +1,408 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: klok.jpg
+// Time generated: 24.03.2014 12:02:06
+// Dimensions    : 80x80 pixels
+// Size          : 12 800 Bytes
+
+const unsigned short klok[0x1900] ={
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0010 (16)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0020 (32)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0030 (48)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0040 (64)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0050 (80)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0060 (96)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0070 (112)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0080 (128)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0090 (144)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00A0 (160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00B0 (176)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00C0 (192)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00D0 (208)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00E0 (224)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x00F0 (240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0100 (256)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0110 (272)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0120 (288)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0130 (304)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0140 (320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0150 (336)
+0x0861, 0x31A6, 0x632C, 0x9492, 0x9CF3, 0x9492, 0x94B2, 0x9CF3, 0x9CF3, 0x9CD3, 0x9CD3, 0x9CD3, 0x9CD3, 0x9CD4, 0xA4D4, 0x9CF4,   // 0x0160 (352)
+0x9CF4, 0x9CF4, 0x9D14, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA514, 0xA534, 0xA534, 0xA514, 0xA514,   // 0x0170 (368)
+0xA514, 0xA514, 0xA514, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x9CF3, 0x8C71, 0x632C, 0x39C7, 0x0861, 0x0000, 0x0000,   // 0x0180 (384)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0190 (400)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB,   // 0x01A0 (416)
+0x7BEF, 0x738E, 0x630C, 0x4A49, 0x4228, 0x4A69, 0x528A, 0x528A, 0x4A69, 0x526A, 0x528A, 0x5A8A, 0x5A8A, 0x5A8B, 0x5A8B, 0x52AB,   // 0x01B0 (432)
+0x52AB, 0x52AB, 0x52CB, 0x5ACB, 0x5ACB, 0x5AEB, 0x5AEB, 0x630C, 0x630B, 0x630C, 0x630C, 0x630C, 0x630C, 0x630C, 0x5AEB, 0x5AEB,   // 0x01C0 (448)
+0x5ACB, 0x5ACB, 0x52AA, 0x52AA, 0x52AA, 0x52AA, 0x528A, 0x528A, 0x528A, 0x528A, 0x52AA, 0x632C, 0x632C, 0x7BEF, 0x630C, 0x0000,   // 0x01D0 (464)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x01E0 (480)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x73AE, 0x632C,   // 0x01F0 (496)
+0x39E7, 0x39E7, 0x4208, 0x4228, 0x39E7, 0x4208, 0x4A49, 0x4A69, 0x4228, 0x4A49, 0x5229, 0x5229, 0x5229, 0x524A, 0x524B, 0x526A,   // 0x0200 (512)
+0x526A, 0x528B, 0x528A, 0x528A, 0x528A, 0x5AAA, 0x5ACA, 0x5ACA, 0x62EB, 0x5AEB, 0x5ACB, 0x5ACB, 0x5ACB, 0x5ACB, 0x52AA, 0x52AA,   // 0x0210 (528)
+0x528A, 0x528A, 0x52AA, 0x528A, 0x528A, 0x4A69, 0x4A69, 0x4A69, 0x4A69, 0x4A49, 0x4228, 0x4A69, 0x4A49, 0x528A, 0x632C, 0x73AE,   // 0x0220 (544)
+0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0230 (560)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x6B6D, 0x52AA, 0x3186,   // 0x0240 (576)
+0x4228, 0x4228, 0x39E7, 0x39E7, 0x4228, 0x4A49, 0x4A69, 0x4A49, 0x4A49, 0x5269, 0x5249, 0x5A49, 0x5249, 0x524A, 0x526A, 0x526A,   // 0x0250 (592)
+0x526A, 0x52AB, 0x52AB, 0x52AB, 0x5AAB, 0x5ACA, 0x5ACA, 0x62AA, 0x5ACA, 0x5ACA, 0x5ACB, 0x5ACB, 0x52AA, 0x52AA, 0x52AA, 0x52AA,   // 0x0260 (608)
+0x5ACB, 0x52AA, 0x528A, 0x528A, 0x528A, 0x4A69, 0x4A69, 0x4A49, 0x4A69, 0x4A69, 0x528A, 0x4208, 0x39E7, 0x4208, 0x4208, 0x5ACB,   // 0x0270 (624)
+0x6B6D, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0280 (640)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x5AEB, 0x4A69, 0x31A6, 0x4208,   // 0x0290 (656)
+0x39E7, 0x4208, 0x39E7, 0x4A49, 0x4A49, 0x4208, 0x4208, 0x4A49, 0x4A69, 0x5228, 0x5208, 0x5229, 0x5A8A, 0x5A6A, 0x4A2A, 0x528A,   // 0x02A0 (672)
+0x5A8B, 0x4A09, 0x4A4A, 0x526A, 0x5229, 0x5228, 0x5A48, 0x5A48, 0x5A48, 0x5A8A, 0x528A, 0x528B, 0x52AA, 0x5ACA, 0x5AEB, 0x52AB,   // 0x02B0 (688)
+0x52AA, 0x528A, 0x52AA, 0x528A, 0x528A, 0x528A, 0x4A69, 0x4A69, 0x4A69, 0x4A49, 0x4A49, 0x4228, 0x4A49, 0x4A69, 0x4228, 0x39E7,   // 0x02C0 (704)
+0x52AA, 0x630C, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x02D0 (720)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x4208, 0x39C7, 0x39E7, 0x3186,   // 0x02E0 (736)
+0x39E7, 0x4208, 0x4208, 0x4208, 0x39E7, 0x4208, 0x4A69, 0x4A69, 0x4A49, 0x5249, 0x5249, 0x5A6A, 0x4A08, 0x4A29, 0x526A, 0x4A29,   // 0x02F0 (752)
+0x62EC, 0x9473, 0xB537, 0xD619, 0xEEFC, 0xEF9D, 0xF79E, 0xEF9D, 0xF75C, 0xEEFB, 0xC658, 0xAD35, 0x8C71, 0x632C, 0x4A49, 0x4A69,   // 0x0300 (768)
+0x528A, 0x52AA, 0x52AA, 0x52AA, 0x4A69, 0x4228, 0x4A69, 0x4A49, 0x4A69, 0x528A, 0x4A49, 0x4228, 0x4228, 0x4208, 0x4208, 0x39E7,   // 0x0310 (784)
+0x4228, 0x52AA, 0x528A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0320 (800)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x5AEB, 0x39C7, 0x39E7, 0x3186, 0x4208,   // 0x0330 (816)
+0x39E7, 0x39E7, 0x4208, 0x4228, 0x4228, 0x4228, 0x4228, 0x4208, 0x4228, 0x5248, 0x5249, 0x49E7, 0x41C7, 0x5ACC, 0x9C93, 0xCE5A,   // 0x0340 (832)
+0xEF7D, 0xF7BE, 0xFFDF, 0xFFDF, 0xFFFF, 0xFFBE, 0xFEFB, 0xFF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDE, 0xF79E, 0xEF7D, 0xCE79, 0x8C72,   // 0x0350 (848)
+0x5AEB, 0x4A49, 0x528A, 0x528A, 0x52AA, 0x528A, 0x4A69, 0x52AA, 0x4228, 0x4228, 0x4A69, 0x4228, 0x39E7, 0x4208, 0x4228, 0x4228,   // 0x0360 (864)
+0x4208, 0x4208, 0x630C, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0370 (880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39C7, 0x4228, 0x39C7, 0x39E7, 0x31A6, 0x39E7,   // 0x0380 (896)
+0x39E7, 0x39E7, 0x39E7, 0x4228, 0x4228, 0x39C7, 0x4208, 0x4A49, 0x4A49, 0x5269, 0x41E6, 0x62EB, 0xB555, 0xEF3D, 0xF7BE, 0xFFFF,   // 0x0390 (912)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF9D, 0xFEBA, 0xFF5C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE,   // 0x03A0 (928)
+0xE71C, 0xA514, 0x5AEB, 0x4208, 0x4A69, 0x4A69, 0x528A, 0x4228, 0x4A69, 0x52AA, 0x4A49, 0x4228, 0x4A49, 0x4228, 0x4208, 0x4A49,   // 0x03B0 (944)
+0x4228, 0x39E7, 0x4A49, 0x39C7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x03C0 (960)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4A49, 0x39C7, 0x31A6, 0x4208, 0x39E7, 0x31A6,   // 0x03D0 (976)
+0x39E7, 0x4228, 0x4208, 0x4208, 0x4228, 0x4228, 0x4A69, 0x4A49, 0x3A07, 0x5289, 0xA4F3, 0xE71C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03E0 (992)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF7D, 0xF5D7, 0xFF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x03F0 (1008)
+0xFFFF, 0xF7BE, 0xE71C, 0x9CF3, 0x52AA, 0x4208, 0x52AA, 0x5AEB, 0x4228, 0x4A69, 0x4A49, 0x4228, 0x4A49, 0x4A49, 0x39E7, 0x4208,   // 0x0400 (1024)
+0x4228, 0x4208, 0x4A69, 0x4A49, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0410 (1040)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0x31A6, 0x31A6, 0x39E7, 0x39C7, 0x39C7,   // 0x0420 (1056)
+0x39E7, 0x4208, 0x4228, 0x4208, 0x4228, 0x528A, 0x39E7, 0x31A6, 0x6B4D, 0xCE78, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0430 (1072)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA492, 0xA3CF, 0xEDB6, 0xBC0F, 0xCCD2, 0xFF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0440 (1088)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xCE79, 0x6B4D, 0x39C7, 0x4A49, 0x528A, 0x4A49, 0x4A49, 0x4228, 0x4228, 0x4228, 0x4208, 0x4208,   // 0x0450 (1104)
+0x4208, 0x4208, 0x4A49, 0x52AA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0460 (1120)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0x39C7, 0x39C7, 0x3186, 0x4208, 0x31A6,   // 0x0470 (1136)
+0x39E7, 0x4208, 0x4208, 0x39E7, 0x39E7, 0x39E7, 0x4228, 0x7BEF, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0480 (1152)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD5F8, 0xABEF, 0xDD34, 0xF77D, 0xB4D2, 0xBCD3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0490 (1168)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0x7BCF, 0x4A49, 0x4A49, 0x4A49, 0x4228, 0x4228, 0x4208, 0x4228, 0x4228, 0x4228,   // 0x04A0 (1184)
+0x4208, 0x39E7, 0x39C7, 0x632C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x04B0 (1200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x31A6, 0x39C7, 0x39C7, 0x39E7,   // 0x04C0 (1216)
+0x39E7, 0x4208, 0x39E7, 0x4A49, 0x4208, 0x4208, 0x8C71, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0xC618, 0xFFFF, 0x9CF4, 0xBDD8,   // 0x04D0 (1232)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF6FB, 0xC472, 0xE4F4, 0xFEBA, 0xE575, 0xE659, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6,   // 0x04E0 (1248)
+0xA534, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x8430, 0x4A49, 0x4A49, 0x4A49, 0x4A69, 0x4228, 0x4208, 0x4228, 0x4208,   // 0x04F0 (1264)
+0x39E7, 0x4208, 0x4228, 0x5AEB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0500 (1280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x4208, 0x39C7, 0x39C7, 0x39E7, 0x39C7,   // 0x0510 (1296)
+0x4208, 0x39E7, 0x39C7, 0x4228, 0x4228, 0x8430, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD639, 0xB515, 0xFFBF, 0x8C72, 0xACF6,   // 0x0520 (1312)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE679, 0xD452, 0xC38F, 0xA2EB, 0xD5D6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA514,   // 0x0530 (1328)
+0x73AE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x8C71, 0x4228, 0x4208, 0x4A49, 0x4A49, 0x4228, 0x4228, 0x4208,   // 0x0540 (1344)
+0x4A49, 0x39C7, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0550 (1360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x31A6, 0x31A6, 0x39C7, 0x39E7, 0x39C7,   // 0x0560 (1376)
+0x4228, 0x4208, 0x4228, 0x2945, 0x73AE, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF3D, 0xCDD8, 0xF77E, 0xC639, 0xCDDA,   // 0x0570 (1392)
+0xFFBF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xFD98, 0xC2AD, 0xAACC, 0xCD33, 0xEF3B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE38,   // 0x0580 (1408)
+0xA534, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x73AE, 0x4228, 0x4A49, 0x4A49, 0x4228, 0x39E7, 0x4228,   // 0x0590 (1424)
+0x39E7, 0x4228, 0x4208, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x05A0 (1440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39C7, 0x31A6, 0x31A6, 0x39E7, 0x39E7,   // 0x05B0 (1456)
+0x39E7, 0x39E7, 0x3186, 0x6B4D, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE6FC, 0xC5B7, 0xF79E, 0xC5F8, 0xC5B8,   // 0x05C0 (1472)
+0xFF9F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF5D, 0xF4B4, 0xF597, 0xFF7D, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDB6,   // 0x05D0 (1488)
+0x9492, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0x5AEB, 0x39E7, 0x4228, 0x4208, 0x4A69, 0x4A49,   // 0x05E0 (1504)
+0x39C7, 0x4208, 0x4208, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x05F0 (1520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x39E7, 0x31A6, 0x39C7, 0x39E7,   // 0x0600 (1536)
+0x39C7, 0x31A6, 0x52AA, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xD659, 0xF7BE, 0xCE7A, 0xDE7B,   // 0x0610 (1552)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF3D, 0xFCD5, 0xFE19, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB,   // 0x0620 (1568)
+0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0x528A, 0x4208, 0x4208, 0x4A49, 0x4208,   // 0x0630 (1584)
+0x4208, 0x39E7, 0x4228, 0x52AA, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0640 (1600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39C7, 0x39E7, 0x39C7, 0x39C7, 0x39C7,   // 0x0650 (1616)
+0x4228, 0x31A6, 0x8430, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFBE, 0xFFFF, 0xF7BF, 0xFFBF,   // 0x0660 (1632)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEFC, 0xFC74, 0xFE19, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0670 (1648)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x8410, 0x31A6, 0x4228, 0x39E7, 0x4208,   // 0x0680 (1664)
+0x4228, 0x4208, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0690 (1680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x31A6, 0x31A6, 0x39E7, 0x39C7,   // 0x06A0 (1696)
+0x3186, 0x528A, 0xD69A, 0xFFFF, 0xFFFF, 0xC638, 0xEF5D, 0xFFFF, 0xAD75, 0xD6DA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06B0 (1712)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEDC, 0xFC33, 0xFDF9, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x06C0 (1728)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xBDF7, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0x5ACB, 0x4228, 0x4A49, 0x4228,   // 0x06D0 (1744)
+0x4208, 0x39E7, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x06E0 (1760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5ACB, 0x4208, 0x2965, 0x31A6, 0x4208, 0x39C7,   // 0x06F0 (1776)
+0x2965, 0x9CD3, 0xFFDF, 0xFFFF, 0xFFFF, 0x8430, 0xC618, 0xCE59, 0xBDD7, 0x9CF2, 0xDF1B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0700 (1792)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF1D, 0xFC74, 0xFDF8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0710 (1808)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xD69A, 0xB5B6, 0xEF5D, 0xFFFF, 0xFFFF, 0xF7BE, 0x8C71, 0x2965, 0x4228, 0x4208,   // 0x0720 (1824)
+0x4228, 0x39E7, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0730 (1840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x39C7, 0x31A6, 0x39C7, 0x31A6, 0x39C7,   // 0x0740 (1856)
+0x528A, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0xBDD7, 0xA534, 0xEF7D, 0x9D13, 0xD6BA, 0xFFFF, 0xFFFF, 0xEF5D, 0xFFFF, 0xFFFF,   // 0x0750 (1872)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEFC, 0xFC95, 0xFE39, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0760 (1888)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x9CF3, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0x528A, 0x4208, 0x4208,   // 0x0770 (1904)
+0x39E7, 0x4208, 0x4228, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0780 (1920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x5AEB, 0x39C7, 0x2965, 0x4228, 0x3186, 0x2945,   // 0x0790 (1936)
+0x8430, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0xBDF7, 0x9492, 0xFFFF, 0x9D13, 0xCE58, 0xFFFF, 0xFFFF, 0x9CD2, 0x4A89, 0xCE9A,   // 0x07A0 (1952)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEDC, 0xF433, 0xF5F8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x07B0 (1968)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0xBDF7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x8410, 0x3186, 0x4208,   // 0x07C0 (1984)
+0x39E7, 0x4228, 0x4228, 0x630C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x07D0 (2000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x528A, 0x39E7, 0x39C7, 0x39E7, 0x31A6, 0x39C7,   // 0x07E0 (2016)
+0xBDD7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0xD6BA, 0xDEDB, 0x8451, 0x9492, 0xEF7D, 0xFFFF, 0xFFFF, 0xDEFB, 0x31E7, 0x2104,   // 0x07F0 (2032)
+0xA535, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFEDC, 0xEC11, 0xEDF8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0800 (2048)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA534, 0x39E7, 0xCE79, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDF7, 0x39E7, 0x4A49,   // 0x0810 (2064)
+0x4228, 0x39E7, 0x4208, 0x5AEB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0820 (2080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0x39E7, 0x31A6, 0x31A6, 0x39E7, 0x4A69,   // 0x0830 (2096)
+0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xFFDF, 0xFFFF, 0xCE79, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCEBA, 0x18E3,   // 0x0840 (2112)
+0x0882, 0x8CF3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFE7A, 0xF3F1, 0xF5F7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0850 (2128)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xB5B6, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x528A, 0x4208,   // 0x0860 (2144)
+0x4208, 0x4208, 0x4A49, 0x5ACB, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0870 (2160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39C7, 0x2965, 0x4208, 0x31A6, 0x39C7, 0x73AE,   // 0x0880 (2176)
+0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B7,   // 0x0890 (2192)
+0x18C3, 0x10A2, 0x4B0B, 0xD699, 0xFFFF, 0xFEDC, 0xFC11, 0xFDF8, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08A0 (2208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x738E, 0x4208,   // 0x08B0 (2224)
+0x4208, 0x4208, 0x4A69, 0x528A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x08C0 (2240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0861, 0x10A2, 0x2124, 0x2945, 0x9CF3,   // 0x08D0 (2256)
+0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08E0 (2272)
+0x8C72, 0x0020, 0x0000, 0x39C5, 0xCD55, 0xFEDC, 0xFC73, 0xFE19, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x08F0 (2288)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x94B2, 0x39E7,   // 0x0900 (2304)
+0x4A49, 0x3186, 0x18E3, 0x31A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0910 (2320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0020, 0x0841, 0xAD55,   // 0x0920 (2336)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0930 (2352)
+0xEF7D, 0x52EB, 0x0020, 0x2881, 0x4904, 0x91A8, 0xF26C, 0xFD96, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0940 (2368)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xAD75, 0x1082,   // 0x0950 (2384)
+0x10A2, 0x0841, 0x0000, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0960 (2400)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0xB5B6,   // 0x0970 (2416)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA514, 0xBDF7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0980 (2432)
+0xFFFF, 0xCE79, 0x41E7, 0x4924, 0x79C7, 0xA926, 0xE928, 0xF2AC, 0xFCF4, 0xFEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0990 (2448)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xB596, 0xEF7D, 0xFFFF, 0xFFFF, 0xBDD7, 0x0000,   // 0x09A0 (2464)
+0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x09B0 (2480)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0xCE59,   // 0x09C0 (2496)
+0xFFFF, 0xFFFF, 0xFFFF, 0x9CD3, 0xAD55, 0xB596, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x09D0 (2512)
+0xFFFF, 0xFFFF, 0xBD35, 0x69A6, 0xC32D, 0xFB0F, 0xC844, 0xEA6B, 0xEB8E, 0x89C7, 0x5AEA, 0x73EF, 0x7C30, 0x8470, 0x9D14, 0xBDF7,   // 0x09E0 (2528)
+0xD6BA, 0xE71C, 0xEF5D, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xA514, 0xA534, 0xFFFF, 0xFFFF, 0xC618, 0x0000,   // 0x09F0 (2544)
+0x0000, 0x0000, 0x0020, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0A00 (2560)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0xD69A,   // 0x0A10 (2576)
+0xFFFF, 0xFFFF, 0xFFFF, 0x8C51, 0xD6BA, 0x9492, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A20 (2592)
+0xFFFF, 0xFFFF, 0xFF9E, 0xC451, 0xE3F1, 0xDA4B, 0xB001, 0xD9A9, 0xFB6E, 0x7125, 0x0000, 0x10C3, 0x0000, 0x0000, 0x0040, 0x10C2,   // 0x0A30 (2608)
+0x2104, 0x2945, 0x2965, 0x31A6, 0x4208, 0x62EB, 0x9CF3, 0xE73C, 0xFFFF, 0xE73C, 0x8C71, 0xBDD7, 0xFFFF, 0xFFFF, 0xCE79, 0x0000,   // 0x0A40 (2624)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0A50 (2640)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x0020, 0x0000, 0x0000, 0x0000, 0xD6BA,   // 0x0A60 (2656)
+0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xDEDB, 0x528A, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0A70 (2672)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFEBB, 0xE411, 0xB188, 0xA822, 0xD947, 0xEA2A, 0x6042, 0x0820, 0x1924, 0x10A2, 0x2925, 0x39C7, 0x4A69,   // 0x0A80 (2688)
+0x630C, 0x6B4D, 0x6B6D, 0x7BCF, 0x8430, 0x9CF3, 0xC618, 0xF79E, 0xFFFF, 0xF7BE, 0xAD75, 0x8430, 0xFFFF, 0xFFFF, 0xCE79, 0x0000,   // 0x0A90 (2704)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0AA0 (2720)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0xCE79,   // 0x0AB0 (2736)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDF7, 0xA534, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0AC0 (2752)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFBF, 0xED76, 0xBA6A, 0xB125, 0xD9E8, 0xE2AB, 0xBB4D, 0xAD13, 0xB5B6, 0xBDD7, 0xCE59, 0xD6BA, 0xE73D,   // 0x0AD0 (2768)
+0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xA534, 0xAD55, 0xFFFF, 0xFFFF, 0xC638, 0x0000,   // 0x0AE0 (2784)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0AF0 (2800)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0xBDF7,   // 0x0B00 (2816)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B10 (2832)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF9E, 0xEE17, 0xE535, 0xED75, 0xFE59, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B20 (2848)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0xCE59, 0xFFFF, 0xFFFF, 0xFFDF, 0xA534, 0x0000,   // 0x0B30 (2864)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0B40 (2880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0020, 0x0000, 0x0000, 0x0000, 0xA514,   // 0x0B50 (2896)
+0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B60 (2912)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0B70 (2928)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x9CD3, 0x0000,   // 0x0B80 (2944)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0B90 (2960)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x7BCF,   // 0x0BA0 (2976)
+0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0BB0 (2992)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0BC0 (3008)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0x8410, 0x0000,   // 0x0BD0 (3024)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0BE0 (3040)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x4208,   // 0x0BF0 (3056)
+0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C00 (3072)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C10 (3088)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x39C7, 0x0000,   // 0x0C20 (3104)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0C30 (3120)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841,   // 0x0C40 (3136)
+0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0xCE59, 0xE73C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C50 (3152)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0C60 (3168)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC638, 0x0000, 0x0000,   // 0x0C70 (3184)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0C80 (3200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0C90 (3216)
+0xA534, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x9CF3, 0xBDF7, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CA0 (3232)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CB0 (3248)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0x9CF3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x9CD3, 0x0000, 0x0000,   // 0x0CC0 (3264)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0CD0 (3280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0CE0 (3296)
+0x528A, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x94B2, 0xBDD7, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0CF0 (3312)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D00 (3328)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x630C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x528A, 0x0000, 0x0000,   // 0x0D10 (3344)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D20 (3360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D30 (3376)
+0x0841, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xBDF7, 0xB596, 0x94B2, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D40 (3392)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D50 (3408)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xD6BA, 0x9CF3, 0xA534, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xC618, 0x1082, 0x0000, 0x0000,   // 0x0D60 (3424)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D70 (3440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0D80 (3456)
+0x0000, 0x6B6D, 0xF7BE, 0xFFFF, 0xFFFF, 0xF79E, 0xC618, 0xC638, 0xAD55, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0D90 (3472)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DA0 (3488)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xDEDB, 0x9CD3, 0x738E, 0xE73C, 0xFFFF, 0xFFFF, 0xF7BE, 0x6B6D, 0x0000, 0x0000, 0x0000,   // 0x0DB0 (3504)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0DC0 (3520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0DD0 (3536)
+0x0000, 0x10A2, 0xC618, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xC638, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DE0 (3552)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0DF0 (3568)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDB, 0x9CF3, 0xF79E, 0xFFFF, 0xFFFF, 0xBDF7, 0x18C3, 0x0000, 0x0000, 0x0000,   // 0x0E00 (3584)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E10 (3600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E20 (3616)
+0x0000, 0x0000, 0x52AA, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xEF7D, 0xFFFF,   // 0x0E30 (3632)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0E40 (3648)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x4A69, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E50 (3664)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E60 (3680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0E70 (3696)
+0x0000, 0x0000, 0x0000, 0xA514, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x9CF3, 0xD69A,   // 0x0E80 (3712)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C,   // 0x0E90 (3728)
+0xDEDB, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x94B2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EA0 (3744)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EB0 (3760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EC0 (3776)
+0x0000, 0x0000, 0x0000, 0x2124, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CD3, 0xBDF7,   // 0x0ED0 (3792)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xA514,   // 0x0EE0 (3808)
+0xB5B6, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0EF0 (3824)
+0x0000, 0x0000, 0x0020, 0x2104, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F00 (3840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F10 (3856)
+0x0000, 0x0000, 0x0000, 0x0000, 0x39E7, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, 0xDEDB, 0xEF7D,   // 0x0F20 (3872)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0xB596,   // 0x0F30 (3888)
+0xD6BA, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE59, 0x31A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F40 (3904)
+0x0000, 0x0000, 0x0020, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F50 (3920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F60 (3936)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4A69, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0xCE59, 0xFFFF,   // 0x0F70 (3952)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xE71C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0F80 (3968)
+0xB596, 0xA534, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0x4208, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0F90 (3984)
+0x0000, 0x0000, 0x0020, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FA0 (4000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FB0 (4016)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x4228, 0xCE59, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0xD6BA, 0xFFFF,   // 0x0FC0 (4032)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x9492, 0xB596, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C,   // 0x0FD0 (4048)
+0xAD75, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC638, 0x39E7, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FE0 (4064)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x0FF0 (4080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1000 (4096)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x39C7, 0xBDD7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1010 (4112)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x7BEF, 0xC618, 0xD6BA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xCE79,   // 0x1020 (4128)
+0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x31A6, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1030 (4144)
+0x0000, 0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1040 (4160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2104, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1050 (4176)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2124, 0x94B2, 0xE71C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1060 (4192)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0xB5B6, 0xCE59, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x1070 (4208)
+0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0x94B2, 0x2124, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1080 (4224)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1090 (4240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10A0 (4256)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x52AA, 0xB5B6, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x10B0 (4272)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xD6BA, 0xBDD7, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x10C0 (4288)
+0xFFFF, 0xEF7D, 0xB5B6, 0x528A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10D0 (4304)
+0x0000, 0x0000, 0x0020, 0x18E3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10E0 (4320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x10F0 (4336)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x6B4D, 0xBDD7, 0xE71C, 0xFFFF,   // 0x1100 (4352)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB,   // 0x1110 (4368)
+0xB5B6, 0x6B4D, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1120 (4384)
+0x0000, 0x0000, 0x0020, 0x0861, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1130 (4400)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1140 (4416)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x52AA, 0x9CF3,   // 0x1150 (4432)
+0xC618, 0xDEDB, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0xDEFB, 0xC618, 0x94B2, 0x4A69,   // 0x1160 (4448)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1170 (4464)
+0x0000, 0x0020, 0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1180 (4480)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x0841, 0x0000, 0x0000, 0x0000,   // 0x1190 (4496)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11A0 (4512)
+0x0000, 0x39E7, 0x738E, 0x9CF3, 0xB596, 0xB5B6, 0xBDD7, 0xBDD7, 0xBDD7, 0xAD75, 0x9492, 0x738E, 0x4208, 0x0000, 0x0000, 0x0000,   // 0x11B0 (4528)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11C0 (4544)
+0x0000, 0x0020, 0x18C3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11D0 (4560)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0861, 0x0020, 0x0000, 0x0000,   // 0x11E0 (4576)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x11F0 (4592)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1200 (4608)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1210 (4624)
+0x0000, 0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1220 (4640)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0000,   // 0x1230 (4656)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1240 (4672)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1250 (4688)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020,   // 0x1260 (4704)
+0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1270 (4720)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18E3, 0x0861,   // 0x1280 (4736)
+0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1290 (4752)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12A0 (4768)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x0020, 0x0861,   // 0x12B0 (4784)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12C0 (4800)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3,   // 0x12D0 (4816)
+0x1082, 0x0020, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12E0 (4832)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x12F0 (4848)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0841, 0x0020, 0x1082, 0x0020, 0x0000,   // 0x1300 (4864)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1310 (4880)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1320 (4896)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1330 (4912)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1340 (4928)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, 0x18E3, 0x0841, 0x0000, 0x0000, 0x0000,   // 0x1350 (4944)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1360 (4960)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1370 (4976)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1380 (4992)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1390 (5008)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13A0 (5024)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13B0 (5040)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13C0 (5056)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13D0 (5072)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13E0 (5088)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x13F0 (5104)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1400 (5120)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1410 (5136)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1420 (5152)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1430 (5168)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1440 (5184)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1450 (5200)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1460 (5216)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1470 (5232)
+0x0000, 0x0000, 0x10A2, 0x2945, 0x1082, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x1082, 0x2945, 0x10A2, 0x0000, 0x0000,   // 0x1480 (5248)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1490 (5264)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14A0 (5280)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14B0 (5296)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x18C3, 0x2124, 0x0861, 0x0000, 0x10A2,   // 0x14C0 (5312)
+0x2945, 0x0861, 0x9CF3, 0xFFFF, 0x7BEF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7BEF, 0xFFFF, 0xA514, 0x0000, 0x0000,   // 0x14D0 (5328)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14E0 (5344)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x14F0 (5360)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1500 (5376)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xBDD7, 0xFFFF, 0x5ACB, 0x1082, 0xBDF7,   // 0x1510 (5392)
+0xFFFF, 0x4A49, 0x8410, 0xFFFF, 0x738E, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x738E, 0xFFFF, 0x9492, 0x0000, 0x0000,   // 0x1520 (5408)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1530 (5424)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1540 (5440)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1550 (5456)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0x52AA, 0xAD55, 0xF7BE,   // 0x1560 (5472)
+0x4A69, 0x0000, 0x94B2, 0xFFFF, 0x738E, 0x0000, 0x0861, 0x2104, 0x2104, 0x0861, 0x0000, 0x738E, 0xFFFF, 0x9492, 0x0020, 0x2104,   // 0x1570 (5488)
+0x10A2, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1580 (5504)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1590 (5520)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15A0 (5536)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD55, 0xFFFF, 0xFFFF, 0xF7BE, 0x4A49,   // 0x15B0 (5552)
+0x0000, 0x0000, 0x94B2, 0xFFFF, 0x6B6D, 0x0861, 0x9CF3, 0xFFFF, 0xFFFF, 0x9CF3, 0x0861, 0x738E, 0xFFFF, 0x8C71, 0x6B4D, 0xFFFF,   // 0x15C0 (5568)
+0x9CD3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15D0 (5584)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15E0 (5600)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x15F0 (5616)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0xFFFF, 0x528A, 0x0000,   // 0x1600 (5632)
+0x0000, 0x0000, 0x94B2, 0xFFFF, 0x52AA, 0x7BCF, 0xFFFF, 0x5ACB, 0x5ACB, 0xFFFF, 0x7BCF, 0x52AA, 0xFFFF, 0xFFFF, 0xFFFF, 0x8430,   // 0x1610 (5648)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1620 (5664)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1630 (5680)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1640 (5696)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0xFFFF, 0x6B6D, 0x0020,   // 0x1650 (5712)
+0x0000, 0x0000, 0x94B2, 0xFFFF, 0x5ACB, 0x738E, 0xFFFF, 0x632C, 0x632C, 0xFFFF, 0x738E, 0x5ACB, 0xFFFF, 0xFFFF, 0x8C71, 0x0000,   // 0x1660 (5728)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1670 (5744)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1680 (5760)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1690 (5776)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD55, 0xFFFF, 0xF79E, 0xFFFF, 0x738E,   // 0x16A0 (5792)
+0x0841, 0x0000, 0x94B2, 0xFFFF, 0x5ACB, 0x738E, 0xFFFF, 0x632C, 0x632C, 0xFFFF, 0x738E, 0x52AA, 0xFFFF, 0xFFFF, 0x9CF3, 0x0841,   // 0x16B0 (5808)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16C0 (5824)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16D0 (5840)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x16E0 (5856)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xAD75, 0xFFFF, 0x31A6, 0x8410, 0xFFFF,   // 0x16F0 (5872)
+0x73AE, 0x0020, 0x9492, 0xFFFF, 0x5ACB, 0x6B4D, 0xFFDF, 0x738E, 0x738E, 0xFFDF, 0x6B6D, 0x5ACB, 0xFFFF, 0xFFDF, 0xFFDF, 0xAD55,   // 0x1700 (5888)
+0x0841, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1710 (5904)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1720 (5920)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1730 (5936)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xA514, 0xF79E, 0x52AA, 0x0000, 0x9492,   // 0x1740 (5952)
+0xFFDF, 0x4A69, 0x7BCF, 0xF79E, 0x6B6D, 0x0000, 0x73AE, 0xFFDF, 0xFFDF, 0x73AE, 0x0000, 0x6B6D, 0xF79E, 0x738E, 0x4208, 0xF7BE,   // 0x1750 (5968)
+0x9CF3, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1760 (5984)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1770 (6000)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1780 (6016)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1790 (6032)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17A0 (6048)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17B0 (6064)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17C0 (6080)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17D0 (6096)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17E0 (6112)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x17F0 (6128)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1800 (6144)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1810 (6160)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1820 (6176)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1830 (6192)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1840 (6208)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1850 (6224)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1860 (6240)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1870 (6256)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1880 (6272)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1890 (6288)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18A0 (6304)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18B0 (6320)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18C0 (6336)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18D0 (6352)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18E0 (6368)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x18F0 (6384)
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,   // 0x1900 (6400)
+};

_719/l.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: l.jpg
+// Time generated: 12.04.2014 22:14:24
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short l[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x18FF, 0x213F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x191D, 0x291F, 0x211E, 0x20FF, 0x211F, 0x193F, 0x191F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x20FF,   // 0x0030 (48)
+0x10FF, 0x191F, 0x18FF, 0x18FF, 0x20DF, 0x20FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10DD, 0x10BF, 0x10DF,   // 0x0050 (80)
+0x10DF, 0x10BF, 0x10BF, 0x189F, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x085F, 0x087F, 0x087F, 0x105E, 0x087F, 0x107F, 0x087F, 0x007E, 0x087E,   // 0x0070 (112)
+0x087F, 0x109F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x083F, 0x085F, 0x085F, 0x083F, 0x103F, 0x001F, 0x081F, 0x105F, 0x001E, 0x103F, 0x083F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F, 0x005F, 0x003E, 0x101F, 0xF7DF, 0xF7DF, 0xF7FD, 0x081F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0xFFDF, 0xFFBF, 0xFFFF, 0xF79F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x003F, 0x18FF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFE, 0xF7DF, 0x081E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003E, 0x001F, 0x081F, 0x001F, 0x20FF, 0xFFBF,   // 0x0100 (256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7DD, 0x081F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0110 (272)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x083F, 0x001E, 0x001F, 0x001F, 0x001F, 0x293F, 0xF7DD, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0120 (288)
+0xF7FF, 0x081F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0130 (304)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39BF, 0xF7DE, 0xFFFF, 0xFFDF, 0xFF9F, 0xF7FF, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001E, 0x081E, 0xFFBF, 0xFFFE, 0xFFFF, 0xFFDF, 0xFFFF, 0x081F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001F, 0x003E, 0x001F, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0x081F, 0x001F, 0x001E, 0x001E, 0x001F, 0x003F, 0x003E, 0x001E,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFDF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x003F, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xFFFF, 0x081F, 0x001E, 0x001F, 0x001F, 0x001E, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xEFDF,   // 0x01D0 (464)
+0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x081E,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x081F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF, 0xF7FF, 0xFFFF, 0x001F, 0x001E,   // 0x0210 (528)
+0x001F, 0x003F, 0x001E, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0x001F, 0x003F, 0x001E,   // 0x0230 (560)
+0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E, 0x001F, 0xF7BD, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x001F, 0x003F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x083F, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001E, 0x001E, 0x001F, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFF9F, 0xFFDE, 0xFF9E, 0xFF9F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x001F, 0x003F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x001F, 0x081F, 0xF7DE, 0xFFDE, 0xFFBF, 0xFFBE, 0xFFBF, 0x003E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x081E, 0xFFDF, 0xFFDD, 0xF7BF, 0xFFBF, 0x081F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0xF7BF, 0xFFBE, 0xF79E, 0x001F, 0x003F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x001E,   // 0x0300 (768)
+0x003C, 0x001E, 0x003D, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x083D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001E, 0x001D, 0x001D, 0x001E, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001A, 0x001C, 0x001C, 0x001A, 0x001C,   // 0x0340 (832)
+0x001A, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x0019, 0x001B, 0x001A, 0x0018, 0x001A, 0x0019, 0x0019,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0018, 0x0039, 0x0018, 0x0019, 0x0019, 0x0019, 0x0018, 0x001A, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_719/left.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: l.jpg
+// Time generated: 12.04.2014 22:14:24
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short le[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x18FF, 0x213F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x191D, 0x291F, 0x211E, 0x20FF, 0x211F, 0x193F, 0x191F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x20FF,   // 0x0030 (48)
+0x10FF, 0x191F, 0x18FF, 0x18FF, 0x20DF, 0x20FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10DD, 0x10BF, 0x10DF,   // 0x0050 (80)
+0x10DF, 0x10BF, 0x10BF, 0x189F, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x085F, 0x087F, 0x087F, 0x105E, 0x087F, 0x107F, 0x087F, 0x007E, 0x087E,   // 0x0070 (112)
+0x087F, 0x109F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x083F, 0x085F, 0x085F, 0x083F, 0x103F, 0x001F, 0x081F, 0x105F, 0x001E, 0x103F, 0x083F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x003F, 0x003F, 0x001F, 0x001F, 0x005F, 0x003E, 0x101F, 0xF7DF, 0xF7DF, 0xF7FD, 0x081F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0xFFDF, 0xFFBF, 0xFFFF, 0xF79F, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x003F, 0x18FF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFE, 0xF7DF, 0x081E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003E, 0x001F, 0x081F, 0x001F, 0x20FF, 0xFFBF,   // 0x0100 (256)
+0xFFFF, 0xFFFF, 0xFFFF, 0xF7DD, 0x081F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0110 (272)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x083F, 0x001E, 0x001F, 0x001F, 0x001F, 0x293F, 0xF7DD, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x0120 (288)
+0xF7FF, 0x081F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0130 (304)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39BF, 0xF7DE, 0xFFFF, 0xFFDF, 0xFF9F, 0xF7FF, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001E, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001E, 0x081E, 0xFFBF, 0xFFFE, 0xFFFF, 0xFFDF, 0xFFFF, 0x081F, 0x003F, 0x003F, 0x003F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001F, 0x003E, 0x001F, 0xFFFF, 0xF7FF, 0xFFFF, 0xFFFF, 0xF7FF, 0x081F, 0x001F, 0x001E, 0x001E, 0x001F, 0x003F, 0x003E, 0x001E,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFDF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x003F, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xFFFF, 0x081F, 0x001E, 0x001F, 0x001F, 0x001E, 0x001F, 0x001E, 0x003F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0xEFDF,   // 0x01D0 (464)
+0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x081E,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x081F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF, 0xF7FF, 0xFFFF, 0x001F, 0x001E,   // 0x0210 (528)
+0x001F, 0x003F, 0x001E, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0x001F, 0x003F, 0x001E,   // 0x0230 (560)
+0x003F, 0x001F, 0x003F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001E, 0x001F, 0xF7BD, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x001F, 0x003F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x083F, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001F, 0x001E, 0x001E, 0x001F, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFF9F, 0xFFDE, 0xFF9E, 0xFF9F, 0x001F, 0x001F, 0x003F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x001F, 0x003F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x001F, 0x081F, 0xF7DE, 0xFFDE, 0xFFBF, 0xFFBE, 0xFFBF, 0x003E, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x081E, 0xFFDF, 0xFFDD, 0xF7BF, 0xFFBF, 0x081F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0xF7BF, 0xFFBE, 0xF79E, 0x001F, 0x003F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x001E,   // 0x0300 (768)
+0x003C, 0x001E, 0x003D, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x083D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001E, 0x001D, 0x001D, 0x001E, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001A, 0x001C, 0x001C, 0x001A, 0x001C,   // 0x0340 (832)
+0x001A, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x0019, 0x001B, 0x001A, 0x0018, 0x001A, 0x0019, 0x0019,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0018, 0x0039, 0x0018, 0x0019, 0x0019, 0x0019, 0x0018, 0x001A, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_719/m.c

@@ -0,0 +1 @@
+

_719/menu.ino

@@ -0,0 +1,420 @@
+//********************************************************************************
+void menu()
+{
+
+  
+    byte bait;
+byte bait1;
+byte bait2;
+byte bait3;
+//long address;
+int i;
+  int w;
+  int w1;
+  int w2;
+  int q=0;
+  int x,y;
+  if( t.hour<7 )
+{night=1;
+}
+else
+{night=0;
+}
+    myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+ sd.chdir("/");
+  delay (100);
+//myFiles.loadBitmap(0, 0, 800, 480, "33a.raw");  
+  myFile.open("33.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (i =0 ; i < 96000; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>399){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, 2*m, 400, 1, pic1, 2);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+
+ 
+//  myGLCD.fillScr(VGA_BLUE);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,0,55);
+ myGLCD.setFont(BigFont);
+
+
+ 
+  myGLCD.setColor(255, 255, 255);
+  
+     myGLCD.drawBitmap (100, 100, 80, 80, flr);
+    myGLCD.drawRoundRect (100, 100, 180, 180);// fl
+    
+     myGLCD.drawBitmap (100, 190, 80, 80, dom1);//******************************
+    myGLCD.drawRoundRect (100, 190, 180, 270);// dom1
+    
+   myGLCD.drawBitmap (10, 10, 80, 80, aandelen);
+    myGLCD.drawRoundRect (10, 10, 90, 90);// Aandelend
+    
+    myGLCD.drawBitmap (100, 10, 80, 80, clokk);
+    myGLCD.drawRoundRect (100, 10, 180, 90);// internet
+    
+    myGLCD.drawBitmap (10, 100, 80, 80,ints);
+    myGLCD.drawRoundRect (10, 100, 90, 180); //Radio
+    
+    myGLCD.drawBitmap (10, 190, 80, 80,wer);
+   myGLCD.drawRoundRect (10, 190, 90, 270); //Klok 
+   
+   
+    myGLCD.drawBitmap (10, 280, 80, 80, fotos);
+    myGLCD.drawRoundRect (10, 280, 90, 360); //Foto 
+    
+    myGLCD.drawBitmap (10, 370, 80, 80, instellingen);
+     myGLCD.drawRoundRect (10, 370, 90, 450); //Install 
+     
+      myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok 
+     
+     myGLCD.drawBitmap (769, 449, 30, 30, jar);
+    myGLCD.drawRoundRect (769, 449, 769+30, 449+30);// яркость
+  kalend();
+clc();
+  c=0; 
+  
+    while(1)
+{ 
+  if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      x=myTouch.getX();
+      y=myTouch.getY();
+      
+         if ((x>=769) && (x<=799))  // Upper row
+      {
+        
+        if ((y>=449) && (y<=479))  // яркость
+          {
+            waitForIt1(769, 449, 799, 479);
+            bright();
+             menu();
+          }
+      } 
+      
+      if ((x>=100) && (x<=180))  // Upper row
+      {
+          if ((y>=10) && (y<=90))  // Aandelend
+        {waitForIt1(100, 10, 180, 90);
+        
+        intime();
+        menu();
+        // grafik();
+        //paint();
+        
+        }
+        
+        if ((y>=100) && (y<=180))  //Radio
+        {waitForIt1(100, 100, 180, 180);
+        //radio2();
+        Serialread();
+       // flower();
+        menu();
+       
+        }
+        
+        if ((y>=190) && (y<=270))  //HOME
+        {waitForIt1(100, 190, 180, 270);
+        //radio2();
+        initial();
+        home1();
+        menu();
+       
+        }
+      }
+      
+      if ((x>=10) && (x<=90))  // Upper row
+      {
+        
+        if ((y>=10) && (y<=90))  // Aandelend
+        {waitForIt1(10, 10, 90, 90);
+        initial();
+         grafik();
+        //paint();
+        
+        }
+        
+         if ((y>=100) && (y<=180))  //Radio
+        {waitForIt1(10, 100, 90, 180);
+        //radio2();
+        internet();
+        menu();
+       
+        }
+        
+          if ((y>=190) && (y<=270))  //(10, 190, 90, 270); //Klok 
+        {waitForIt1(10, 190, 90, 270);
+        initial();
+        pogoda();
+        
+        }
+        
+          if ((y>=280) && (y<=360))  //(10, 280, 90, 360); //Foto 
+        {
+          waitForIt1(10, 280, 90, 360);
+          initial();
+        raw();
+        }
+        
+          if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Install 
+        {waitForIt1(10, 370, 90, 450);
+       sdlist();
+       menu();
+        }
+     }    
+    
+    
+    if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            menu();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+         vrem();
+          clok();
+        }
+      } 
+        
+    }
+
+ 
+ //***************************************** 
+  
+t = rtc.getTime();
+ // sec=t.sec;
+ if (raw1==0)
+ {raw1=1;
+ raw();
+ }
+if (t.sec==0)
+{
+delay(800);
+clc();
+}
+if ((t.sec==5) || (t.sec==20) || (t.sec==35)|| (t.sec==50))
+{  
+   priem();
+}
+ if ((t.sec==14) || (t.sec==42) )
+{
+dtu21();
+
+ bmp085();
+ 
+ uart();
+ }
+ 
+
+ 
+}
+
+
+
+}
+//*******************************************************************************
+void kalend()
+{
+byte bait;
+byte bait1;
+
+//long address;
+
+  int w;
+  int i;
+  int q=0;
+ // char* S1[]={"fam1.txt","fam.txt","fam2.txt","fam3.txt"};
+
+  
+
+
+ 
+ 
+myFile.open("Kalendar.raw", O_READ);
+  
+int n=0;
+int m=0;
+//160*160=25600
+   for (i =0 ; i < 25600; i = i++) {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>159){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (640, m, 160, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close();
+ }
+//************************************************************************************ 
+ 
+void clc() 
+{ char* strm[] = {" JAN","FEBR","MARCH","APRIL"," MAY","JUNE","JULY"," AUG","SEPT"," OCT"," NOV"," DEC"};
+  int cx=640;
+  int cy=383;
+  int month1;
+//**********CLOK*******************************************************************************
+ myGLCD.setColor(VGA_WHITE);
+  myGLCD.setBackColor(0,38,92);
+myGLCD.setFont( SevenSegNumFont);
+ t = rtc.getTime();
+    if (t.hour<10)
+  {
+    myGLCD.printNumI(0,cx, cy);
+    myGLCD.printNumI(t.hour, cx+32, cy);
+  }
+  else
+  {
+    myGLCD.printNumI(t.hour,cx, cy);
+  }
+  myGLCD.print(":",cx+64, cy);
+  if (t.min<10)
+  {
+    myGLCD.printNumI(0,cx+96, cy);
+    myGLCD.printNumI(t.min, cx+128, cy);
+  }
+  else
+  {
+    myGLCD.printNumI(t.min, cx+96, cy);
+  }
+  myGLCD.setFont( Ubuntubold);
+  //myGLCD.setFont(BigFont);
+  
+  myGLCD.setColor(0,0,155);
+  myGLCD.setBackColor(255,114,0);
+  month1=t.mon;
+   myGLCD.print(strm[month1-1], 663, 18);
+   
+// **********WIFI work ********************************************************************
+if(t.hour>7)
+{
+ if (t.min==7)  
+  {if (fwifi==1)
+     {fwifi=0;
+      internet();
+     }
+  } 
+  if (wifi>0) //если была ошибка подключения
+  {if (t.min==23)
+     {
+          internet();
+         
+      } 
+  }
+}  
+
+ //**************************опрос всех датчиков каждый час и запись всех данных в massiv 23:00 ******************
+ if (t.min==0)
+ {
+
+  //  printmassiv();
+  if (fsec==1)
+  {uart();
+  bmp085();
+  uart();
+  savemastd();//запись данных датчиков в рабочий массив
+  
+   digitalWrite(53, LOW);//reset NRF
+ delay(100);
+ digitalWrite(53, HIGH);
+ 
+  fsec=0;  //delay (300);
+  if(t.hour==23)
+  {sdwrite();//запись данных в файлы по месяцам и дням  директориии улица и дом Temul i Temdom
+   savemasclok();//запись времени на sd 12:56 15/05/14 и массива rab
+     saveminmax();//запись макс  мин и средних значений датчиков за день
+  } 
+  
+   if((t.hour>=0)||(t.hour<23))
+  {
+   savemasclok();//запись времени на sd 12:56 15/05/14 и массива rab
+  } 
+
+  
+  }   
+  
+}
+
+ if (t.min>30)
+ {fsec=1;
+  fwifi=1;
+ }
+ //*****************************************************************    
+
+//  myGLCD.print(rtc.getDOWStr(FORMAT_SHORT), 256+450, 8);
+myGLCD.setFont( SevenSegNumFont);
+ myGLCD.setColor(0,0,155);
+  myGLCD.setBackColor(255,255,255);
+  if (t.date<10)
+    myGLCD.printNumI(t.date, 710, 56);
+  else
+    myGLCD.printNumI(t.date, 695, 56);
+   // myGLCD.setFont(BigFont);
+   // myGLCD.setBackColor(180,180,180);
+   myGLCD.setFont( Ubuntubold);
+   dow= t.dow;
+   myGLCD.print(str[dow-1], 690,110);
+ /// myGLCD.printNumI(rtc_clock.get_months(), 695, 122);
+ myGLCD.setFont(BigFont);
+  myGLCD.setBackColor(180,180,180);
+  myGLCD.printNumI(t.year, 694, 143);
+
+   
+myGLCD.setBackColor(0,0,55);
+
+}
+
+void waitForIt1(int x1, int y1, int x2, int y2)
+{
+  myGLCD.setColor(255, 232, 13);
+  myGLCD.drawRoundRect (x1, y1, x2, y2);
+  while (myTouch.dataAvailable())
+    myTouch.read();
+  myGLCD.setColor(255, 255, 255);
+  myGLCD.drawRoundRect (x1, y1, x2, y2);
+}

_719/mi.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: -.jpg
+// Time generated: 12.04.2014 22:13:44
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short mi[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF,   // 0x0030 (48)
+0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF,   // 0x0050 (80)
+0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F,   // 0x0070 (112)
+0x087F, 0x087F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x085F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0013, 0x0017, 0x0019, 0x0019, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0100 (256)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0016, 0x0017,   // 0x0110 (272)
+0x0018, 0x001D, 0x001D, 0x001E, 0x001F, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0120 (288)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0017, 0x0018, 0x001C,   // 0x0130 (304)
+0x001E, 0x003E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0015, 0x0019, 0x001B, 0x001D, 0x001D,   // 0x0150 (336)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001E, 0x005F, 0x001F, 0x081E,   // 0x0170 (368)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0016, 0x0019, 0x001A, 0x001D, 0x001F, 0x001D, 0xF7FF, 0xFFFF, 0xFFFF,   // 0x0190 (400)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0014, 0x0018, 0x0018, 0x001C, 0x001F, 0x001E, 0x001F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01B0 (432)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0014, 0x0017, 0x0019, 0x001A, 0x001D, 0x001F, 0x081F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,   // 0x01D0 (464)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01F0 (496)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0210 (528)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02A0 (672)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E,   // 0x0300 (768)
+0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B,   // 0x0340 (832)
+0x001B, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019,   // 0x0370 (880)
+0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };

_719/nightgraf.ino

@@ -0,0 +1,233 @@
+void nightgraf()
+{
+  
+ mon1=t.mon;
+ years1=t.year;
+ days1=t.date;
+ 
+    myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(0, 0, 635, 475);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(0, 0, 635, 475);//прямоугольник с  обводкой
+  
+  pikgrafik();
+  colorgraf=0;
+  picgraftoday();
+  myGLCD.setFont( SevenSegNumFont);//myGLCD.setFont(BigFont);Ubuntubold
+  myGLCD.setBackColor( VGA_TRANSPARENT);
+  
+   myGLCD.setColor(255,242, 0);
+  myGLCD.printNumI(pressure,430,205);// myGLCD.print(":",cx+32+32, cy);
+    myGLCD.setFont( Ubuntubold); 
+    myGLCD.print("MM",430+103, 205+24);
+    
+    
+    //*********TEMPUL**************************************    
+    //  myGLCD.setColor(255,142,21);
+      myGLCD.setColor(VGA_WHITE);
+ myGLCD.setBackColor( VGA_TRANSPARENT);
+ if (zn<2)
+ {myGLCD.print("-",420, 65+8);
+ }
+ else
+ {myGLCD.print("+",420, 65+8);
+ }
+ 
+ myGLCD.print(",",420+88, 65+24);
+ myGLCD.print("C",420+88+20+32+10, 68);
+ 
+  myGLCD.setFont( SevenSegNumFont);
+  if (tu<10)
+ { myGLCD.printNumI(tu,420+24+32,65);// myGLCD.print(":",cx+32+32, cy);
+ }
+ else
+ {myGLCD.printNumI(tu,420+24,65);
+ }
+ myGLCD.printNumI(tud,420+88+20,65);    
+//*********HUG**************************************     
+  myGLCD.setColor(129,239,255);
+  
+ myGLCD.setBackColor( VGA_TRANSPARENT);    
+  myGLCD.setFont( Ubuntubold);
+ myGLCD.print(",",420+88, 300+24); 
+ myGLCD.print("%",420+88+20+32+10, 300+24); 
+ myGLCD.setFont( SevenSegNumFont);
+ myGLCD.printNumI(hu,420+24,300);
+ myGLCD.printNumI(hud,420+88+20,300);
+//*************tdom*******************************    
+   myGLCD.setColor(5,252,46);
+ 
+  myGLCD.setFont( Ubuntubold);
+ myGLCD.print("+",420, 395+8); 
+myGLCD.print(",",420+88, 395+27);
+ myGLCD.print("C",420+88+20+32+10, 395); 
+  myGLCD.setFont( SevenSegNumFont);
+ myGLCD.printNumI(tdc,420+24,395);
+ //int tem = temperatur;
+ myGLCD.printNumI(tdd,420+88+20,395);
+ myGLCD.setBackColor( VGA_TRANSPARENT); 
+ //*********************min max************************************************
+ // myGLCD.setBackColor(8,101,192); 
+  myGLCD.setColor(255, 55, 55);
+  myGLCD.setFont(BigFont);
+  int px=430;
+  int py=80+50;
+   byte hh;
+  byte mm;
+  byte d;
+  byte m;
+  word y;
+  //*************max****************************************
+  d=time1[24]/1000;
+  m=(time1[24]%1000)/10;
+  y=((time1[24]%1000)%10)*10;
+  hh=time1[25]/1000;
+  mm=(time1[25]%1000)/10;
+   y=y+((time1[25]%1000)%10);
+      myGLCD.setBackColor(255,255,255); 
+  myGLCD.print("Tmax=+" ,px, py);
+   myGLCD.printNumI(temul[24]/10, px+16*6, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(temul[24]%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+     
+      myGLCD.setBackColor( VGA_TRANSPARENT); 
+      myGLCD.print(":" ,px-4+16*2, py+16);
+     if(hh<10)
+     { myGLCD.print("0" ,px, py+16);
+       myGLCD.printNumI(hh, px+16, py+16);
+     }
+    else 
+     {myGLCD.printNumI(hh, px, py+16);
+     }
+  //myGLCD.print(":" ,px+16*2, py+16);
+  
+   if(mm<10)
+     { myGLCD.print("0" ,px+16*3-8, py+16);
+       myGLCD.printNumI(mm, px+16*4-8, py+16);
+     }
+    else 
+     {myGLCD.printNumI(mm, px+16*3-8, py+16);
+     }
+ // myGLCD.print(" " ,px+16*5, py+16);
+  myGLCD.print("." ,px+16*7-4, py+16);
+  if(d<10)
+     { myGLCD.print("0" ,px+16*5, py+16);
+       myGLCD.printNumI(d, px+16*6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(d, px+16*5, py+16);
+     }
+  
+   myGLCD.print("." ,px+16*10-10, py+16);
+  if(m<10)
+     { myGLCD.print("0" ,px+16*8-6, py+16);
+       myGLCD.printNumI(m, px+16*9-6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(m, px+16*8-6, py+16);
+     }
+ // myGLCD.print("." ,px+16*11-12, py+16);
+  
+  myGLCD.printNumI(y, px+16*11-14, py+16);
+ 
+//*************min ***********************************************
+  myGLCD.setColor(55, 55, 255);
+  myGLCD.setBackColor(255,255,255); 
+ d=time1[26]/1000;
+  m=(time1[26]%1000)/10;
+  y=((time1[26]%1000)%10)*10;
+  hh=time1[27]/1000;
+  mm=(time1[27]%1000)/10;
+   y=y+((time1[27]%1000)%10);
+  int Tm; 
+  py=py+35;
+    if (temul[25]>1000)
+       {   Tm=temul[25]-1000;
+       
+        if(Tm<100)
+        {myGLCD.print("Tmin= -" ,px, py);
+        }
+        else
+        { myGLCD.print("Tmin=-" ,px, py);
+        }
+       }
+    else
+   {
+    Tm=temul[25];
+     if(Tm<100)
+        {myGLCD.print("Tmin= +" ,px, py);
+        }
+        else
+        { myGLCD.print("Tmin=+" ,px, py);
+        }
+   }
+  
+ if(Tm<100) 
+ { // myGLCD.print(" " ,px+16*6, py);
+   myGLCD.printNumI(Tm/10, px+16*7, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(Tm%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+ }  
+  else
+  { myGLCD.printNumI(Tm/10, px+16*6, py); 
+    myGLCD.print("," ,px+16*8, py);
+     myGLCD.printNumI(Tm%10, px+16*9, py);
+     myGLCD.print("C " ,px+16*10, py);
+  }
+     
+     
+      myGLCD.setBackColor( VGA_TRANSPARENT); 
+     myGLCD.print(":" ,px-4+16*2, py+16);
+     if(hh<10)
+     { myGLCD.print("0" ,px, py+16);
+       myGLCD.printNumI(hh, px+16, py+16);
+     }
+    else 
+     {myGLCD.printNumI(hh, px, py+16);
+     }
+ // myGLCD.print(":" ,px+16*2, py+16);
+  
+   if(mm<10)
+     { myGLCD.print("0" ,px+16*3-8, py+16);
+       myGLCD.printNumI(mm, px+16*4-8, py+16);
+     }
+    else 
+     {myGLCD.printNumI(mm, px+16*3-8, py+16);
+     }
+//  myGLCD.print(" " ,px+16*5, py+16);
+   myGLCD.print("." ,px+16*7-4, py+16);
+  if(d<10)
+     { myGLCD.print("0" ,px+16*5, py+16);
+       myGLCD.printNumI(d, px+16*6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(d, px+16*5, py+16);
+     }
+     
+   myGLCD.print("." ,px+16*10-10, py+16);
+  
+  if(m<10)
+     { myGLCD.print("0" ,px+16*8-6, py+16);
+       myGLCD.printNumI(m, px+16*9-6, py+16);
+     }
+    else 
+     {myGLCD.printNumI(m, px+16*8-6, py+16);
+     }
+  
+  myGLCD.printNumI(y, px+16*11-14, py+16);
+ 
+ 
+ 
+    myGLCD.setColor(255, 255, 255);
+  myGLCD.setFont( Ubuntubold);
+  
+ 
+ 
+ 
+ 
+ 
+//delay(8000);
+  
+}

_719/open.c

@@ -0,0 +1,108 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: open.jpg
+// Time generated: 04.05.2014 19:24:37
+// Dimensions    : 40x40 pixels
+// Size          : 3 200 Bytes
+
+const unsigned short open[0x640] ={
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0010 (16)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0020 (32)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0030 (48)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0040 (64)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0050 (80)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0060 (96)
+0x210A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0070 (112)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x527B, 0x93F0, 0xD501, 0xCCC1, 0xD4E0, 0xC4C5,   // 0x0080 (128)
+0x5A9A, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x18C8, 0x2929, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0090 (144)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00A0 (160)
+0x001F, 0xAC4C, 0xD4C1, 0xDD00, 0xDD20, 0xDD40, 0xDD41, 0xDD20, 0xCCE1, 0x525B, 0x001F, 0x001F, 0x001F, 0x001F, 0x10C8, 0x39AE,   // 0x00B0 (176)
+0x0000, 0x2970, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00C0 (192)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x39BD, 0xCCE1, 0xD540, 0xD540, 0xDD21, 0xDD20, 0xD501, 0xDD20,   // 0x00D0 (208)
+0xDD20, 0xC4C7, 0x001F, 0x001F, 0x3193, 0x1086, 0x296F, 0x2124, 0x1922, 0x10C7, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00E0 (224)
+0x8352, 0x93AE, 0xA3EB, 0xAC09, 0xB428, 0xB428, 0xB448, 0xB448, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x00F0 (240)
+0x083F, 0xDD20, 0xDD20, 0xDD21, 0xDD40, 0xE561, 0xE560, 0xE580, 0xE540, 0xA401, 0x41EE, 0x212B, 0x3128, 0x18C3, 0x2965, 0x18E4,   // 0x0100 (256)
+0x3287, 0x10C7, 0x001F, 0x297D, 0x18FE, 0x39BD, 0x001F, 0xD5CE, 0xCD4C, 0xC509, 0xC4E8, 0xC4C6, 0xC4A6, 0xC4A6, 0xC4E6, 0xA3E9,   // 0x0110 (272)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x10DF, 0xD4E1, 0xDD40, 0xDD40, 0xD500, 0xAC21, 0xBC81, 0x8B60,   // 0x0120 (288)
+0x2901, 0x3164, 0x41E6, 0x39A4, 0x8BC9, 0x0822, 0x7266, 0xCBE5, 0x72C4, 0x08A3, 0x31EA, 0x63B0, 0xA599, 0xC69C, 0xE75E, 0xEF9F,   // 0x0130 (304)
+0xFFDF, 0xFFFE, 0xFFBE, 0xF77C, 0xF75A, 0xEF19, 0xEEF8, 0xEEB6, 0x18DF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0140 (320)
+0x001F, 0xB489, 0xE560, 0x9BC1, 0x2102, 0x10A3, 0x0841, 0x41E6, 0x10A3, 0x5246, 0x8C0A, 0x0841, 0x19E9, 0x73D3, 0xC46C, 0x5204,   // 0x0150 (336)
+0x61A3, 0x2082, 0x39E7, 0x636B, 0x7C51, 0x63F1, 0x6C12, 0xAD12, 0x7476, 0x7CF8, 0xD615, 0xBDD7, 0xADD8, 0xC617, 0xCE58, 0xCE99,   // 0x0160 (352)
+0x087F, 0x10BF, 0x085F, 0x083F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA42D, 0xED60, 0x7B00, 0x738A, 0xACCC, 0x0001, 0x8389,   // 0x0170 (368)
+0x2965, 0x08A2, 0x1903, 0x0000, 0x33F5, 0x7D1A, 0x938B, 0xA343, 0xA2C3, 0x1862, 0x39E2, 0x6B67, 0xEE6F, 0xD56D, 0x9C6D, 0xFE6E,   // 0x0180 (384)
+0xA4CE, 0x6B8E, 0xF5EC, 0xDDC5, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0x003F, 0x001F,   // 0x0190 (400)
+0x001F, 0x8394, 0xE560, 0x7B20, 0x39E6, 0x49E4, 0x0842, 0x3124, 0x7286, 0x4A68, 0x2A45, 0x0820, 0x1A2B, 0x6457, 0xE509, 0xEC03,   // 0x01A0 (416)
+0x6A03, 0x10A3, 0x3183, 0x5AC4, 0xC56A, 0xFEAF, 0xF630, 0xF60F, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5,   // 0x01B0 (432)
+0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5E5, 0xE5C4, 0x003F, 0x001F, 0x001F, 0x4A1C, 0xE540, 0x8B40, 0x0085, 0x2B72, 0x7AF0, 0xD48B,   // 0x01C0 (448)
+0xBBE6, 0xA343, 0x4A24, 0x0021, 0x1988, 0x5436, 0x8348, 0x82C2, 0x49E5, 0x1904, 0x5223, 0x8345, 0xBCC8, 0xF64B, 0xE5C5, 0xE5C4,   // 0x01D0 (464)
+0xE5C5, 0xE5E4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0x003F, 0x001F,   // 0x01E0 (480)
+0x001F, 0x295E, 0xDD22, 0x8300, 0x1148, 0x565F, 0x8C34, 0x938C, 0x6266, 0x61C2, 0x5102, 0x0000, 0x2B31, 0x6CD5, 0x6AC8, 0x6285,   // 0x01F0 (496)
+0xA488, 0xACE9, 0xD588, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5E5, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5,   // 0x0200 (512)
+0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE62A, 0xE62A, 0x003F, 0x001F, 0x001F, 0x001F, 0xCCE8, 0x8300, 0x0947, 0x55FF, 0x6392, 0xD46B,   // 0x0210 (528)
+0xED44, 0xDC24, 0xB406, 0x83A6, 0xB52A, 0xDE0A, 0xE607, 0xEE27, 0xEE27, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4,   // 0x0220 (544)
+0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C4, 0xEDC5, 0xE5E4, 0xE62A, 0xE60A, 0xE62A, 0xE62B, 0x001F, 0x001F,   // 0x0230 (560)
+0x001F, 0x001F, 0x9C12, 0x8300, 0x1127, 0x5DFF, 0x4B52, 0x8368, 0xF648, 0xEE47, 0xF624, 0xF625, 0xEDE3, 0xEDC3, 0xE5C4, 0xE5C4,   // 0x0240 (576)
+0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5E5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5,   // 0x0250 (592)
+0xE5C5, 0xE60A, 0xE60A, 0xE62A, 0xE62A, 0xE60A, 0x003F, 0x001F, 0x001F, 0x001F, 0x8BB4, 0x82E0, 0x0927, 0x55FF, 0x4B91, 0xB4E8,   // 0x0260 (608)
+0xF644, 0xEDA1, 0xE5C2, 0xE5A2, 0xE5A2, 0xE5C4, 0xE5C4, 0xEDC4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4,   // 0x0270 (624)
+0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C4, 0xE5E9, 0xE609, 0xE60A, 0xE60A, 0xE62A, 0xEE2A, 0xE609, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0x001F, 0x5ABA, 0x8300, 0x0927, 0x55BF, 0x6D99, 0xEE26, 0xEDC0, 0xE5C2, 0xE5C2, 0xE5A2, 0xE5C2, 0xE5C5, 0xE5C5, 0xE5C4,   // 0x0290 (656)
+0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xEDE5, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5E7, 0xE5E8, 0xE5E9,   // 0x02A0 (672)
+0xE60A, 0xE62A, 0xEE0B, 0xE60A, 0xE60A, 0xE609, 0x001F, 0x001F, 0x001F, 0x001F, 0x18FF, 0x8300, 0x0927, 0x4DDF, 0x761C, 0xF605,   // 0x02B0 (688)
+0xEDA0, 0xE5C2, 0xEDC2, 0xE5A2, 0xE5A2, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5E5, 0xE5C4,   // 0x02C0 (704)
+0xE5C5, 0xE5C4, 0xE5C4, 0xE5E7, 0xE5E7, 0xE5E8, 0xE5E8, 0xE609, 0xE60A, 0xE60A, 0xE60A, 0xE609, 0xE60A, 0x001F, 0x001F, 0x001F,   // 0x02D0 (720)
+0x001F, 0x001F, 0x18DF, 0x82E0, 0x0928, 0x55BF, 0x75FC, 0xEE05, 0xEDA1, 0xE5C2, 0xE5C2, 0xEDA2, 0xEDA2, 0xFFFF, 0xFFFF, 0xE5A3,   // 0x02E0 (736)
+0xE5C3, 0xFFFF, 0xFFFE, 0xFFFF, 0xE5C4, 0xE5C5, 0xFFFF, 0xFFFF, 0xFFFF, 0xE5C6, 0xFFFF, 0xE5C7, 0xE5E8, 0xE5E8, 0xFFFF, 0xE60A,   // 0x02F0 (752)
+0xE60A, 0xEE0B, 0xE60A, 0xE609, 0xE5EA, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x72C7, 0x1127, 0x55BF, 0x75FD, 0xEE27,   // 0x0300 (768)
+0xE5A1, 0xE5C2, 0xE5A2, 0xEDA2, 0xFFFE, 0xE5C3, 0xEDA3, 0xFFFF, 0xE5C4, 0xFFFF, 0xE5C4, 0xE5C5, 0xFFFF, 0xE5E5, 0xFFFE, 0xE5E6,   // 0x0310 (784)
+0xE5C7, 0xE5E7, 0xFFFF, 0xFFFF, 0xE5E8, 0xE5E8, 0xFFFE, 0xE60A, 0xE60B, 0xE60A, 0xE5EA, 0xE5EA, 0xE5EA, 0x001F, 0x001F, 0x001F,   // 0x0320 (800)
+0x001F, 0x001F, 0x001F, 0x62AF, 0x0926, 0x55DF, 0x95B6, 0xF606, 0xE5A1, 0xEDA2, 0xEDC3, 0xE5A2, 0xFFFF, 0xE5C3, 0xE5C3, 0xFFFF,   // 0x0330 (816)
+0xE5C4, 0xFFFF, 0xE5C5, 0xE5C5, 0xFFFF, 0xE5C5, 0xFFFF, 0xFFDF, 0xE5C7, 0xE5C7, 0xFFFF, 0xE5E7, 0xFFFF, 0xE5E9, 0xFFFF, 0xEDEA,   // 0x0340 (832)
+0xE60A, 0xE5EA, 0xE5EA, 0xE5EA, 0xE5EA, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x41D9, 0x0907, 0x5DDD, 0xAC05, 0xD480,   // 0x0350 (848)
+0xE5E2, 0xE5A2, 0xE5A3, 0xE5E3, 0xFFFE, 0xE5C3, 0xEDC3, 0xFFFF, 0xE5C4, 0xFFFE, 0xFFFF, 0xFFDF, 0xE5C5, 0xE5C5, 0xFFFF, 0xE5C6,   // 0x0360 (864)
+0xE5C6, 0xE5C7, 0xFFFF, 0xE5E8, 0xE5E8, 0xFFDF, 0xFFFF, 0xE5EA, 0xE5EA, 0xDDEA, 0xDDE9, 0xE5EB, 0xE5CA, 0x001F, 0x001F, 0x001F,   // 0x0370 (880)
+0x001F, 0x001F, 0x001F, 0x319B, 0x0063, 0x8C8C, 0xC380, 0xCC80, 0xEDC2, 0xEDA2, 0xE5C3, 0xE5C3, 0xFFFF, 0xE5C4, 0xE5C4, 0xFFFF,   // 0x0380 (896)
+0xE5C4, 0xFFFF, 0xE5C5, 0xE5C5, 0xE5C6, 0xE5C5, 0xFFFE, 0xE5C7, 0xE5C7, 0xDDE7, 0xFFFF, 0xE5E8, 0xE5E9, 0xE5EA, 0xFFFF, 0xDDEA,   // 0x0390 (912)
+0xDDA8, 0xDDA7, 0xD5A7, 0xDDCA, 0xDDCA, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x295D, 0x6A02, 0xBBA0, 0xBBA0, 0xCC80,   // 0x03A0 (928)
+0xEDC3, 0xE5C2, 0xEDC3, 0xE5C3, 0xE5C3, 0xFFFF, 0xFFFF, 0xE5C4, 0xE5C5, 0xFFFF, 0xE5C5, 0xE5A5, 0xE5C5, 0xE5C6, 0xFFFF, 0xFFFF,   // 0x03B0 (944)
+0xFFFF, 0xDDC7, 0xFFFF, 0xDDC8, 0xDDC8, 0xDDC8, 0xFFFF, 0xD586, 0xD566, 0xD567, 0xD567, 0xD5A9, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x03C0 (960)
+0x001F, 0x001F, 0x001F, 0x001F, 0xC3C3, 0xC3A0, 0xBB80, 0xCC81, 0xEDE3, 0xE5C3, 0xEDC3, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4,   // 0x03D0 (976)
+0xE5C5, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C5, 0xE5C6, 0xE5C7, 0xDDC7, 0xDDC7, 0xE5A7, 0xDDA7, 0xDD86, 0xDD87, 0xD587, 0xD586, 0xD566,   // 0x03E0 (992)
+0xD566, 0xD546, 0xCD47, 0xCD68, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x936F, 0xBB80, 0xBBA0, 0xD4A2,   // 0x03F0 (1008)
+0xEDE3, 0xE5C3, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5, 0xE5A5, 0xE5A5, 0xE5C6, 0xDDC6, 0xDDA6, 0xDD85,   // 0x0400 (1024)
+0xDD85, 0xD565, 0xD585, 0xD566, 0xD586, 0xD566, 0xCD45, 0xCD45, 0xC546, 0xCD26, 0xCD27, 0xBCE6, 0x003F, 0x001F, 0x001F, 0x001F,   // 0x0410 (1040)
+0x001F, 0x001F, 0x001F, 0x001F, 0x6AD7, 0xBB80, 0xBB80, 0xD4A3, 0xEDE4, 0xE5C3, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C5,   // 0x0420 (1056)
+0xE5A5, 0xE5A5, 0xE5A5, 0xE5A5, 0xDD84, 0xDD64, 0xDD64, 0xD564, 0xD564, 0xD565, 0xD565, 0xD566, 0xCD46, 0xCD25, 0xC524, 0xC505,   // 0x0430 (1072)
+0xC505, 0xC4E5, 0xA445, 0x5A95, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x293E, 0xBB81, 0xBBA0, 0xD4C4,   // 0x0440 (1088)
+0xEDE4, 0xE5C3, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5A5, 0xE5C5, 0xE5A5, 0xDD84, 0xDD83, 0xDD83, 0xD563, 0xD563, 0xD564, 0xD544,   // 0x0450 (1104)
+0xD545, 0xD545, 0xCD46, 0xCD46, 0xCD25, 0xC4E4, 0xC4C4, 0xB484, 0x9C06, 0x83AA, 0x39B9, 0x297D, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0460 (1120)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xB361, 0xBB80, 0xD4E4, 0xEE04, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5C4, 0xE5A4, 0xDD83, 0xDD83,   // 0x0470 (1136)
+0xDD63, 0xDD63, 0xDD63, 0xD563, 0xD544, 0xD544, 0xD524, 0xD525, 0xCD24, 0xC526, 0xCD26, 0xC504, 0xBCA3, 0xA425, 0x8BA7, 0x73AC,   // 0x0480 (1152)
+0x31BB, 0x215E, 0x089F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA388, 0xBB80, 0xDCE6,   // 0x0490 (1168)
+0xEE05, 0xE5C4, 0xE5C3, 0xE5A3, 0xDD82, 0xDD82, 0xDD63, 0xDD82, 0xD563, 0xD544, 0xD543, 0xD543, 0xCD24, 0xCD24, 0xCD24, 0xC504,   // 0x04A0 (1184)
+0xC525, 0xC4E5, 0xB464, 0x93C5, 0x7B89, 0x31B8, 0x29BD, 0x18FF, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x04B0 (1200)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x934E, 0xB360, 0xD507, 0xEE06, 0xE5C3, 0xE582, 0xDD82, 0xDD82, 0xDD62, 0xDD63, 0xD542,   // 0x04C0 (1216)
+0xD543, 0xD523, 0xD523, 0xCD23, 0xC504, 0xC504, 0xC4E4, 0xBCA4, 0xA405, 0x8387, 0x738C, 0x31DB, 0x295E, 0x10BF, 0x001F, 0x001F,   // 0x04D0 (1232)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5A79, 0xBB40, 0xD4C7,   // 0x04E0 (1248)
+0xEE27, 0xE5A3, 0xE582, 0xDD62, 0xDD62, 0xDD62, 0xD543, 0xD543, 0xCD23, 0xCD03, 0xC503, 0xC503, 0xC4C4, 0xAC63, 0x8BC6, 0x7369,   // 0x04F0 (1264)
+0x7BD0, 0x29BC, 0x211E, 0x087F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0500 (1280)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x317D, 0xB341, 0xCC66, 0xEE28, 0xE583, 0xDD82, 0xDD62, 0xDD42, 0xD542, 0xCD23, 0xCD03,   // 0x0510 (1296)
+0xC503, 0xC4E3, 0xB4A3, 0x9BE4, 0x7B47, 0x738C, 0x31DA, 0x297E, 0x10DF, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0520 (1312)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xB363, 0xC405,   // 0x0530 (1328)
+0xEE28, 0xDDA3, 0xDD42, 0xD542, 0xD522, 0xCD03, 0xC502, 0xC4C2, 0xAC23, 0x8386, 0x6B49, 0x73D0, 0x31BC, 0x211E, 0x107F, 0x001F,   // 0x0540 (1344)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0550 (1360)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xA3CD, 0xD483, 0xEE09, 0xDD63, 0xD542, 0xD523, 0xCD02, 0xBC83, 0x9BC4, 0x7347,   // 0x0560 (1376)
+0x6B6D, 0x8453, 0x297D, 0x10DF, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0570 (1392)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x5A7B, 0xD568,   // 0x0580 (1408)
+0xE609, 0xDD42, 0xD502, 0xAC43, 0x8385, 0x6B29, 0x73D0, 0x31BC, 0x213E, 0x109F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0590 (1424)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05A0 (1440)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x7B77, 0x93D0, 0xA403, 0x7B27, 0x6B6D, 0x7C53, 0x297D, 0x18DF, 0x085F,   // 0x05B0 (1456)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05C0 (1472)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05D0 (1488)
+0x4217, 0x31F7, 0x31DC, 0x213E, 0x109F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05E0 (1504)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x05F0 (1520)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0600 (1536)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0610 (1552)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0620 (1568)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0630 (1584)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0640 (1600)
+};

_719/paint.ino

@@ -0,0 +1,130 @@
+//***************************************************************************************************
+void paint()
+{
+
+  myGLCD.clrScr();
+    myGLCD.setColor(VGA_WHITE);
+  myGLCD.drawLine(32,0,32,myGLCD.getDisplayYSize()-1);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,0,myGLCD.getDisplayXSize()-32,myGLCD.getDisplayYSize()-1);
+  myGLCD.print("C", myGLCD.getDisplayXSize()-24, 8);
+  myGLCD.print("L", myGLCD.getDisplayXSize()-24, 24);
+  myGLCD.print("E", myGLCD.getDisplayXSize()-24, 40);
+  myGLCD.print("A", myGLCD.getDisplayXSize()-24, 56);
+  myGLCD.print("R", myGLCD.getDisplayXSize()-24, 72);
+  myGLCD.print("+", myGLCD.getDisplayXSize()-24, 136);
+  myGLCD.print("-", myGLCD.getDisplayXSize()-24, 200);
+ // myButtons.drawButton(but7);
+  myGLCD.fillRect(myGLCD.getDisplayXSize()-32,96,myGLCD.getDisplayXSize()-1,128);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,160,myGLCD.getDisplayXSize()-1,160);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,192,myGLCD.getDisplayXSize()-1,192);
+  myGLCD.drawLine(myGLCD.getDisplayXSize()-32,224,myGLCD.getDisplayXSize()-1,224);
+  for (int i=0; i<8; i++)
+  {
+    myGLCD.setColor(colorlist[i]);
+    myGLCD.fillRect(0, (i*30), 24, (((i+1)*30)-1));
+  }
+  drawColorMarkerAndBrushSize(color);
+    int x;
+int y;
+int a=0;
+ do
+  {
+  
+  
+ while (myTouch.dataAvailable() == true)
+ {
+    myTouch.read();
+    x = myTouch.getX();
+    y = myTouch.getY();
+// if ((x>300) and (y>230)) 
+//{a=1;
+//}
+ if ((x<700) and (y>400)) 
+{a=1;
+}
+    if ((x!=-1) and (y!=-1))
+    {
+      if (x>(31+bsize) and (x<myGLCD.getDisplayXSize()-(31+bsize)))
+      {
+        if (bsize==1)
+          myGLCD.drawPixel(x, y);
+        else
+          myGLCD.fillCircle(x, y, bsize);
+      }
+      else
+      {
+        if (x<(30+bsize))
+        {
+          if (y<240)
+          {
+            color = y / 30;
+            drawColorMarkerAndBrushSize(color);
+            while (myTouch.dataAvailable()) {};
+            delay(50);
+         }
+        }
+        else
+        {
+          if (y<96)
+          {
+            myGLCD.setColor(VGA_BLACK);
+            myGLCD.fillRect(33, 0, myGLCD.getDisplayXSize()-33, myGLCD.getDisplayYSize()-1);
+            myGLCD.setColor(colorlist[color]);
+          }
+          if ((y>128) and (y<160))
+          {
+            if (bsize<7)
+            {
+              bsize++;
+              drawColorMarkerAndBrushSize(color);
+              while (myTouch.dataAvailable()) {};
+              delay(50);
+            }
+          }
+          if ((y>160) and (y<192))
+          {
+              bsize=4;
+              drawColorMarkerAndBrushSize(color);
+              while (myTouch.dataAvailable()) {};
+              delay(50);
+          }
+          if ((y>192) and (y<224))
+          {
+            if (bsize>1)
+            {
+              bsize--;
+              drawColorMarkerAndBrushSize(color);
+              while (myTouch.dataAvailable()) {};
+              delay(50);
+            }
+          }
+        }
+        }
+      }
+  }
+  } while (a<1);
+menu();
+}
+
+void drawColorMarkerAndBrushSize(int col)
+
+{
+  myGLCD.setColor(VGA_BLACK);
+  myGLCD.fillRect(25, 0, 31, 239);
+  myGLCD.fillRect(myGLCD.getDisplayXSize()-31, 161, myGLCD.getDisplayXSize()-1, 191);
+  myGLCD.setColor(VGA_WHITE);
+  myGLCD.drawPixel(25, (col*30)+15);
+  for (int i=1; i<7; i++)
+    myGLCD.drawLine(25+i, ((col*30)+15)-i, 25+i, ((col*30)+15)+i);
+  
+  if (color==1)
+    myGLCD.setColor(VGA_WHITE);
+  else
+    myGLCD.setColor(colorlist[col]);
+  if (bsize==1)
+    myGLCD.drawPixel(myGLCD.getDisplayXSize()-15, 177);
+  else
+    myGLCD.fillCircle(myGLCD.getDisplayXSize()-15, 177, bsize);
+    
+  myGLCD.setColor(colorlist[col]);
+}

_719/pict_radio.ino

@@ -0,0 +1,46 @@
+void pictrad()
+{
+    byte bait;
+byte bait1;
+
+//long address;
+long i;
+  int w;
+  int w1;
+  int w2;
+  int q=0;
+
+    myGLCD.setFont( BigFont);
+    
+ // myGLCD.fillScr(200,200,200);
+  
+  myFile.open("rad.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (i =0 ; i <  384000; i = i++)
+  {
+    n=n+1;
+  bait = myFile.read();
+ 
+  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+ w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>799){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+//   myGLCD.drawBitmap (0, 2*m, 320, 1, pic1, 2);
+  myGLCD.drawBitmap (0, m, 800, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:d
+ myFile.close(); 
+}

_719/pogoda.ino

@@ -0,0 +1,393 @@
+void pogoda()
+{
+   
+ 
+   myGLCD.setColor(VGA_WHITE);
+myGLCD.setBackColor(VGA_BLUE);
+ myGLCD.setFont(BigFont);
+ myGLCD.fillScr(VGA_BLUE); 
+  kalend();
+
+ //*************************************************************************
+   myGLCD.drawBitmap (639, 370, 160, 80,  cl);
+     myGLCD.drawRoundRect (639, 370, 799, 450); //Clok
+         
+  clc();
+  
+ myGLCD.setColor(0,38,92);
+  myGLCD.fillRoundRect(645, 155, 797, 367);//рисуем синий пр-к
+      myGLCD.setColor(255, 255, 255);//цвет обводки
+  myGLCD.drawRoundRect(645, 155, 797, 367);//прямоугольник с  обводкой
+ info(); 
+ 
+   myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+        myGLCD.setFont( Ubuntubold);
+
+
+//int pos=(10*temperature/90)+42; 
+
+//*****************************************************************************************
+int xtd=10;
+ termdom(xtd);
+int xb=140;
+barometr(xb);
+int xtu=270;
+ termul(xtu);
+
+
+
+
+
+
+//************************************************************************************************************************************************************
+  while(1)
+  {
+    
+    
+     sec=t.sec;
+  //   myGLCD.setColor(VGA_BLUE);
+  //    myGLCD.setBackColor(255,255,255);
+   //     myGLCD.setFont( Ubuntubold); 
+  //   myGLCD.printNumI(sec , 700, 160);
+     
+if ((sec==0) ||(sec==15) || (sec==30) || (sec==45))
+{
+//  myGLCD.setBackColor(0,0,255);
+//      myGLCD.drawBitmap (769, 339, 30, 30, jar);
+   
+    
+delay(800);
+
+clc();
+ bmp085();
+
+    myGLCD.setColor(VGA_BLUE);
+      myGLCD.setBackColor(255,255,255);
+        myGLCD.setFont( Ubuntubold);
+ int tem = tdc*10+tdd;      
+int pos=(10*tem/50); 
+//bar(x,y, pos,l,h);
+barvert(xtd+58,42, pos,10,340);
+
+//bar(x,y, pos,l,h);
+ pos=(100*(pressure-730)/50);
+barbarom(xb+58,42, pos,10,340);  
+int tem1=tdc*10+tdd;
+pos=(10*(tem1+340)/85); 
+//bar(x,y, pos,l,h);
+
+int tempul=tu*10+tud; 
+ pos=(10*(tempul+340)/85); 
+//bar(x,y, pos,l,h);
+barult(xtu+58,42, pos,10,340); 
+//barvert(xtu+58,42, pos,10,340); 
+
+}
+
+ if ((sec==11) || (sec==42) )
+{
+
+ info(); 
+ }
+ 
+ if ((sec==55) || (sec==25) )
+{
+
+ info();  
+
+ } 
+
+
+ //*****************************************************************
+if (myTouch.dataAvailable())
+ 
+    {
+      myTouch.read();
+      int x=myTouch.getX();
+      int y=myTouch.getY();
+      
+     //      myGLCD.setColor(VGA_BLUE);
+   //   myGLCD.setBackColor(255,255,255);
+   //   myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("x=    " , 650, 32);
+  //    myGLCD.printNumI(x , 700, 32);  
+   //   myGLCD.setFont( Ubuntubold);
+   //   myGLCD.print("y=    " ,650 , 72);
+    //  myGLCD.printNumI(y , 700, 72); 
+      
+      
+      
+      
+         if ((x>=640) && (x<=799))  // Upper row
+      { 
+        
+            if ((y>=10) && (y<=150))  //(10, 370, 90, 450); //Install 
+        {
+           kalendarset();
+            pogoda();
+        }
+        
+         if ((y>=370) && (y<=450))  //(10, 370, 90, 450); //Clok 
+        {waitForIt1(639, 370, 799, 450);
+         prognoz();
+          menu();
+        }
+      } 
+    }
+
+
+}
+}
+//***************************************************************************************************************************************************
+void termdom(int xtd)// xtd- координата начала вывода term dom по х
+{
+   myFile.open("termd.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 58086; i = i++) {
+    n=n+1;
+byte  bait = myFile.read();
+ 
+byte  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+int w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>125){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (xtd, m+8, 126, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close(); 
+ int tem=tdc*10+tdd;
+int pos=(10*tem/50); 
+//bar(x,y, pos,l,h);
+barvert(xtd+58,42, pos,10,340); 
+ 
+ 
+}
+
+
+void barvert(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(150,150,150);
+    
+    myGLCD.fillRoundRect(x-2, y-2, l+x+2, h+y+2);//рисуем серый пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ if (tdc>27)
+ { myGLCD.setColor(255,50,50);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor( 255,0,0); 
+ }
+ else
+ {
+     myGLCD.setColor(7,120,34);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+     myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+     myGLCD.setBackColor( 7,120,34); 
+ }
+myGLCD.setColor(255,255,255);
+myGLCD.setFont( Ubuntubold);
+//myGLCD.setBackColor( VGA_TRANSPARENT);
+ myGLCD.print("+" , x-48 , 380+30);
+ myGLCD.print("." ,x-48+24+40, 380+30);
+myGLCD.printNumI(tdc, x-48+24, 380+30);
+
+//int tdes=temperatur;
+myGLCD.printNumI(tdd , x-48+24+40+20, 380+30);
+
+  
+}
+//**********************************************************************
+
+
+void barometr(int xb)// xb- координата начала вывода бар по х
+{
+ myFile.open("barometr.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 58086; i = i++) {
+    n=n+1;
+byte  bait = myFile.read();
+ 
+byte  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+int w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>125){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (xb, m+8, 126, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+ 
+
+  // close the file:
+ myFile.close();   
+//bar(x,y, pos,l,h);
+
+int pos=(100*(pressure-730)/50); 
+barbarom(xb+58,42, pos,10,340);  
+}
+
+
+void barbarom(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(150,150,150);
+    
+    myGLCD.fillRoundRect(x-2, y-2, l+x+2, h+y+2);//рисуем серый пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ if (pressure<743)
+ { myGLCD.setColor(0,70,167);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//син
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor(0,70,167); 
+ }
+      if ((pressure<755)&&(pressure>742))
+ { myGLCD.setColor(60,212,209);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//бир
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor(60,212,209); 
+ }
+       if ((pressure<768)&&(pressure>754))
+ { myGLCD.setColor(230,94,32);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//ор
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor(230,94,32); 
+ }
+
+ if (pressure>767)
+ {
+     myGLCD.setColor(250,221,8);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//ж
+     myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+     myGLCD.setBackColor(250,221,8); 
+ }
+myGLCD.setColor(255,255,255);
+myGLCD.setFont( Ubuntubold);
+myGLCD.printNumI(pressure , x-30,  380+30); 
+//myGLCD.setBackColor( VGA_TRANSPARENT);
+ //myGLCD.print("+" ,20+58 , 380+30);
+
+
+  
+}
+
+
+
+
+
+
+void termul(int xtu)// xtu- координата начала вывода term dom по х
+{
+   myFile.open("termu.raw", O_READ);
+  
+int n=0;
+int m=0;
+  for (int i =0 ; i < 58086; i = i++) {
+    n=n+1;
+byte  bait = myFile.read();
+ 
+byte  bait1 =myFile.read();
+  
+// w1= (bait - 48) << 4 | (bait1 - 48);
+// w2= (bait2 - 48) << 4 | (bait3 - 48);
+int w= bait<<8|bait1;
+ 
+ pic1[n]=w;
+ //3199
+ if (n>125){
+ n=0;  
+// myGLCD.drawBitmap (0, 20*m, 320, 10, pic1, 2);
+  myGLCD.drawBitmap (xtu, m+8, 126, 1, pic1, 1);
+ m=m+1;
+ }
+  }
+
+ 
+
+  // close the file:
+ myFile.close(); 
+int tempul=tu*10+tud; 
+int pos=(10*(tempul+340)/85); 
+//bar(x,y, pos,l,h);
+barult(xtu+58,42, pos,10,340); 
+ 
+ 
+}
+
+//*******************************************************************************************
+void barult(int x,int y,int pos,int l,int h)//kalendar(days, mon, years); l-длинна шкалы pos-позиция метки положения h-высота
+{
+
+ //int h=40;//высота шкалы
+ myGLCD.setBackColor(0,0,255);
+  myGLCD.setColor(150,150,150);
+    
+    myGLCD.fillRoundRect(x-2, y-2, l+x+2, h+y+2);//рисуем серый пр-к
+     myGLCD.setColor(255, 255, 255);
+  myGLCD.fillRoundRect(x, y, l+x, h+y);//с белой обводкой
+  //myGLCD.setColor(255,114,0);
+ //myGLCD.fillRoundRect(80, 35, 632, 87);
+ if (tdc>27)
+ { myGLCD.setColor(255,50,50);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+   myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+   myGLCD.setBackColor( 255,0,0); 
+ }
+ else
+ {
+     myGLCD.setColor(7,120,34);
+  myGLCD.fillRoundRect(x+1, y+h-1, l+x-1, h+y-(pos*h/100));//уровень
+     myGLCD.fillCircle (l/2+x,y+h+40+3,40);
+     myGLCD.setBackColor( 7,120,34); 
+ }
+myGLCD.setColor(255,255,255);
+myGLCD.setFont( Ubuntubold);
+//myGLCD.setBackColor( VGA_TRANSPARENT);
+ myGLCD.print("+" , x-48 , 380+30);
+ myGLCD.print("." ,x-48+24+40, 380+30);
+myGLCD.printNumI(tu , x-48+24, 380+30);
+
+//int tempul=tu*10+tud; 
+//int tdes=tempul;
+myGLCD.printNumI(tud , x-48+24+40+20, 380+30);
+
+  
+}
+
+
+
+
+
+ //******************************DHT11***********************************
+ 

_719/pr.c

@@ -0,0 +1,64 @@
+// Generated by  : ImageConverter 565 v2.1
+// Generated from: pr.jpg
+// Time generated: 12.04.2014 22:14:34
+// Dimensions    : 30x30 pixels
+// Size          : 1 800 Bytes
+
+const unsigned short pr[0x384] ={
+0x001C, 0x001D, 0x001F, 0x085F, 0x10DF, 0x18FF, 0x191F, 0x211F, 0x211E, 0x211F, 0x18FF, 0x211F, 0x211F, 0x211D, 0x211F, 0x211F,   // 0x0010 (16)
+0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x211F, 0x213F, 0x295F, 0x317F, 0x39BF, 0x39FF, 0x3A1F, 0x001A, 0x001C,   // 0x0020 (32)
+0x001E, 0x003F, 0x089F, 0x10DF, 0x18FF, 0x18FF, 0x18FF, 0x10FF, 0x211F, 0x18BF, 0x10FF, 0x18FF, 0x20DF, 0x18DF, 0x18FF, 0x18FF,   // 0x0030 (48)
+0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x18FF, 0x191F, 0x215F, 0x317F, 0x39DF, 0x421F, 0x423F, 0x0018, 0x001A, 0x001D, 0x001E,   // 0x0040 (64)
+0x003F, 0x089F, 0x10BF, 0x10BF, 0x109F, 0x10BF, 0x18DF, 0x10BF, 0x10BF, 0x10BF, 0x10DF, 0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x10BF,   // 0x0050 (80)
+0x10BF, 0x10BF, 0x10BF, 0x10BF, 0x18DF, 0x211F, 0x295F, 0x39DF, 0x421F, 0x423F, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x085F,   // 0x0060 (96)
+0x087F, 0x087F, 0x107F, 0x105F, 0x005E, 0x089F, 0x105F, 0x107F, 0x007F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F, 0x087F,   // 0x0070 (112)
+0x087F, 0x087F, 0x109F, 0x18DF, 0x213F, 0x31BF, 0x421F, 0x423F, 0x0015, 0x0017, 0x001A, 0x001D, 0x001E, 0x001F, 0x003F, 0x083F,   // 0x0080 (128)
+0x003F, 0x003F, 0x105F, 0x081F, 0x083E, 0x003F, 0x081F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x003F,   // 0x0090 (144)
+0x087F, 0x10BF, 0x20FF, 0x319F, 0x39FF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001C, 0x001E, 0x001F, 0x001F, 0x001F, 0x001E, 0xEFFE,   // 0x00A0 (160)
+0xFFFF, 0xF7FD, 0x081F, 0x003F, 0x003F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x109F,   // 0x00B0 (176)
+0x18FF, 0x297F, 0x39DF, 0x423F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFDF, 0xFFFF,   // 0x00C0 (192)
+0xF7DF, 0x081F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x00D0 (208)
+0x39DF, 0x423F, 0x0015, 0x0016, 0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0xF7FE, 0xFFDF, 0xFFFF, 0xFFFF,   // 0x00E0 (224)
+0xF7FF, 0x20FF, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x295F, 0x31DF, 0x423F,   // 0x00F0 (240)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001E, 0xF7BF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF,   // 0x0100 (256)
+0x291E, 0x001E, 0x003F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0110 (272)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xF7FF, 0xFFDF, 0xFFFE, 0xFFFF, 0xF7BF, 0x213F,   // 0x0120 (288)
+0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x005F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0130 (304)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001E, 0x005F, 0x001F, 0xFFFF, 0xFFBF, 0xFFFF, 0xFFFF, 0xF7DF, 0x319F, 0x001F,   // 0x0140 (320)
+0x001F, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0150 (336)
+0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xF7FE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFDF, 0x001F, 0x001E, 0x001F,   // 0x0160 (352)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0170 (368)
+0x001E, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFBF, 0xFFFD, 0xF7FE, 0xFFFF, 0x001F, 0x001F, 0x003F, 0x001E,   // 0x0180 (384)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0190 (400)
+0x001E, 0x001F, 0x001F, 0x001E, 0x001E, 0x001D, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x081F, 0x001F, 0x001F, 0x003F, 0x087F,   // 0x01A0 (416)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01B0 (432)
+0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x01C0 (448)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x01D0 (464)
+0x001F, 0x001F, 0x001E, 0xEFFF, 0xFFDF, 0xFFDF, 0xFFDF, 0xF7FF, 0x081F, 0x001E, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x01E0 (480)
+0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001D, 0x003F,   // 0x01F0 (496)
+0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x001E, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016,   // 0x0200 (512)
+0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x001F, 0x081F, 0x001F, 0xFFFF, 0xFFFF, 0xFFFE,   // 0x0210 (528)
+0xFFDF, 0xF7FE, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B,   // 0x0220 (544)
+0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x005F, 0x001F, 0x001F, 0x001F, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFDF, 0xFFFF, 0x085F,   // 0x0230 (560)
+0x001F, 0x001E, 0x003F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F,   // 0x0240 (576)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0xF7FF, 0xFFFF, 0xFFFF, 0xFFDF, 0xF7DE, 0x001E, 0x001F, 0x001F, 0x001F,   // 0x0250 (592)
+0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F,   // 0x0260 (608)
+0x001F, 0x001F, 0x001F, 0x085F, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F,   // 0x0270 (624)
+0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F,   // 0x0280 (640)
+0x001F, 0xF79E, 0xFFDE, 0xFF9F, 0xFFBE, 0xF7DE, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 0x001E, 0x001F, 0x001F, 0x003F, 0x087F,   // 0x0290 (656)
+0x18DF, 0x297F, 0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0xFF9F, 0xFFBF,   // 0x02A0 (672)
+0xF7DF, 0xFFBF, 0xFFDF, 0x081F, 0x003F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x087F, 0x18DF, 0x297F,   // 0x02B0 (688)
+0x39DF, 0x421F, 0x0015, 0x0016, 0x0019, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0xF7DF, 0xFFDE, 0xFFBE, 0xFFFD, 0x001E,   // 0x02C0 (704)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x003F, 0x001F, 0x001F, 0x001F, 0x003F, 0x003F, 0x087F, 0x18DF, 0x297F, 0x39DF, 0x421F,   // 0x02D0 (720)
+0x0014, 0x0016, 0x0018, 0x001B, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0xEFBE, 0xFF9F, 0xF79F, 0x081F, 0x003F, 0x001F, 0x001F,   // 0x02E0 (736)
+0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x001F, 0x085F, 0x18BF, 0x213F, 0x31BF, 0x3A1F, 0x0014, 0x0016,   // 0x02F0 (752)
+0x0018, 0x001B, 0x001D, 0x001F, 0x001F, 0x001F, 0x001E, 0x001E, 0x001D, 0x003E, 0x001D, 0x001F, 0x003E, 0x001D, 0x001E, 0x001E,   // 0x0300 (768)
+0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001F, 0x003F, 0x107F, 0x20FF, 0x31BF, 0x39FF, 0x0014, 0x0015, 0x0017, 0x0019,   // 0x0310 (784)
+0x001A, 0x001B, 0x001C, 0x001C, 0x001D, 0x001E, 0x001D, 0x001D, 0x001C, 0x001E, 0x001D, 0x081D, 0x001D, 0x001D, 0x001D, 0x001D,   // 0x0320 (800)
+0x001D, 0x001D, 0x001D, 0x001D, 0x001D, 0x001F, 0x083F, 0x109F, 0x213F, 0x297F, 0x0014, 0x0015, 0x0016, 0x0018, 0x0019, 0x001B,   // 0x0330 (816)
+0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001C, 0x001B, 0x001C, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B,   // 0x0340 (832)
+0x001B, 0x001B, 0x001D, 0x001D, 0x001E, 0x005F, 0x10DF, 0x213F, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001A,   // 0x0350 (848)
+0x0019, 0x0019, 0x0019, 0x0019, 0x001B, 0x0019, 0x001A, 0x0019, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A, 0x001A,   // 0x0360 (864)
+0x001A, 0x001B, 0x001D, 0x003F, 0x085F, 0x10BF, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x0019, 0x0019, 0x0039, 0x0019,   // 0x0370 (880)
+0x0019, 0x0018, 0x0038, 0x0019, 0x0019, 0x0819, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x0019, 0x001A, 0x001A,   // 0x0380 (896)
+0x001C, 0x001D, 0x001E, 0x087E, };