Utiliser une image sur écran LED 480x320

**Benji861905** · 08/08/2015, 21h32

Bonjour,
Depuis 1 semaine je cherche a comprendre comment marche le system bitmap pour afficher des image sur arduino, j'ai essayer beaucoup de tutoriel mais sa ne fonctionne toujours pas, si quelqu'un pouvais juste me donner un petit code simple avec juste une image et qu'il pourrait m'expliquer comment ce code marche sa serrait super !

Je suis sur une mega avec un écran 480x320 : http://www.banggood.com/fr/3_0-Inch-...-p-963573.html

Merci d'avance a tout ce qui vont me répondre et m'aider

**Vincent PETIT** · 08/08/2015, 22h40

Salut,
Il va falloir que tu nous montres où tu en es dans ton programme et sur quoi tu bloques car à moins de trouver : un gars sur le forum, qui a la même Arduino que toi, qui a acheté le même écran que toi et qui veut faire la même chose toi ! ... ça va être compliqué de répondre.

As tu la bibliothèque qui va bien avec le driver de ton afficheur ?
Est ce que tu dois écrire cette bibliothèque ou les fonctions ?
Connais tu le driver au moins ?
Y a t'il des exemples fournis avec l'afficheur ?
Arrives tu as afficher des pixels sur l'écran, depuis un simple programme ?

**Benji861905** · 08/08/2015, 23h01

Salut et merci de m'aider,
Ma librairie est "UTFT", oui il y a des exemple fournie avec et qui fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
// UTFT_Demo_480x320 (C)2014 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution 
// of 480x320 pixels.
//
// This program requires the UTFT library.
//
 
#include <UTFT.h>
 
// Declare which fonts we will be using
extern uint8_t SmallFont[];
 
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Arduino Uno / 2009:
// -------------------
// Standard Arduino Uno/2009 shield            : <display model>,A5,A4,A3,A2
// DisplayModule Arduino Uno TFT shield        : <display model>,A5,A4,A3,A2
//
// Arduino Mega:
// -------------------
// Standard Arduino Mega/Due shield            : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Mega      : <display model>,38,39,40,41
//
// Remember to change the model parameter to suit your display module!
UTFT myGLCD(HX8357C,38,39,40,41);
 
void setup()
{
  randomSeed(analogRead(0));
 
// Setup the LCD
  myGLCD.InitLCD();
  myGLCD.InitLCD();
  myGLCD.setFont(SmallFont);
}
 
void loop()
{
  int buf[478];
  int x, x2;
  int y, y2;
  int r;
 
// Clear the screen and draw the frame
  myGLCD.clrScr();
 
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRect(0, 0, 479, 13);
  myGLCD.setColor(64, 64, 64);
  myGLCD.fillRect(0, 306, 479, 319);
  myGLCD.setColor(255, 255, 255);
  myGLCD.setBackColor(255, 0, 0);
  myGLCD.print("* Universal Color TFT Display Library *", CENTER, 1);
  myGLCD.setBackColor(64, 64, 64);
  myGLCD.setColor(255,255,0);
  myGLCD.print("<http://electronics.henningkarlsen.com>", CENTER, 307);
 
  myGLCD.setColor(0, 0, 255);
  myGLCD.drawRect(0, 14, 479, 305);
 
// Draw crosshairs
  myGLCD.setColor(0, 0, 255);
  myGLCD.setBackColor(0, 0, 0);
  myGLCD.drawLine(239, 15, 239, 304);
  myGLCD.drawLine(1, 159, 478, 159);
  for (int i=9; i<470; i+=10)
    myGLCD.drawLine(i, 157, i, 161);
  for (int i=19; i<220; i+=10)
    myGLCD.drawLine(237, i, 241, i);
 
// Draw sin-, cos- and tan-lines  
  myGLCD.setColor(0,255,255);
  myGLCD.print("Sin", 5, 15);
  for (int i=1; i<478; i++)
  {
    myGLCD.drawPixel(i,159+(sin(((i*1.13)*3.14)/180)*95));
  }
 
  myGLCD.setColor(255,0,0);
  myGLCD.print("Cos", 5, 27);
  for (int i=1; i<478; i++)
  {
    myGLCD.drawPixel(i,159+(cos(((i*1.13)*3.14)/180)*95));
  }
 
  myGLCD.setColor(255,255,0);
  myGLCD.print("Tan", 5, 39);
  for (int i=1; i<478; i++)
  {
    myGLCD.drawPixel(i,159+(tan(((i*1.13)*3.14)/180)));
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
  myGLCD.setColor(0, 0, 255);
  myGLCD.setBackColor(0, 0, 0);
  myGLCD.drawLine(239, 15, 239, 304);
  myGLCD.drawLine(1, 159, 478, 159);
 
// Draw a moving sinewave
  x=1;
  for (int i=1; i<(478*15); i++) 
  {
    x++;
    if (x==479)
      x=1;
    if (i>479)
    {
      if ((x==239)||(buf[x-1]==159))
        myGLCD.setColor(0,0,255);
      else
        myGLCD.setColor(0,0,0);
      myGLCD.drawPixel(x,buf[x-1]);
    }
    myGLCD.setColor(0,255,255);
    y=159+(sin(((i*0.7)*3.14)/180)*(90-(i / 100)));
    myGLCD.drawPixel(x,y);
    buf[x-1]=y;
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some filled rectangles
  for (int i=1; i<6; i++)
  {
    switch (i)
    {
      case 1:
        myGLCD.setColor(255,0,255);
        break;
      case 2:
        myGLCD.setColor(255,0,0);
        break;
      case 3:
        myGLCD.setColor(0,255,0);
        break;
      case 4:
        myGLCD.setColor(0,0,255);
        break;
      case 5:
        myGLCD.setColor(255,255,0);
        break;
    }
    myGLCD.fillRect(150+(i*20), 70+(i*20), 210+(i*20), 130+(i*20));
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some filled, rounded rectangles
  for (int i=1; i<6; i++)
  {
    switch (i)
    {
      case 1:
        myGLCD.setColor(255,0,255);
        break;
      case 2:
        myGLCD.setColor(255,0,0);
        break;
      case 3:
        myGLCD.setColor(0,255,0);
        break;
      case 4:
        myGLCD.setColor(0,0,255);
        break;
      case 5:
        myGLCD.setColor(255,255,0);
        break;
    }
    myGLCD.fillRoundRect(270-(i*20), 70+(i*20), 330-(i*20), 130+(i*20));
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some filled circles
  for (int i=1; i<6; i++)
  {
    switch (i)
    {
      case 1:
        myGLCD.setColor(255,0,255);
        break;
      case 2:
        myGLCD.setColor(255,0,0);
        break;
      case 3:
        myGLCD.setColor(0,255,0);
        break;
      case 4:
        myGLCD.setColor(0,0,255);
        break;
      case 5:
        myGLCD.setColor(255,255,0);
        break;
    }
    myGLCD.fillCircle(180+(i*20),100+(i*20), 30);
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some lines in a pattern
  myGLCD.setColor (255,0,0);
  for (int i=15; i<304; i+=5)
  {
    myGLCD.drawLine(1, i, (i*1.6)-10, 304);
  }
  myGLCD.setColor (255,0,0);
  for (int i=304; i>15; i-=5)
  {
    myGLCD.drawLine(478, i, (i*1.6)-11, 15);
  }
  myGLCD.setColor (0,255,255);
  for (int i=304; i>15; i-=5)
  {
    myGLCD.drawLine(1, i, 491-(i*1.6), 15);
  }
  myGLCD.setColor (0,255,255);
  for (int i=15; i<304; i+=5)
  {
    myGLCD.drawLine(478, i, 490-(i*1.6), 304);
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some random circles
  for (int i=0; i<100; i++)
  {
    myGLCD.setColor(random(255), random(255), random(255));
    x=32+random(416);
    y=45+random(226);
    r=random(30);
    myGLCD.drawCircle(x, y, r);
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some random rectangles
  for (int i=0; i<100; i++)
  {
    myGLCD.setColor(random(255), random(255), random(255));
    x=2+random(476);
    y=16+random(289);
    x2=2+random(476);
    y2=16+random(289);
    myGLCD.drawRect(x, y, x2, y2);
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
// Draw some random rounded rectangles
  for (int i=0; i<100; i++)
  {
    myGLCD.setColor(random(255), random(255), random(255));
    x=2+random(476);
    y=16+random(289);
    x2=2+random(476);
    y2=16+random(289);
    myGLCD.drawRoundRect(x, y, x2, y2);
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
  for (int i=0; i<100; i++)
  {
    myGLCD.setColor(random(255), random(255), random(255));
    x=2+random(476);
    y=16+random(289);
    x2=2+random(476);
    y2=16+random(289);
    myGLCD.drawLine(x, y, x2, y2);
  }
 
  delay(2000);
 
  myGLCD.setColor(0,0,0);
  myGLCD.fillRect(1,15,478,304);
 
  for (int i=0; i<10000; i++)
  {
    myGLCD.setColor(random(255), random(255), random(255));
    myGLCD.drawPixel(2+random(476), 16+random(289));
  }
 
  delay(2000);
 
  myGLCD.fillScr(0, 0, 255);
  myGLCD.setColor(255, 0, 0);
  myGLCD.fillRoundRect(160, 70, 319, 169);
 
  myGLCD.setColor(255, 255, 255);
  myGLCD.setBackColor(255, 0, 0);
  myGLCD.print("That's it!", CENTER, 93);
  myGLCD.print("Restarting in a", CENTER, 119);
  myGLCD.print("few seconds...", CENTER, 132);
 
  myGLCD.setColor(0, 255, 0);
  myGLCD.setBackColor(0, 0, 255);
  myGLCD.print("Runtime: (msecs)", CENTER, 290);
  myGLCD.printNumI(millis(), CENTER, 305);
 
  delay (10000);
}

Mais il n'y a qu'un seul exemple qui montre comment on affiche des image, le soucis c'est que les images sont afficher sur des bouton :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// UTFT_Buttons_Bitmap_Demo (C)2013 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics
//
// A small demo to demonstrate the use of some of the
// functions of the UTFT_Buttons add-on library.
//
// This demo was made for modules with a screen resolution 
// of 320x240 pixels, but should work on larger screens as
// well.
//
// This demo will not work on Arduino 2009/Uno/Leonardo
// due to the size of the images.
//
// This program requires both the UTFT and UTouch libraries
// in addition to the UTFT_Buttons add-on library.
//
 
// This code block is only needed to support multiple
// MCU architectures in a single sketch.
#if defined(__AVR__)
	#define imagedatatype  unsigned int
#elif defined(__PIC32MX__)
	#define imagedatatype  unsigned short
#elif defined(__arm__)
	#define imagedatatype  unsigned short
#endif
// End of multi-architecture block
 
#include <UTFT.h>
#include <UTouch.h>
#include <UTFT_Buttons.h>
 
// Declare which fonts we will be using
extern uint8_t BigFont[];
 
// Declare which bitmaps we will be using
extern imagedatatype cat[];
extern imagedatatype dog[];
extern imagedatatype bird[];
extern imagedatatype monkey[];
 
// Set up UTFT...
// Set the pins to the correct ones for your development board
// -----------------------------------------------------------
// Standard Arduino 2009/Uno/Leonardo shield   : NOT SUPPORTED DUE TO LACK OF MEMORY
// Standard Arduino Mega/Due shield            : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Due       : <display model>,25,26,27,28
// Standard chipKit Uno32/uC32                 : <display model>,34,35,36,37
// Standard chipKit Max32                      : <display model>,82,83,84,85
// AquaLEDSource All in One Super Screw Shield : <display model>,82,83,84,85
//
// Remember to change the model parameter to suit your display module!
UTFT          myGLCD(HX8357C,38,39,40,41);
 
// Set up UTouch...
// Set the pins to the correct ones for your development board
// -----------------------------------------------------------
// Standard Arduino 2009/Uno/Leonardo shield   : NOT SUPPORTED DUE TO LACK OF MEMORY
// Standard Arduino Mega/Due shield            : 6,5,4,3,2
// CTE TFT LCD/SD Shield for Arduino Due       : 6,5,4,3,2
// Standard chipKit Uno32/uC32                 : 20,21,22,23,24
// Standard chipKit Max32                      : 62,63,64,65,66
// AquaLEDSource All in One Super Screw Shield : 62,63,64,65,66
UTouch  myTouch(52, 48, 51,50, 49);
 
// Finally we set up UTFT_Buttons :)
UTFT_Buttons  myButtons(&myGLCD, &myTouch);
 
void setup()
{
  myGLCD.InitLCD();
  myGLCD.clrScr();
  myGLCD.setFont(BigFont);
 
  myTouch.InitTouch();
  myTouch.setPrecision(PREC_MEDIUM);
 
  myButtons.setTextFont(BigFont);
}
 
void loop()
{
  int but1, but2, but3, but4, but5, pressed_button;
 
  but1 = myButtons.addButton( 10,  10, 80,  60, cat);
  but2 = myButtons.addButton( 120,  10, 80,  60, dog);
  but3 = myButtons.addButton( 10,  80, 80,  60, bird);
  but4 = myButtons.addButton( 120,  80, 80,  60, monkey, BUTTON_NO_BORDER);
  but5 = myButtons.addButton( 10, 150, 190, 30, "Disable Dog");
  myButtons.drawButtons();
 
  myGLCD.print("You pressed:", 10, 200);
  myGLCD.setColor(VGA_BLACK);
  myGLCD.setBackColor(VGA_WHITE);
  myGLCD.print("None    ", 10, 220);
 
  while(1) 
  {
    if (myTouch.dataAvailable() == true)
    {
      pressed_button = myButtons.checkButtons();
 
      if (pressed_button==but5)
        if (myButtons.buttonEnabled(but2))
        {
          myButtons.disableButton(but2);
          myButtons.relabelButton(but5, "Enable Dog", true);
          myButtons.drawButton(but2);
        }
        else
        {
          myButtons.enableButton(but2);
          myButtons.relabelButton(but5, "Disable Dog", true);
          myButtons.drawButton(but2);
        }
 
      if (pressed_button==but1)
        myGLCD.print("Cat     ", 10, 220);
      if (pressed_button==but2)
        myGLCD.print("Dog     ", 10, 220);
      if (pressed_button==but3)
        myGLCD.print("Bird    ", 10, 220);
      if (pressed_button==but4)
        myGLCD.print("Monkey  ", 10, 220);
      if (pressed_button==-1)
        myGLCD.print("None    ", 10, 220);
    }
  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
// Generated by  : ImageConverter 565 v1.2
// Dimensions    : 80x60 pixels
// Size          : 9*600 Bytes
 
#if defined(__AVR__)
	#include <avr/pgmspace.h>
#elif defined(__PIC32MX__)
	#define PROGMEM
#elif defined(__arm__)
	#define PROGMEM
#endif
 
const unsigned short bird[0x12C0] PROGMEM ={
0x71A0, 0x6980, 0x7A20, 0xAB61, 0xDC82, 0xECC1, 0xF4C0, 0xECE1, 0xED03, 0xD4C5, 0x9BA5, 0x7AC2, 0x9320, 0xBC22, 0xC421, 0xBBE0,   // 0x0010 (16)
0xB3E0, 0xA3A1, 0x7A81, 0x5180, 0x4140, 0x51A1, 0x6A82, 0x8303, 0x7281, 0x61A0, 0x5980, 0x5961, 0x5101, 0x5901, 0x5921, 0x6140,   // 0x0020 (32)
0x69E0, 0x92E1, 0xAB42, 0xAB00, 0xAB60, 0xBBE3, 0xAB62, 0x8A40, 0x8A20, 0xB382, 0xE504, 0xF583, 0xF561, 0xD4A0, 0xABA0, 0xA361,   // 0x0030 (48)
0xBBA1, 0xC381, 0xB320, 0xA320, 0x9B41, 0x8B01, 0x82E1, 0x7AA2, 0x7264, 0x6A43, 0x6A20, 0x82A0, 0xAB80, 0xBBE1, 0xAB61, 0x8A80,   // 0x0040 (64)
0x71E0, 0x61C1, 0x6A01, 0x7262, 0x6A81, 0x62C1, 0x62E1, 0x6B02, 0x7322, 0x6B22, 0x62C1, 0x5260, 0x4A61, 0x4A62, 0x4A42, 0x4A02,   // 0x0050 (80)
0x6160, 0x6160, 0x71E0, 0x9B21, 0xD441, 0xE4A1, 0xECC1, 0xE4C2, 0xE4E3, 0xD4C5, 0xAC06, 0x8B23, 0xA381, 0xC442, 0xC421, 0xBBA0,   // 0x0060 (96)
0xBB80, 0xAB40, 0x7AA1, 0x51C0, 0x3140, 0x4161, 0x5A21, 0x7262, 0x7241, 0x61A0, 0x5940, 0x5120, 0x48E0, 0x48E0, 0x5120, 0x61A0,   // 0x0070 (112)
0x7A60, 0x9B20, 0xAB41, 0x9AE0, 0xAB60, 0xC443, 0xB3E2, 0x8AC0, 0x92A0, 0xBBC2, 0xE503, 0xF563, 0xE541, 0xCC80, 0x9BA0, 0x9B60,   // 0x0080 (128)
0xAB80, 0xB380, 0xAB40, 0x9B21, 0x8B01, 0x82E1, 0x7AC2, 0x7AC3, 0x7263, 0x7262, 0x7240, 0x8AA0, 0xB360, 0xCC22, 0xCC02, 0xB341,   // 0x0090 (144)
0x9A40, 0x89A0, 0x79C0, 0x71E0, 0x6241, 0x62A1, 0x6301, 0x6321, 0x6B41, 0x6B41, 0x6301, 0x5281, 0x4241, 0x4A43, 0x4A24, 0x4A04,   // 0x00A0 (160)
0x59A1, 0x59A1, 0x6A00, 0x9301, 0xC421, 0xD481, 0xD461, 0xD462, 0xD4A4, 0xCCC5, 0xB445, 0x9B62, 0xABA1, 0xC483, 0xC441, 0xA360,   // 0x00B0 (176)
0x92C0, 0x9B01, 0x82E2, 0x5A20, 0x3980, 0x3961, 0x49C3, 0x5A05, 0x6A24, 0x61E2, 0x59A2, 0x5141, 0x4920, 0x4920, 0x5160, 0x69C0,   // 0x00C0 (192)
0x8AA0, 0x9B20, 0x9B00, 0x92A0, 0xAB80, 0xC483, 0xB423, 0x9320, 0x8AE0, 0xB3C2, 0xDCE3, 0xE523, 0xD4E2, 0xB441, 0x8BA0, 0x8340,   // 0x00D0 (208)
0xA380, 0xB3C1, 0xB3C2, 0x9B42, 0x82E1, 0x72A2, 0x7AC2, 0x7AE3, 0x7AA3, 0x7A82, 0x7A81, 0x8AA0, 0xAB20, 0xD401, 0xDC61, 0xD3C0,   // 0x00E0 (224)
0xC280, 0xA9A0, 0x9140, 0x8180, 0x71E1, 0x6A81, 0x62E1, 0x6320, 0x6320, 0x6B41, 0x6302, 0x5261, 0x4201, 0x4A03, 0x4A25, 0x4A05,   // 0x00F0 (240)
0x59E3, 0x59C2, 0x61E1, 0x82A1, 0xABC1, 0xBC01, 0xBBE1, 0xBBE3, 0xC424, 0xC465, 0xBC25, 0xA361, 0xA360, 0xBC44, 0xB422, 0x8B00,   // 0x0100 (256)
0x7280, 0x7282, 0x7A83, 0x61E3, 0x5162, 0x4121, 0x4160, 0x51E2, 0x6221, 0x6A02, 0x61A2, 0x5122, 0x4902, 0x5101, 0x5980, 0x7200,   // 0x0110 (272)
0x8A81, 0x9281, 0x8A60, 0x92A0, 0xB3C1, 0xC483, 0xAC03, 0x8B21, 0x8AE0, 0xABC3, 0xD4A4, 0xDCC4, 0xBC43, 0x9381, 0x7B21, 0x7B00,   // 0x0120 (288)
0x9340, 0xABC1, 0xB3E2, 0x9B41, 0x7AA1, 0x6A82, 0x72A3, 0x7AC4, 0x7AA3, 0x7A82, 0x7A81, 0x8280, 0x9AC0, 0xBBA1, 0xDC42, 0xDBC1,   // 0x0130 (304)
0xCA80, 0xB180, 0x9900, 0x9141, 0x89C2, 0x7A42, 0x6AA0, 0x62A0, 0x6300, 0x6301, 0x62C2, 0x5242, 0x49E2, 0x4A03, 0x5A24, 0x5A25,   // 0x0140 (320)
0x59E1, 0x51A0, 0x59C0, 0x7280, 0x9B60, 0xA3A0, 0xAB81, 0xABA3, 0xABC4, 0xABE4, 0xAC04, 0xA382, 0x9321, 0x9BA3, 0x9362, 0x6A80,   // 0x0150 (336)
0x51C0, 0x5A01, 0x6222, 0x59E3, 0x49A2, 0x3121, 0x3141, 0x5203, 0x6284, 0x6223, 0x51C2, 0x4181, 0x4981, 0x4960, 0x5940, 0x79A1,   // 0x0160 (352)
0x81E1, 0x8A21, 0x8A40, 0x9AE0, 0xBC01, 0xBC42, 0x9BA2, 0x8B21, 0x9322, 0xB3E4, 0xD4A4, 0xCC83, 0xAC02, 0x8B41, 0x7AC2, 0x7281,   // 0x0170 (368)
0x82C0, 0xA360, 0xB3C1, 0x9B40, 0x7AA0, 0x7261, 0x7A83, 0x82C4, 0x8283, 0x7A62, 0x7281, 0x7AA1, 0x8AA0, 0xA321, 0xC3A2, 0xCB82,   // 0x0180 (384)
0xB261, 0xA160, 0xA100, 0xA121, 0x99A2, 0x9222, 0x8261, 0x6A60, 0x62A1, 0x5A82, 0x5242, 0x5202, 0x5202, 0x6202, 0x6A23, 0x7223,   // 0x0190 (400)
0x69E0, 0x61E0, 0x6A40, 0x7AE0, 0x8B81, 0x9380, 0x9B61, 0xA383, 0x9B63, 0x9323, 0x9B63, 0x9363, 0x82E1, 0x7281, 0x6241, 0x51E0,   // 0x01A0 (416)
0x41C0, 0x39A1, 0x4A03, 0x49E4, 0x39A3, 0x4289, 0x5452, 0x5538, 0x4D9C, 0x3CF9, 0x3C33, 0x3B4D, 0x4286, 0x41A1, 0x4140, 0x5960,   // 0x01B0 (432)
0x71C0, 0x9261, 0x9AE0, 0xAB40, 0xBC01, 0xB401, 0x9361, 0x8302, 0x9364, 0xAC25, 0xC483, 0xC4A2, 0xBC62, 0xABC2, 0x9342, 0x82A1,   // 0x01C0 (448)
0x8AA0, 0x9B20, 0xB381, 0x9B20, 0x7A80, 0x7260, 0x8282, 0x8AC4, 0x8A83, 0x8262, 0x7281, 0x7A81, 0x7A80, 0x92C0, 0xB322, 0xBB22,   // 0x01D0 (464)
0xAA41, 0x9980, 0xA121, 0xA942, 0xA982, 0xA202, 0x8A41, 0x7241, 0x6A42, 0x5A22, 0x51E2, 0x5A02, 0x6A22, 0x7242, 0x8221, 0x8A22,   // 0x01E0 (480)
0x8A80, 0x92C0, 0x8B60, 0x93C1, 0x8BA0, 0x8B60, 0x9B60, 0xABC3, 0x9383, 0x7AC1, 0x7AC2, 0x7AE3, 0x6A81, 0x5200, 0x49A1, 0x4182,   // 0x01F0 (496)
0x3962, 0x39A3, 0x3182, 0x3248, 0x4C55, 0x3D1C, 0x149E, 0x047F, 0x0C5D, 0x043C, 0x04BE, 0x153E, 0x255D, 0x3497, 0x4B0B, 0x51C2,   // 0x0200 (512)
0x82A2, 0xA342, 0xB361, 0xAB60, 0xABA1, 0x9B41, 0x7AC2, 0x72A3, 0x8B66, 0x9BE6, 0xA403, 0xB422, 0xC463, 0xC463, 0xB402, 0xA361,   // 0x0210 (528)
0x9B20, 0xA361, 0xB382, 0x9AE0, 0x7A40, 0x7A20, 0x8280, 0x9AE2, 0x9AC2, 0x9281, 0x7A61, 0x7A81, 0x7A80, 0x8AA0, 0xAAE2, 0xBB02,   // 0x0220 (544)
0xB281, 0xA9E0, 0xB182, 0xB162, 0xA982, 0xA203, 0x8A42, 0x7221, 0x6222, 0x5A22, 0x6202, 0x6A21, 0x7A61, 0x8A61, 0x9241, 0x9221,   // 0x0230 (560)
0xB360, 0xB3E1, 0xB462, 0xA441, 0x83A0, 0x8360, 0xA3E1, 0xBC64, 0xA3E4, 0x7AE1, 0x6A61, 0x6A82, 0x5A41, 0x49E1, 0x4182, 0x4163,   // 0x0240 (576)
0x4142, 0x3143, 0x322A, 0x43B5, 0x2C3B, 0x0BDC, 0x03BD, 0x039D, 0x03BC, 0x03DC, 0x0C3E, 0x043E, 0x0C7E, 0x253F, 0x359D, 0x5515,   // 0x0250 (592)
0x8C29, 0xBC25, 0xB3A2, 0xA300, 0x9302, 0x7A62, 0x6A02, 0x6A64, 0x8368, 0x8BA7, 0x8343, 0x9341, 0xB3E2, 0xC443, 0xC462, 0xB401,   // 0x0260 (608)
0xB3E2, 0xB3C3, 0xBBA3, 0xA2E1, 0x7A20, 0x7A20, 0x92A0, 0xAB42, 0xBB63, 0xB323, 0x8AC2, 0x7A61, 0x7A60, 0x8A80, 0xAAC1, 0xC302,   // 0x0270 (624)
0xCB02, 0xC261, 0xC1C2, 0xB162, 0xA181, 0x99E2, 0x8242, 0x6A22, 0x5A22, 0x6243, 0x6A62, 0x7A61, 0x8A80, 0x9281, 0x9A42, 0x9A02,   // 0x0280 (640)
0xCC40, 0xD4A1, 0xBC61, 0x9BC0, 0x8380, 0x8380, 0xAC41, 0xD505, 0xC4A3, 0x9361, 0x6261, 0x5A22, 0x6222, 0x59E2, 0x49C3, 0x41E3,   // 0x0290 (656)
0x39A0, 0x2A06, 0x33F7, 0x139B, 0x02FA, 0x0B1B, 0x0ADB, 0x0AFB, 0x0AD9, 0x02D9, 0x0B9C, 0x03DC, 0x047C, 0x04BC, 0x04BF, 0x155F,   // 0x02A0 (672)
0x2DDE, 0x5DD9, 0x7C8F, 0x7B25, 0x7261, 0x6A20, 0x51E2, 0x62A4, 0x8BA6, 0x9BE6, 0x93A4, 0x8B41, 0x9B80, 0xB3E0, 0xB402, 0xABE3,   // 0x02B0 (688)
0xA3C4, 0xABE5, 0xA3A3, 0x92E0, 0x8220, 0x8A00, 0xAAE0, 0xCBE2, 0xD442, 0xB3A1, 0x8B00, 0x82E1, 0x92E1, 0xA301, 0xAB01, 0xC321,   // 0x02C0 (704)
0xCB62, 0xCB02, 0xC262, 0xA9C1, 0x99C1, 0x91C2, 0x79E3, 0x69C2, 0x71E1, 0x7A41, 0x82A0, 0x8280, 0x8A80, 0x92A2, 0x9261, 0x8A00,   // 0x02D0 (720)
0xDCA0, 0xD4A1, 0xAC00, 0x8B60, 0x7B20, 0x7B40, 0xAC21, 0xDD45, 0xD504, 0xA381, 0x7281, 0x6A63, 0x6A43, 0x6243, 0x6264, 0x4A04,   // 0x02E0 (736)
0x4226, 0x53B1, 0x2359, 0x029A, 0x0258, 0x0216, 0x0215, 0x0215, 0x0277, 0x02B8, 0x031B, 0x0B9D, 0x039C, 0x041D, 0x0C5D, 0x045C,   // 0x02F0 (752)
0x0CBD, 0x151D, 0x2DBC, 0x4DB8, 0x53AB, 0x4203, 0x4A24, 0x7B06, 0xAC07, 0xC465, 0xBC41, 0xB420, 0xA3E1, 0x9BC2, 0x9BC3, 0x9342,   // 0x0300 (768)
0x9343, 0x9B43, 0x9321, 0x8AA0, 0x7A40, 0x8A60, 0xB360, 0xD442, 0xDC82, 0xBBC0, 0x9B20, 0x9B21, 0xB3A2, 0xBBA2, 0xBB61, 0xBB40,   // 0x0310 (784)
0xCB80, 0xCB61, 0xC301, 0xB261, 0xA201, 0x89E2, 0x71E2, 0x69C2, 0x71E1, 0x8262, 0x82C0, 0x7AA0, 0x7A60, 0x8261, 0x8A21, 0x81C0,   // 0x0320 (800)
0xE4C1, 0xCC61, 0x9360, 0x72C0, 0x6AC0, 0x7B00, 0xAC00, 0xDD24, 0xDD04, 0xB3E1, 0x8B01, 0x7AC3, 0x7AA4, 0x7AA4, 0x7284, 0x6286,   // 0x0330 (816)
0x532C, 0x4BD4, 0x12B7, 0x0237, 0x0192, 0x0191, 0x01B2, 0x0214, 0x0296, 0x1319, 0x0B19, 0x0B7A, 0x0B7A, 0x0B9A, 0x039A, 0x03FB,   // 0x0340 (832)
0x047D, 0x04FE, 0x04FD, 0x157D, 0x3E1E, 0x4D16, 0x5329, 0x9386, 0xCC66, 0xDCA4, 0xD4A1, 0xD4C0, 0xC460, 0xB3E0, 0xA3A1, 0x9301,   // 0x0350 (848)
0x8AC2, 0x8AE2, 0x9301, 0x82A0, 0x7A60, 0x92E0, 0xC401, 0xDC81, 0xDC81, 0xBBA0, 0xA300, 0xAB40, 0xC422, 0xD422, 0xC381, 0xBB20,   // 0x0360 (864)
0xC380, 0xCBA0, 0xCBA2, 0xBB42, 0xAAE1, 0x9A81, 0x8241, 0x7201, 0x7A21, 0x8282, 0x7AC1, 0x72A0, 0x7260, 0x7240, 0x7A21, 0x79E0,   // 0x0370 (880)
0xE482, 0xBBE1, 0x7AC0, 0x5A40, 0x6260, 0x7AE0, 0xABC0, 0xD4C3, 0xDCE3, 0xBC01, 0x9B41, 0x8AE2, 0x8B04, 0x82E4, 0x7263, 0x6286,   // 0x0380 (896)
0x5B6E, 0x2AD1, 0x0A33, 0x01D3, 0x0191, 0x012F, 0x0191, 0x01B2, 0x1235, 0x0235, 0x0298, 0x02F9, 0x033B, 0x03DD, 0x03FD, 0x041D,   // 0x0390 (912)
0x0C7C, 0x049C, 0x049D, 0x04FE, 0x0D5E, 0x35BD, 0x5599, 0x7CD0, 0xC4C7, 0xDC61, 0xE4A1, 0xED01, 0xE4E0, 0xCC60, 0xABC0, 0x9320,   // 0x03A0 (928)
0x8AC2, 0x9B03, 0xA363, 0xA321, 0x9AE0, 0xAB60, 0xD460, 0xE4C0, 0xD460, 0xB360, 0x9AC0, 0xA320, 0xC401, 0xCC01, 0xBB41, 0xB2E0,   // 0x03B0 (944)
0xBB21, 0xC381, 0xC3C2, 0xC3C1, 0xBBC1, 0xB3A1, 0x9B41, 0x92E1, 0x82A1, 0x82A1, 0x72C1, 0x6AC1, 0x6AA0, 0x6A80, 0x7280, 0x7A60,   // 0x03C0 (960)
0xD442, 0xAB40, 0x6A40, 0x51E0, 0x6240, 0x72A0, 0x9B40, 0xC422, 0xD4A3, 0xC422, 0x9B21, 0x8AE2, 0x82E3, 0x7AC4, 0x7AE4, 0x5A64,   // 0x03D0 (976)
0x7C2E, 0x5BF0, 0x018A, 0x012B, 0x00C9, 0x00C8, 0x00E6, 0x1168, 0x0149, 0x01CE, 0x02B5, 0x0319, 0x039B, 0x0C5D, 0x0C7C, 0x043B,   // 0x03E0 (992)
0x047C, 0x049D, 0x049D, 0x049D, 0x0CDD, 0x049B, 0x0C9A, 0x55DA, 0x8D6F, 0xB4C7, 0xDCA2, 0xF4C2, 0xECC2, 0xD482, 0xAC22, 0x9361,   // 0x03F0 (1008)
0x92E2, 0xAB43, 0xC3E3, 0xCBE2, 0xC3A0, 0xCBE0, 0xE480, 0xECC0, 0xD460, 0xB380, 0x92C0, 0x9AE0, 0xB380, 0xC381, 0xB300, 0xB2C1,   // 0x0400 (1024)
0xBAC2, 0xC343, 0xC3A2, 0xBBC1, 0xC401, 0xCC41, 0xBC21, 0xABC1, 0x9B40, 0x8300, 0x7300, 0x6B00, 0x6AE0, 0x6AA0, 0x6AC0, 0x72E1,   // 0x0410 (1040)
0xCC02, 0xA300, 0x7220, 0x61E0, 0x6240, 0x6A40, 0x8280, 0xAB81, 0xC423, 0xAB60, 0x92E1, 0x8AA2, 0x9345, 0x7AE5, 0x6285, 0x8C0D,   // 0x0420 (1056)
0xAD75, 0x530D, 0x0083, 0x0042, 0x1083, 0x1082, 0x18E2, 0x0061, 0x00E6, 0x124F, 0x0AF6, 0x039B, 0x0BFC, 0x03FC, 0x03FB, 0x0C1B,   // 0x0430 (1072)
0x0C3B, 0x0C7C, 0x047B, 0x049C, 0x0C9B, 0x1CFC, 0x153D, 0x1D1B, 0x3D7A, 0x7574, 0xACE9, 0xDCC4, 0xF4C2, 0xEC61, 0xCC62, 0xAB80,   // 0x0440 (1088)
0xA301, 0xB382, 0xD403, 0xE442, 0xE441, 0xEC81, 0xF4C0, 0xECC1, 0xDC81, 0xB3C0, 0x9B00, 0x92C0, 0xA300, 0xB321, 0xB2E1, 0xB2C1,   // 0x0450 (1104)
0xBB23, 0xC3A4, 0xC3C2, 0xBBA0, 0xC3E1, 0xD462, 0xD482, 0xC441, 0xABE0, 0x9BA0, 0x8B80, 0x83A0, 0x8360, 0x7300, 0x72E0, 0x6AC1,   // 0x0460 (1120)
0xCC22, 0xB380, 0x8AA0, 0x7220, 0x6A20, 0x6A00, 0x7A20, 0xA301, 0xAB61, 0xA301, 0x8A81, 0x8AA3, 0x8283, 0x7AC6, 0x840D, 0x8450,   // 0x0470 (1136)
0x52AB, 0x7C30, 0x846F, 0x4AC8, 0x10C0, 0x10E2, 0x0904, 0x0147, 0x11ED, 0x0A71, 0x02F4, 0x03B8, 0x03D9, 0x0378, 0x0BFA, 0x0C1A,   // 0x0480 (1152)
0x147B, 0x0C5A, 0x0C7A, 0x0C5A, 0x0439, 0x047A, 0x0499, 0x0CBA, 0x1CDA, 0x455B, 0x5D97, 0x9591, 0xD527, 0xECA1, 0xDC82, 0xC3E1,   // 0x0490 (1168)
0xBBC1, 0xCC02, 0xDC42, 0xEC82, 0xECA1, 0xEC81, 0xECA1, 0xECC1, 0xE4A1, 0xCC40, 0xB3A0, 0xA300, 0xAAE0, 0xB2E1, 0xB2C2, 0xBB23,   // 0x04A0 (1184)
0xC3C4, 0xCC45, 0xCC83, 0xC401, 0xCBC1, 0xD422, 0xD482, 0xCC82, 0xBC40, 0xAC00, 0x9BE0, 0xA400, 0xA3E0, 0x9BA0, 0x8341, 0x72E0,   // 0x04B0 (1200)
0xDC82, 0xCC21, 0xAB40, 0x8240, 0x6A00, 0x6A00, 0x8240, 0xA302, 0xAB63, 0x92A0, 0x8A42, 0x8243, 0x8A84, 0x8308, 0x73AD, 0x7C72,   // 0x04C0 (1216)
0x9D35, 0x9534, 0x9574, 0x7450, 0x0966, 0x0168, 0x01CD, 0x0251, 0x0274, 0x0AF6, 0x0B98, 0x0399, 0x141C, 0x039A, 0x03FA, 0x0C7C,   // 0x04D0 (1232)
0x047C, 0x049C, 0x04BD, 0x049C, 0x047A, 0x14DB, 0x14DC, 0x0C9A, 0x14B9, 0x253A, 0x3D9C, 0x55BA, 0x7DB6, 0x9D4F, 0xCCC5, 0xE481,   // 0x04E0 (1248)
0xDC82, 0xDC82, 0xECA2, 0xECA2, 0xE4A1, 0xE461, 0xE461, 0xECA1, 0xECC1, 0xE4A0, 0xD440, 0xBB80, 0xBB00, 0xBAE2, 0xB303, 0xBB84,   // 0x04F0 (1264)
0xC405, 0xD4C6, 0xDD25, 0xD482, 0xCC01, 0xD401, 0xD461, 0xD482, 0xC462, 0xB401, 0xABC1, 0xABC1, 0xBC02, 0xBC22, 0x9BC1, 0x8340,   // 0x0500 (1280)
0xE4A1, 0xDC61, 0xBBC1, 0x92C0, 0x71E0, 0x71E0, 0x9260, 0xAB02, 0xAB42, 0x9AE0, 0x9280, 0x9AA0, 0x92C2, 0x8AA3, 0x82A6, 0x72C9,   // 0x0510 (1296)
0x5ACA, 0x21A6, 0x2186, 0x1188, 0x016B, 0x01F1, 0x0A98, 0x0AFB, 0x0B39, 0x0B59, 0x0B98, 0x0398, 0x0376, 0x043A, 0x047B, 0x0CBC,   // 0x0520 (1312)
0x0C59, 0x0BF7, 0x03F7, 0x0438, 0x047A, 0x0CBA, 0x14FA, 0x1498, 0x24D7, 0x34F8, 0x3D3B, 0x4DBD, 0x457B, 0x54D4, 0xA50E, 0xD4E8,   // 0x0530 (1328)
0xDCE3, 0xE4C1, 0xECE3, 0xEC82, 0xE481, 0xDC60, 0xDC60, 0xE4C0, 0xE4C0, 0xE4A1, 0xE461, 0xD401, 0xB340, 0xA321, 0xB364, 0xABA4,   // 0x0540 (1344)
0xA404, 0xC4C5, 0xE505, 0xE4C3, 0xD440, 0xC400, 0xCC41, 0xD483, 0xD483, 0xCC63, 0xAC03, 0x9381, 0x9BA2, 0xB463, 0xBC42, 0xABC0,   // 0x0550 (1360)
0xE4A1, 0xDCA2, 0xBC23, 0x92E1, 0x7200, 0x71E0, 0x9260, 0xAB01, 0xAB21, 0xA2E0, 0xAAE0, 0xB300, 0xB322, 0xAB23, 0x9AE4, 0x7A85,   // 0x0560 (1376)
0x6B29, 0x29E6, 0x0127, 0x09CD, 0x0A31, 0x0213, 0x0276, 0x0B18, 0x0337, 0x0378, 0x0378, 0x0399, 0x0BFA, 0x145B, 0x0C7A, 0x14BB,   // 0x0570 (1392)
0x0C37, 0x0C58, 0x0479, 0x0CFB, 0x253C, 0x24DB, 0x24FA, 0x2D1B, 0x2D1A, 0x2CFA, 0x2CFA, 0x355A, 0x45BA, 0x3557, 0x3D55, 0x6D50,   // 0x0580 (1408)
0xB4E6, 0xDCC2, 0xE4C3, 0xECC3, 0xDC21, 0xE421, 0xEC61, 0xE460, 0xDCA1, 0xDC60, 0xDC00, 0xD3C0, 0xBB61, 0xAB63, 0x9BC4, 0x8B83,   // 0x0590 (1424)
0x8B42, 0xB404, 0xDCE4, 0xE503, 0xCC81, 0xBBE0, 0xBC00, 0xCC83, 0xD4A3, 0xD483, 0xBC42, 0x9B80, 0x9320, 0xA3A2, 0xBC22, 0xC421,   // 0x05A0 (1440)
0xDC81, 0xD4A3, 0xB403, 0x8AC0, 0x61C0, 0x69C0, 0x9260, 0xAAE1, 0xAAE0, 0xB300, 0xC320, 0xC340, 0xCBA1, 0xD3E3, 0xC384, 0x9AC3,   // 0x05B0 (1456)
0x7B28, 0x4AAB, 0x018C, 0x01F2, 0x0A54, 0x0255, 0x02B7, 0x0B38, 0x0BF8, 0x03B7, 0x0BF9, 0x0C1B, 0x0C3B, 0x147C, 0x14DB, 0x14BA,   // 0x05C0 (1472)
0x0C9B, 0x14DC, 0x0CDC, 0x1CDC, 0x34DC, 0x3CBB, 0x34BB, 0x3CDB, 0x5D1B, 0x5CFA, 0x4CD8, 0x3435, 0x3455, 0x34B6, 0x1497, 0x3CB4,   // 0x05D0 (1488)
0x948A, 0xC444, 0xE483, 0xE482, 0xDC62, 0xCBE0, 0xDC01, 0xEC61, 0xEC60, 0xE420, 0xCBC0, 0xBB81, 0xBB80, 0xB3C2, 0x9BE4, 0x8322,   // 0x05E0 (1504)
0x7AC2, 0xA383, 0xCCA3, 0xDD23, 0xC4A1, 0xA3A0, 0xA3A0, 0xBC22, 0xCCA2, 0xD4A2, 0xCC83, 0xB3C1, 0x9AE0, 0xA301, 0xBBA1, 0xCC43,   // 0x05F0 (1520)
0xD461, 0xCC42, 0xA3A1, 0x7240, 0x5980, 0x69C0, 0x9260, 0xAAC0, 0xAAE0, 0xBB20, 0xC340, 0xCB40, 0xCB80, 0xDC22, 0xDC03, 0xB344,   // 0x0600 (1536)
0x8B6A, 0x6370, 0x1231, 0x0255, 0x0275, 0x0296, 0x0339, 0x0BDA, 0x0C9C, 0x045A, 0x0C79, 0x0C79, 0x0438, 0x0479, 0x0CDA, 0x0499,   // 0x0610 (1552)
0x0CDB, 0x0C9A, 0x0C99, 0x1CBA, 0x1C99, 0x1458, 0x0C99, 0x24F9, 0x3CF8, 0x44B6, 0x2C56, 0x2416, 0x2C77, 0x2477, 0x1437, 0x4519,   // 0x0620 (1568)
0x7D75, 0x9CCD, 0xC485, 0xE4C3, 0xD441, 0xC3E0, 0xD3E1, 0xE462, 0xE4A1, 0xDC60, 0xCBC0, 0xBB21, 0xB321, 0xBBA4, 0xB3E3, 0x9B41,   // 0x0630 (1584)
0x8AC1, 0x9B42, 0xBC42, 0xC4E2, 0xA461, 0x8360, 0x8320, 0x9B82, 0xBC02, 0xCC43, 0xCC63, 0xC402, 0xAB21, 0xA2C0, 0xB320, 0xC3C2,   // 0x0640 (1600)
0xDC61, 0xCC21, 0x9B61, 0x7240, 0x59A0, 0x7200, 0x9AA0, 0xB300, 0xBB60, 0xC360, 0xCB60, 0xC340, 0xC360, 0xD401, 0xDC23, 0xB3A5,   // 0x0650 (1616)
0x83ED, 0x5414, 0x1336, 0x0317, 0x0338, 0x0BDA, 0x0C7D, 0x0CBD, 0x04DC, 0x04DC, 0x0C7A, 0x0438, 0x0417, 0x0458, 0x0479, 0x0459,   // 0x0660 (1632)
0x0477, 0x0CB9, 0x0CBB, 0x047B, 0x045A, 0x0459, 0x0478, 0x0477, 0x0496, 0x0CB7, 0x1C57, 0x2416, 0x4D19, 0x44F8, 0x2477, 0x24D9,   // 0x0670 (1648)
0x255B, 0x5DB7, 0xB4C8, 0xDCA2, 0xCC22, 0xB3A1, 0xC402, 0xD462, 0xD4E2, 0xDCA2, 0xD3A2, 0xC2C1, 0xBAA2, 0xC323, 0xC3C2, 0xB3A0,   // 0x0680 (1664)
0x9B20, 0x9341, 0x9BA0, 0xA401, 0x8BA0, 0x6B00, 0x6AC0, 0x82E2, 0x9B43, 0xB384, 0xC404, 0xCC04, 0xBB82, 0xAAE0, 0xAAE0, 0xB342,   // 0x0690 (1680)
0xDC61, 0xCC21, 0x9B61, 0x7240, 0x61C0, 0x7220, 0xAAE0, 0xCBA1, 0xD3C1, 0xD3C0, 0xD3A1, 0xC360, 0xC3A0, 0xD402, 0xD403, 0xA3A6,   // 0x06A0 (1696)
0x6C4F, 0x3C76, 0x1419, 0x03FB, 0x043C, 0x151F, 0x0D5F, 0x051E, 0x04FC, 0x04DC, 0x14BC, 0x0C19, 0x03D7, 0x1439, 0x0C18, 0x03D6,   // 0x06B0 (1712)
0x03B5, 0x03B6, 0x03BA, 0x03DB, 0x0C3B, 0x041A, 0x03D8, 0x0C59, 0x049A, 0x0C37, 0x2C15, 0x2B72, 0x43F3, 0x3BF3, 0x3475, 0x1435,   // 0x06C0 (1728)
0x0499, 0x3559, 0x8DD3, 0xACEA, 0xBC44, 0xC3E2, 0xC423, 0xCC64, 0xDCA3, 0xE483, 0xD3E3, 0xC322, 0xBAA0, 0xBAE0, 0xC3A1, 0xC3E1,   // 0x06D0 (1744)
0xA3A0, 0x9340, 0x8B00, 0x8320, 0x7300, 0x62A0, 0x6A80, 0x7281, 0x8282, 0x92C2, 0xAB63, 0xC3C3, 0xC3A2, 0xB320, 0xAAC0, 0xAB01,   // 0x06E0 (1760)
0xDC41, 0xC3E1, 0x9320, 0x7260, 0x6200, 0x7A40, 0xB320, 0xE402, 0xE400, 0xDBE0, 0xCB80, 0xC360, 0xCBC0, 0xD422, 0xCBE2, 0x9B85,   // 0x06F0 (1776)
0x6450, 0x23F6, 0x0C1A, 0x049D, 0x04FF, 0x055F, 0x051D, 0x0D3E, 0x0D1C, 0x0CDC, 0x1CFE, 0x043B, 0x03D8, 0x0C38, 0x0BF7, 0x0374,   // 0x0700 (1792)
0x0332, 0x0B73, 0x1375, 0x0B34, 0x0B54, 0x1374, 0x0B53, 0x0B54, 0x03B6, 0x13D5, 0x3475, 0x23D3, 0x0B94, 0x1C36, 0x34B7, 0x23F3,   // 0x0710 (1808)
0x022C, 0x130F, 0x3D78, 0x7657, 0x9C47, 0xBBA2, 0xC3E4, 0xD446, 0xD485, 0xDC84, 0xD442, 0xCBC1, 0xBB21, 0xBB00, 0xC381, 0xC401,   // 0x0720 (1824)
0xB401, 0x9B60, 0x8B00, 0x82C0, 0x72A0, 0x6AA0, 0x7AC0, 0x82C1, 0x8261, 0x8A61, 0x9AC0, 0xB342, 0xC381, 0xBB20, 0xAAA0, 0xA281,   // 0x0730 (1840)
0xCC00, 0xB380, 0x8B00, 0x7280, 0x6A20, 0x8260, 0xBB40, 0xEC21, 0xEC61, 0xE400, 0xD380, 0xCB60, 0xD3E1, 0xDC43, 0xCBE2, 0x9B65,   // 0x0740 (1856)
0x63F2, 0x2BD7, 0x13FA, 0x047C, 0x053E, 0x055F, 0x051E, 0x0D1E, 0x0CDD, 0x14FE, 0x1D5F, 0x045B, 0x0479, 0x0C99, 0x0417, 0x0BF6,   // 0x0750 (1872)
0x0352, 0x0373, 0x03D4, 0x0372, 0x02CD, 0x0AAC, 0x1AED, 0x1B0E, 0x0B11, 0x0B52, 0x13B0, 0x1BF2, 0x03B4, 0x13F5, 0x2370, 0x4BD1,   // 0x0760 (1888)
0x534F, 0x4B4F, 0x33AF, 0x6DB6, 0xA615, 0x8C4A, 0xAC25, 0xCC85, 0xD484, 0xD463, 0xCC61, 0xCC41, 0xBBC2, 0xBB41, 0xC381, 0xCC02,   // 0x0770 (1904)
0xC421, 0xABA0, 0x9321, 0x8AC1, 0x7AA0, 0x7AC0, 0x8B41, 0x9B63, 0x9B42, 0x92E1, 0x92C0, 0xAB21, 0xC362, 0xC322, 0xAAA1, 0xA261,   // 0x0780 (1920)
0xA382, 0x9AE0, 0x9280, 0x8A60, 0x7260, 0x8280, 0xAB60, 0xDC21, 0xF442, 0xEBE0, 0xCB80, 0xC3A0, 0xD400, 0xDC62, 0xD423, 0x9BA6,   // 0x0790 (1936)
0x5C52, 0x1BF7, 0x0419, 0x151E, 0x0D1D, 0x0D3D, 0x0D1E, 0x0D3E, 0x04DD, 0x0CFD, 0x155D, 0x0439, 0x03B7, 0x13B8, 0x0B77, 0x1398,   // 0x07A0 (1952)
0x1396, 0x0B12, 0x1331, 0x024C, 0x1A6B, 0x120A, 0x1A6D, 0x1AD0, 0x0AD1, 0x0B53, 0x0353, 0x0393, 0x0331, 0x02CE, 0x230F, 0x4B6F,   // 0x07B0 (1968)
0x6BCE, 0x8C4F, 0x7BED, 0x4B2B, 0x5D77, 0x9EDB, 0x9CCC, 0xBCA7, 0xC4A4, 0xBC62, 0xBC61, 0xCC82, 0xCC41, 0xCBC1, 0xCBA1, 0xD3E2,   // 0x07C0 (1984)
0xD422, 0xC3E1, 0xA360, 0x8B00, 0x82A0, 0x8AA0, 0xA300, 0xBB82, 0xCBC2, 0xC3C2, 0xAB40, 0xA320, 0xB3A1, 0xBBA2, 0xBB22, 0xB2A1,   // 0x07D0 (2000)
0x92E0, 0x9AE0, 0x9AE0, 0x92A0, 0x7240, 0x7240, 0xA320, 0xD401, 0xEC61, 0xE400, 0xC380, 0xBB80, 0xCBE1, 0xDC63, 0xD443, 0x9B84,   // 0x07E0 (2016)
0x63AB, 0x3C32, 0x0C79, 0x0D3F, 0x0D1E, 0x0D1E, 0x049C, 0x049C, 0x0CBD, 0x14FD, 0x151E, 0x047B, 0x03F8, 0x0316, 0x0B58, 0x0293,   // 0x07F0 (2032)
0x022F, 0x01CB, 0x0A2B, 0x01A9, 0x026C, 0x02CE, 0x0310, 0x0B52, 0x0B73, 0x0353, 0x03B4, 0x0BB3, 0x1330, 0x01EB, 0x02AD, 0x2B8F,   // 0x0800 (2048)
0x19C6, 0x0903, 0x0082, 0x0083, 0x0925, 0x53D0, 0x8DFA, 0x84D1, 0xB446, 0xBBC0, 0xAC40, 0xB4E2, 0xB4C3, 0xBC63, 0xC402, 0xCBE1,   // 0x0810 (2064)
0xD441, 0xCC21, 0xB3C1, 0x9B00, 0x8280, 0x8260, 0x92C0, 0xB381, 0xCC22, 0xD462, 0xC3E2, 0xAB60, 0xAB61, 0xBBC3, 0xC3E3, 0xBB61,   // 0x0820 (2080)
0xA300, 0xAB80, 0xB382, 0x92E1, 0x7220, 0x7220, 0xA320, 0xD421, 0xEC81, 0xDC20, 0xBB80, 0xAB20, 0xBB81, 0xCC03, 0xCC03, 0xA362,   // 0x0830 (2096)
0x6B23, 0x540C, 0x2CF9, 0x0D1E, 0x04BD, 0x04BD, 0x0CDE, 0x0C7D, 0x045C, 0x14BD, 0x0CDD, 0x043A, 0x0335, 0x1397, 0x0295, 0x0274,   // 0x0840 (2112)
0x0272, 0x0291, 0x02D2, 0x0312, 0x0B72, 0x1BF3, 0x0B71, 0x1392, 0x0BB2, 0x022C, 0x026E, 0x1352, 0x0BB5, 0x0395, 0x0373, 0x13B3,   // 0x0850 (2128)
0x1B2F, 0x01A8, 0x1987, 0x2987, 0x2147, 0x0907, 0x2330, 0x7DD6, 0x94CB, 0x9C03, 0xB444, 0xC463, 0xCCC1, 0xC4A0, 0xBC20, 0xBBC0,   // 0x0860 (2144)
0xD440, 0xDC62, 0xD421, 0xAB60, 0x8AA0, 0x7A60, 0x8280, 0x9301, 0xB3C0, 0xD462, 0xD462, 0xBBA0, 0x9B00, 0xAB42, 0xBC02, 0xBC02,   // 0x0870 (2160)
0xBBE0, 0xC442, 0xBBE3, 0x92C0, 0x6A00, 0x7A40, 0xAB40, 0xD421, 0xE481, 0xDC20, 0xBB80, 0xAB00, 0xB301, 0xC342, 0xC362, 0xB321,   // 0x0880 (2176)
0x8AC1, 0x6348, 0x3CD7, 0x0C9B, 0x045A, 0x043A, 0x0C7D, 0x0C7D, 0x14DE, 0x043B, 0x0CBC, 0x0419, 0x0292, 0x12F4, 0x0AD4, 0x02D5,   // 0x0890 (2192)
0x0316, 0x0377, 0x0B55, 0x1334, 0x1B32, 0x128E, 0x228C, 0x0187, 0x126A, 0x234F, 0x0AAF, 0x026F, 0x0313, 0x03D6, 0x03B6, 0x13B6,   // 0x08A0 (2208)
0x2C14, 0x2B4F, 0x2A08, 0x5B0C, 0x6BAE, 0x6BCE, 0x5BED, 0x8552, 0x9E16, 0x950F, 0xBCC5, 0xDD02, 0xDD01, 0xD481, 0xBC00, 0xBBC0,   // 0x08B0 (2224)
0xD400, 0xE482, 0xE461, 0xC3A0, 0x9B00, 0x8280, 0x7241, 0x7A60, 0x9B20, 0xC401, 0xDCA2, 0xC422, 0x9B00, 0x8AA0, 0x9B80, 0xB443,   // 0x08C0 (2240)
0xD4A1, 0xD4C3, 0xB403, 0x8AC0, 0x7A40, 0x92E0, 0xBBC1, 0xDC61, 0xE481, 0xDC40, 0xCBA1, 0xBB20, 0xBAC0, 0xBAC1, 0xC2C1, 0xBAC1,   // 0x08D0 (2256)
0xAAC3, 0x7AE8, 0x4434, 0x1458, 0x1459, 0x03F8, 0x0377, 0x03FA, 0x0C7B, 0x14BC, 0x0459, 0x1459, 0x0AF3, 0x022F, 0x12F1, 0x12F1,   // 0x08E0 (2272)
0x128F, 0x0A6E, 0x0A6D, 0x0A0C, 0x11CB, 0x0948, 0x0986, 0x2A29, 0x10E5, 0x2A2A, 0x1B6F, 0x0330, 0x028F, 0x0AF2, 0x0BB4, 0x0BB4,   // 0x08F0 (2288)
0x13D4, 0x0ACE, 0x0165, 0x1123, 0x10C1, 0x2122, 0x39C4, 0x1184, 0x1B8F, 0x7617, 0xBDCD, 0xCD25, 0xBD01, 0xC4E1, 0xC402, 0xCBA2,   // 0x0900 (2304)
0xDC22, 0xE482, 0xE481, 0xCBE0, 0xAB40, 0x92E0, 0x7A82, 0x7A41, 0x8AC0, 0xAB81, 0xCC42, 0xCC22, 0xA321, 0x7200, 0x7A60, 0x9BA3,   // 0x0910 (2320)
0xDD02, 0xD4C3, 0xABE2, 0x8AC0, 0x8AC0, 0xAB81, 0xD442, 0xE4A2, 0xEC81, 0xDC40, 0xD3E0, 0xCB60, 0xC321, 0xC2C1, 0xBA60, 0xBA61,   // 0x0920 (2336)
0xC2C3, 0x9B07, 0x63D0, 0x3415, 0x0BF7, 0x0C18, 0x0335, 0x0376, 0x0395, 0x0C18, 0x0479, 0x0C79, 0x1BD7, 0x024F, 0x020B, 0x1A6B,   // 0x0930 (2352)
0x0965, 0x19C6, 0x32CC, 0x228B, 0x01E7, 0x22CB, 0x19C8, 0x0926, 0x2ACB, 0x0186, 0x0126, 0x2AEE, 0x1371, 0x0352, 0x03B4, 0x03B4,   // 0x0940 (2368)
0x0BD4, 0x0B11, 0x1ACE, 0x32AD, 0x19C8, 0x1125, 0x08A1, 0x00C2, 0x00C5, 0x1AEE, 0x55B8, 0x7E34, 0xBD47, 0xD4A0, 0xD480, 0xCC40,   // 0x0950 (2384)
0xDC41, 0xDC62, 0xDC82, 0xCC20, 0xB3A0, 0xAB61, 0x9B22, 0x92E2, 0x8AC0, 0x9B01, 0xABA2, 0xBBE3, 0xAB43, 0x7A20, 0x69E0, 0x82C3,   // 0x0960 (2400)
0xDCE1, 0xCC81, 0xA381, 0x8AE0, 0x9B41, 0xC402, 0xDC61, 0xECA1, 0xE480, 0xDC40, 0xD400, 0xCBC0, 0xCB80, 0xC300, 0xBA81, 0xBA82,   // 0x0970 (2416)
0xC302, 0xAB45, 0x8369, 0x5BD0, 0x1374, 0x03D7, 0x03B7, 0x0B96, 0x0334, 0x0B96, 0x0418, 0x0C59, 0x1458, 0x1393, 0x0126, 0x11C8,   // 0x0980 (2432)
0x1A29, 0x0145, 0x1A28, 0x4BAE, 0x334D, 0x22CC, 0x2B2C, 0x0A07, 0x09E7, 0x436E, 0x1A09, 0x11E9, 0x1ACC, 0x130E, 0x1392, 0x1372,   // 0x0990 (2448)
0x3B70, 0x4370, 0x3391, 0x232F, 0x338F, 0x3B6E, 0x4B2D, 0x3209, 0x2166, 0x0107, 0x0395, 0x355A, 0x7615, 0x9D8C, 0xC4C4, 0xD460,   // 0x09A0 (2464)
0xD461, 0xCC41, 0xCC61, 0xC441, 0xC401, 0xC422, 0xC443, 0xBBE3, 0x9301, 0x82A0, 0x8280, 0x9AE2, 0x9AE2, 0x8220, 0x69A0, 0x7202,   // 0x09B0 (2480)
0xDCA0, 0xC440, 0xA361, 0x9321, 0xB3C2, 0xD483, 0xE4A1, 0xE480, 0xE460, 0xDC40, 0xD420, 0xCBE0, 0xC3A0, 0xC340, 0xB2A2, 0xBAE3,   // 0x09C0 (2496)
0xCBC3, 0xBBC4, 0x9B04, 0x7B6B, 0x2BD3, 0x0376, 0x03B8, 0x13F9, 0x0B36, 0x0B35, 0x0BF7, 0x03F7, 0x03D5, 0x2436, 0x22EE, 0x00C5,   // 0x09D0 (2512)
0x01A8, 0x1A6B, 0x11A7, 0x1986, 0x530C, 0x63CE, 0x43AE, 0x43CE, 0x1269, 0x1A69, 0x53AE, 0x3AAA, 0x31E7, 0x3A08, 0x3289, 0x42C9,   // 0x09E0 (2528)
0x6B48, 0x7348, 0x7B48, 0x6B4A, 0x434D, 0x2B4E, 0x3390, 0x22AC, 0x1165, 0x0965, 0x024B, 0x1C16, 0x149B, 0x34D9, 0x84EF, 0xB4C8,   // 0x09F0 (2544)
0xCCA3, 0xC420, 0xBC21, 0xBC42, 0xC442, 0xDCA3, 0xE504, 0xD4C3, 0xABE3, 0x82A0, 0x7200, 0x7A21, 0x8A41, 0x8200, 0x69A0, 0x69E2,   // 0x0A00 (2560)
0xD4A1, 0xC420, 0xB380, 0xBBA0, 0xD462, 0xDCA3, 0xD461, 0xD440, 0xD480, 0xD4A1, 0xCC21, 0xBBA0, 0xBB81, 0xB341, 0xB321, 0xC3A3,   // 0x0A10 (2576)
0xE484, 0xDC43, 0xC382, 0x8AE4, 0x5B6C, 0x3392, 0x0354, 0x0BD7, 0x0355, 0x0334, 0x0395, 0x0BD6, 0x03B6, 0x0BF7, 0x1BF6, 0x026F,   // 0x0A20 (2592)
0x00A5, 0x00A3, 0x0965, 0x0123, 0x1103, 0x4AA9, 0x5B4C, 0x530B, 0x3A68, 0x3A47, 0x3A06, 0x39C5, 0x39C4, 0x4205, 0x4245, 0x4246,   // 0x0A30 (2608)
0x52A8, 0x62E9, 0x6AE8, 0x7309, 0x7B28, 0x6AE8, 0x3A68, 0x2A8A, 0x126B, 0x0168, 0x0128, 0x23B4, 0x0C18, 0x0419, 0x14DB, 0x3CF7,   // 0x0A40 (2624)
0x8D0E, 0xAC67, 0xA3C1, 0xB3A0, 0xC421, 0xD4C2, 0xE543, 0xE524, 0xC442, 0x9B40, 0x7220, 0x61E0, 0x7221, 0x71E1, 0x61C0, 0x6A01,   // 0x0A50 (2640)
0xC440, 0xBC00, 0xBBE0, 0xCC41, 0xDCC3, 0xD482, 0xC3E0, 0xBBC0, 0xD480, 0xDCA1, 0xC421, 0xAB60, 0xAB40, 0xAB61, 0xBBC2, 0xD463,   // 0x0A60 (2656)
0xF503, 0xF503, 0xCBE3, 0xA344, 0x72C5, 0x532B, 0x1B51, 0x0334, 0x0B34, 0x02F4, 0x0397, 0x0375, 0x0BD5, 0x13F6, 0x0395, 0x1374,   // 0x0A70 (2672)
0x1AD0, 0x0169, 0x00A2, 0x00A1, 0x08A0, 0x3184, 0x41C6, 0x41C7, 0x3165, 0x3185, 0x52C9, 0x52A8, 0x3A05, 0x39C4, 0x5205, 0x49E5,   // 0x0A80 (2688)
0x4A47, 0x4A67, 0x5289, 0x5ACA, 0x5AC9, 0x62C9, 0x6B09, 0x41E5, 0x18E2, 0x1145, 0x016A, 0x12F3, 0x0BD9, 0x03DA, 0x03DA, 0x14BC,   // 0x0A90 (2704)
0x24BA, 0x5D58, 0x6C6C, 0x6B22, 0x9360, 0xC482, 0xE503, 0xE503, 0xD4C3, 0xABA1, 0x7AC1, 0x6A61, 0x6221, 0x6201, 0x5A02, 0x51E2,   // 0x0AA0 (2720)
0xB400, 0xB3C0, 0xCC20, 0xDCC2, 0xE502, 0xCC61, 0xB3C0, 0xB3A0, 0xCC60, 0xD481, 0xC401, 0xA320, 0x9B40, 0xB3C1, 0xCC62, 0xED23,   // 0x0AB0 (2736)
0xFDA2, 0xFD82, 0xDC62, 0xB321, 0x8240, 0x5245, 0x2B4F, 0x0B12, 0x0A70, 0x0A71, 0x1334, 0x0B54, 0x0393, 0x13F5, 0x0332, 0x0353,   // 0x0AC0 (2752)
0x1BD5, 0x0AF0, 0x01A8, 0x0924, 0x1102, 0x08C1, 0x2165, 0x2986, 0x2144, 0x1924, 0x3ACA, 0x3B0B, 0x32CA, 0x2A48, 0x4227, 0x4206,   // 0x0AD0 (2768)
0x4226, 0x39E5, 0x4205, 0x4226, 0x3A06, 0x31C5, 0x4205, 0x4A87, 0x39E5, 0x29A6, 0x0107, 0x09ED, 0x0270, 0x02B3, 0x0B56, 0x03B7,   // 0x0AE0 (2784)
0x14DB, 0x2D1A, 0x54D5, 0x642D, 0x73A5, 0xA422, 0xD4C2, 0xECC1, 0xE481, 0xCBE0, 0x9B00, 0x7A80, 0x7A60, 0x6A21, 0x61E1, 0x59E2,   // 0x0AF0 (2800)
0xA360, 0xAB80, 0xCC20, 0xE4C2, 0xDCE2, 0xC440, 0xB3C0, 0xBBE0, 0xD460, 0xDC81, 0xC3E0, 0xAB40, 0xABA0, 0xC441, 0xDCC1, 0xF562,   // 0x0B00 (2816)
0xFDE2, 0xF5A2, 0xE4A2, 0xB361, 0x7A61, 0x4A03, 0x434C, 0x336F, 0x1AAE, 0x0A2E, 0x01ED, 0x024E, 0x028F, 0x02D0, 0x026D, 0x0B30,   // 0x0B10 (2832)
0x0BD3, 0x0351, 0x026D, 0x0168, 0x09C9, 0x09A8, 0x0125, 0x0145, 0x1164, 0x19A5, 0x32EA, 0x3B4C, 0x330C, 0x2A8A, 0x3227, 0x3A27,   // 0x0B20 (2848)
0x4228, 0x4A29, 0x4207, 0x4A07, 0x5248, 0x4207, 0x2122, 0x2102, 0x31C5, 0x3A49, 0x0106, 0x0169, 0x09ED, 0x020F, 0x0271, 0x0335,   // 0x0B30 (2864)
0x03B9, 0x0CBD, 0x1D3C, 0x34F8, 0x4412, 0x638C, 0x9BE7, 0xCC85, 0xDCE2, 0xCC60, 0xABA0, 0x8B00, 0x72A0, 0x6260, 0x5A60, 0x6260,   // 0x0B40 (2880)
0x9300, 0xA360, 0xCC21, 0xDCA2, 0xD4A1, 0xCC40, 0xBC00, 0xC421, 0xDC81, 0xE481, 0xD400, 0xC3E0, 0xCC40, 0xDCC1, 0xED00, 0xFD41,   // 0x0B50 (2896)
0xFDC2, 0xF583, 0xD4A3, 0xABC3, 0x72A3, 0x5203, 0x5A85, 0x5B29, 0x2B0C, 0x026C, 0x026D, 0x022D, 0x022D, 0x020C, 0x128D, 0x028D,   // 0x0B60 (2912)
0x0B4F, 0x0B70, 0x024D, 0x026F, 0x0290, 0x0A8F, 0x022B, 0x0A09, 0x0965, 0x0944, 0x19E5, 0x3247, 0x3A88, 0x42A9, 0x4AA9, 0x3A27,   // 0x0B70 (2928)
0x31E6, 0x3A48, 0x3A28, 0x4268, 0x4227, 0x52A8, 0x5AE8, 0x3A05, 0x29C4, 0x2184, 0x0903, 0x1165, 0x0965, 0x11E6, 0x1A06, 0x1A26,   // 0x0B80 (2944)
0x330C, 0x2370, 0x0C78, 0x151C, 0x2D1A, 0x2C14, 0x332E, 0x4ACA, 0x83EA, 0xA468, 0xAC03, 0x9320, 0x7AC0, 0x6A80, 0x5A80, 0x5AA0,   // 0x0B90 (2960)
0x9B20, 0xB3A1, 0xCC21, 0xD461, 0xD460, 0xCC40, 0xC420, 0xCC41, 0xE481, 0xDC60, 0xD420, 0xD440, 0xE4C1, 0xE4E1, 0xECE0, 0xFD20,   // 0x0BA0 (2976)
0xFD62, 0xED22, 0xD482, 0xABA2, 0x82E2, 0x6A21, 0x6200, 0x6283, 0x4B08, 0x3B4B, 0x12ED, 0x020C, 0x026E, 0x0A8E, 0x0A4C, 0x0A2A,   // 0x0BB0 (2992)
0x12AC, 0x0A6C, 0x020C, 0x0A8F, 0x0290, 0x0AD1, 0x0AB0, 0x0A6E, 0x09EB, 0x0188, 0x0125, 0x0924, 0x19A6, 0x21E7, 0x326A, 0x2A28,   // 0x0BC0 (3008)
0x3227, 0x3A47, 0x3A07, 0x3A07, 0x5227, 0x49E6, 0x5227, 0x5A68, 0x5227, 0x5205, 0x6A44, 0x9B66, 0xAB63, 0xB381, 0xBBC0, 0xC401,   // 0x0BD0 (3024)
0xBBA2, 0x8B22, 0x4B23, 0x2B46, 0x33AB, 0x5471, 0x5454, 0x4392, 0x330D, 0x4B2B, 0x8389, 0x9387, 0x7AC3, 0x7240, 0x7280, 0x6AA0,   // 0x0BE0 (3040)
0xB380, 0xBBE1, 0xCC21, 0xCC00, 0xCC20, 0xD440, 0xCC20, 0xD440, 0xDC80, 0xD460, 0xD440, 0xD480, 0xDCC0, 0xDCA0, 0xDCA0, 0xE4E1,   // 0x0BF0 (3056)
0xED02, 0xE4C2, 0xD441, 0xAB41, 0x8AE3, 0x7262, 0x7242, 0x7283, 0x72C3, 0x7346, 0x5349, 0x2ACA, 0x024A, 0x020B, 0x01C8, 0x0A09,   // 0x0C00 (3072)
0x0A2A, 0x126B, 0x0A6B, 0x0A6C, 0x0A6C, 0x020C, 0x0A6D, 0x01EB, 0x01EA, 0x09C9, 0x0187, 0x00E4, 0x00C3, 0x00E2, 0x1984, 0x2A06,   // 0x0C10 (3088)
0x2A67, 0x11E6, 0x2A48, 0x3248, 0x3228, 0x3207, 0x3A27, 0x4247, 0x4226, 0x49E4, 0x59A1, 0x92A3, 0xBB82, 0xBB40, 0xCBC0, 0xCC02,   // 0x0C20 (3104)
0xB3A2, 0x9301, 0x7260, 0x6200, 0x6A00, 0x7260, 0x8305, 0x942C, 0x742F, 0x4B2C, 0x3AA8, 0x5349, 0x73EA, 0x6B05, 0x5A60, 0x6A80,   // 0x0C30 (3120)
0xC3E0, 0xD442, 0xD441, 0xCC20, 0xD460, 0xDC80, 0xDC60, 0xDC61, 0xD480, 0xD460, 0xCC60, 0xD480, 0xD4A0, 0xCC40, 0xC420, 0xD480,   // 0x0C40 (3136)
0xE4C0, 0xDC81, 0xB3A1, 0x9323, 0x72A3, 0x7284, 0x7A84, 0x92E4, 0xAB64, 0xABA5, 0x8B43, 0x5AE4, 0x2AC8, 0x0A69, 0x0209, 0x01E9,   // 0x0C50 (3152)
0x022B, 0x028C, 0x0AAC, 0x0A6A, 0x1A4A, 0x1A29, 0x0186, 0x09C6, 0x0183, 0x0963, 0x1123, 0x18E2, 0x20E0, 0x6283, 0x8B22, 0x9300,   // 0x0C60 (3168)
0x8AE2, 0x82C3, 0x5A23, 0x4A46, 0x3269, 0x2A49, 0x3206, 0x31C4, 0x3A26, 0x4206, 0x41C5, 0x4983, 0x8A63, 0xAAA2, 0xBB43, 0xC3A4,   // 0x0C70 (3184)
0xA381, 0x82C0, 0x8240, 0x8202, 0x79A0, 0x81E0, 0x9AA0, 0xAB81, 0xAC25, 0xA468, 0x7388, 0x52E7, 0x6326, 0x62C4, 0x6220, 0x6A40,   // 0x0C80 (3200)
0xD460, 0xDCA0, 0xDCC0, 0xDCC0, 0xE4A0, 0xF4C1, 0xECE1, 0xE4A0, 0xDC80, 0xD440, 0xDC60, 0xDC81, 0xD4A0, 0xC420, 0xC3E0, 0xCC60,   // 0x0C90 (3216)
0xD4C2, 0xC442, 0xA341, 0x8280, 0x7A62, 0x82C3, 0xA363, 0xB3C3, 0xC403, 0xC444, 0xB3C3, 0x7AC2, 0x10A0, 0x00E2, 0x09A6, 0x1A8A,   // 0x0CA0 (3232)
0x1A69, 0x1248, 0x0A27, 0x01C6, 0x01C7, 0x01C7, 0x01A7, 0x19E7, 0x21C5, 0x1943, 0x08C2, 0x10C2, 0x2941, 0x7B67, 0x93A2, 0x9B20,   // 0x0CB0 (3248)
0x92A0, 0x9A80, 0x9A82, 0x8A83, 0x6A63, 0x5223, 0x39E3, 0x29A2, 0x19A3, 0x2183, 0x31A6, 0x3965, 0x4103, 0x69E3, 0xA303, 0xBB63,   // 0x0CC0 (3264)
0xAB03, 0x9A62, 0x9242, 0x9222, 0x8200, 0x8A20, 0x9AE0, 0xAB60, 0xBBE1, 0xBBE1, 0xABC1, 0x8B41, 0x6AE1, 0x6AC3, 0x6AA3, 0x6243,   // 0x0CD0 (3280)
0xDCA0, 0xE4E0, 0xE500, 0xE500, 0xF500, 0xFD01, 0xF501, 0xECE0, 0xE480, 0xDC60, 0xDC80, 0xE4A0, 0xDCE1, 0xD4A0, 0xD460, 0xDCA0,   // 0x0CE0 (3296)
0xDCC0, 0xBC00, 0x9B01, 0x7A41, 0x7A62, 0x9B43, 0xC423, 0xDCA2, 0xD481, 0xD4A4, 0xC488, 0x51A0, 0x0840, 0x0081, 0x0081, 0x0903,   // 0x0CF0 (3312)
0x29E6, 0x21E6, 0x2227, 0x09A5, 0x0144, 0x01E6, 0x01A5, 0x01C5, 0x1206, 0x09A5, 0x00E3, 0x1944, 0x2921, 0x59E1, 0x9300, 0xA300,   // 0x0D00 (3328)
0xAB00, 0xA281, 0x9A21, 0x9A43, 0x9284, 0x8AC5, 0x7AC4, 0x6A83, 0x6283, 0x5A63, 0x5A64, 0x5225, 0x41A3, 0x4161, 0x6A41, 0xA365,   // 0x0D10 (3344)
0xA303, 0x9A83, 0x9A62, 0x9242, 0x9261, 0x9AC1, 0xB381, 0xC401, 0xC3E0, 0xAB80, 0x9320, 0x7AA0, 0x6260, 0x6282, 0x6AA3, 0x6A83,   // 0x0D20 (3360)
0xDCE0, 0xE500, 0xE520, 0xED00, 0xF520, 0xFD00, 0xF500, 0xF4E0, 0xE4A0, 0xE480, 0xDC80, 0xE4C0, 0xE501, 0xE521, 0xDCE0, 0xE500,   // 0x0D30 (3376)
0xDCC1, 0xBBC0, 0x8AC2, 0x6A21, 0x7AA1, 0xABA3, 0xDCA2, 0xF522, 0xED23, 0xC484, 0x6202, 0x41C5, 0x2965, 0x3A08, 0x4208, 0x1081,   // 0x0D40 (3392)
0x0060, 0x1901, 0x3960, 0x8387, 0x6AC3, 0x6B24, 0x52A3, 0x3A22, 0x42A6, 0x1100, 0x3941, 0x7223, 0x7200, 0x8A80, 0x9B20, 0xC402,   // 0x0D50 (3408)
0xC3A2, 0xAAE1, 0x9A41, 0x9282, 0x8AE3, 0x8B24, 0x8B03, 0x8AC1, 0x9280, 0x8A40, 0x8A01, 0x8A23, 0x8244, 0x6A03, 0x7262, 0x9344,   // 0x0D60 (3424)
0xAB84, 0xAB03, 0x9A82, 0x9241, 0x9260, 0xAB21, 0xC3E1, 0xD462, 0xCC41, 0xAB80, 0x8AC0, 0x6A40, 0x5A00, 0x5A00, 0x6220, 0x6A40,   // 0x0D70 (3440)
0xDCE0, 0xE520, 0xE500, 0xECE0, 0xF520, 0xFD00, 0xF4E0, 0xF4E0, 0xECC0, 0xE480, 0xD460, 0xD480, 0xE4E0, 0xED21, 0xED20, 0xE501,   // 0x0D80 (3456)
0xDC82, 0xB381, 0x8282, 0x7221, 0x82C1, 0xB403, 0xE4E3, 0xF544, 0xED87, 0x6220, 0x6B2A, 0x8451, 0x3A69, 0x5B2D, 0x7C10, 0x5ACB,   // 0x0D90 (3472)
0x18A3, 0x1020, 0x38E0, 0x9B86, 0xA363, 0xB381, 0xD440, 0xE4E3, 0xBC44, 0x48E0, 0x9AA1, 0x9220, 0x89C0, 0xA2A1, 0xC3C1, 0xD463,   // 0x0DA0 (3488)
0xC3E2, 0xAB20, 0x9AA1, 0x9AE2, 0x9B43, 0x9B43, 0x9B02, 0x9AC1, 0xA2C1, 0xA260, 0xA200, 0x99E0, 0x9A01, 0xA282, 0xB303, 0xC3A3,   // 0x0DB0 (3504)
0xC423, 0xBBC2, 0xA2C1, 0x8A00, 0x9220, 0xA2A1, 0xB361, 0xC3E2, 0xC422, 0xB3A1, 0x8B01, 0x7260, 0x6220, 0x6A40, 0x72A0, 0x7AA0,   // 0x0DC0 (3520)
0xDCE0, 0xE500, 0xED00, 0xECE0, 0xF520, 0xFD20, 0xF4E0, 0xECE0, 0xE4C0, 0xDC80, 0xCC20, 0xCC20, 0xDC80, 0xECE0, 0xED00, 0xECE1,   // 0x0DD0 (3536)
0xDC21, 0xBB41, 0x9261, 0x8A21, 0x9AC1, 0xC3E3, 0xED03, 0xF545, 0xD4E7, 0x6A82, 0xA553, 0x7C31, 0x636D, 0x740F, 0x73EF, 0x6B6D,   // 0x0DE0 (3552)
0x2143, 0x1080, 0x5243, 0x6A62, 0x6A21, 0x92E2, 0xC380, 0xE4A5, 0x8240, 0x79E0, 0xAB23, 0x9220, 0x9240, 0xAB01, 0xD420, 0xDC40,   // 0x0DF0 (3568)
0xC380, 0xAAA0, 0xAA60, 0xBB03, 0xC3A4, 0xBBA4, 0xB342, 0xAAE1, 0xAAA0, 0xAA60, 0xAA60, 0xAA81, 0xAAC1, 0xAB00, 0xBB60, 0xCC21,   // 0x0E00 (3584)
0xDCC1, 0xC440, 0xA320, 0x9220, 0x91E1, 0x9A22, 0xA282, 0xB302, 0xAB61, 0x9B41, 0x82E0, 0x6A60, 0x6220, 0x6A60, 0x7AE0, 0x8B20,   // 0x0E10 (3600)
0xDCC0, 0xE500, 0xED00, 0xED00, 0xF520, 0xF540, 0xECE0, 0xE4C0, 0xDCA0, 0xD460, 0xBC00, 0xBC00, 0xD460, 0xE4A1, 0xECE0, 0xECC1,   // 0x0E20 (3616)
0xE420, 0xCB20, 0xB221, 0xA1E1, 0xAA61, 0xD3A2, 0xF4E2, 0xF543, 0xE506, 0x8B24, 0xAD32, 0x8431, 0x7BEF, 0x94B1, 0x8CB0, 0x6BCD,   // 0x0E30 (3632)
0x31C7, 0x1903, 0x4A24, 0x49C2, 0x49A0, 0x6A41, 0x9B42, 0xB3C4, 0x5920, 0xAB65, 0x9AC1, 0x9A60, 0x9A80, 0xB342, 0xC3E1, 0xCBC1,   // 0x0E40 (3648)
0xB2C0, 0xA240, 0xAA20, 0xC323, 0xD425, 0xDC64, 0xCBA2, 0xBAE0, 0xB280, 0xB240, 0xB220, 0xB2A1, 0xBB82, 0xB3A1, 0xB3C0, 0xCCA1,   // 0x0E50 (3664)
0xDD01, 0xCC80, 0xAB40, 0x9220, 0x91C2, 0x99C3, 0x9A02, 0xA262, 0x92C1, 0x8AE0, 0x72E0, 0x6A80, 0x6260, 0x6A60, 0x7AE0, 0x8B81,   // 0x0E60 (3680)
0xDCC0, 0xE4E1, 0xED00, 0xF500, 0xF520, 0xF541, 0xED01, 0xE4C0, 0xD4A0, 0xC460, 0xB400, 0xBC00, 0xCC40, 0xE480, 0xECA0, 0xEC81,   // 0x0E70 (3696)
0xE401, 0xD2E0, 0xB9E1, 0xA981, 0xAA00, 0xCB41, 0xECA1, 0xF501, 0xECE3, 0xC486, 0xB531, 0x8C51, 0x8C70, 0x9CD1, 0x9CD1, 0x73CE,   // 0x0E80 (3712)
0x4207, 0x31A5, 0x4A46, 0x3182, 0x39C2, 0x5A03, 0x82E5, 0x6120, 0x8220, 0xA302, 0x9280, 0x92A0, 0x92C0, 0xA321, 0xC3C1, 0xB340,   // 0x0E90 (3728)
0x9AE0, 0x9A80, 0xA261, 0xBB02, 0xDC24, 0xECA5, 0xE423, 0xCB21, 0xAA40, 0xAA60, 0xB280, 0xB302, 0xBB82, 0xB3A1, 0xB3C0, 0xCC61,   // 0x0EA0 (3744)
0xDCC1, 0xCC40, 0xAB40, 0x9240, 0x99E2, 0xA1E3, 0xA203, 0x9222, 0x8240, 0x7280, 0x6A80, 0x6280, 0x6260, 0x6240, 0x72A0, 0x8361,   // 0x0EB0 (3760)
0xD4A0, 0xDCC0, 0xECE0, 0xECE0, 0xE4E0, 0xE500, 0xE500, 0xDCC0, 0xCC80, 0xC460, 0xAC00, 0xB400, 0xCC40, 0xDC40, 0xE460, 0xE441,   // 0x0EC0 (3776)
0xDBA2, 0xC2A2, 0xB1C2, 0xA161, 0xA1E0, 0xC341, 0xE482, 0xF4E2, 0xE4A1, 0xC444, 0xBD91, 0xAD95, 0x94D1, 0xB5D6, 0xA535, 0x8432,   // 0x0ED0 (3792)
0x738F, 0x3186, 0x5268, 0x49E4, 0x3981, 0x49E3, 0x3984, 0x3101, 0x82E3, 0x8280, 0x8AA0, 0x92C0, 0x9AE0, 0xA321, 0xAB41, 0xB322,   // 0x0EE0 (3808)
0xAB01, 0xB2E1, 0xAAC1, 0xB2E1, 0xBBC2, 0xDCA5, 0xDC64, 0xCB83, 0xAA60, 0xAA20, 0xB261, 0xBB02, 0xB362, 0xABA1, 0xABE1, 0xB401,   // 0x0EF0 (3824)
0xCC41, 0xC3E1, 0xAB21, 0x9A60, 0xA222, 0xAA23, 0xA202, 0x9201, 0x8261, 0x72A1, 0x62A0, 0x5AA0, 0x5A60, 0x5A60, 0x6AC0, 0x8342,   // 0x0F00 (3840)
0xC420, 0xCC60, 0xDCA0, 0xE4C0, 0xDCA0, 0xDCA0, 0xD4C0, 0xCCA0, 0xC480, 0xB460, 0xB420, 0xB400, 0xCC20, 0xDC40, 0xE440, 0xE401,   // 0x0F10 (3856)
0xC361, 0xAAA1, 0x9200, 0x8A00, 0x8A60, 0xAB41, 0xCC61, 0xDCE2, 0xD481, 0xABA2, 0xBD0F, 0xC5F7, 0x9CB3, 0x94B2, 0xA533, 0x9471,   // 0x0F20 (3872)
0x8C2F, 0x31A6, 0x29A5, 0x3A07, 0x2943, 0x3984, 0x2902, 0x3100, 0x8AC5, 0x9282, 0x9AC2, 0xAB22, 0xBB21, 0xBB20, 0xC380, 0xCBE1,   // 0x0F30 (3888)
0xCBE1, 0xCBC0, 0xBB81, 0xAB00, 0xAB00, 0xCBC3, 0xDC23, 0xCBC1, 0xB2C0, 0xB280, 0xB2C1, 0xB2C2, 0xA2E3, 0xA323, 0xA383, 0xA3A2,   // 0x0F40 (3904)
0xABA2, 0xABA2, 0x9B02, 0x9AE2, 0xAB22, 0xA2E2, 0x9A82, 0x9241, 0x8A81, 0x82E1, 0x7300, 0x62E0, 0x5AA0, 0x5A80, 0x7300, 0x8BC0,   // 0x0F50 (3920)
0xA380, 0xB3E0, 0xCC61, 0xD461, 0xC420, 0xC420, 0xCC60, 0xCC80, 0xC480, 0xBC40, 0xB420, 0xB400, 0xCC00, 0xDC41, 0xDC00, 0xD3A1,   // 0x0F60 (3936)
0xBB01, 0xAA60, 0x9A21, 0x9221, 0x8A60, 0x9B21, 0xBC21, 0xC481, 0xC421, 0x9B21, 0x940A, 0xB574, 0xAD54, 0x9492, 0xA513, 0x840F,   // 0x0F70 (3952)
0x738D, 0x2124, 0x31C6, 0x4228, 0x20E3, 0x3144, 0x18A1, 0x3921, 0x9325, 0xA322, 0xAB62, 0xBBA2, 0xCBC1, 0xCBC1, 0xD421, 0xD461,   // 0x0F80 (3968)
0xDCA1, 0xD481, 0xC401, 0xAB40, 0x9AC0, 0xAB21, 0xC3C1, 0xCBE1, 0xCB81, 0xC361, 0xBB22, 0xAAA1, 0x9261, 0x92A2, 0x9303, 0x9B42,   // 0x0F90 (3984)
0x9B21, 0xA341, 0x9B21, 0xAB63, 0xBBE4, 0xBBA3, 0xA302, 0x9281, 0x92E1, 0x9B82, 0x93C1, 0x8360, 0x7300, 0x72E0, 0x8360, 0x9C01,   // 0x0FA0 (4000)
0x8320, 0x9360, 0xABE1, 0xB3E1, 0xAB80, 0xB3A0, 0xBC20, 0xC440, 0xBC60, 0xB440, 0xAC00, 0xB3E0, 0xC400, 0xD421, 0xD3C1, 0xC320,   // 0x0FB0 (4016)
0xAA80, 0xA241, 0x9221, 0x8A20, 0x8A80, 0x9320, 0x9BC0, 0xAC01, 0x9B81, 0x7A80, 0x6AC6, 0xAD52, 0xC5F6, 0xA513, 0xA533, 0xAD74,   // 0x0FC0 (4032)
0xBE18, 0x634D, 0x5AEB, 0x2986, 0x10A2, 0x18C2, 0x39C6, 0x6AE8, 0xA384, 0xB3A2, 0xBBE2, 0xC401, 0xD441, 0xD461, 0xDC80, 0xE4C1,   // 0x0FD0 (4048)
0xE500, 0xDCE1, 0xC441, 0xAB40, 0x9280, 0x9AC0, 0xBB81, 0xD443, 0xDC64, 0xDC64, 0xD423, 0xB341, 0x9280, 0x8A41, 0x8262, 0x8AA2,   // 0x0FE0 (4064)
0x92E1, 0x9B01, 0xAB42, 0xBBE4, 0xD485, 0xCC64, 0xB3A2, 0x9B00, 0x9B40, 0xABE2, 0xB462, 0xAC01, 0x9360, 0x9360, 0x93E0, 0xA461,   // 0x0FF0 (4080)
0x7300, 0x7B20, 0x8B40, 0x9340, 0x9320, 0x9B60, 0xB400, 0xBC60, 0xBC60, 0xAC40, 0xA3E0, 0xA3C0, 0xBBC0, 0xCBE1, 0xC381, 0xB2C0,   // 0x1000 (4096)
0x9A40, 0x9241, 0x8A21, 0x8220, 0x8260, 0x82E0, 0x8361, 0x83A1, 0x8301, 0x6A81, 0x5223, 0x9CAF, 0xC5F6, 0xB5B6, 0xA534, 0xAD95,   // 0x1010 (4112)
0xA554, 0x5B0C, 0x2104, 0x2945, 0x31A6, 0x2965, 0x738D, 0x7348, 0xA3C4, 0xC402, 0xC422, 0xCC41, 0xD480, 0xD480, 0xD460, 0xE4C0,   // 0x1020 (4128)
0xE500, 0xDCE0, 0xCC40, 0xAB20, 0x9A80, 0xA2A0, 0xBB81, 0xD443, 0xE4A3, 0xECE4, 0xE503, 0xCC62, 0xAB41, 0x8A60, 0x7A20, 0x8261,   // 0x1030 (4144)
0x8AC0, 0x9B00, 0xB362, 0xCC23, 0xDCC4, 0xD4C3, 0xBC42, 0xA3A0, 0xA3A0, 0xB400, 0xC461, 0xCC61, 0xBC00, 0xABC0, 0xA420, 0xAC80,   // 0x1040 (4160)
0x6300, 0x6B00, 0x7B00, 0x82E0, 0x82E0, 0x9360, 0xAC21, 0xB461, 0xAC40, 0xA420, 0x93C0, 0x9360, 0xA360, 0xB381, 0xAB21, 0x9A80,   // 0x1050 (4176)
0x8A40, 0x8241, 0x8241, 0x7A20, 0x7A60, 0x7AC0, 0x7321, 0x7341, 0x6AE2, 0x6283, 0x4A02, 0x8C0D, 0xCE17, 0xAD55, 0xAD75, 0xAD75,   // 0x1060 (4192)
0x3A07, 0x18E3, 0x4228, 0x630B, 0x39E7, 0x4228, 0x8C4F, 0x6AA5, 0xABE4, 0xC423, 0xCC43, 0xD463, 0xD4A2, 0xD480, 0xD440, 0xDC81,   // 0x1070 (4208)
0xECE0, 0xE4C1, 0xCBE0, 0xAAC0, 0x9A40, 0xA281, 0xBB41, 0xCC02, 0xD462, 0xE4C2, 0xE522, 0xE4E1, 0xC441, 0xA360, 0x92C0, 0x8AA0,   // 0x1080 (4224)
0x8AC0, 0x9B01, 0xB382, 0xCC23, 0xD4A3, 0xD4C2, 0xBCA1, 0xAC20, 0xA3E0, 0xABE0, 0xC440, 0xD481, 0xCC80, 0xC440, 0xB460, 0xB460,   // 0x1090 (4240)
0x6B00, 0x6B00, 0x8320, 0x8320, 0x8300, 0x9360, 0xA401, 0xAC21, 0x9C00, 0x93C0, 0x8360, 0x7B00, 0x8B00, 0x9B20, 0x9B00, 0x8A80,   // 0x10A0 (4256)
0x8280, 0x8281, 0x8260, 0x8240, 0x8A40, 0x8AC0, 0x7B20, 0x6B00, 0x62A2, 0x5A62, 0x5A64, 0x8BEC, 0xC5F6, 0xBDB7, 0x9CB2, 0x5ACB,   // 0x10B0 (4272)
0x52CA, 0x6B6D, 0x7BCD, 0x630B, 0x2124, 0x6B6C, 0x736A, 0x6A84, 0xABC5, 0xBBE3, 0xCC44, 0xDCA4, 0xDCC3, 0xD481, 0xD421, 0xD421,   // 0x10C0 (4288)
0xDC82, 0xDC62, 0xBB80, 0xA280, 0x9200, 0xA281, 0xB322, 0xC3A2, 0xC401, 0xD481, 0xDD01, 0xE521, 0xD4C2, 0xC441, 0xB3A0, 0xA320,   // 0x10D0 (4304)
0x92E0, 0x9B20, 0xB3A2, 0xC402, 0xCC62, 0xCCA2, 0xBCA1, 0xAC60, 0xA420, 0xA400, 0xB420, 0xC460, 0xCC81, 0xCCA1, 0xC481, 0xB420,   // 0x10E0 (4320)
0x72E0, 0x7AE0, 0x8B20, 0x9320, 0x9320, 0x9B40, 0xA3A1, 0x9BA1, 0x8B60, 0x8360, 0x7320, 0x72C0, 0x7AA0, 0x9300, 0x9B00, 0x8AC0,   // 0x10F0 (4336)
0x82C0, 0x82A0, 0x8A60, 0x9240, 0xA240, 0xA2C0, 0x8B20, 0x72E0, 0x6260, 0x6AC4, 0x5A83, 0x942C, 0xCE37, 0xC5F7, 0x7BCE, 0x73AD,   // 0x1100 (4352)
0xB575, 0x9471, 0x842F, 0x5AEA, 0x4A48, 0x736C, 0x5243, 0x7B04, 0x9B64, 0xA363, 0xC3E4, 0xE4A5, 0xE4C3, 0xD481, 0xCC21, 0xC3E1,   // 0x1110 (4368)
0xC402, 0xBBC2, 0xA320, 0x8A60, 0x8220, 0x8A41, 0x9AC1, 0xA321, 0xAB41, 0xBC01, 0xD4A2, 0xDD02, 0xD4C2, 0xCC61, 0xC420, 0xB3C0,   // 0x1120 (4384)
0xA360, 0x9B41, 0xAB82, 0xB3A1, 0xBBE0, 0xC461, 0xBCA0, 0xAC60, 0xA440, 0x9C00, 0x9BC0, 0xA3E0, 0xB420, 0xC481, 0xC461, 0xB3E0,   // 0x1130 (4400)
0x7A81, 0x82A0, 0x92E0, 0x9B00, 0x9300, 0x9B21, 0x9B61, 0x9341, 0x8300, 0x7B01, 0x72E1, 0x6AA0, 0x7AA0, 0x92E0, 0x9B20, 0x9B20,   // 0x1140 (4416)
0x8AE0, 0x8AA0, 0x9A60, 0xA240, 0xB220, 0xBAA0, 0x9B20, 0x7AC0, 0x6A80, 0x6AA2, 0x6283, 0xA4CE, 0xC5F6, 0xC638, 0xA533, 0xAD74,   // 0x1150 (4432)
0xBDB6, 0xA4F3, 0x8C70, 0x5289, 0x39C6, 0x5246, 0x6283, 0x8303, 0x82C2, 0x92C2, 0xBBA3, 0xDC84, 0xE4C2, 0xDCA1, 0xCC41, 0xB3C0,   // 0x1160 (4448)
0x9B60, 0x9300, 0x82A0, 0x7A40, 0x7A40, 0x8241, 0x8A81, 0x92A1, 0x92C0, 0xA341, 0xBC22, 0xCC82, 0xC420, 0xBBE0, 0xC420, 0xC441,   // 0x1170 (4464)
0xABC1, 0xA361, 0xA341, 0xA320, 0xAB60, 0xBC21, 0xBC80, 0xAC60, 0x9C40, 0x93E0, 0x8B80, 0x8B60, 0xA3C0, 0xB420, 0xBC00, 0xABC0,   // 0x1180 (4480)
0x8A40, 0x8220, 0x8A60, 0x92C1, 0x92E1, 0x92E2, 0x8303, 0x8303, 0x7AC3, 0x72C2, 0x6AA1, 0x6A80, 0x7AA0, 0x9300, 0xA341, 0xA321,   // 0x1190 (4496)
0x92E1, 0x9AA1, 0xA220, 0xB1E0, 0xB220, 0xBA81, 0xAAC1, 0x8AA0, 0x7260, 0x6A82, 0x62A5, 0xAD51, 0xBDD5, 0xBDF6, 0xB5D6, 0xA514,   // 0x11A0 (4512)
0xBDF7, 0xCE59, 0x8C50, 0x5A88, 0x6A47, 0x7A45, 0x8243, 0x8A62, 0x8241, 0x8A61, 0xAB04, 0xCBE5, 0xD463, 0xCC62, 0xC402, 0xAB81,   // 0x11B0 (4528)
0x8B21, 0x72E1, 0x62C0, 0x62A0, 0x6AA1, 0x72C2, 0x7AA1, 0x82A0, 0x8280, 0x92A0, 0xAB22, 0xB363, 0xA321, 0x9B00, 0xAB80, 0xC422,   // 0x11C0 (4544)
0xBBC1, 0xAB61, 0x9300, 0x8AE0, 0x9B40, 0xB420, 0xBC81, 0xAC40, 0xA420, 0x9BE0, 0x9360, 0x9320, 0xA3A0, 0xB420, 0xB421, 0xA3A0,   // 0x11D0 (4560)
0x8221, 0x8200, 0x8240, 0x8A81, 0x92A1, 0x8AA1, 0x82A2, 0x7AC3, 0x72A3, 0x72A3, 0x6AA2, 0x7281, 0x7AA0, 0x92E1, 0xA301, 0xA2E1,   // 0x11E0 (4576)
0x9AC1, 0xA281, 0xAA01, 0xB1C0, 0xB1C0, 0xB221, 0xA261, 0x9260, 0x7241, 0x6A42, 0x62A6, 0x9C8F, 0xAD53, 0xBDD6, 0xB575, 0xA513,   // 0x11F0 (4592)
0xC638, 0xBDD6, 0xA513, 0x62A9, 0x7287, 0x7A25, 0x8243, 0x8222, 0x8201, 0x8221, 0x9A83, 0xB343, 0xB3A2, 0xBBC2, 0xB3C3, 0xA383,   // 0x1200 (4608)
0x8362, 0x6B21, 0x62E0, 0x5AC0, 0x6AC1, 0x72C2, 0x7AC1, 0x82C1, 0x8280, 0x8A60, 0x9280, 0x9280, 0x8260, 0x7A40, 0x92E0, 0xAB81,   // 0x1210 (4624)
0xB3A2, 0xAB41, 0x92C0, 0x8AA0, 0x9B40, 0xBC21, 0xBC61, 0xB400, 0xA3E0, 0xA3C0, 0x9B80, 0xABA0, 0xB420, 0xC441, 0xB421, 0xA3A0,   // 0x1220 (4640)
0x8A01, 0x8200, 0x8220, 0x8A61, 0x8A61, 0x8A62, 0x7A82, 0x7283, 0x7A83, 0x7283, 0x72A3, 0x7AA2, 0x8281, 0x92A1, 0x9AC1, 0x9AC1,   // 0x1230 (4656)
0x9AA2, 0xA282, 0xB202, 0xB181, 0xB160, 0xA9A1, 0xA201, 0x9222, 0x7A23, 0x6A23, 0x7B08, 0x8BCD, 0x83CE, 0xBDB6, 0xBDB6, 0xA4F3,   // 0x1240 (4672)
0xBDF6, 0xB5B6, 0xC637, 0x940E, 0x7AA7, 0x7A23, 0x8222, 0x8A22, 0x81E2, 0x81C2, 0x9222, 0x9A83, 0x9AC2, 0x9AE2, 0x9B23, 0x9364,   // 0x1250 (4688)
0x8363, 0x6B22, 0x5B00, 0x5AE0, 0x6AE1, 0x72E1, 0x82E1, 0x8AE2, 0x92E1, 0x92A1, 0x8A60, 0x8220, 0x7200, 0x69E0, 0x7A40, 0x92E1,   // 0x1260 (4704)
0xAB62, 0xA321, 0x8A80, 0x8260, 0xA320, 0xBC01, 0xC441, 0xB3E0, 0xB3E0, 0xB3E1, 0xABC1, 0xBBE1, 0xCC62, 0xC441, 0xB400, 0xB3E0,   // 0x1270 (4720)
0x8A01, 0x81E1, 0x8221, 0x8A61, 0x8A62, 0x8262, 0x7A63, 0x7263, 0x7264, 0x7A63, 0x7A83, 0x8283, 0x8A82, 0x92A2, 0x9AA2, 0xA2A2,   // 0x1280 (4736)
0x9AA2, 0xAA62, 0xB202, 0xB161, 0xA920, 0xA941, 0xA1C2, 0x9203, 0x7A23, 0x61E3, 0x6A87, 0xB4F2, 0x9470, 0x9CD2, 0xBDB6, 0x9CB2,   // 0x1290 (4752)
0xBDD6, 0xBDD6, 0xC618, 0xACB1, 0x7A85, 0x8222, 0x8A22, 0x8A02, 0x81C2, 0x89C2, 0x9222, 0x9242, 0x8A62, 0x8A83, 0x8AC3, 0x8B24,   // 0x12A0 (4768)
0x7343, 0x6321, 0x5B21, 0x5B00, 0x6AE1, 0x7AE1, 0x82E1, 0x92E1, 0xA322, 0x9B02, 0x8A81, 0x7A41, 0x7221, 0x6201, 0x6A00, 0x8281,   // 0x12B0 (4784)
0x9B21, 0x9B01, 0x8A80, 0x8260, 0xA320, 0xBBE2, 0xC401, 0xBBE0, 0xBC01, 0xBC01, 0xB3C1, 0xBBE1, 0xCC42, 0xC421, 0xB3E1, 0xB401,   // 0x12C0 (4800)
};

Alors que je souhaite afficher une image en grand écrans...

**al1_24** · 08/08/2015, 23h14

Tu trouveras des exemples d'affichage d'image sur tout l'écran avec la bibliothèque UTFT_TinyFat

**Benji861905** · 08/08/2015, 23h20

Merci je vais jeter un coup d’œil a cette libaririe

**Benji861905** · 08/08/2015, 23h38

Merci beaucoup, sa marche et les image s'affiche de super bonne qualiter !
Juste le temps pour moi d’étudier cette librairie et d'en tenir au courant sur ce topic avant de mettre résolut !
Merci encore !

**Vincent PETIT** · 08/08/2015, 23h46

Tant mieux si tu as trouvé une solution toute faite.
Sinon la fonction (ou methode plutôt) qui t'aurait intéressé est : drawPixel (x, y) pour allumer 1 pixel.

En gardant les lignes dans la fonction Setup et dans Loop faire :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
myGLCD.clrScr();
myGLCD.setColor(0,255,255);
myGLCD.drawPixel(10,10);

Aurait du allumer 1 point ensuite il restait à lire un bitmap pixel par pixel et d'allumer les points correspondant sur l'écran.

**Benji861905** · 09/08/2015, 00h06

Avec ta méthode il aurais fallu faire tout les pixel 1 par 1 ?

**Vincent PETIT** · 09/08/2015, 00h13

Oui en effet, lire la position du pixel dans le .bmp et faire un drawPixel sur l'écran au même endroit.

Je n'ai pas regardé la bibliothèque que al_1 à trouvé mais il y a fort à parier que c'est de cette façon qu'elle fonctionne.

Utiliser une image sur écran LED 480x320

Arduino

Vue hybride

Discussions similaires

Partager

Partager