OpenCores
URL https://opencores.org/ocsvn/s6soc/s6soc/trunk

Subversion Repositories s6soc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /s6soc/trunk
    from Rev 45 to Rev 44
    ↔ Reverse comparison
  •

Rev 45 → Rev 44

/sw/zipos/doorbell.c
53,18 → 53,11
#include "ktraps.h"
#include "errno.h"
#include "swint.h"
#include "txfns.h"
 
#include "../dev/display.h"
#include "../dev/rtcsim.h"
#include "../dev/keypad.h"
 
typedef unsigned size_t;
 
size_t strlen(const char *);
char *strcat(char *, const char *);
char *strcpy(char *, const char *);
 
/* Our system will need some pipes to handle ... life. How about these:
*
* rxpipe - read()s from this pipe read from the UART
147,14 → 140,6
*/
#define DOORBELL_TASK doorbell_task_id
 
 
/*
* Just print Hello World every 15 seconds or so. This is really a test of the
* write() and txpipe infrastructure, but not really a valid part of the task.
*
*/
// #define HELLO_TASK hello_task_id
 
#define LAST_TASK last_task_id
 
typedef enum {
172,8 → 157,8
#ifdef MENU_TASK
MENU_TASK,
#endif
#ifdef HELLO_TASK
HELLO_TASK,
#ifdef COMMAND_TASK
COMMAND_TASK,
#endif
LAST_TASK
} TASKNAME;
183,8 → 168,7
doorbell_task(void),
display_task(void),
keypad_task(void),
menu_task(void),
hello_task(void);
menu_task(void);
// idle_task ... is accomplished within the kernel
extern void restore_context(int *), save_context(int *);
extern SYSPIPE *rxpipe, *txpipe, *pwmpipe, *lcdpipe;
195,20 → 179,20
return LAST_TASK;
} void kinit(TASKP *tasklist) {
#ifdef RTCCLOCK_TASK
// Stack = 36 (rtctask) + 4(rtcdatenext)
tasklist[RTCCLOCK_TASK] = new_task(64, rtctask);
//
tasklist[RTCCLOCK_TASK] = new_task(16, rtctask);
#endif
 
#ifdef DOORBELL_TASK
#ifdef DISPLAY_TASK
// Stack = 36 + 36 (uread/write) + 24(memcpy) + 32(uarthex)+8(uartchr)
tasklist[DOORBELL_TASK] = new_task(256, doorbell_task);
// 13 + 10 +9(uwrite)+4(uarthex)+2(uartstr)+2(uartchr)
tasklist[DOORBELL_TASK] = new_task(96, doorbell_task);
// tasklist[DOORBELL_TASK]->fd[FILENO_STDOUT]= kopen((int)lcdpipe,pipedev);
tasklist[DOORBELL_TASK]->fd[FILENO_STDERR]= kopen((int)txpipe, pipedev);
tasklist[DOORBELL_TASK]->fd[FILENO_AUX] = kopen((int)pwmpipe, pipedev);
 
// Stack = 16 + 36(uread/write) + 24(memcpy)
tasklist[DISPLAY_TASK] = new_task(128, display_task);
//
tasklist[DISPLAY_TASK] = new_task(32, display_task);
tasklist[DISPLAY_TASK]->fd[FILENO_STDIN] = kopen((int)lcdpipe,pipedev);
#endif
#endif
215,27 → 199,18
 
 
#ifdef KEYPAD_TASK
// Stack = 28 + 36(uwrite) + 24(memcpy) = 88 bytes
tasklist[KEYPAD_TASK] = new_task(128, keypad_task);
// Stack = 7 + 9(uwrite) + 2*4
tasklist[KEYPAD_TASK] = new_task(32, keypad_task);
tasklist[KEYPAD_TASK]->fd[FILENO_STDOUT] = kopen((int)keypipe,pipedev);
#endif
#ifdef MENU_TASK
// Stack = 76 + 48(showbell/shownow)
// + 36(uwrite)
// + 8(menu_readkey)
// + 24(memcpy)
// +100(time_menu/dawn_menu/dusk_menu)
//
tasklist[MENU_TASK] = new_task(512, menu_task);
// Stack = 18 + 10(showbell/shownow) + 9(uwrite) + 2(menu_readkey)
// + 18 (time_menu/dawn_menu/dusk_menu)
tasklist[MENU_TASK] = new_task(72, menu_task);
// tasklist[MENU_TASK]->fd[FILENO_STDIN] = kopen((int)keypipe,pipedev);
tasklist[MENU_TASK]->fd[FILENO_STDOUT]= kopen((int)lcdpipe,pipedev);
tasklist[MENU_TASK]->fd[FILENO_STDERR]= kopen((int)txpipe, pipedev);
#endif
 
#ifdef HELLO_TASK
tasklist[HELLO_TASK] = new_task(512, hello_task);
tasklist[HELLO_TASK]->fd[FILENO_STDOUT]= kopen((int)txpipe,pipedev);
#endif
}
 
// #define HALF_HOUR_S 1800 // Seconds per half hour
248,58 → 223,60
const unsigned dawn = 0x060000, dusk = 0x180000;
#endif
 
const char basemsg[] = "\e[jTime: xx:xx:xx\e[1;0H ";
const char nighttime[] = "Night time";
const char daylight[] = "Daylight!";
const char dbellstr[] = "Doorbell!";
void shownow(unsigned now) {
char dmsg[40];
strcpy(dmsg, basemsg);
 
dmsg[ 9] = ((now>>20)&0x0f)+'0';
dmsg[10] = ((now>>16)&0x0f)+'0';
//
dmsg[12] = ((now>>12)&0x0f)+'0';
dmsg[13] = ((now>> 8)&0x0f)+'0';
//
dmsg[15] = ((now>> 4)&0x0f)+'0';
dmsg[16] = ((now )&0x0f)+'0';
 
void shownow(unsigned now) { // Uses 10 stack slots + 8 for write()
char dmsg[9];
dmsg[0] = PACK(0x1b,'[','j','T');
dmsg[1] = PACK('i','m','e',':');
dmsg[2] = PACK(' ',((now>>20)&0x3)+'0',
((now>>16)&0xf)+'0',':');
dmsg[3] = PACK( ((now>>12)&0xf)+'0',
((now>> 8)&0xf)+'0',
':',
((now>> 4)&0xf)+'0');
dmsg[4] = PACK( ((now )&0xf)+'0',
0x1b, '[', '1');
dmsg[5] = PACK(';','0','H',' ');
if ((now < dawn)||(now > dusk)) {
strcat(dmsg, nighttime);
dmsg[6] = PACK('N','i','g','h');
dmsg[7] = PACK('t',' ','t','i');
dmsg[8] = PACK('m','e',0,0);
} else {
strcat(dmsg, daylight);
} write(FILENO_STDOUT, dmsg, strlen(dmsg));
dmsg[6] = PACK('D','a','y','l');
dmsg[7] = PACK('i','g','h','t');
dmsg[8] = PACK('!',' ',0,0);
} write(FILENO_STDOUT, dmsg, 9);
}
 
void showbell(unsigned now) { // Uses 10 stack slots + 8 for write()
char dmsg[40];
 
strcpy(dmsg, basemsg);
 
dmsg[ 9] = ((now>>20)&0x0f)+'0';
dmsg[10] = ((now>>16)&0x0f)+'0';
//
dmsg[12] = ((now>>12)&0x0f)+'0';
dmsg[13] = ((now>> 8)&0x0f)+'0';
//
dmsg[15] = ((now>> 4)&0x0f)+'0';
dmsg[16] = ((now )&0x0f)+'0';
 
strcat(dmsg, dbellstr);
write(FILENO_STDOUT, dmsg, strlen(dmsg));
char dmsg[9];
dmsg[0] = PACK(0x1b,'[','j','T');
dmsg[1] = PACK('i','m','e',':');
dmsg[2] = PACK(' ',((now>>20)&0x3)+'0',
((now>>16)&0xf)+'0',':');
dmsg[3] = PACK( ((now>>12)&0xf)+'0',
((now>> 8)&0xf)+'0',
':',
((now>> 4)&0xf)+'0');
dmsg[4] = PACK( ((now )&0xf)+'0',
0x1b, '[', '1');
dmsg[5] = PACK(';','0','H',' ');
dmsg[6] = PACK('D','o','o','r');
dmsg[7] = PACK('b','e','l','l');
dmsg[8] = PACK('!',' ',0,0);
write(FILENO_STDOUT, dmsg, 9);
}
 
void uartchr(char v) {
if (write(FILENO_STDERR, &v, 1) != 1)
write(FILENO_STDERR, "APPLE-PANIC\r\n", 13);
write(FILENO_STDERR, "APPLE-PANIC", 11);
}
 
void uartstr(const char *str) {
int cnt;
cnt = strlen(str);
int cnt=0;
while(str[cnt])
cnt++;
if (cnt != write(FILENO_STDERR, str, cnt))
write(FILENO_STDERR, "PIPE-PANIC\r\n", 12);
write(FILENO_STDERR, "PIPE-PANIC", 10);
}
 
void uarthex(int num) {
318,10 → 295,11
#include "../dev/samples.c"
 
void belllight(unsigned now) {
IOSPACE *sys = (IOSPACE *)IOADDR;
if ((now < dawn)||(now > dusk))
_sys->io_spio = 0x088; // Turn our light on
sys->io_spio = 0x088; // Turn our light on
else
_sys->io_spio = 0x80; // Turn light off
sys->io_spio = 0x80; // Turn light off
}
 
void doorbell_task(void) {
332,12 → 310,13
// write(KFD_STDOUT, disp_build_gtlogo, sizeof(disp_build_gtlogo));
// write(KFD_STDOUT, disp_reset_data, sizeof(disp_reset_data));
// write(KFD_STDOUT, disp_gtech_data, sizeof(disp_gtech_data));
IOSPACE *sys = (IOSPACE *)IOADDR;
 
while(1) {
int event;
// Initial state: doorbell is not ringing. In this state, we
// can wait forever for an event
_sys->io_spio = 0x080; // Turn our light off
sys->io_spio = 0x080; // Turn our light off
event = wait(INT_BUTTON|SWINT_PPS,-1);
 
#ifndef MENU_TASK
361,15 → 340,15
 
// Check time: should we turn our light on or not?
belllight((volatile unsigned)rtcclock);
const short *sptr = sound_data;
const int *sptr = sound_data;
// uartchr('N');
while(sptr < &sound_data[NSAMPLE_WORDS]) {
int len = &sound_data[NSAMPLE_WORDS]-sptr;
if (len > 512)
len = 512;
if (len > 256)
len = 256;
 
// We will stall here, if the audio FIFO is full
write(FILENO_AUX, sptr,
sizeof(sound_data[0])*len);
write(FILENO_AUX, sptr, len);
sptr += len;
 
// If the user presses the button more than
419,65 → 398,83
#endif
 
#ifdef MENU_TASK
const char menustr[] = "\e[1;0H : ";
 
void entered_menu_str(char *str, unsigned now,int pos) {
//
// Set current time
// xx:xx:xx
//
strcpy(str, menustr);
str[0] = PACK(0x1b, '[', '1',';');
str[1] = PACK('0','H',' ',' ');
str[2] = PACK(' ','x','x',':');
str[3] = PACK('x','x',' ',' ');
//str[3]=PACK('x','x',':','x');
str[4] = PACK(' ','\0','\0','\0');
 
if (pos>0) {
int ch = ((now >> 20)&0x0f)+'0';
str[9] = ch;
str[2] &= ~0x0ff0000;
str[2] |= (ch<<16);
 
if (pos > 1) {
ch = ((now >> 16)&0x0f)+'0';
str[10] = ch;
int ch = ((now >> 16)&0x0f)+'0';
str[2] &= ~0x0ff00;
str[2] |= (ch<<8);
 
if (pos > 2) {
ch = ((now >> 12)&0x0f)+'0';
str[12] = ch;
int ch = ((now >> 12)&0x0f)+'0';
str[3] &= ~0xff000000;
str[3] |= (ch<<24);
 
if (pos > 3) {
int ch = ((now >> 8)&0x0f)+'0';
str[13] = ch;
str[3] &= ~0x0ff0000;
str[3] |= (ch<<16);
 
if (pos > 4) {
ch = ((now >> 4)&0x0f)+'0';
str[15] = ch;
str[14] = ':';
int ch = ((now >> 4)&0x0f)+'0';
str[3] &= ~0x0ff00;
str[3] |= ':'<<8;
str[3] &= ~0x0ff;
str[3] |= (ch);
 
if (pos > 5)
ch = (now&0x0f)+'0';
else
ch = 'x';
str[16] = ch;
}}}}} str[17] = '\0';
str[4] &= ~0x0ff000000;
str[4] |= (ch<<24);
}}}}}
}
 
const char timmenu[] = "\e[jSet current time:";
 
void show_time_menu(unsigned when, int posn) {
char dmsg[64];
strcpy(dmsg, timmenu);
entered_menu_str(&dmsg[20], when, posn);
write(FILENO_STDOUT, dmsg, strlen(dmsg));
char dmsg[10];
dmsg[0] = PACK(0x1b,'[','j','S');
dmsg[1] = PACK('e','t',' ','c');
dmsg[2] = PACK('u','r','r','e');
dmsg[3] = PACK('n','t',' ','t');
dmsg[4] = PACK('i','m','e',':');
entered_menu_str(&dmsg[5], when, posn);
write(FILENO_STDOUT, dmsg, 9);
}
 
const char dawnmenu[] = "\e[jSet sunrise: ";
void show_dawn_menu(unsigned when, int posn) {
char dmsg[64];
strcpy(dmsg, dawnmenu);
entered_menu_str(&dmsg[16], when, posn);
write(FILENO_STDOUT, dmsg, strlen(dmsg));
char dmsg[10];
dmsg[0] = PACK(0x1b,'[','j','S');
dmsg[1] = PACK('e','t',' ','s');
dmsg[2] = PACK('u','n','r','i');
dmsg[3] = PACK('s','e',':','\0');
entered_menu_str(&dmsg[4], when, posn);
write(FILENO_STDOUT, dmsg, 8);
}
 
const char duskmenu[] = "\e[;Set sunset: ";
void show_dusk_menu(unsigned when, int posn) {
char dmsg[64];
entered_menu_str(&dmsg[15], when, posn);
write(FILENO_STDOUT, dmsg, strlen(dmsg));
char dmsg[10];
dmsg[0] = PACK(0x1b,'[','j','S');
dmsg[1] = PACK('e','t',' ','s');
dmsg[2] = PACK('u','n','s','e');
dmsg[3] = PACK('t',':','\0','\0');
entered_menu_str(&dmsg[4], when, posn);
write(FILENO_STDOUT, dmsg, 8);
}
 
int menu_readkey(void) {
608,12 → 605,23
} dusk = newdusk;
}
 
const char unknownstr[] = "\e[jUnknown Cmd Key\e[1;0HA/Tm B/Dwn C/Dsk";
void unknown_menu(void) {
// 0123456789ABCDEF
// Unknown Cmd Key
// A/Tm B/Dwn C/Dsk
write(FILENO_STDOUT, unknownstr, strlen(unknownstr));
char dmsg[11];
dmsg[0] = PACK(0x1b,'[','j','U');
dmsg[1] = PACK('n','k','n','o');
dmsg[2] = PACK('w','n',' ','C');
dmsg[3] = PACK('m','d',' ','K');
dmsg[4] = PACK('e','y','\0','\0');
dmsg[5] = PACK(0x1b,'[','1',';');
dmsg[6] = PACK('0','H','A','/');
dmsg[7] = PACK('T','m',' ','B');
dmsg[8] = PACK('/','D','w','n');
dmsg[9] = PACK(' ','C','/','D');
dmsg[10] = PACK('s','k',0,0);
write(FILENO_STDOUT, dmsg, 11);
}
void menu_task(void) {
// Controls LED 0x08
623,8 → 631,10
// write(KFD_STDOUT, disp_build_gtlogo, sizeof(disp_build_gtlogo));
// write(KFD_STDOUT, disp_reset_data, sizeof(disp_reset_data));
// write(KFD_STDOUT, disp_gtech_data, sizeof(disp_gtech_data));
// IOSPACE *sys = (IOSPACE *)IOADDR;
unsigned belltime = 0, when;
 
 
when = (volatile unsigned)rtcclock;
while(1) {
int event;
662,14 → 672,3
}
#endif
 
 
#ifdef HELLO_TASK
static const char *hello_string = "Hello, World!\r\n";
void hello_task(void) {
while(1) {
for(int i=0; i<15; i++)
wait(SWINT_CLOCK, -1);
write(FILENO_STDOUT, hello_string, strlen(hello_string));
}
}
#endif
/sw/zipos/ktraps.h
56,8 → 56,7
// If the timeout < 0, clears any pending timeout wakeup
// If the timeout > 0, sets a pending timeout wakeup and
// returns.
// If the timeout == 0, clears the respective interrupt
// slash event, and does nothing more.
// If the timeout == 0, does nothing.
TRAPID_WAIT, TRAPID_CLEAR, TRAPID_POST,
// Yield: Yields the processor until the next scheduled time slice.
TRAPID_YIELD,
64,10 → 63,10
TRAPID_READ, TRAPID_WRITE,
TRAPID_TIME,
// Return from a kernel system call. This is necessary if ever an
// exception triggers a system call. In such cases, it will be
// exception triggers a syste call. In such cases, it will be
// impossible to return the caller back to his context in a pristine
// manner ... without help.
// TRAPID_KRETURN,
// TRAPID_KRETURN
// Semaphore ID's. These allow us to run the rest of the trap
// stuffs in kernel space
TRAPID_SEMGET, TRAPID_SEMPUT, TRAPID_SEMNEW,
/sw/zipos/kernel.c
72,13 → 72,12
 
int LAST_TASK;
 
extern void txstr(const char *);
 
void kernel_entry(void) {
int nheartbeats= 0, tickcount = 0, milliseconds=0, ticks = 0;
int audiostate = 0, buttonstate = 0;
TASKP *tasklist, current;
int *last_context;
IOSPACE *sys = (IOSPACE *)IOADDR;
 
tasklist = ksetup();
 
88,17 → 87,16
 
unsigned enableset =
INT_ENABLEV(INT_BUTTON)
|INT_ENABLEV(INT_TIMER)
|INT_ENABLEV(INT_TIMA)
// |INT_ENABLEV(INT_UARTRX)
// |INT_ENABLEV(INT_UARTTX) // Needs to be turned on by driver
// |INT_ENABLEV(INT_AUDIO // Needs to be turned on by driver)
// |INT_ENABLEV(INT_GPIO)
// |INT_ENABLEV(INT_TIMB);
;
// Then selectively turn some of them back on
_sys->io_pic = INT_ENABLE | enableset | 0x07fff;
sys->io_pic = INT_ENABLE | enableset | 0x07fff;
 
txstr("HEAP: "); txhex(heap);
 
do {
int need_resched = 0, context_has_been_saved, pic;
nheartbeats++;
107,11 → 105,11
 
last_context = current->context;
context_has_been_saved = 0;
pic = _sys->io_pic;
pic = sys->io_pic;
 
if (pic & 0x8000) { // If there's an active interrupt
// Interrupt processing
_sys->io_spio = 0x44;
sys->io_spio = 0x44;
 
// First, turn off pending interrupts
// Although we migt just write 0x7fff7fff to the
121,18 → 119,18
// know about.
pic &= 0x7fff;
// Acknowledge current ints, and turn off pending ints
_sys->io_pic = INT_DISABLEV(pic)|(INT_CLEAR(pic));
if(pic&INT_TIMER) {
sys->io_pic = INT_DISABLEV(pic)|(INT_CLEAR(pic));
if(pic&INT_TIMA) {
if (++ticks >= TICKS_PER_SECOND) {//(pic & SYSINT_PPS)
// Toggle the low order LED
tickcount++;
ticks = 0;
_sys->io_spio = ((_sys->io_spio&1)^1)|0x010;
sys->io_spio = ((sys->io_spio&1)^1)|0x010;
pic |= SWINT_CLOCK;
}
if (buttonstate)
buttonstate--;
else if ((_sys->io_spio & 0x0f0)==0)
else
enableset |= INT_ENABLEV(INT_BUTTON);
}
//
139,14 → 137,12
if (pic&INT_BUTTON) {
// Need to turn the button interrupt off
enableset &= ~(INT_ENABLEV(INT_BUTTON));
if ((_sys->io_spio&0x0f0)==0x030)
if ((sys->io_spio&0x0f0)==0x030)
kpanic();
if (buttonstate)
pic &= ~INT_BUTTON;
buttonstate = 50;
buttonstate = 3;
}
if (pic & INT_UARTRX) {
int v = _sys->io_uart;
int v = sys->io_uart;
if ((v & (~0x7f))==0) {
kpush_syspipe(rxpipe, v);
153,42 → 149,44
 
// Local Echo
if (pic & INT_UARTTX) {
_sys->io_uart = v;
_sys->io_pic = INT_UARTTX;
sys->io_uart = v;
sys->io_pic = INT_UARTTX;
pic &= ~INT_UARTTX;
}
}
} if (pic & INT_UARTTX) {
char ch;
if (kpop_syspipe(txpipe, &ch)==0) {
unsigned v = ch;
int v;
if (kpop_syspipe(txpipe, &v)==0) {
enableset |= (INT_ENABLEV(INT_UARTTX));
_sys->io_uart= v;
_sys->io_pic = INT_UARTTX;
sys->io_uart= v;
sys->io_pic = INT_UARTTX;
// if (v == 'W')
// sys->io_watchdog = 5;
// sys->io_timb = 5;
// 75k was writing the 'e'
} else
enableset&= ~(INT_DISABLEV(INT_UARTTX));
enableset &= ~(INT_ENABLEV(INT_UARTTX));
} if (audiostate) {
if (pic & INT_AUDIO) {
unsigned short sample;
 
int v;
// States:
// 0 -- not in use
// 1 -- in use
 
if (kpop_short_syspipe(pwmpipe, &sample)==0) {
_sys->io_pwm_audio = sample;
_sys->io_spio = 0x022;
// audiostate = 1;
// 1 -- First sample, buffer empty
// time to read a new sample
// 2 -- second sample, to read new
// 3 -- Need to turn off
if ((audiostate & 3)==2) {
sys->io_pwm_audio = (audiostate>>2)&0x0ffff;
audiostate = 1;
} else if (kpop_syspipe(pwmpipe, &v)==0) {
audiostate = (2|(v<<2))&0x03ffff;
sys->io_pwm_audio = (v>>16)&0x0ffff;
} else {
audiostate = 0;
// Turn the device off
_sys->io_pwm_audio = 0x10000;
sys->io_pwm_audio = 0x10000;
// Turn the interrupts off
enableset &= ~(INT_ENABLEV(INT_AUDIO));
_sys->io_spio = 0x020;
sys->io_spio = 0x020;
}
 
// This particular interrupt cannot be cleared
197,50 → 195,46
// it now. If it needs retriggering, the port
// will retrigger itself -- despite being
// cleared here.
_sys->io_pic = INT_AUDIO;
}}
/*
else { // if (audiostate == 0)
unsigned short sample;
 
if (kpop_short_syspipe(pwmpipe, &sample)==0) {
audiostate = 1;
_sys->io_pwm_audio = 0x310000 | sample;
sys->io_pic = INT_AUDIO;
}} else { // if (audiostate == 0)
int sample;
if (kpop_syspipe(pwmpipe, &sample)==0) {
audiostate = (2|(sample<<2))&0x03ffff;
sys->io_pwm_audio = 0x310000 | ((sample>>16)&0x0ffff);
enableset |= (INT_ENABLEV(INT_AUDIO));
_sys->io_spio = 0x022;
_sys->io_pic = INT_AUDIO;
sys->io_spio = 0x022;
sys->io_pic = INT_AUDIO;
} // else sys->io_spio = 0x020;
}
*/
milliseconds = kpost(tasklist, pic, milliseconds);
 
// Restart interrupts
enableset &= (~0x0ffff); // Keep the bottom bits off
_sys->io_pic = INT_ENABLE|enableset;
sys->io_pic = INT_ENABLE|enableset;
} else {
_sys->io_pic = INT_ENABLE; // Make sure interrupts are on
unsigned short sample;
sys->io_pic = INT_ENABLE; // Make sure interrupts are on
int sample;
 
// Check for the beginning of an audio pipe. If the
// interrupt is not enabled, we still might need to
// enable it.
 
if ((audiostate==0)&&(kpop_short_syspipe(pwmpipe, &sample)==0)) {
audiostate = 1;
_sys->io_pwm_audio = 0x310000 | (sample);
_sys->io_pic = INT_AUDIO;
if ((audiostate==0)&&(kpop_syspipe(pwmpipe, &sample)==0)) {
audiostate = (2|(sample<<2))&0x03ffff;
sys->io_pwm_audio = 0x310000 | ((sample>>16)&0x0ffff);
sys->io_pic = INT_AUDIO;
enableset |= (INT_ENABLEV(INT_AUDIO));
_sys->io_spio = 0x022;
sys->io_spio = 0x022;
} // else sys->io_spio = 0x020;
 
// Or the beginning of a transmit pipe.
if (pic & INT_UARTTX) {
char ch;
if (kpop_syspipe(txpipe, &ch)==0) {
unsigned v = ch;
int v;
if (kpop_syspipe(txpipe, &v)==0) {
enableset |= (INT_ENABLEV(INT_UARTTX));
_sys->io_uart = v;
_sys->io_pic = INT_UARTTX;
sys->io_uart = v;
sys->io_pic = INT_UARTTX;
// if (v == 'W')
// sys->io_timb = 5;
} else
enableset &= ~(INT_ENABLEV(INT_UARTTX));
}
250,9 → 244,9
// as syspipe() accomplishes within uwrite_syspipe()
// (We also might've just turned them off ... ooops)
enableset &= (~0x0ffff); // Keep the bottom bits off
_sys->io_pic = INT_ENABLE | enableset;
sys->io_pic = INT_ENABLE | enableset;
}
_sys->io_spio = 0x40;
sys->io_spio = 0x40;
 
int zcc = zip_ucc();
if (zcc & CC_TRAPBIT) {
360,7 → 354,8
restore_context(last_context);
} else if (zcc & (CC_BUSERR|CC_DIVERR|CC_FPUERR|CC_ILL)) {
current->state = SCHED_ERR;
current->errno = (int)_sys->io_buserr;
// current->errno = -EBUS;
current->errno = (int)sys->io_buserr;
save_context(last_context);
context_has_been_saved = 1;
kpanic();
414,7 → 409,7
 
int kpost(TASKP *tasklist, unsigned events, int milliseconds) {
int i;
if (events & INT_TIMER)
if (events & INT_TIMA)
milliseconds++;
if (milliseconds<0) {
milliseconds -= 0x80000000;
/sw/zipos/ksetup.c
46,18 → 46,15
#include "ktraps.h"
#include "errno.h"
#include "swint.h"
#include "txfns.h"
 
typedef unsigned size_t;
 
extern int kntasks(void);
extern void kinit(TASKP *tasklist);
extern void restore_context(int *), save_context(int *);
SYSPIPE *rxpipe, *txpipe, *keypipe, *lcdpipe, *pwmpipe, *cmdpipe;
KDEVICE *pipedev, *txdev, *pwmdev;
char *heap; // = _top_of_heap; // Need to wait on startup to set this
void *heap; // = _top_of_heap; // Need to wait on startup to set this
 
#define CONTEXT_LENGTH (80000-1) // 1ms
#define CONTEXT_LENGTH 80000 // 1ms
 
int LAST_TASK;
 
64,12 → 61,12
__attribute__((cold))
TASKP *ksetup(void) {
TASKP *tasklist;
volatile IOSPACE *const sys = _sys;
IOSPACE *sys = (IOSPACE *)IOADDR;
 
sys->io_spio = 0x0f0;
sys->io_watchdog = 0; // Turn off the watchdog timer
sys->io_timb = 0; // Turn off the watchdog timer
LAST_TASK = kntasks();
heap = (char *)_top_of_heap;
heap = _top_of_heap;
 
pipedev = sys_malloc(sizeof(KDEVICE));
pipedev->write = (RWFDFUN)kwrite_syspipe;
78,25 → 75,26
 
txdev = pwmdev = pipedev;
 
rxpipe = new_syspipe(64); //rxpipe->m_wrtask=INTERRUPT_WRITE_TASK;
txpipe = new_syspipe(64); txpipe->m_rdtask = INTERRUPT_READ_TASK;
keypipe = new_syspipe(64);
lcdpipe = new_syspipe(64);
pwmpipe = new_syspipe(512); pwmpipe->m_rdtask= INTERRUPT_READ_TASK;
cmdpipe = new_syspipe(64);
rxpipe = new_syspipe(16); //rxpipe->m_wrtask=INTERRUPT_WRITE_TASK;
txpipe = new_syspipe(8); txpipe->m_rdtask = INTERRUPT_READ_TASK;
keypipe = new_syspipe(16);
lcdpipe = new_syspipe(16);
pwmpipe = new_syspipe(128); pwmpipe->m_rdtask= INTERRUPT_READ_TASK;
cmdpipe = new_syspipe(16);
 
tasklist = sys_malloc(sizeof(TASKP)*(1+LAST_TASK));
kinit(tasklist);
tasklist[LAST_TASK] = new_task(8, idle_task);
tasklist[LAST_TASK] = new_task(2, idle_task);
 
// Turn all interrupts off, acknowledge all at the same time
sys->io_pic = INT_CLEARPIC;
sys->io_pic = 0x7fff7fff;
 
sys->io_timer = CONTEXT_LENGTH | TM_REPEAT;
sys->io_tima = CONTEXT_LENGTH | TM_REPEAT;
 
{
// Reset our wishbone scope for debug later
_scope->s_ctrl = 2;
SCOPE *scope = (SCOPE *)SCOPEADDR;
scope->s_control = 2;
}
sys->io_spio = 0x0f1;
 
104,13 → 102,15
}
 
void kwait_on_buttonpress(void) {
IOSPACE *sys = (IOSPACE *)IOADDR;
 
// Wait on a button press before starting
while((_sys->io_spio & 0x0f0)==0)
while((sys->io_spio & 0x0f0)==0)
;
_sys->io_spio = 0x0f3;
sys->io_spio = 0x0f3;
for(int i=0; i<40000; i++)
_sys->io_spio = ((i>>14)&2)|0x020;
_sys->io_spio = 0x0f7;
sys->io_spio = ((i>>14)&2)|0x020;
sys->io_spio = 0x0f7;
}
 
// __attribute__((noreturn))
119,9 → 119,19
}
 
__attribute__((malloc))
void *sys_malloc(size_t sz) {
void *sys_malloc(int sz) {
if (0) {
SCOPE *s = (SCOPE *)SCOPEADDR;
s->s_control = TRIGGER_SCOPE_NOW | (s->s_control & 0x0ffff);
}
 
void *res = heap;
heap = heap + ((sz+3)&-4);
heap += sz;
if ((int)heap > ((int)&res)-32) {
IOSPACE *sys = (IOSPACE *)IOADDR;
sys->io_spio = 0xf3;
asm("break 0");
}
return res;
}
 
/sw/zipos/cmodram.ld
40,51 → 40,34
 
MEMORY
{
blkram (wx) : ORIGIN = 0x0004000, LENGTH = 0x0004000
flash (rx) : ORIGIN = 0x1000000, LENGTH = 0x1000000
blkram (wx) : ORIGIN = 0x002000, LENGTH = 0x001000
flash (rx) : ORIGIN = 0x400000, LENGTH = 0x400000
}
 
_flash = ORIGIN(flash);
_blkram = ORIGIN(blkram);
_sdram = 0;
_top_of_stack = ORIGIN(blkram) + LENGTH(blkram) - 4;
_sdram_image_start = 0;
_sdram_image_end = 0;
_top_of_stack = ORIGIN(blkram) + LENGTH(blkram) - 1;
 
SECTIONS
{
.rocode 0x1200000 : ALIGN(4) {
_boot_address = .;
*(.start) *(.boot)
. = 0x0480000;
.rocode 0x0480000 : { *(.start)
obj-zip/bootloader.o(.text)
obj-zip/ksetup.o(.text)
obj-zip/pipesetup.o(.text)
obj-zip/taskp.o(.text)
obj-zip/keypad.o(.text*)
obj-zip/display.o(.text*)
obj-zip/rtcsim.o(.text*)
obj-zip/doorbell.o(.text*)
*(.rodata*)
*(.strings*)
__rocode_alignment = (. + 3) & ~ 3;
. = __rocode_alignment;
} > flash
_kernel_image_start = . ;
.ramcode : ALIGN_WITH_INPUT {
obj-zip/kernel.o(.text*)
obj-zip/syspipe.o(.text*)
obj-zip/doorbell.o(.text)
obj-zip/keypad.o(.text)
obj-zip/display.o(.text)
obj-zip/rtcsim.o(.text)
*(.rodata*) *(.strings)
load_image_start = . ;
} > flash
.ramcode : {
obj-zip/kernel.o(.text)
obj-zip/syspipe.o(.text)
} > blkram AT> flash
.data : ALIGN_WITH_INPUT {
*(.kernel*)
*(.fixdata*)
*(.data*)
*(COMMON*)
_kernel_image_end = . ;
}> blkram AT> flash
_blkram_image_end = . ;
.bss : ALIGN_WITH_INPUT {
*(.bss*)
_bss_image_end = . ;
} > blkram
_top_of_heap = .;
.data : { *(.fixdata) *(.data) *(COMMON)
load_image_end = . ;
} > blkram AT> flash
.bss : { *(.bss) bss_image_end = . ; } > blkram
_top_of_heap = .;
}
/sw/zipos/Makefile
42,56 → 42,49
AS := $(CROSS)as
OBJDUMP := $(CROSS)objdump
OBJDIR := obj-zip
DEVSRCSR:= display.c keypad.c rtcsim.c txfns.c
DEVSRCSR:= display.c keypad.c rtcsim.c
DEVSRCS := $(addprefix ../dev/,$(DEVSRCSR))
DEVOBJS := $(addprefix $(OBJDIR)/,$(subst .c,.o,$(DEVSRCSR)))
SOURCES := bootloader.c kernel.c ksetup.c syspipe.c pipesetup.c taskp.c doorbell.c zipsys.c string.c # ziplib.c
SOURCES := bootloader.c kernel.c ksetup.c syspipe.c pipesetup.c taskp.c doorbell.c zipsys.c # ziplib.c
OBJECTS := $(addprefix $(OBJDIR)/,$(subst .c,.o,$(SOURCES))) $(DEVOBJS) $(OBJDIR)/resetdump.o
HEADERS := $(wildcard *.h) $(subst .c,.h,$(DEVSRCS))
# CFLAGS := -O3 -fdump-tree-all -Wall -Wextra -nostdlib -fno-builtin
# CFLAGS := -O3 -fdump-rtl-all -DZIPOS -Wall -Wextra -nostdlib -fno-builtin
CFLAGS := -I. -I../dev -Os -DZIPOS -Wall -Wextra -nostdlib -fno-builtin -Wa,-nocis
LDFLAGS := -T cmodram.ld -Wl,-Map,$(OBJDIR)/doorbell.map -nostdlib
CFLAGS := -O3 -DZIPOS -Wall -Wextra -nostdlib -fno-builtin
# CFLAGS := -Wall -Wextra -nostdlib -fno-builtin
LDFLAGS := -T cmodram.ld -Wl,-Map,$(OBJDIR)/doorbell.map
 
all: doorbell
all: $(OBJDIR)/ doorbell
$(OBJDIR)/:
$(mk-objdir)
@bash -c "if [ ! -e $(OBJDIR) ]; then mkdir -p $(OBJDIR); fi"
 
%.o: $(OBJDIR)/%.o
$(CC) $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/%.o: %.c
$(mk-objdir)
$(CC) $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/%.o: ../dev/%.c
$(mk-objdir)
$(CC) $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/%.txt: $(OBJDIR)/%.o
$(OBJDUMP) -Dr $^ > $@
$(OBJDUMP) -d $^ -o $@
 
$(OBJDIR)/%.s: %.c
$(mk-objdir)
$(CC) -S $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/%.s: ../dev/%.c
$(mk-objdir)
$(CC) -S $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/resetdump.o: resetdump.s
$(mk-objdir)
$(AS) -nocis $^ -o $@
$(AS) $^ -o $@
 
doorbell: $(OBJECTS) cmodram.ld
$(CC) $(LDFLAGS) $(OBJECTS) -o $@
 
doorbell.txt: doorbell
$(OBJDIR)/doorbell.txt: doorbell
$(OBJDUMP) -d $^ > $@
 
define mk-objdir
@bash -c "if [ ! -e $(OBJDIR) ]; then mkdir -p $(OBJDIR); fi"
endef
 
define build-depends
@echo "Building dependency file(s)"
@$(CC) $(CPPFLAGS) -MM $(SOURCES) $(DEVSRCS) > $(OBJDIR)/xdepends.txt
100,8 → 93,7
endef
 
.PHONY: depends
depends: tags
$(mk-objdir)
depends: $(OBJDIR)/ tags
$(build-depends)
 
tags: $(SOURCES) $(HEADERS)
/sw/zipos/syspipe.h
46,7 → 46,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
73,10 → 73,8
#ifndef SYSPIPE_H
#define SYSPIPE_H
 
typedef unsigned size_t;
extern void *sys_malloc(int sz);
 
extern void *sys_malloc(size_t sz);
 
typedef struct {
unsigned int m_mask;
int m_head, m_tail;
85,15 → 83,14
int dummy;
int m_error;
 
char m_buf[1];
int m_buf[1];
} SYSPIPE;
 
SYSPIPE *new_syspipe(const unsigned int len);
extern void kread_syspipe( TASKP tsk, int dev, char *dst, int len);
extern void kwrite_syspipe(TASKP tsk, int dev, char *src, int len);
void kpush_syspipe(SYSPIPE *p, char val);
int kpop_syspipe(SYSPIPE *p, char *val);
int kpop_short_syspipe(SYSPIPE *p, unsigned short *val);
extern void kread_syspipe( TASKP tsk, int dev, int *dst, int len);
extern void kwrite_syspipe(TASKP tsk, int dev, int *src, int len);
void kpush_syspipe(SYSPIPE *p, int val);
int kpop_syspipe(SYSPIPE *p, int *val);
extern int num_avail_syspipe(SYSPIPE *p);
extern int len_syspipe(SYSPIPE *p);
 
/sw/zipos/zipsys.h
79,11 → 79,13
#endif
 
static inline void DISABLE_INTS(void) {
_sys->io_pic = 0;
IOSPACE *sys = (IOSPACE *)IOADDR;
sys->io_pic = 0;
}
 
static inline void ENABLE_INTS(void) {
_sys->io_pic = INT_ENABLE;
IOSPACE *sys = (IOSPACE *)IOADDR;
sys->io_pic = INT_ENABLE;
}
 
#endif
/sw/zipos/pipesetup.c
44,7 → 44,6
#include "syspipe.h"
#include "zipsys.h"
#include "ktraps.h"
#include "txfns.h"
 
#ifndef NULL
#define NULL (void *)0
78,10 → 77,43
p->m_nwritten = 0;
}
 
// These routines really belong elsewhere in a uartdump.c file or some such.
// However, until placed there, they'll stay put here for a bit longer.
void txchr(char v) {
volatile IOSPACE *sys = (IOSPACE *)IOADDR;
if (v < 10)
return;
v &= 0x0ff;
sys->io_pic = INT_UARTTX;
while((sys->io_pic&INT_UARTTX)==0)
;
sys->io_uart = v;
}
 
void txstr(const char *str) {
const char *ptr = str;
while(*ptr) {
txchr(*ptr++);
}
}
 
void txhex(int num) {
for(int ds=28; ds>=0; ds-=4) {
int ch;
ch = (num>>ds)&0x0f;
if (ch >= 10)
ch = 'A'+ch-10;
else
ch += '0';
txchr(ch);
} txstr("\r\n");
}
 
void pipe_panic(SYSPIPE *pipe) {
extern void kpanic(void);
volatile IOSPACE *sys = (IOSPACE *)IOADDR;
 
_sys->io_spio = 0x0fa;
sys->io_spio = 0x0fa;
txstr("SYSPIPE PANIC!\r\n");
txstr("ADDR: "); txhex((int)pipe);
94,7 → 126,7
SYSPIPE *new_syspipe(const unsigned int len) {
unsigned msk;
 
for(msk=16; msk<len; msk<<=1)
for(msk=2; msk<len; msk<<=1)
;
SYSPIPE *pipe = sys_malloc(sizeof(SYSPIPE)-1+msk);
pipe->m_mask = msk-1;
/sw/zipos/resetdump.s
32,7 → 32,7
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;//
;;
;; Copyright (C) 2015-2017, Gisselquist Technology, LLC
;; Copyright (C) 2015-2016, Gisselquist Technology, LLC
;;
;; This program is free software (firmware): you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as published
62,29 → 62,56
_start:
; Upon reset, we must output our registers to the UART, lest we reset because
; of a crash
SW R0,(DBG)
JSR internal_kpanic
STO R0,(DBG)
MOV PC+1,R0
BRA internal_kpanic
LDI _top_of_stack,SP
LDI kernel_entry,R0
BRA _bootloader
BRA bootloader
 
.global kpanic
.type kpanic,@function
kpanic:
SW R0,(DBG)
SW R1,4(DBG)
SW R2,8(DBG)
LDI panicstr, R1
JSR raw_put_string
LW 4(DBG),R1
LW 8(DBG),R2
JSR internal_kpanic
STO R0,(DBG)
STO R1,1(DBG)
STO R2,2(DBG)
LDI 'P',R1
MOV PC+1,R0
JMP raw_put_uart
LDI 'a',R1
MOV PC+1,R0
JMP raw_put_uart
LDI 'n',R1
MOV PC+1,R0
JMP raw_put_uart
LDI 'i',R1
MOV PC+1,R0
JMP raw_put_uart
LDI 'c',R1
MOV PC+1,R0
JMP raw_put_uart
LDI ':',R1
MOV PC+1,R0
JMP raw_put_uart
LDI ' ',R1
MOV PC+1,R0
JMP raw_put_uart
LDI '\r',R1
MOV PC+1,R0
JMP raw_put_uart
LDI '\n',R1
MOV PC+1,R0
JMP raw_put_uart
LOD 1(DBG),R1
LOD 2(DBG),R2
MOV PC+1,R0
JMP internal_kpanic
kpanic_wait_for_button_release:
LW (SPIO),R0
LOD (SPIO),R0
TEST 0x010,R0
BNZ kpanic_wait_for_button_release
kpanic_wait_for_button:
LW (SPIO),R0
LOD (SPIO),R0
TEST 0x010,R0
BZ kpanic_wait_for_button
BRA _start
91,159 → 118,191
HALT
internal_kpanic:
; The original R0 is stored in (DBG)
SW R1,4(DBG)
SW R2,8(DBG)
SW R0,12(DBG) ; Our return address
STO R1,1(DBG)
STO R2,2(DBG)
STO R0,3(DBG) ; Our return address
 
; R0
LDI 0,R1
LW (DBG),R2
JSR uart_put_reg_value
LOD (DBG),R2
MOV .Lcall0(PC),R0
JMP uart_put_reg_value
.Lcall0:
 
; R1
LDI 1,R1
LW 4(DBG),R2
JSR uart_put_reg_value
LOD 1(DBG),R2
MOV .Lcall1(PC),R0
JMP uart_put_reg_value
.Lcall1:
; R2
LDI 2,R1
LW 8(DBG),R2
JSR uart_put_reg_value
LOD 2(DBG),R2
MOV PC+1,R0
JMP uart_put_reg_value
; R3
LDI 3,R1
MOV R3,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R4
LDI 4,R1
MOV R4,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R5
LDI 5,R1
MOV R5,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R6
LDI 6,R1
MOV R6,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R7
LDI 7,R1
MOV R7,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R8
LDI 8,R1
MOV R8,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R9
LDI 9,R1
MOV R9,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R10
LDI 10,R1
MOV R10,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R11
LDI 11,R1
MOV R11,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; R12
LDI 12,R1
MOV R12,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; SP
LDI 13,R1
MOV R13,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; uR0
LDI 16,R1
MOV uR0,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; uR1
LDI 17,R1
MOV uR1,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 18,R1
MOV uR2,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 19,R1
MOV uR3,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 20,R1
MOV uR4,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 21,R1
MOV uR5,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 22,R1
MOV uR6,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 23,R1
MOV uR7,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 24,R1
MOV uR8,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 25,R1
MOV uR9,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 26,R1
MOV uR10,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 27,R1
MOV uR11,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
LDI 28,R1
MOV uR12,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; uSP
LDI 29,R1
MOV uSP,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; uCC
LDI 30,R1
MOV uCC,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
; uPC
LDI 31,R1
MOV uPC,R2
JSR uart_put_reg_value
MOV PC+1,R0
JMP uart_put_reg_value
 
;stack_mem_dump:
; LDI 0,R4
; LDI _top_of_stack,R5
;LDI 0,R4
;LDI _top_of_stack,R5
;stack_mem_dump_loop:
; MOV R4,R1
; LW (R5),R2
; JSR uart_put_stack_value
; ADD 4,R4
; SUB 4,R5
; CMP 256,R4
; BLT stack_mem_dump_loop
;MOV R4,R1
;LOD (R5),R2
;MOV PC+1,R0
;JMP uart_put_stack_value
;ADD 1,R4
;SUB 1,R5
;CMP 64,R4
;BLT stack_mem_dump_loop
 
; Get prepared for a proper start by setting our stack register
LDI _top_of_stack,SP
254,22 → 313,23
; Now, do a full dump of all memory--all registers are available to us
dump_memory:
LDI RAM,R5
LDI 0x0fff,R6
LDI 0x1000,R6
LDI 0x0f8,R7
SW R7,(SPIO)
STO R7,(SPIO)
full_mem_dump_loop:
MOV R5,R1
LW (R5),R2
JSR uart_dump_mem_value
LOD (R5),R2
MOV PC+1,R0
JMP uart_dump_mem_value
LDI 0x0f2,R7
SW R7,(SPIO)
STO R7,(SPIO)
 
ADD 4,R5
ADD 1,R5
SUB 1,R6
BGE full_mem_dump_loop
BGT full_mem_dump_loop
 
LDI 0x0f5,R7
SW R7,(SPIO)
STO R7,(SPIO)
 
dump_scope:
; Finally, do a full dump of the scope--if it had triggered
276,9 → 336,10
; First, dump the scope control word
LDI SCOPE,R7 ; R7 = Debugging scope address
MOV R7,R1
LW (R7),R2
LOD (R7),R2
MOV R2,R5 ; R5 will not be changed by a subroutine
JSR uart_dump_mem_value
MOV PC+1,R0
BRA uart_dump_mem_value
; Then test whether or not the scope has stopped
LDI 0x40000000,R1
TEST R1,R5
288,72 → 349,116
LSR 20,R5
AND 0x1f,R5
LDI 1,R6
LSL R5,R6 ; R6 is now the size (number of words) of the scope
SUB 1,R6 ; Now it is one less than the size,2 support the BGE l8r
LSL R5,R6
; And start dumping
ADD 4,R7 ; Get the scope data address
ADD 1,R7 ; Get the scope data address
dump_scope_loop:
MOV R7,R1
LW (R7),R2
JSR uart_dump_mem_value
LOD (R7),R2
MOV PC+1,R0
BRA uart_dump_mem_value
SUB 1,R6
BGE dump_scope_loop
BGT dump_scope_loop
 
dump_buserr:
; Dump a bus error address, if used
LDI buserr_header, R1
JSR raw_put_string
LDI 'B',R1
MOV PC+1,R0
BRA raw_put_uart
LDI 'u',R1
MOV PC+1,R0
BRA raw_put_uart
LDI 's',R1
MOV PC+1,R0
BRA raw_put_uart
LDI 'E',R1
MOV PC+1,R0
BRA raw_put_uart
LDI 'r',R1
MOV PC+1,R0
BRA raw_put_uart
LDI 'r',R1
MOV PC+1,R0
BRA raw_put_uart
LDI ':',R1
MOV PC+1,R0
BRA raw_put_uart
LDI ' ',R1
MOV PC+1,R0
BRA raw_put_uart
LDI BUSERR,R1
LW (R1),R2
JSR uart_dump_mem_value
LOD (R1),R2
MOV PC+1,R0
BRA uart_dump_mem_value
 
end_internal_panic:
LDI doublenewline,R1
JSR raw_put_string
LDI '\r',R1
MOV PC+1,R0
BRA raw_put_uart
LDI '\n',R1
MOV PC+1,R0
BRA raw_put_uart
LDI '\r',R1
MOV PC+1,R0
BRA raw_put_uart
LDI '\n',R1
MOV PC+1,R0
BRA raw_put_uart
LDI 0x0ff,R7
SW R7,(SPIO)
LW 12(DBG),PC
STO R7,(SPIO)
LOD 3(DBG),PC
JMP R0
 
; R0 is return address
; R1 is register ID
; R2 is register value to output
; R2 is register to output
uart_put_reg_value:
SW R0,16(DBG)
SW R2,20(DBG)
SW R3,24(DBG)
STO R0,4(DBG)
STO R2,5(DBG)
STO R3,6(DBG)
MOV R1,R2
LDI 'u',R1
CMP 16,R2
LDILO.LT 's',R1
SUB.GE 16,R2
JSR raw_put_uart
MOV PC+1,R0
JMP raw_put_uart
LDI '0',R1
CMP 10,R2
LDILO.GE '1',R1
SUB.GE 10,R2
JSR raw_put_uart
MOV PC+1,R0
JMP raw_put_uart
MOV R2,R1
AND 15,R1
JSR get_hex
JSR raw_put_uart
LDI ':',R1
JSR raw_put_uart
LW 20(DBG),R2
MOV PC+1,R0
JMP get_hex
MOV PC+1,R0
JMP raw_put_uart
LDI 58,R1 ; A ':'
MOV PC+1,R0
JMP raw_put_uart
LOD 5(DBG),R2
LDI 8,R3
uart_put_loop:
ROL 4,R2
MOV R2,R1
LSR 28,R1
LSL 4,R2
JSR get_hex
JSR raw_put_uart
AND 15,R1
MOV PC+1,R0
JMP get_hex
MOV PC+1,R0
JMP raw_put_uart
SUB 1,R3
BNZ uart_put_loop
LDI newline, R1
JSR raw_put_string
LW 16(DBG),R0
LW 20(DBG),R2
LW 24(DBG),R3
LDI '\r',R1
MOV PC+1,R0
JMP raw_put_uart
LDI '\n',R1
MOV PC+1,R0
JMP raw_put_uart
LOD 4(DBG),R0
LOD 5(DBG),R2
LOD 6(DBG),R3
JMP R0
 
uart_dump_mem_value:
361,109 → 466,107
; R1 = Memory address
; R2 = Memory Value
; Local: R3 = working value
SW R0,28(DBG)
STO R0,7(DBG)
MOV R1,R3 ; R3 = Memory address
MOV R2,R4 ; R4 = Memory Value
LDI memopenstr,R1
JSR raw_put_string
LDI 77,R1 ; 77 = 'M'
MOV PC+1,R0
JMP raw_put_uart
LDI 91,R1 ; 91 = '['
MOV PC+1,R0
JMP raw_put_uart
LDI 48,R1 ; A '0'
MOV PC+1,R0
JMP raw_put_uart
LDI 120,R1 ; An 'x'
MOV PC+1,R0
JMP raw_put_uart
; Set up a loop to dump things
LSL 16,R3 ; Ignore the first 16 bits
ROL 16,R3 ; Ignore the first 16 bits
LDI 4,R2 ; We're going to do four hex digits here
;
uart_put_mem_address_loop:
ROL 4,R3
MOV R3,R1
LSR 28,R1
LSL 4,R3
JSR get_hex
JSR raw_put_uart
AND 15,R1
MOV PC+1,R0
JMP get_hex
MOV PC+1,R0
JMP raw_put_uart
SUB 1,R2
BNZ uart_put_mem_address_loop
; Put some transition characters
LDI memmidstr,R1
JSR raw_put_string
LDI 93,R1 ; 93 = ']'
MOV PC+1,R0
JMP raw_put_uart
LDI 58, R1 ; A semicolon
MOV PC+1,R0
JMP raw_put_uart
LDI 32, R1 ; A space
MOV PC+1,R0
JMP raw_put_uart
 
; Set up a loop to dump the memory value now
LDI 8,R2
uart_put_mem_value_loop:
ROL 4,R4
MOV R4,R1
LSR 28,R1
LSL 4,R4
JSR get_hex
JSR raw_put_uart
AND 15,R1
MOV PC+1,R0
JMP get_hex
MOV PC+1,R0
JMP raw_put_uart
SUB 1,R2
BNZ uart_put_mem_value_loop
; Clear the line
LDI newline,R1
JSR raw_put_string
LDI '\r', R1
MOV PC+1,R0
JMP raw_put_uart
LDI '\n', R1
MOV PC+1,R0
JMP raw_put_uart
; And return from our subroutine
LW 28(DBG),R0
LOD 7(DBG),R0
JMP R0
 
get_hex:
ADD 0x30,R1
CMP 0x3a,R1
ADD.GE 7,R1 ; Add 'A'-'0'-10
CMP 0x39,R1
ADD.GT 7,R1 ; Add 'A'-'0'-10
JMP R0
 
; R0 is the return address
; R1 is the string address
raw_put_string:
SW R0,36(DBG)
SW R2,40(DBG)
MOV R1,R2
raw_put_string_next:
LB (R2),R1
CMP 0,R1
LW.Z 36(DBG),R0
LW.Z 40(DBG),R2
RTN.Z
ADD 1,R2
MOV raw_put_string_next(PC),R0
BRA raw_put_uart
; R0 is return address,
; R1 is value to transmit
raw_put_uart:
SW R2,32(DBG)
raw_put_uart: ; R0 is return address, R1 is value to transmit
STO R2,8(DBG)
LDI INT_UARTTX,R2
SW R2,(PIC) ; Clear the PIC, turn off interrupts, etc.
STO R2,(PIC) ; Clear the PIC, turn off interrupts, etc.
raw_put_uart_retest:
LW (PIC),R2
LOD (PIC),R2
TEST INT_UARTTX,R2
BZ raw_put_uart_retest
SW R1,(UART)
LW 32(DBG),R2
STO R1,(UART)
LOD 8(DBG),R2
JMP R0
 
.section .fixdata
DBG:
.int 0,0,0,0,0,0,0,0,0,0
.byte 0,0,0,0,0,0,0,0,0
 
.set INT_UARTRX, 0x040
.set INT_UARTTX, 0x080
.set PIC, 0x0400
.set BUSERR, 0x0404
.set TMRA, 0x0408
.set TMRB, 0x040c
.set PWM, 0x0410
.set SPIO, 0x0414
.set GPIO, 0x0418
.set UART, 0x041c
.set VERSION, 0x0420
.set SCOPE, 0x0800
.set SCOPED, 0x0804
.set RAM, 0x8000
.section .rodata
doublenewline:
.ascii "\r\n"
newline:
.asciz "\r\n"
buserr_header:
.string "BusErr: "
panicstr:
.string "Panic: \r\n"
memopenstr:
.string "M[0x"
memmidstr:
.string "]; "
 
.set PIC, 0x0100
.set BUSERR, 0x0101
.set TMRA, 0x0102
.set TMRB, 0x0103
.set PWM, 0x0104
.set SPIO, 0x0105
.set GPIO, 0x0106
.set UART, 0x0107
.set VERSION, 0x0108
.set SCOPE, 0x0200
.set SCOPED, 0x0201
.set CLOCK, 0x0800
.set CONFIG, 0x0400
.set TIMER, 0x0801
.set STOPWATCH,0x802
.set ALARM, 0x0803
.set RAM, 0x2000
/sw/zipos/bootloader.c
38,24 → 38,22
//
//
#include "board.h"
#include "bootloader.h"
 
// These values will be filled in by the linker. They are unknown at compile
// time.
extern int load_image_start, load_image_end, bss_image_end;
 
void _bootloader(void) __attribute__ ((section(".boot")));
void bootloader(void) {
int len = ((int)&load_image_end) - RAMADDR;
int *flash = &load_image_start;
int *mem = (int *)RAMADDR;
 
void _bootloader(void) {
int *flash = _kernel_image_start;
int *mem = _blkram;
 
while(mem < _kernel_image_end)
*mem++ = *flash++;
 
for(int i=0; i<len; i++)
mem[i] = flash[i];
// While I'd love to continue and clear to the end of memory, doing
// so will corrupt my stack and perhaps even my return address. Hence
// we only do this much.
while(mem < _bss_image_end)
*mem++ = 0;
for(int i=len; i< ((int)&bss_image_end)-RAMADDR; i++)
mem[i] = 0;
}
 
/sw/zipos/syspipe.c
46,13 → 46,12
#include "syspipe.h"
#include "zipsys.h"
#include "ktraps.h"
#include "string.h"
 
#ifndef NULL
#define NULL (void *)0
#endif
 
void kpush_syspipe(SYSPIPE *pipe, char val) {
void kpush_syspipe(SYSPIPE *pipe, int val) {
int tst = (pipe->m_head+1)&pipe->m_mask;
if (tst != pipe->m_tail) {
pipe->m_buf[pipe->m_head] = val;
63,15 → 62,8
}
 
extern void pipe_panic(SYSPIPE *p);
/*
* kpop_syspipe
*
* Called from an interrupt context to pop one byte off of the syspipe.
*/
int kpop_syspipe(SYSPIPE *pipe, char *vl) {
int kpop_syspipe(SYSPIPE *pipe, int *vl) {
if (pipe->m_head != pipe->m_tail) {
// The head will *only* equal the tail if the pipe is empty.
// We come in here, therefore, if the pipe is non-empty
*vl = pipe->m_buf[pipe->m_tail];
pipe->m_tail = (pipe->m_tail+1)&pipe->m_mask;
if (pipe->m_wrtask)
81,30 → 73,12
return 1; // Error condition
}
 
/*
* kpop_short_syspipe
*
* This is identical to kpop_syspipe, save that we are pulling a short value
* off of the syspipe (i.e. a pair of chars), not just a single char.
/* Returns how many values are in the pipe
*/
int kpop_short_syspipe(SYSPIPE *pipe, unsigned short *vl) {
if (pipe->m_head == pipe->m_tail)
return 1; // Error condition
 
unsigned short *sptr = (unsigned short *)&pipe->m_buf[pipe->m_tail];
// sv = pipe->m_buf[pipe->m_tail];
*vl = *sptr;;
pipe->m_tail = (pipe->m_tail+2)&pipe->m_mask;
if (pipe->m_wrtask)
pipe->m_wrtask->state = SCHED_READY;
return 0;
}
 
/*
/* Of course ... if it's not used, why include it?
int len_syspipe(SYSPIPE *p) {
return (p->m_head-p->m_tail) & p->m_mask;
} */
 
/* Returns how many empty spaces are in the pipe
*/
int num_avail_syspipe(SYSPIPE *p) {
122,8 → 96,7
// Another task may write to the pipe during this call. If the pipe becomes
// full, that task will block.
//
static int uread_syspipe(TASKP tsk __attribute__((__unused__)),
SYSPIPE *p, char *dst, int len) {
static int uread_syspipe(TASKP tsk __attribute__((__unused__)), SYSPIPE *p, int *dst, int len) {
int nleft= len, h;
if (len == 0) {
// We'll only get here if we were released from within a
143,8 → 116,9
int ln1 = p->m_mask+1 - p->m_tail; // Navail to be read
ln1 = (ln1 > nleft) ? nleft : ln1;
if (ln1 > 0) {
memcpy(dst, &p->m_buf[p->m_tail], ln1);
dst += ln1;
register int *src = &p->m_buf[p->m_tail];
for(int i=0; i<ln1; i++)
*dst++ = *src++;
 
p->m_nread += ln1;
nleft -= ln1;
170,8 → 144,9
int ln1 = h - p->m_tail;
ln1 = (ln1 < nleft) ? ln1 : nleft;
 
memcpy(dst, &p->m_buf[p->m_tail], ln1);
dst += ln1;
int *src = &p->m_buf[p->m_tail];
for(int i=0; i<ln1; i++)
*dst++ = *src++;
 
p->m_nread += ln1;
nleft -= ln1;
197,8 → 172,7
// pointer. It can change from one time through our loop
// to the next.
if (((volatile SYSPIPE *)p)->m_wrtask) {
int ln;
char *src;
int *src, ln;
 
// If the head changed before the write task blocked,
// then go around again and copy some more before
215,11 → 189,11
ln = nleft;
if (p->m_wrtask->context[4] < nleft)
ln = p->m_wrtask->context[4];
src = (char *)p->m_wrtask->context[3];
memcpy(dst, src, ln);
dst += ln;
src += ln;
src = (int *)p->m_wrtask->context[3];
 
for(int i=0; i<ln; i++)
*dst++ = *src++;
 
p->m_nwritten += ln;
p->m_nread += ln;
 
270,7 → 244,7
}
 
static int uwrite_syspipe(TASKP tsk __attribute__((__unused__)),
SYSPIPE *p, char *src, int len) {
SYSPIPE *p, int *src, int len) {
int nleft = len;
 
// The kernel guarantees, before we come into here, that we have a
289,8 → 263,9
int ln = nleft;
if (ln > p->m_rdtask->context[4])
ln = p->m_rdtask->context[4];
memcpy((char *)p->m_rdtask->context[3], src, ln);
src += ln;
int *dst = (int *)p->m_rdtask->context[3];
for(int i=0; i<ln; i++)
*dst++ = *src++;
p->m_nread += ln;
p->m_rdtask->context[3]+= ln;
p->m_rdtask->context[4]-= ln;
343,17 → 318,34
// so that it remains consistent under interrupt
// conditions.
int ln = p->m_mask+1-p->m_head;
int *dst = &p->m_buf[p->m_head];
if (ln > nleft) ln = nleft;
if (ln > navail) ln = navail;
 
memcpy((void *)&p->m_buf[p->m_head], src, ln);
src += ln;
for(int i=0; i<ln; i++)
*dst++ = *src++;
 
p->m_head = (p->m_head+ln)&p->m_mask;
nleft -= ln;
p->m_nwritten += ln;
navail -= ln;
nleft -= ln;
p->m_nwritten += ln;
navail -= ln;
}
 
/*
// Write into the rest of the pipe
if ((0 == p->m_head)&&(nleft>0)&&(navail>0)) {
int ln = navail;
if (nleft < ln)
ln = nleft;
int *dst = &p->m_buf[p->m_head];
 
for(int i=0; i<ln; i++)
*dst++ = *src++;
 
p->m_head += ln;
p->m_nwritten += ln;
nleft -= ln;
}*/
}
 
if ((nleft > 0)&&(navail == 0)) {
379,7 → 371,7
}
 
// This will be called from a kernel (interrupt) context
void kread_syspipe(TASKP tsk, int dev, char *dst, int len) {
void kread_syspipe(TASKP tsk, int dev, int *dst, int len) {
SYSPIPE *p = (SYSPIPE *)dev;
if (p->m_rdtask != NULL) {
// If the pipe already has a read task, then we fail
423,7 → 415,7
}
}
 
void kwrite_syspipe(TASKP tsk, int dev, char *src, int len) {
void kwrite_syspipe(TASKP tsk, int dev, int *src, int len) {
SYSPIPE *p = (SYSPIPE *)dev;
if (p->m_wrtask != NULL) {
// If the pipe already has a write task, then we fail
/sw/zipos/cmod.ld
34,38 → 34,18
 
MEMORY
{
blkram (wx) : ORIGIN = 0x0004000, LENGTH = 0x0004000
flash (rx) : ORIGIN = 0x1000000, LENGTH = 0x1000000
blkram (wx) : ORIGIN = 0x002000, LENGTH = 0x001000
flash (rx) : ORIGIN = 0x400000, LENGTH = 0x400000
}
 
_flash = ORIGIN(flash);
_blkram = ORIGIN(blkram);
_sdram = 0;
_top_of_stack = ORIGIN(blkram) + LENGTH(blkram) - 4;
_sdram_image_start = 0;
_sdram_image_end = 0;
_top_of_stack = ORIGIN(blkram) + LENGTH(blkram) - 1;
 
SECTIONS
{
.rocode 0x1200000 : {
_boot_address = .;
*(.start) *(.boot)
*(.text*)
*(.rodata*)
*(.strings*)
} > flash
_kernel_image_start = . ;
.data : {
*(.kernel*)
*(.fixdata*)
*(.data*)
*(COMMON*)
_kernel_image_end = . ;
}> blkram AT> flash
_blkram_image_end = . ;
.bss : {
*(.bss*)
_bss_image_end = . ;
} > blkram
_top_of_heap = .;
. = 0x0480000;
.rocode 0x0480000 : { *(.start) *(.text)
*(.rodata)
*(.strings) } > flash
.data : { *(.fixdata) *(.data) *(COMMON) *(.bss) } > blkram
_top_of_heap = .;
}
/sw/zipos/taskp.c
39,7 → 39,6
#include "ksched.h"
#include "kfildes.h"
#include "taskp.h"
#include "txfns.h"
 
extern void *sys_malloc(int sz);
TASKP new_task(unsigned ln, VENTRYP entry) {
48,11 → 47,11
 
for(i=0; (unsigned)i<sizeof(struct TASK_S)+ln; i++)
((unsigned int *)tsk)[i] = 0;
tsk->context[ 0] = (int)(idle_task);
tsk->context[ 0] = (int)((long)(int *)idle_task);
tsk->context[12] = (int)&tsk->user_data[ln]; // Set the stack pointer
tsk->context[13] = (int)&tsk->user_data[ln]; // Set the stack pointer
tsk->context[14] = 0x20; // GIE bit only
tsk->context[15] = (int)((int *)entry);
tsk->context[15] = (int)((long)(int *)entry);
tsk->user_heap = &tsk->user_data[0];
tsk->state = SCHED_READY;
 
/sw/zipos/ziplib.c
5,7 → 5,5
do {
*p++ = c;
} while(n-- > 0);
 
return s;
}
 
/sw/zipos/board.h
59,8 → 59,9
#define INT_BUTTON 0x001
#define INT_BUSERR 0x002 // Kind of useless, a buserr will kill us anyway
#define INT_SCOPE 0x004
#define INT_TIMER 0x010
//#define INT_WATCHDOG 0x020 // Catching a watchdog/reset interrupt makes no sense
#define INT_RTC 0x008 // May not be available, due to lack of space
#define INT_TIMA 0x010
#define INT_TIMB 0x020
#define INT_UARTRX 0x040
#define INT_UARTTX 0x080
#define INT_KEYPAD 0x100
70,8 → 71,6
#define INT_ENABLEV(IN) (INT_ENABLE|((IN)<<16))
#define INT_DISABLEV(IN) ((IN)<<16)
#define INT_CLEAR(IN) (IN)
#define INT_CLEARPIC 0x7fff7fff
#define INT_DALLPIC 0x7fff0000
 
// Clocks per second, for use with the timer
#define TM_ONE_SECOND 80000000
78,46 → 77,50
#define TM_REPEAT 0x80000000
 
typedef struct {
int io_pic;
unsigned *io_buserr;
int io_timer, io_watchdog;
unsigned io_pwm_audio;
unsigned io_spio; // aka keypad, buttons, and keyboard
unsigned io_gpio;
unsigned io_uart;
unsigned io_version;
volatile int io_pic;
volatile unsigned *io_buserr;
volatile int io_tima, io_timb;
volatile unsigned io_pwm_audio;
volatile unsigned io_spio; // aka keypad, buttons, and keyboard
volatile unsigned io_gpio;
volatile unsigned io_uart;
volatile unsigned io_version;
} IOSPACE;
 
// Wishbone scope control
#define TRIGGER_SCOPE_NOW 0x88000000
#define SCOPE_IS_STOPPED 0x40000000
#define DISABLE_TRIGGER 0x84000000
typedef struct {
volatile unsigned s_control, s_data;
} SCOPE;
 
#define WBSCOPE_NO_RESET 0x80000000
#define WBSCOPE_MANUAL WBSCOPE_TRIGGER
//
#define WBSCOPE_STOPPED 0x40000000
#define WBSCOPE_TRIGGERED 0x20000000
#define WBSCOPE_PRIMED 0x10000000
#define WBSCOPE_TRIGGER (0x08000000|WBSCOPE_NO_RESET)
#define WBSCOPE_DISABLED 0x04000000
#define WBSCOPE_DISABLE 0x04000000 // Disable the scope trigger
#define WBSCOPE_RZERO 0x02000000 // Unused,true if ptd at begning
#define WBSCOPE_LGLEN(A) ((A>>20)&0x01f)
#define WBSCOPE_LENGTH(A) (1<<(WBSCOPE_LGLEN(A)))
typedef struct {
volatile unsigned f_crc, f_far_maj, f_far_min, f_fdri,
f_fdro, f_cmd, f_ctl, f_mask,
f_stat, f_lout, f_cor1, f_cor2,
f_pwrdn, f_flr, f_idcode, f_cwdt,
f_hcopt, f_csbo, f_gen1, f_gen2,
f_gen3, f_gen4, f_gen5, f_mode,
f_gwe, f_mfwr, f_cclk, f_seu, f_exp, f_rdbk,
f_bootsts, f_eye, f_cbc;
} FPGACONFIG;
 
typedef struct WBSCOPE_S {
unsigned s_ctrl, s_data;
} WBSCOPE;
typedef struct {
volatile unsigned c_clock, c_timer, c_stopwatch, c_alarm;
} RTCCLOCK;
 
#define IOADDR 0x000400
#define SCOPEADDR 0x000800
// #define FCTLADDR 0x000c00 // Flash control, depends upon write capability
#define RAMADDR 0x004000
#define RAMSZ (RAMADDR)
#define FLASHADDR 0x1000000
#define RESET_ADDR 0x1200000
#define FLASHSZ (FLASHADDR)
#define IOADDR 0x000100
#define SCOPEADDR 0x000200
// #define FCTLADDR 0x000300 // Flash control, depends upon write capability
#define CONFIGADDR 0x000400
// #define RTCADDR 0x000800 // Disabled for lack of space on device
#define RAMADDR 0x002000
#define RAMSZ 0x001000
#define FLASHADDR 0x400000
#define RESET_ADDR 0x480000
#define FLASHSZ 0x400000
 
static volatile IOSPACE *const _sys = (IOSPACE *)IOADDR;
static volatile WBSCOPE *const _scope = (WBSCOPE *)SCOPEADDR;
 
#define valid_ram_region(PTR,LN) (((int)(PTR)>=RAMADDR)&&((int)(PTR+LN)<RAMADDR+RAMSZ))
#define valid_flash_region(PTR,LN) (((int)(PTR)>=FLASHADDR)&&((int)(PTR+LN)<FLASHADDR+FLASHSZ))
#define valid_mem_region(PTR,LN) ((valid_ram_region(PTR,LN))||(valid_flash_region(PTR,LN)))
/sw/host/zipload.cpp
18,7 → 18,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
30,11 → 30,6
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. (It's in the $(ROOT)/doc directory. Run make with no
// target there if the PDF file isn't present.) If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License: GPL, v3, as defined and found on www.gnu.org,
// http://www.gnu.org/licenses/gpl.html
//
42,6 → 37,7
////////////////////////////////////////////////////////////////////////////////
//
//
//
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
59,57 → 55,304
#include "deppi.h"
#include "regdefs.h"
#include "flashdrvr.h"
#include "zipelf.h"
 
bool iself(const char *fname) {
FILE *fp;
bool ret = true;
 
if ((!fname)||(!fname[0]))
return false;
 
fp = fopen(fname, "rb");
 
if (!fp) return false;
if (0x7f != fgetc(fp)) ret = false;
if ('E' != fgetc(fp)) ret = false;
if ('L' != fgetc(fp)) ret = false;
if ('F' != fgetc(fp)) ret = false;
fclose(fp);
return ret;
}
 
long fgetwords(FILE *fp) {
// Return the number of words in the current file, and return the
// file as though it had never been adjusted
long fpos, flen;
fpos = ftell(fp);
if (0 != fseek(fp, 0l, SEEK_END)) {
fprintf(stderr, "ERR: Could not determine file size\n");
perror("O/S Err:");
exit(-2);
} flen = ftell(fp);
if (0 != fseek(fp, fpos, SEEK_SET)) {
fprintf(stderr, "ERR: Could not seek on file\n");
perror("O/S Err:");
exit(-2);
} flen /= sizeof(FPGA::BUSW);
return flen;
}
 
FPGA *m_fpga;
class SECTION {
public:
unsigned m_start, m_len;
FPGA::BUSW m_data[1];
};
 
void usage(void) {
printf("USAGE: zipload [-h] [<bit-file> [<alt-bit-file>]] <zip-program-file>\n");
printf("\n"
"\t-h\tDisplay this usage statement\n"
);
SECTION **singlesection(int nwords) {
fprintf(stderr, "NWORDS = %d\n", nwords);
size_t sz = (2*(sizeof(SECTION)+sizeof(SECTION *))
+(nwords-1)*(sizeof(FPGA::BUSW)));
char *d = (char *)malloc(sz);
SECTION **r = (SECTION **)d;
memset(r, 0, sz);
r[0] = (SECTION *)(&d[2*sizeof(SECTION *)]);
r[0]->m_len = nwords;
r[1] = (SECTION *)(&r[0]->m_data[r[0]->m_len]);
r[0]->m_start = 0;
r[1]->m_start = 0;
r[1]->m_len = 0;
 
return r;
}
 
void skip_bitfile_header(FILE *fp) {
const unsigned SEARCHLN = 204, MATCHLN = 16;
const unsigned char matchstr[MATCHLN] = {
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
//
0xaa, 0x99, 0x55, 0x66 };
unsigned char buf[SEARCHLN];
SECTION **rawsection(const char *fname) {
SECTION **secpp, *secp;
unsigned num_words;
FILE *fp;
int nr;
 
rewind(fp);
fread(buf, sizeof(char), SEARCHLN, fp);
for(int start=0; start+MATCHLN<SEARCHLN; start++) {
int mloc;
fp = fopen(fname, "r");
if (fp == NULL) {
fprintf(stderr, "Could not open: %s\n", fname);
exit(-1);
}
 
// Search backwards, since the starting bytes just aren't that
// interesting.
for(mloc = MATCHLN-1; mloc >= 0; mloc--)
if (buf[start+mloc] != matchstr[mloc])
break;
if (mloc < 0) {
fseek(fp, start, SEEK_SET);
return;
if ((num_words=fgetwords(fp)) > FLASHWORDS-(RESET_ADDRESS-SPIFLASH)) {
fprintf(stderr, "File overruns flash memory\n");
exit(-1);
}
secpp = singlesection(num_words);
secp = secpp[0];
secp->m_start = RAMBASE;
secp->m_len = num_words;
nr= fread(secp->m_data, sizeof(FPGA::BUSW), num_words, fp);
if (nr != (int)num_words) {
fprintf(stderr, "Could not read entire file\n");
perror("O/S Err:");
exit(-2);
} assert(secpp[1]->m_len == 0);
 
return secpp;
}
 
unsigned byteswap(unsigned n) {
unsigned r;
 
r = (n&0x0ff); n>>= 8;
r = (r<<8) | (n&0x0ff); n>>= 8;
r = (r<<8) | (n&0x0ff); n>>= 8;
r = (r<<8) | (n&0x0ff); n>>= 8;
 
return r;
}
 
// #define CHEAP_AND_EASY
#ifdef CHEAP_AND_EASY
#else
#include <libelf.h>
#include <gelf.h>
 
void elfread(const char *fname, unsigned &entry, SECTION **&sections) {
Elf *e;
int fd, i;
size_t n;
char *id;
Elf_Kind ek;
GElf_Ehdr ehdr;
GElf_Phdr phdr;
const bool dbg = false;
 
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "ELF library initialization err, %s\n", elf_errmsg(-1));
perror("O/S Err:");
exit(EXIT_FAILURE);
} if ((fd = open(fname, O_RDONLY, 0)) < 0) {
fprintf(stderr, "Could not open %s\n", fname);
perror("O/S Err:");
exit(EXIT_FAILURE);
} if ((e = elf_begin(fd, ELF_C_READ, NULL))==NULL) {
fprintf(stderr, "Could not run elf_begin, %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
}
 
ek = elf_kind(e);
if (ek == ELF_K_ELF) {
; // This is the kind of file we should expect
} else if (ek == ELF_K_AR) {
fprintf(stderr, "Cannot run an archive!\n");
exit(EXIT_FAILURE);
} else if (ek == ELF_K_NONE) {
;
} else {
fprintf(stderr, "Unexpected ELF file kind!\n");
exit(EXIT_FAILURE);
}
 
if (gelf_getehdr(e, &ehdr) == NULL) {
fprintf(stderr, "getehdr() failed: %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
} if ((i=gelf_getclass(e)) == ELFCLASSNONE) {
fprintf(stderr, "getclass() failed: %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
} if ((id = elf_getident(e, NULL)) == NULL) {
fprintf(stderr, "getident() failed: %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
} if (i != ELFCLASS32) {
fprintf(stderr, "This is a 64-bit ELF file, ZipCPU ELF files are all 32-bit\n");
exit(EXIT_FAILURE);
}
 
if (dbg) {
printf(" %-20s 0x%jx\n", "e_type", (uintmax_t)ehdr.e_type);
printf(" %-20s 0x%jx\n", "e_machine", (uintmax_t)ehdr.e_machine);
printf(" %-20s 0x%jx\n", "e_version", (uintmax_t)ehdr.e_version);
printf(" %-20s 0x%jx\n", "e_entry", (uintmax_t)ehdr.e_entry);
printf(" %-20s 0x%jx\n", "e_phoff", (uintmax_t)ehdr.e_phoff);
printf(" %-20s 0x%jx\n", "e_shoff", (uintmax_t)ehdr.e_shoff);
printf(" %-20s 0x%jx\n", "e_flags", (uintmax_t)ehdr.e_flags);
printf(" %-20s 0x%jx\n", "e_ehsize", (uintmax_t)ehdr.e_ehsize);
printf(" %-20s 0x%jx\n", "e_phentsize", (uintmax_t)ehdr.e_phentsize);
printf(" %-20s 0x%jx\n", "e_shentsize", (uintmax_t)ehdr.e_shentsize);
printf("\n");
}
 
 
// Check whether or not this is an ELF file for the ZipCPU ...
if (ehdr.e_machine != 0x0dadd) {
fprintf(stderr, "This is not a ZipCPU ELF file\n");
exit(EXIT_FAILURE);
}
 
// Get our entry address
entry = ehdr.e_entry;
 
 
// Now, let's go look at the program header
if (elf_getphdrnum(e, &n) != 0) {
fprintf(stderr, "elf_getphdrnum() failed: %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
}
 
unsigned total_octets = 0, current_offset=0, current_section=0;
for(i=0; i<(int)n; i++) {
total_octets += sizeof(SECTION *)+sizeof(SECTION);
 
if (gelf_getphdr(e, i, &phdr) != &phdr) {
fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
}
 
if (dbg) {
printf(" %-20s 0x%x\n", "p_type", phdr.p_type);
printf(" %-20s 0x%jx\n", "p_offset", phdr.p_offset);
printf(" %-20s 0x%jx\n", "p_vaddr", phdr.p_vaddr);
printf(" %-20s 0x%jx\n", "p_paddr", phdr.p_paddr);
printf(" %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);
printf(" %-20s 0x%jx\n", "p_memsz", phdr.p_memsz);
printf(" %-20s 0x%x [", "p_flags", phdr.p_flags);
 
if (phdr.p_flags & PF_X) printf(" Execute");
if (phdr.p_flags & PF_R) printf(" Read");
if (phdr.p_flags & PF_W) printf(" Write");
printf("]\n");
printf(" %-20s 0x%jx\n", "p_align", phdr.p_align);
}
 
total_octets += phdr.p_memsz;
}
 
fprintf(stderr, "Could not find bin-file header within bit file\n");
fclose(fp);
exit(EXIT_FAILURE);
char *d = (char *)malloc(total_octets + sizeof(SECTION)+sizeof(SECTION *));
memset(d, 0, total_octets);
 
SECTION **r = sections = (SECTION **)d;
current_offset = (n+1)*sizeof(SECTION *);
current_section = 0;
 
for(i=0; i<(int)n; i++) {
r[i] = (SECTION *)(&d[current_offset]);
 
if (gelf_getphdr(e, i, &phdr) != &phdr) {
fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));
exit(EXIT_FAILURE);
}
 
if (dbg) {
printf(" %-20s 0x%jx\n", "p_offset", phdr.p_offset);
printf(" %-20s 0x%jx\n", "p_vaddr", phdr.p_vaddr);
printf(" %-20s 0x%jx\n", "p_paddr", phdr.p_paddr);
printf(" %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);
printf(" %-20s 0x%jx\n", "p_memsz", phdr.p_memsz);
printf(" %-20s 0x%x [", "p_flags", phdr.p_flags);
 
if (phdr.p_flags & PF_X) printf(" Execute");
if (phdr.p_flags & PF_R) printf(" Read");
if (phdr.p_flags & PF_W) printf(" Write");
printf("]\n");
 
printf(" %-20s 0x%jx\n", "p_align", phdr.p_align);
}
 
current_section++;
 
r[i]->m_start = phdr.p_paddr;
r[i]->m_len = phdr.p_filesz/ sizeof(FPGA::BUSW);
 
current_offset += phdr.p_memsz + sizeof(SECTION);
 
// Now, let's read in our section ...
if (lseek(fd, phdr.p_offset, SEEK_SET) < 0) {
fprintf(stderr, "Could not seek to file position %08lx\n", phdr.p_offset);
perror("O/S Err:");
exit(EXIT_FAILURE);
} if (phdr.p_filesz > phdr.p_memsz)
phdr.p_filesz = 0;
if (read(fd, r[i]->m_data, phdr.p_filesz) != (int)phdr.p_filesz) {
fprintf(stderr, "Didnt read entire section\n");
perror("O/S Err:");
exit(EXIT_FAILURE);
}
 
// Next, we need to byte swap it from big to little endian
for(unsigned j=0; j<r[i]->m_len; j++)
r[i]->m_data[j] = byteswap(r[i]->m_data[j]);
 
if (dbg) for(unsigned j=0; j<r[i]->m_len; j++)
fprintf(stderr, "ADR[%04x] = %08x\n", r[i]->m_start+j,
r[i]->m_data[j]);
}
 
r[i] = (SECTION *)(&d[current_offset]);
r[current_section]->m_start = 0;
r[current_section]->m_len = 0;
 
elf_end(e);
close(fd);
}
#endif
 
void usage(void) {
printf("USAGE: ziprun [-h] [<bit-file> [<alt-bit-file>]] <zip-program-file>\n");
printf("\n"
"\t-h\tDisplay this usage statement\n");
}
 
int main(int argc, char **argv) {
int skp=0, argn;
bool debug_only = false, verbose = false;
bool ignore_missing_memory = false;
unsigned entry = 0;
int skp=0;
bool permit_raw_files = false, debug_only = false;
unsigned entry = RAMBASE;
FLASHDRVR *flash = NULL;
const char *bitfile = NULL, *altbitfile = NULL, *execfile = NULL;
size_t bitsz;
FILE *fp;
const char *bitfile = NULL, *altbitfile = NULL;
 
if (argc < 2) {
usage();
117,7 → 360,7
}
 
skp=1;
for(argn=0; argn<argc-skp; argn++) {
for(int argn=0; argn<argc-skp; argn++) {
if (argv[argn+skp][0] == '-') {
switch(argv[argn+skp][1]) {
case 'd':
127,8 → 370,8
usage();
exit(EXIT_SUCCESS);
break;
case 'v':
verbose = true;
case 'r':
permit_raw_files = true;
break;
default:
fprintf(stderr, "Unknown option, -%c\n\n",
137,158 → 380,112
exit(EXIT_FAILURE);
break;
} skp++; argn--;
} else {
// Anything here must be either the program to load,
// or a bit file to load
argv[argn] = argv[argn+skp];
} else { // Check for bit files
int sl = strlen(argv[argn+skp]);
if ((sl>4)&&(strcmp(&argv[argn+skp][sl-4],".bit")==0)) {
if (bitfile == NULL)
bitfile = argv[argn+skp];
else if (altbitfile == NULL)
altbitfile = argv[argn+skp];
else {
fprintf(stderr, "Err: Too many bit files listed\n");
exit(EXIT_FAILURE);
} skp++; argn--;
} else
argv[argn] = argv[argn+skp];
}
} argc -= skp;
 
 
for(argn=0; argn<argc; argn++) {
if (iself(argv[argn])) {
if (execfile) {
printf("Too many executable files given, %s and %s\n", execfile, argv[argn]);
usage();
exit(EXIT_FAILURE);
} execfile = argv[argn];
} else { // if (isbitfile(argv[argn]))
if (!bitfile)
bitfile = argv[argn];
else if (!altbitfile)
altbitfile = argv[argn];
else {
printf("Unknown file name or too many files, %s\n", argv[argn]);
usage();
exit(EXIT_FAILURE);
}
}
}
 
if (verbose) {
if (bitfile) printf(" BITFILE: %s\n", bitfile);
if (altbitfile) printf("ABITFILE: %s\n", altbitfile);
if (execfile) printf("EXECTFILE: %s\n", execfile);
}
 
if ((execfile == NULL)&&(bitfile == NULL)) {
printf("No executable or bit file(s) given!\n\n");
usage();
exit(EXIT_FAILURE);
}
 
if ((bitfile == NULL)&&(altbitfile != NULL)) {
printf("Cannot program an alternate bitfile without a main bitfile\n\n");
usage();
exit(EXIT_FAILURE);
}
 
if ((bitfile)&&(access(bitfile,R_OK)!=0)) {
// If there's no code file, or the code file cannot be opened
fprintf(stderr, "Cannot open bitfile, %s\n", bitfile);
exit(EXIT_FAILURE);
}
 
if ((altbitfile)&&(access(altbitfile,R_OK)!=0)) {
// If there's no code file, or the code file cannot be opened
fprintf(stderr, "Cannot open alternate bitfile, %s\n", altbitfile);
} if ((altbitfile)&&(access(altbitfile,R_OK)!=0)) {
fprintf(stderr, "Cannot open alternate bitfile, %s\n",
altbitfile);
exit(EXIT_FAILURE);
} if ((execfile)&&(access(execfile,R_OK)!=0)) {
} if(((!bitfile)&&(argc<=0)) || ((argc>0)&&(access(argv[0],R_OK)!=0))) {
// If there's no code file, or the code file cannot be opened
fprintf(stderr, "Cannot open executable, %s\n\n", execfile);
usage();
if (argc>0)
fprintf(stderr, "Cannot open executable, %s\n", argv[0]);
else
usage();
exit(EXIT_FAILURE);
} else if (!iself(execfile)) {
printf("%s is not an executable file\n\n", execfile);
usage();
exit(EXIT_FAILURE);
}
 
char *fbuf = new char[FLASHLEN];
const char *codef = (argc>0)?argv[0]:NULL;
DEVBUS::BUSW *fbuf = new DEVBUS::BUSW[FLASHWORDS];
 
// Set the flash buffer to all ones
memset(fbuf, -1, FLASHLEN);
memset(fbuf, -1, FLASHWORDS*sizeof(fbuf[0]));
 
if (debug_only) {
m_fpga = NULL;
} else {
char szSel[64];
strcpy(szSel, S6SN);
strcpy(szSel, "SN:210282768825");
m_fpga = new FPGA(new DEPPI(szSel));
}
 
// Make certain we can talk to the FPGA
try {
unsigned v = m_fpga->readio(R_VERSION);
if (v < 0x20170000) {
fprintf(stderr, "Could not communicate with board (invalid version)\n");
exit(EXIT_FAILURE);
}
} catch(BUSERR b) {
fprintf(stderr, "Could not communicate with board (BUSERR when reading VERSION)\n");
exit(EXIT_FAILURE);
}
 
flash = (debug_only)?NULL : new FLASHDRVR(m_fpga);
 
// First, see if we need to load a bit file
if (bitfile) {
int len;
FILE *fp = fopen(bitfile, "rb");
 
fp = fopen(bitfile, "r");
if (strcmp(&argv[argn][strlen(argv[argn])-4],".bit")==0)
skip_bitfile_header(fp);
bitsz = fread(&fbuf[CONFIG_ADDRESS-SPIFLASH],
fseek(fp, 0x5dl, SEEK_SET);
len = fread(&fbuf[CONFIG_ADDRESS-SPIFLASH],
sizeof(fbuf[0]),
FLASHLEN - (CONFIG_ADDRESS-SPIFLASH), fp);
FLASHWORDS-(CONFIG_ADDRESS-SPIFLASH), fp);
assert(len + CONFIG_ADDRESS < ALTCONFIG_ADDRESS);
fclose(fp);
 
try {
printf("Loading: %s\n", bitfile);
flash->write(CONFIG_ADDRESS, bitsz, fbuf, true);
} catch(BUSERR b) {
fprintf(stderr, "BUS-ERR @0x%08x\n", b.addr);
exit(-1);
for(int i=0; i<4; i++) {
// printf("0x%08x\n", fbuf[i]);
assert(fbuf[i] == 0x0ffffffff);
} // printf("0x%08x\n", fbuf[4]);
assert(fbuf[4] == 0x0665599aa);
 
printf("Loading: %s\n", bitfile);
if ((flash)&&(!flash->write(CONFIG_ADDRESS, len, &fbuf[CONFIG_ADDRESS-SPIFLASH], true))) {
fprintf(stderr, "Could not write primary bitfile\n");
exit(EXIT_FAILURE);
}
}
} if (altbitfile) {
int len;
FILE *fp = fopen(altbitfile, "rb");
 
// Then see if we were given an alternate bit file
if (altbitfile) {
size_t altsz;
assert(CONFIG_ADDRESS + bitsz < ALTCONFIG_ADDRESS);
 
fp = fopen(altbitfile, "r");
if (strcmp(&argv[argn][strlen(argv[argn])-4],".bit")==0)
skip_bitfile_header(fp);
altsz = fread(&fbuf[ALTCONFIG_ADDRESS-SPIFLASH],
// The alternate configuration follows the first configuration
len = fread(&fbuf[ALTCONFIG_ADDRESS-SPIFLASH],
sizeof(fbuf[0]),
FLASHLEN-(ALTCONFIG_ADDRESS-SPIFLASH), fp);
assert(ALTCONFIG_ADDRESS+altsz < RESET_ADDRESS);
FLASHWORDS-(ALTCONFIG_ADDRESS-SPIFLASH), fp);
assert(len + ALTCONFIG_ADDRESS < RESET_ADDRESS);
fclose(fp);
printf("Loading: %s\n", altbitfile);
 
try {
printf("Loading: %s\n", altbitfile);
flash->write(ALTCONFIG_ADDRESS, altsz, fbuf, true);
} catch(BUSERR b) {
fprintf(stderr, "BUS-ERR @0x%08x\n", b.addr);
exit(-1);
if ((flash)&&(!flash->write(ALTCONFIG_ADDRESS, len, &fbuf[ALTCONFIG_ADDRESS-SPIFLASH], true))) {
fprintf(stderr, "Could not write alternate bitfile\n");
exit(EXIT_FAILURE);
}
} else {
assert(CONFIG_ADDRESS+bitsz < RESET_ADDRESS);
}
 
if (execfile) try {
ELFSECTION **secpp = NULL, *secp;
if (codef) try {
SECTION **secpp = NULL, *secp;
 
if(iself(execfile)) {
if(iself(codef)) {
// zip-readelf will help with both of these ...
elfread(execfile, entry, secpp);
elfread(codef, entry, secpp);
assert(entry == RESET_ADDRESS);
} else if (permit_raw_files) {
secpp = rawsection(codef);
entry = RESET_ADDRESS;
} else {
fprintf(stderr, "ERR: %s is not in ELF format\n", execfile);
fprintf(stderr, "ERR: %s is not in ELF format\n", codef);
exit(EXIT_FAILURE);
}
 
printf("Loading: %s\n", execfile);
printf("Loading: %s\n", codef);
// assert(secpp[1]->m_len = 0);
for(int i=0; secpp[i]->m_len; i++) {
bool valid = false;
295,13 → 492,16
secp= secpp[i];
if ((secp->m_start >= RESET_ADDRESS)
&&(secp->m_start+secp->m_len
<= SPIFLASH+FLASHLEN))
<= SPIFLASH+FLASHWORDS))
valid = true;
if ((secp->m_start >= RAMBASE)
&&(secp->m_start+secp->m_len
<= RAMBASE+MEMWORDS))
valid = true;
if (!valid) {
fprintf(stderr, "No such memory on board: 0x%08x - %08x\n",
secp->m_start, secp->m_start+secp->m_len);
if (!ignore_missing_memory)
exit(EXIT_FAILURE);
exit(EXIT_FAILURE);
}
}
 
308,34 → 508,28
unsigned startaddr = RESET_ADDRESS, codelen = 0;
for(int i=0; secpp[i]->m_len; i++) {
secp = secpp[i];
 
unsigned start, idx, ln;
 
start = secp->m_start;
idx = 0;
ln = secp->m_len;
if (secp->m_start < SPIFLASH) {
start = SPIFLASH;
idx = SPIFLASH-secp->m_start;
if (idx > secp->m_len)
continue;
ln = secp->m_len-idx;
} if (start + ln > SPIFLASH+FLASHLEN) {
if (start > SPIFLASH+FLASHLEN)
continue;
ln = SPIFLASH+FLASHLEN-start;
if ((secp->m_start >= RAMBASE)
&&(secp->m_start+secp->m_len
<= RAMBASE+MEMWORDS)) {
for(int i=0; (unsigned)i<secp->m_len; i++) {
if (secp->m_data[i] != 0) {
fprintf(stderr, "ERR: Cannot set RAM upon bootup!\n");
fprintf(stderr, "(The bootloaders just not that smart ... yet)\n");
fprintf(stderr, "Attempting to set %08x - %08x\n", secp->m_start, secp->m_start+secp->m_len-1);
fprintf(stderr, "%08x cannot be set to %08x\n", secp->m_start+i, secp->m_data[i]);
exit(EXIT_FAILURE);
}
}
} else {
if (secp->m_start < startaddr) {
codelen += (startaddr-secp->m_start);
startaddr = secp->m_start;
} if (secp->m_start+secp->m_len > startaddr+codelen) {
codelen = secp->m_start+secp->m_len-startaddr;
} memcpy(&fbuf[secp->m_start-SPIFLASH],
secp->m_data,
secp->m_len*sizeof(FPGA::BUSW));
}
 
// We only ever write to the flash
if (start < startaddr) {
// Keep track of the first address in
// flash, as well as the last address
// that we will write
codelen += (startaddr-secp->m_start);
startaddr = secp->m_start;
} if (start+ln > startaddr+codelen) {
codelen = secp->m_start+secp->m_len-startaddr;
} memcpy(&fbuf[start-SPIFLASH], &secp->m_data[idx], ln);
}
if ((flash)&&(!flash->write(startaddr, codelen, &fbuf[startaddr-SPIFLASH], true))) {
fprintf(stderr, "ERR: Could not write program to flash\n");
346,8 → 540,13
if (m_fpga) m_fpga->readio(R_VERSION); // Check for bus errors
 
// Now ... how shall we start this CPU?
printf("The CPU should be fully loaded, you may now start\n");
printf("it. To start the CPU, either toggle power or type\n");
printf("%% wbregs fpgagen1 0 \n");
printf("%% wbregs fpgagen2 0x0300 \n");
printf("%% wbregs fpgacmd 14 \n");
} catch(BUSERR a) {
fprintf(stderr, "S6-BUS error: %08x\n", a.addr);
fprintf(stderr, "XULA-BUS error: %08x\n", a.addr);
exit(-2);
}
 
/sw/host/dumpuart.cpp
54,21 → 54,7
const char *fname = (argc>=3)?argv[2]:NULL;
int ttyfd = -1, dumpfd = -1;
 
if (argc < 2) {
fprintf(stderr, "USAGE: dumpuart /dev/tty... \n");
exit(EXIT_FAILURE);
}
 
ttyfd = open(dev, O_RDONLY);
if (ttyfd < 0) {
fprintf(stderr, "Could not open device, %s\n", dev);
exit(EXIT_FAILURE);
}
if (!isatty(ttyfd)) {
fprintf(stderr, "Err: %s is not a terminal!\n", dev);
exit(EXIT_FAILURE);
}
 
if (fname)
dumpfd = open(fname, O_CREAT|O_TRUNC|O_WRONLY, 0644);
 
/sw/host/flashdrvr.cpp
11,7 → 11,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016-2017, Gisselquist Technology, LLC
// Copyright (C) 2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
23,11 → 23,6
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. (It's in the $(ROOT)/doc directory. Run make with no
// target there if the PDF file isn't present.) If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License: GPL, v3, as defined and found on www.gnu.org,
// http://www.gnu.org/licenses/gpl.html
//
35,9 → 30,9
////////////////////////////////////////////////////////////////////////////////
//
//
//
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <strings.h>
#include <ctype.h>
48,7 → 43,6
#include "devbus.h"
#include "regdefs.h"
#include "flashdrvr.h"
#include "byteswap.h"
 
const bool HIGH_SPEED = false;
 
80,11 → 74,11
}
 
bool FLASHDRVR::erase_sector(const unsigned sector, const bool verify_erase) {
DEVBUS::BUSW page[SZPAGEW];
DEVBUS::BUSW page[SZPAGE];
 
if (m_debug) printf("Erasing sector: %08x\n", sector);
printf("Erasing sector: %08x\n", sector);
m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
m_fpga->writeio(R_QSPI_EREG, ERASEFLAG + (sector>>2));
m_fpga->writeio(R_QSPI_EREG, ERASEFLAG + sector);
 
// If we're in high speed mode and we want to verify the erase, then
// we can skip waiting for the erase to complete by issueing a read
94,21 → 88,19
if ((!HIGH_SPEED)||(!verify_erase)) {
flwait();
 
if (m_debug) {
printf("@%08x -> %08x\n", R_QSPI_EREG,
printf("@%08x -> %08x\n", R_QSPI_EREG,
m_fpga->readio(R_QSPI_EREG));
printf("@%08x -> %08x\n", R_QSPI_SREG,
m_fpga->readio(R_QSPI_SREG));
printf("@%08x -> %08x\n", sector,
printf("@%08x -> %08x\n", R_QSPI_SREG,
m_fpga->readio(R_QSPI_SREG));
printf("@%08x -> %08x\n", sector,
m_fpga->readio(sector));
}
}
 
// Now, let's verify that we erased the sector properly
if (verify_erase) {
for(int i=0; i<NPAGES; i++) {
m_fpga->readi(sector+i*SZPAGEW, SZPAGEW, page);
for(int i=0; i<SZPAGEW; i++)
m_fpga->readi(sector+i*SZPAGE, SZPAGE, page);
for(int i=0; i<SZPAGE; i++)
if (page[i] != 0xffffffff)
return false;
}
117,54 → 109,41
return true;
}
 
bool FLASHDRVR::page_program(const unsigned addr, const unsigned len,
const char *data, const bool verify_write) {
DEVBUS::BUSW buf[SZPAGEW], bswapd[SZPAGEW];
bool FLASHDRVR::write_page(const unsigned addr, const unsigned len,
const unsigned *data, const bool verify_write) {
DEVBUS::BUSW buf[SZPAGE];
 
assert(len > 0);
assert(len <= PGLENB);
assert(len <= PGLEN);
assert(PAGEOF(addr)==PAGEOF(addr+len-1));
 
if (len <= 0)
return true;
 
bool empty_page = true;
for(unsigned i=0; i<len; i+=4) {
DEVBUS::BUSW v;
v = buildword((const unsigned char *)&data[i]);
bswapd[(i>>2)] = v;
if (v != 0xffffffff)
empty_page = false;
}
// Write the page
m_fpga->writeio(R_ICONTROL, ISPIF_DIS);
m_fpga->clear();
m_fpga->writeio(R_ICONTROL, ISPIF_EN);
printf("Writing page: 0x%08x - 0x%08x\n", addr, addr+len-1);
m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
m_fpga->writei(addr, len, data);
 
if (!empty_page) {
// Write the page
m_fpga->writeio(R_ICONTROL, ISPIF_DIS);
m_fpga->clear();
m_fpga->writeio(R_ICONTROL, ISPIF_EN);
printf("Writing page: 0x%08x - 0x%08x\r", addr, addr+len-1);
m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
m_fpga->writei(addr, (len>>2), bswapd);
fflush(stdout);
 
// If we're in high speed mode and we want to verify the write,
// then we can skip waiting for the write to complete by
// issueing a read command immediately. As soon as the write
// completes the read will begin sending commands back. This
// allows us to recover the lost time between the interrupt and
// the next command being received.
flwait();
}
// If we're in high speed mode and we want to verify the write, then
// we can skip waiting for the write to complete by issueing a read
// command immediately. As soon as the write completes the read will
// begin sending commands back. This allows us to recover the lost
// time between the interrupt and the next command being received.
flwait();
// if ((!HIGH_SPEED)||(!verify_write)) { }
if (verify_write) {
// printf("Attempting to verify page\n");
// NOW VERIFY THE PAGE
m_fpga->readi(addr, len>>2, buf);
for(unsigned i=0; i<(len>>2); i++) {
if (buf[i] != bswapd[i]) {
printf("\nVERIFY FAILS[%d]: %08x\n", i, (i<<2)+addr);
m_fpga->readi(addr, len, buf);
for(unsigned i=0; i<len; i++) {
if (buf[i] != data[i]) {
printf("\nVERIFY FAILS[%d]: %08x\n", i, i+addr);
printf("\t(Flash[%d]) %08x != %08x (Goal[%08x])\n",
(i<<2), buf[i], bswapd[i], (i<<2)+addr);
i, buf[i], data[i], i+addr);
return false;
}
} // printf("\nVerify success\n");
172,38 → 151,47
}
 
bool FLASHDRVR::write(const unsigned addr, const unsigned len,
const char *data, const bool verify) {
const unsigned *data, const bool verify) {
// Work through this one sector at a time.
// If this buffer is equal to the sector value(s), go on
// If not, erase the sector
 
for(unsigned s=SECTOROF(addr); s<SECTOROF(addr+len+SECTORSZB-1);
s+=SECTORSZB) {
/*
fprintf(stderr, "FLASH->write(%08x, %d, ..., %s)\n", addr, len,
(verify)?"Verify":"");
*/
// m_fpga->writeio(R_QSPI_CREG, 2);
// m_fpga->readio(R_VERSION); // Read something innocuous
// m_fpga->writeio(R_QSPI_SREG, 0);
// m_fpga->readio(R_VERSION); // Read something innocuous
 
for(unsigned s=SECTOROF(addr); s<SECTOROF(addr+len+SECTORSZ-1); s+=SECTORSZ) {
// printf("IN LOOP, s=%08x\n", s);
// Do we need to erase?
bool need_erase = false, need_program = false;
bool need_erase = false;
unsigned newv = 0; // (s<addr)?addr:s;
{
char *sbuf = new char[SECTORSZB];
const char *dp; // pointer to our "desired" buffer
DEVBUS::BUSW *sbuf = new DEVBUS::BUSW[SECTORSZ];
const DEVBUS::BUSW *dp;
unsigned base,ln;
 
base = (addr>s)?addr:s;
ln=((addr+len>s+SECTORSZB)?(s+SECTORSZB):(addr+len))-base;
m_fpga->readi(base, ln>>2, (uint32_t *)sbuf);
byteswapbuf(ln>>2, (uint32_t *)sbuf);
ln=((addr+len>s+SECTORSZ)?(s+SECTORSZ):(addr+len))-base;
m_fpga->readi(base, ln, sbuf);
 
dp = &data[base-addr];
for(unsigned i=0; i<ln; i++) {
if ((sbuf[i]&dp[i]) != dp[i]) {
if (m_debug) {
printf("\nNEED-ERASE @0x%08x ... %08x != %08x (Goal)\n",
i+base-addr, sbuf[i], dp[i]);
}
printf("\nNEED-ERASE @0x%08x ... %08x != %08x (Goal)\n",
i+base-addr, sbuf[i], dp[i]);
need_erase = true;
newv = (i&-4)+base;
newv = i+base;
break;
} else if ((sbuf[i] != dp[i])&&(newv == 0))
newv = (i&-4)+base;
} else if ((sbuf[i] != dp[i])&&(newv == 0)) {
// if (newv == 0)
// printf("MEM[%08x] = %08x (!= %08x (Goal))\n",
// i+base, sbuf[i], dp[i]);
newv = i+base;
}
}
}
 
210,10 → 198,10
if (newv == 0)
continue; // This sector already matches
 
// Erase the sector if necessary
if (!need_erase) {
if (m_debug) printf("NO ERASE NEEDED\n");
} else {
// Just erase anyway
if (!need_erase)
printf("NO ERASE NEEDED\n");
else {
printf("ERASING SECTOR: %08x\n", s);
if (!erase_sector(s, verify)) {
printf("SECTOR ERASE FAILED!\n");
220,25 → 208,21
return false;
} newv = (s<addr) ? addr : s;
}
 
// Now walk through all of our pages in this sector and write
// to them.
for(unsigned p=newv; (p<s+SECTORSZB)&&(p<addr+len); p=PAGEOF(p+PGLENB)) {
for(unsigned p=newv; (p<s+SECTORSZ)&&(p<addr+len); p=PAGEOF(p+PGLEN)) {
unsigned start = p, len = addr+len-start;
 
// BUT! if we cross page boundaries, we need to clip
// our results to the page boundary
if (PAGEOF(start+len-1)!=PAGEOF(start))
len = PAGEOF(start+PGLENB)-start;
if (!page_program(start, len, &data[p-addr], verify)) {
len = PAGEOF(start+PGLEN)-start;
if (!write_page(start, len, &data[p-addr], verify)) {
printf("WRITE-PAGE FAILED!\n");
return false;
}
} if ((need_erase)||(need_program))
printf("Sector 0x%08x: DONE%15s\n", s, "");
}
}
 
m_fpga->writeio(R_QSPI_EREG, ENABLEWP); // Re-enable write protection
m_fpga->writeio(R_QSPI_EREG, 0); // Re-enable write protection
 
return true;
}
/sw/host/Makefile
39,22 → 39,20
##
##
all:
PROGRAMS := wbregs readflash zipload dumpuart
PROGRAMS := wbregs readflash zipload buildsamples dumpuart
all: $(PROGRAMS)
 
CXX := g++
OBJDIR := obj-pc
# BUSSRCS:= deppbus.cpp regdefs.cpp
BUSSRCS:= deppi.cpp regdefs.cpp llcomms.cpp ttybus.cpp byteswap.cpp
CPUSRCS:= zipelf.cpp
SOURCES:= wbregs.cpp readflash.cpp zipload.cpp flashdrvr.cpp
ALLSRCS:= $(SOURCES) $(CPUSRCS) $(BUSSRCS)
BUSSRCS:= deppi.cpp regdefs.cpp llcomms.cpp ttybus.cpp
SOURCES:= wbregs.cpp readflash.cpp zipload.cpp flashdrvr.cpp # flashload.cpp/ziprun.cpp
ADEPT := ../../../refs/digilent.adept.sdk_2.3.1
HEADERS:= deppbus.h devbus.h flashdrvr.h regdefs.h twoc.h
OBJECTS:= $(addprefix $(OBJDIR)/,$(subst .cpp,.o,$(ALLSRCS)))
OBJECTS:= $(addprefix $(OBJDIR)/,$(subst .cpp,.o,$(SOURCES)))
BUSOBJS:= $(addprefix $(OBJDIR)/,$(subst .cpp,.o,$(BUSSRCS)))
CFLAGS := -g -Wall -I$(ADEPT)/inc -I.
LIBS := -L /usr/local/lib64/digilent/adept -ldmgr -ldepp -ldpcomm -ldftd2xx -ldabs
LIBS := -L /usr/lib64/digilent/adept -ldmgr -ldepp
 
%.o: $(OBJDIR)/ $(OBJDIR)/%.o
$(OBJDIR)/%.o: %.cpp
67,21 → 65,21
wbregs: $(OBJDIR)/wbregs.o $(BUSOBJS)
$(CXX) $(CFLAGS) $^ $(LIBS) -o $@
 
scope: $(OBJDIR)/scope.o $(BUSOBJS)
$(CXX) $(CFLAGS) $^ $(LIBS) -o $@
 
readflash: $(OBJDIR)/readflash.o $(BUSOBJS)
$(CXX) $(CFLAGS) $^ $(LIBS) -o $@
 
zipload: $(OBJDIR)/zipload.o $(OBJDIR)/flashdrvr.o $(BUSOBJS) $(OBJDIR)/zipelf.o
zipload: $(OBJDIR)/zipload.o $(OBJDIR)/flashdrvr.o $(BUSOBJS)
$(CXX) $(CFLAGS) $^ $(LIBS) -lelf -o $@
 
buildsamples: buildsamples.cpp
$(CXX) $(CFLAGS) $^ -o $@
 
dumpuart: dumpuart.cpp
$(CXX) $(CFLAGS) $^ -o $@
 
define build-depends
@echo "Building dependency file(s)"
@$(CXX) $(CFLAGS) -MM $(ALLSRCS) > $(OBJDIR)/xdepends.txt
@$(CXX) $(CFLAGS) -MM $(SOURCES) $(BUSSRCS) > $(OBJDIR)/xdepends.txt
@sed -e 's/^.*.o: /$(OBJDIR)\/&/' < $(OBJDIR)/xdepends.txt > $(OBJDIR)/depends.txt
@rm $(OBJDIR)/xdepends.txt
endef
/sw/host/regdefs.h
4,8 → 4,7
//
// Project: CMod S6 System on a Chip, ZipCPU demonstration project
//
// Purpose: This file defines C constants which can be used when
// communicating with the FPGA device from the PC host.
// Purpose:
//
// Creator: Dan Gisselquist, Ph.D.
// Gisselquist Technology, LLC
12,7 → 11,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
39,41 → 38,78
#ifndef REGDEFS_H
#define REGDEFS_H
 
#define R_ICONTROL 0x00000400
#define R_BUSERR 0x00000404
#define R_ITIMERA 0x00000408
#define R_ITIMERB 0x0000040c
#define R_PWM 0x00000410
#define R_SPIO 0x00000414
#define R_GPIO 0x00000418
#define R_UART 0x0000041c
#define R_VERSION 0x00000420
#define R_VERSION 0x00000108
#define R_ICONTROL 0x00000100
#define R_BUSERR 0x00000101
#define R_ITIMERA 0x00000102
#define R_ITIMERB 0x00000103
#define R_PWM 0x00000104
#define R_SPIO 0x00000105
#define R_GPIO 0x00000106
#define R_UART 0x00000107
 
// WB Scope registers
#define R_SCOPE 0x00000800
#define R_SCOPED 0x00000804
#define R_SCOPE 0x00000200
#define R_SCOPED 0x00000201
//
// And because the flash driver needs these constants defined ...
#define R_QSPI_EREG 0x00000c00
#define R_QSPI_CREG 0x00000c04
#define R_QSPI_SREG 0x00000c08
#define R_QSPI_IDREG 0x00000c0c
#define R_QSPI_EREG 0x0000030c
#define R_QSPI_CREG 0x0000030d
#define R_QSPI_SREG 0x0000030e
#define R_QSPI_IDREG 0x0000030f
//
// FPGA CONFIG/ICAP REGISTERS
#define R_CFG_CRC 0x00000400
#define R_CFG_FAR_MAJ 0x00000401
#define R_CFG_FAR_MIN 0x00000402
#define R_CFG_FDRI 0x00000403
#define R_CFG_FDRO 0x00000404
#define R_CFG_CMD 0x00000405
#define R_CFG_CTL 0x00000406
#define R_CFG_MASK 0x00000407
#define R_CFG_STAT 0x00000408
#define R_CFG_LOUT 0x00000409
#define R_CFG_COR1 0x0000040a
#define R_CFG_COR2 0x0000040b
#define R_CFG_PWRDN 0x0000040c
#define R_CFG_FLR 0x0000040d
#define R_CFG_IDCODE 0x0000040e
#define R_CFG_CWDT 0x0000040f
#define R_CFG_HCOPT 0x00000410
#define R_CFG_CSBO 0x00000412
#define R_CFG_GEN1 0x00000413
#define R_CFG_GEN2 0x00000414
#define R_CFG_GEN3 0x00000415
#define R_CFG_GEN4 0x00000416
#define R_CFG_GEN5 0x00000417
#define R_CFG_MODE 0x00000418
#define R_CFG_GWE 0x00000419
#define R_CFG_GTS 0x0000041a
#define R_CFG_MFWR 0x0000041b
#define R_CFG_CCLK 0x0000041c
#define R_CFG_SEU 0x0000041d
#define R_CFG_EXP 0x0000041e
#define R_CFG_RDBK 0x0000041f
#define R_CFG_BOOTSTS 0x00000420
#define R_CFG_EYE 0x00000421
#define R_CFG_CBC 0x00000422
// RTC clock control
#define R_CLOCK 0x00000800
#define R_TIMER 0x00000801
#define R_STOPWATCH 0x00000802
#define R_CKALARM 0x00000803
 
// RAM memory space
#define LGMEMSZ 14
#define RAMBASE (1<<LGMEMSZ)
#define MEMWORDS (1<<(LGMEMSZ-1))
#define RAMLEN (1<<LGMEMSZ)
#define RAMBASE 0x00002000
#define MEMWORDS (1<<12)
#define RAMLEN MEMWORDS
 
// Flash memory space
#define LGFLASHSZ 24 // Log_2 of the number of bytes in flash
#define SPIFLASH (1<<LGFLASHSZ)
#define FLASHWORDS (1<<(LGFLASHSZ-2))
#define FLASHLEN (1<<LGFLASHSZ)
#define CONFIG_ADDRESS SPIFLASH // Main Xilinx configuration (ZipCPU)
#define ALTCONFIG_ADDRESS (SPIFLASH+0x100000) // Alt Xilinx config (Dbg)
#define RESET_ADDRESS (SPIFLASH+0x200000) // ZipCPU Reset address
#define SPIFLASH 0x00400000
#define FLASHWORDS (1<<22)
#define CONFIG_ADDRESS 0x00400000 // Main Xilinx configuration (ZipCPU)
#define ALTCONFIG_ADDRESS 0x440000 // Alternate Xilinx configuration (Debug)
#define RESET_ADDRESS 0x00480000 // ZipCPU Reset address
 
// Interrupt control constants
#define GIE 0x80000000 // Enable all interrupts
85,24 → 121,19
// Flash control constants
#define ERASEFLAG 0x80000000
#define DISABLEWP 0x10000000
#define ENABLEWP 0x00000000
 
// Sectors are defined as 64 kB (16 kW)
#define SZPAGEB 256
#define PGLENB 256
#define SZPAGEW 64
#define PGLENW 64
#define SZPAGE 64 // 256 bytes
#define PGLEN 64 // 256 bytes
#define NPAGES 256 // 64 kB sectors / 256 bytes is ...
#define SECTORSZB (NPAGES * SZPAGEB) // In bytes, not words!!
#define SECTORSZW (NPAGES * SZPAGEW) // In words
#define NSECTORS (FLASHLEN/SECTORSZB) // 256 sectors
#define SECTOROF(A) ((A) & (-1<<16))
#define PAGEOF(A) ((A) & (-1<<8))
#define SECTORSZ (NPAGES * SZPAGE)
#define NSECTORS (FLASHWORDS/SECTORSZ) // 256 sectors
#define SECTOROF(A) ((A) & (-1<<14)) // 64 kB ea
#define PAGEOF(A) ((A) & (-1<<6))
 
// Scop definition/sequences
#define SCOPE_NO_RESET 0x80000000
#define SCOPE_TRIGGER (0x08000000|SCOPE_NO_RESET)
#define SCOPE_MANUAL SCOPE_TRIGGER
#define SCOPE_DISABLE (0x04000000)
 
typedef struct {
/sw/host/ttybus.h
17,7 → 17,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
30,7 → 30,7
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. (It's in the $(ROOT)/doc directory. Run make with no
// with this program. (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.) If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
91,7 → 91,6
BUSW readword(void); // Reads a word value from the bus
void readv(const BUSW a, const int inc, const int len, BUSW *buf);
void writev(const BUSW a, const int p, const int len, const BUSW *buf);
void readidle(void);
 
int lclread(char *buf, int len);
int lclreadcode(char *buf, int len);
110,8 → 109,8
void close(void) { m_dev->close(); }
void writeio(const BUSW a, const BUSW v);
BUSW readio(const BUSW a);
void readi( const BUSW a, const int len, BUSW *buf);
void readz( const BUSW a, const int len, BUSW *buf);
void readi(const BUSW a, const int len, BUSW *buf);
void readz(const BUSW a, const int len, BUSW *buf);
void writei(const BUSW a, const int len, const BUSW *buf);
void writez(const BUSW a, const int len, const BUSW *buf);
bool poll(void) { return m_interrupt_flag; };
/sw/host/flashdrvr.h
4,8 → 4,7
//
// Project: CMod S6 System on a Chip, ZipCPU demonstration project
//
// Purpose: Flash driver. Encapsulates writing, both erasing sectors and
// the programming pages, to the flash device.
// Purpose: Flash driver. Encapsulate writing to the flash device.
//
// Creator: Dan Gisselquist, Ph.D.
// Gisselquist Technology, LLC
12,7 → 11,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
25,7 → 24,7
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. (It's in the $(ROOT)/doc directory. Run make with no
// with this program. (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.) If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
45,16 → 44,15
class FLASHDRVR {
private:
DEVBUS *m_fpga;
bool m_debug;
 
void flwait(void);
public:
FLASHDRVR(DEVBUS *fpga) : m_fpga(fpga), m_debug(false) {}
FLASHDRVR(DEVBUS *fpga) : m_fpga(fpga) {}
bool erase_sector(const unsigned sector, const bool verify_erase=true);
bool page_program(const unsigned addr, const unsigned len,
const char *data, const bool verify_write=true);
bool write_page(const unsigned addr, const unsigned len,
const unsigned *data, const bool verify_write=true);
bool write(const unsigned addr, const unsigned len,
const char *data, const bool verify=false);
const unsigned *data, const bool verify=false);
};
 
#endif
/sw/host/deppi.cpp
52,67 → 52,14
#include "llcomms.h"
#include "deppi.h"
 
FILE *dbgfp = stderr;
 
DEPPI::DEPPI(const char *szSel) {
if ((!szSel)||(szSel[0] == '\0')) {
// Number of digilent devcies on a system
int pcdvc;
 
// Go fish and try to find the device
DmgrEnumDevices(&pcdvc);
 
if (pcdvc < 0) {
depperr();
exit(EXIT_FAILURE);
}
 
//
int found = 0; // Number of devices found mtg our criteria
DVC dvcinfo; // A structure to receive device info
int foundid=-1; // The id number of the device we found
 
//
for(int devid=0; devid < pcdvc; devid++) {
DmgrGetDvc(devid, &dvcinfo);
// fprintf(dbgfp, "DEVICE NAME: %s\n", dvcinfo.szName);
if (strcmp(dvcinfo.szName, "CmodS6")==0) {
found++;
// fprintf(dbgfp, "Found a CMOD!\n");
foundid = devid;
}
}
 
if (found == 0) {
fprintf(stderr, "No CModS6 devices found\n");
exit(EXIT_FAILURE);
} else if (found > 1) {
fprintf(stderr, "More than one CModS6 device found. Please consider opening your\n");
fprintf(stderr, "device with a valid serial number instead.\n");
exit(EXIT_FAILURE);
}
 
DmgrGetDvc(foundid, &dvcinfo);
if (!DmgrOpen(&m_dev, dvcinfo.szConn)) {
fprintf(stderr, "Could not open device!\n");
depperr();
exit(EXIT_FAILURE);
}
 
//
DmgrFreeDvcEnum();
} else if (!DmgrOpen(&m_dev, (char *)szSel)) {
// We know the device serial number, so go open that particular
// device
fprintf(stderr, "Named device open (DmgrOpen) failed!\n");
depperr();
DEPPI::DEPPI(char *szSel) {
if (!DmgrOpen(&m_dev, szSel)) {
fprintf(stderr, "Open failed!\n");
exit(EXIT_FAILURE);
}
 
if (!DeppEnable(m_dev)) {
fprintf(stderr, "Could not enable DEPP interface to (opened) device\n");
 
depperr();
fprintf(stderr, "Could not enable DEPP interface\n");
exit(EXIT_FAILURE);
}
 
136,15 → 83,10
void DEPPI::depperr(void) {
ERC erc = DmgrGetLastError();
if(erc != ercNoErc) {
char scode[cchErcMax], smsg[cchErcMsgMax];
DmgrSzFromErc(erc, scode, smsg);
fprintf(stderr, "ErrCode(%d): %s\n", erc, scode);
fprintf(stderr, "ErrMessage: %s\n", smsg);
 
if (erc == ercCapabilityConflict) {
fprintf(stderr, "Do you have the hardware manager in Vivado open?\n");
fprintf(stderr, "That could cause this conflict.\n");
}
char scode[cchErcMax], msg[cchErcMsgMax];
DmgrSzFromErc(erc, scode, msg);
fprintf(stderr, "ErrCode : %s\n", scode);
fprintf(stderr, "ErrMessage: %s\n", msg);
close();
exit(EXIT_FAILURE);
}
152,9 → 94,8
 
void DEPPI::write(char *buf, int len) {
bool good = true;
const bool dbg = false;
 
if (dbg) {
if (false) {
// Debug code--write one at a time
fputs("WR: ", stdout);
for(int i=0; i<len; i++) {
174,11 → 115,10
int DEPPI::read(char *buf, int len, int timeout_ms) {
int left = len, nr=0;
struct timespec now, later;
const bool dbg = false;
 
clock_gettime(CLOCK_MONOTONIC, &now);
 
if (dbg) fprintf(dbgfp, "USBI::read(%d) (FIFO is %d-%d)\n", len, m_rend, m_rbeg);
// printf("USBI::read(%d) (FIFO is %d-%d)\n", len, m_rend, m_rbeg);
nr = pop_fifo(buf, left);
left -= nr;
187,7 → 127,7
nr = pop_fifo(&buf[len-left], left);
left -= nr;
 
if (dbg) fprintf(dbgfp, "\tWHILE (nr = %d, LEFT = %d, len=%d)\n", nr, left, len);
// printf("\tWHILE (nr = %d, LEFT = %d, len=%d)\n", nr, left, len);
if (nr == 0)
break;
#define TIMEOUT
211,7 → 151,7
#endif
}
 
if(dbg) fprintf(dbgfp, "READ %d characters (%d req, %d left)\n", len-left, len, left);
// printf("READ %d characters (%d req, %d left)\n", len-left, len, left);
return len-left;
}
 
219,10 → 159,7
int empty = RCV_BUFMASK - ((m_rbeg - m_rend)&(RCV_BUFMASK));
int len = clen;
bool good = true;
const bool dbg = false;
 
 
if (dbg) fprintf(dbgfp, "DEPPI::raw_read(len=%d)\n", clen);
if (len > empty)
len = empty;
if (len > 0) {
240,7 → 177,7
}
} else
good = good && DeppGetRegRepeat(m_dev, 0, (unsigned char *)m_rxbuf, ln, false);
if(dbg) fprintf(dbgfp, "DEPP: Pushing to FIFO\n");
// fprintf(stdout, "Pushing to FIFO\n");
push_fifo(m_rxbuf, ln);
len -= ln;
}
250,39 → 187,31
}
 
void DEPPI::flush_read(void) {
const bool dbg = false;
 
if (dbg) fprintf(dbgfp, "DEPPI::FLUSH-READ()\n");
 
do {
while(poll(4)) {
m_rbeg = m_rend = 0;
} while(poll(4));
 
if (dbg) fprintf(dbgfp, "DEPPI::FLUSH-READ() -- COMPLETE\n");
}
}
 
void DEPPI::push_fifo(char *buf, int len) {
char last = 0;
char *sptr = buf;
const bool dbg = false;
 
if (dbg) fprintf(dbgfp, "DEPP::PUSH(%d)\n", len);
// fprintf(stdout, "PUSH(%d)\n", len);
 
if (m_rbeg != m_rend)
last = m_rbuf[(m_rbeg-1)&RCV_BUFMASK];
if (dbg) fprintf(dbgfp, "DEPPI::PUSH() last=%d, rbeg=%d, rend=%d\n", last, m_rbeg, m_rend);
for(int i=0; i<len; i++) {
char v = *sptr++;
if (((v & 0x80)||((unsigned char)v < 0x10))&&(v == last)) {
// Skipp any stuff bytes
if (dbg) fprintf(dbgfp, "SKIPPING-1: %02x\n", v & 0x0ff);
// fprintf(stderr, "SKIPPING-1: %02x\n", v & 0x0ff);
} else if ((unsigned char)v == 0x0ff) {
// Skipp any not-yet-ready bytes
if (dbg) fprintf(dbgfp, "SKIPPING-2: %02x\n", 0x0ff);
// fprintf(stdout, "SKIPPING-2: %02x\n", 0x0ff);
} else {
m_rbuf[m_rbeg] = v;
if (dbg) fprintf(dbgfp, "PUSHING: 0x%02x \'%c\'\n",
v&0x0ff, isprint(v)?v:'.');
// fprintf(stdout, "PUSHING: %02x %c\n", v&0x0ff,
// isprint(v)?v:'.');
m_rbeg = (m_rbeg+1)&(RCV_BUFMASK);
} last = v;
}
292,10 → 221,9
int avail = (m_rbeg - m_rend)&(RCV_BUFMASK);
int left = len;
int nr = 0;
const bool dbg = false;
 
if (dbg) fprintf(dbgfp, "Attempting to pop %d items from FIFO (%d - %d)\n",
len, m_rend, m_rbeg);
// printf("Attempting to pop %d items from FIFO (%d - %d)\n",
// len, m_rend, m_rbeg);
while((avail > 0)&&(left > 0)) {
int ln = RCV_BUFLEN-m_rend;
if (ln > left)
316,11 → 244,10
bool DEPPI::poll(unsigned ms) {
int avail = (m_rbeg-m_rend)&(RCV_BUFMASK);
bool r = true;
const bool dbg = false;
 
if (dbg) fprintf(dbgfp, "POLL\n");
// printf("POLL\n");
if ((avail < 2)&&((avail<1)||(m_rbuf[m_rend]&0x80)||(m_rbuf[m_rend]<0x10))) {
if (dbg) fprintf(dbgfp, "POLL -- CALLS RAW READ\n");
// printf("POLL -- CALLS RAW READ\n");
raw_read(4,ms);
avail = (m_rbeg-m_rend)&(RCV_BUFMASK);
 
332,7 → 259,7
if (avail == ((m_rbeg-m_rend)&(RCV_BUFMASK)))
break; // We didn't read anything more
avail = (m_rbeg-m_rend)&(RCV_BUFMASK);
if (dbg) fprintf(dbgfp, "POLL/LOOP -- %d available\n", avail);
// printf("POLL/LOOP -- %d available\n", avail);
}
if (avail < 1)
r = false;
340,7 → 267,7
r = false;
} else r = false;
}
if (dbg) fprintf(dbgfp, "POLL -- is %s\n", (r)?"true":"false");
// printf("POLL -- is %s\n", (r)?"true":"false");
 
return r;
}
/sw/host/deppi.h
52,9 → 52,6
#define RCV_BUFLEN 512
#define RCV_BUFMASK (RCV_BUFLEN-1)
 
// #define S6SN "SN:210282768825"
#define S6SN ""
 
#include "llcomms.h"
 
class DEPPI : public LLCOMMSI { // DEPP Interface
72,7 → 69,7
void depperr(void);
 
public:
DEPPI(const char *szSel);
DEPPI(char *szSel);
~DEPPI(void);
 
virtual void close(void);
/sw/host/llcomms.cpp
80,10 → 80,8
}
 
void LLCOMMSI::close(void) {
if(m_fdw>=0)
::close(m_fdw);
if((m_fdr>=0)&&(m_fdr != m_fdw))
::close(m_fdr);
if(m_fdw>=0) ::close(m_fdw);
if((m_fdr>=0)&&(m_fdr != m_fdw)) ::close(m_fdr);
m_fdw = m_fdr = -1;
}
 
99,10 → 97,6
} else return false;
}
 
int LLCOMMSI::available(void) {
return poll(0)?1:0;
}
 
TTYCOMMS::TTYCOMMS(const char *dev) {
m_fdr = ::open(dev, O_RDWR | O_NONBLOCK);
if (m_fdr < 0) {
/sw/host/llcomms.h
55,10 → 55,6
virtual void write(char *buf, int len);
virtual int read(char *buf, int len);
virtual bool poll(unsigned ms);
 
// Tests whether or not bytes are available to be read, returns a
// count of the bytes that may be immediately read
virtual int available(void); // { return 0; };
};
 
class TTYCOMMS : public LLCOMMSI {
/sw/host/wbregs.cpp
105,7 → 105,7
nm = "no name";
 
char szSel[64];
strcpy(szSel, S6SN);
strcpy(szSel, "SN:210282768825");
m_fpga = FPGAOPEN(szSel);
 
if (argc < 2) {
/sw/host/readflash.cpp
72,7 → 72,7
FPGA::BUSW *buf = new FPGA::BUSW[BUFLN];
 
char szSel[64];
strcpy(szSel, S6SN);
strcpy(szSel, "SN:210282768825");
m_fpga = FPGAOPEN(szSel);
 
fprintf(stderr, "Before starting, nread = %ld\n",
/sw/host/ttybus.cpp
1,6 → 1,6
////////////////////////////////////////////////////////////////////////////////
//
// Filename: ttybus.cpp
// Filename: ttybus.cpp
//
// Project: CMod S6 System on a Chip, ZipCPU demonstration project
//
8,9 → 8,9
// with a serial port (through DEPP) on an FPGA, to command the
// WISHBONE on that same FPGA to ... whatever we wish to command it to do.
//
// This code does not run on an FPGA, is not a test bench, neither
// is it a simulator. It is a portion of a command program
// for commanding an FPGA from an attached host computer.
// This code does not run on an FPGA, is not a test bench, neither is it
// a simulator. It is a portion of a command program for commanding an
// FPGA from an attached host computer.
//
// Creator: Dan Gisselquist, Ph.D.
// Gisselquist Technology, LLC
17,7 → 17,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
30,7 → 30,7
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. (It's in the $(ROOT)/doc directory. Run make with no
// with this program. (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.) If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
41,6 → 41,7
////////////////////////////////////////////////////////////////////////////////
//
//
//
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
68,20 → 69,17
#define TTYC_INT '4'
#define TTYC_ERR '5'
 
const unsigned TTYBUS::MAXRDLEN = 64;
const unsigned TTYBUS::MAXRDLEN = 1024;
const unsigned TTYBUS::MAXWRLEN = 32;
 
#define DBGPRINTF null
// #define DBGPRINTF printf
// #define DBGPRINTF filedump
#ifndef DBGPRINTF
#define DBGPRINTF null
#else
#warning "TTYBUS DEBUG IS TURNED ON"
#endif
 
void null(...) {}
 
#include <stdarg.h> // replaces the (defunct) varargs.h include file
#include <stdarg.h>
// #include <varargs.h>
/*
void filedump(const char *fmt, ...) {
static FILE *dbgfp = NULL;
va_list args;
92,13 → 90,8
vfprintf(dbgfp, fmt, args);
va_end(args);
fflush(dbgfp);
 
// If you want the debug output to go to stderr as well, you can
// uncomment the next couple of lines
// va_start(args, fmt);
// vfprintf(stderr, fmt, args);
// va_end(args);
}
*/
 
char TTYBUS::charenc(const int sixbitval) const {
if (sixbitval < 10)
199,16 → 192,7
 
void TTYBUS::writev(const BUSW a, const int p, const int len, const BUSW *buf) {
char *ptr;
int nw = 0;
 
// We'll never be called with more than MAXWRLEN words to write at once.
// This is a configurable option length, set at the top of this file.
// (currently set at 32, but subject to change ...) This is important,
// as the return channel *must* be capable of holding at least this many
// acknowledgments in its buffer.
//
// assert(len <= MAXWRLEN);
 
// Allocate a buffer of six bytes per word, one for addr, plus
// six more
bufalloc((len+2)*6);
218,90 → 202,83
ptr = encode_address(a);
m_lastaddr = a; m_addr_set = true;
 
while(nw < len) {
int ln = len-nw;
if ((unsigned)ln > MAXWRLEN)
ln = MAXWRLEN;
for(int i=0; i<len; i++) {
BUSW val = buf[i];
 
DBGPRINTF("WRITEV-SUB(%08x%s,#%d,&buf[%d])\n", a+nw, (p)?"++":"", ln, nw);
for(int i=0; i<ln; i++) {
BUSW val = buf[nw+i];
 
int caddr = 0;
// Let's try compression
for(int i=1; i<256; i++) {
unsigned tstaddr;
tstaddr = (m_wraddr - i) & 0x0ff;
if ((!m_wrloaded)&&(tstaddr > (unsigned)m_wraddr))
break;
if (m_writetbl[tstaddr] == val) {
caddr = ( m_wraddr- tstaddr ) & 0x0ff;
break;
}
int caddr = 0;
// Let's try compression
for(int i=1; i<256; i++) {
unsigned tstaddr;
tstaddr = (m_wraddr - i) & 0x0ff;
if ((!m_wrloaded)&&(tstaddr > (unsigned)m_wraddr))
break;
if (m_writetbl[tstaddr] == val) {
caddr = ( m_wraddr- tstaddr ) & 0x0ff;
break;
}
}
 
/*
if (caddr != 0)
DBGPRINTF("WR[%08x] = %08x (= TBL[%4x] <= %4x)\n", m_lastaddr, val, caddr, m_wraddr);
else
DBGPRINTF("WR[%08x] = %08x\n", m_lastaddr, val);
*/
 
if (caddr != 0) {
*ptr++ = charenc( (((caddr>>6)&0x03)<<1) + (p?1:0) + 0x010);
*ptr++ = charenc( caddr &0x3f );
if (caddr != 0) {
*ptr++ = charenc( (((caddr>>6)&0x03)<<1) + (p?1:0) + 0x010);
*ptr++ = charenc( caddr &0x3f );
} else {
// For testing, let's start just doing this the hard way
*ptr++ = charenc( (((val>>30)&0x03)<<1) + (p?1:0) + 0x018);
*ptr++ = charenc( (val>>24)&0x3f);
*ptr++ = charenc( (val>>18)&0x3f);
*ptr++ = charenc( (val>>12)&0x3f);
*ptr++ = charenc( (val>> 6)&0x3f);
*ptr++ = charenc( (val )&0x3f);
} else {
// For testing, let's start just doing this the hard way
*ptr++ = charenc( (((val>>30)&0x03)<<1) + (p?1:0) + 0x018);
*ptr++ = charenc( (val>>24)&0x3f);
*ptr++ = charenc( (val>>18)&0x3f);
*ptr++ = charenc( (val>>12)&0x3f);
*ptr++ = charenc( (val>> 6)&0x3f);
*ptr++ = charenc( (val )&0x3f);
 
m_writetbl[m_wraddr++] = val;
m_wraddr &= 0x0ff;
if (m_wraddr == 0) {
m_wrloaded = true;
}
m_writetbl[m_wraddr++] = val;
m_wraddr &= 0x0ff;
if (m_wraddr == 0) {
m_wrloaded = true;
}
 
if (p == 1) m_lastaddr+=4;
}
// *ptr++ = charenc(0x2e);
if (ln == len-nw)
*ptr++ = '\n';
*ptr = '\0';
m_dev->write(m_buf, ptr-m_buf);
DBGPRINTF(">> %s\n", m_buf);
 
readidle();
if (p == 1) m_lastaddr++;
}
// *ptr++ = charenc(0x2e);
*ptr++ = '\n'; *ptr = '\0';
m_dev->write(m_buf, ptr-m_buf);
 
nw += ln;
ptr = m_buf;
}
DBGPRINTF(">> %s\n", m_buf);
DBGPRINTF("WR: LAST ADDRESS LEFT AT %08x\n", m_lastaddr);
 
// Need to clear the incoming queue ... if there's anything there.
// We could do a ...
// readacks(len);
// to clear a known number of acks (up to half the length of our buffer
// which we can let just sit for speed ...), or we could do a ...
// readtilidle(void);
// Then, upon startup we could also start with a readtilidle(); command.
// This would help to clear out the problems between programs, where
// one program doesn't finish reading, and the next gets a confusing
// message.
readidle();
}
 
void TTYBUS::writez(const BUSW a, const int len, const BUSW *buf) {
writev(a, 0, len, buf);
int ln = len;
const TTYBUS::BUSW *bptr = buf;
TTYBUS::BUSW addr = a;
 
while((unsigned)ln > MAXWRLEN) {
writev(addr, 0, MAXWRLEN, bptr);
bptr += MAXWRLEN;
ln -= MAXWRLEN;
// addr += MAXWRLEN;
} if ((unsigned)ln > 0)
writev(addr, 0, ln, bptr);
}
 
void TTYBUS::writei(const BUSW a, const int len, const BUSW *buf) {
writev(a, 1, len, buf);
int ln = len;
const TTYBUS::BUSW *bptr = buf;
TTYBUS::BUSW addr = a;
 
while((unsigned)ln > MAXWRLEN) {
writev(addr, 1, MAXWRLEN, bptr);
bptr += MAXWRLEN;
ln -= MAXWRLEN;
addr += MAXWRLEN;
} if ((unsigned)ln > 0)
writev(addr, 1, ln, bptr);
}
 
TTYBUS::BUSW TTYBUS::readio(const TTYBUS::BUSW a) {
313,7 → 290,6
try {
readv(a, 0, 1, &v);
} catch(BUSERR b) {
DBGPRINTF("BUSERR trying to read %08x\n", a);
throw BUSERR(a);
}
 
328,13 → 304,12
}
 
char *TTYBUS::encode_address(const TTYBUS::BUSW a) {
TTYBUS::BUSW addr = a>>2;
TTYBUS::BUSW addr = a;
char *ptr = m_buf;
 
// Double check that we are aligned
if ((a&3)!=0) {
throw BUSERR(a);
}
// #warning DEBUG_APPROACH
// encode(0, addr, ptr);
// return ptr+6;
 
if ((m_addr_set)&&(a == m_lastaddr))
return ptr;
341,7 → 316,7
if (m_addr_set) {
// Encode a difference address
int diffaddr = (a - m_lastaddr)>>2;
int diffaddr = addr - m_lastaddr;
ptr = m_buf;
if ((diffaddr >= -32)&&(diffaddr < 32)) {
*ptr++ = charenc(0x09);
363,10 → 338,7
*ptr++ = charenc( diffaddr & 0x03f);
}
*ptr = '\0';
DBGPRINTF("DIF-ADDR: (%ld) \'%s\' encodes last_addr(0x%08x) %c %d(0x%08x)\n",
ptr-m_buf, m_buf,
m_lastaddr, (diffaddr<0)?'-':'+',
diffaddr, diffaddr&0x0ffffffff);
DBGPRINTF("DIF-ADDR: (%ld) \'%s\'\n", ptr-m_buf, m_buf);
}
 
{
416,17 → 388,15
char *TTYBUS::readcmd(const int inc, const int len, char *buf) {
char *ptr = buf;
 
DBGPRINTF("READCMD: LEN = %d: ", len);
DBGPRINTF("READCMD: LEN = %d\n", len);
assert(len < 520);
assert(len > 0);
 
if (len <= 8) {
if ((len < 8)||((len == 8)&&(inc))) {
*ptr++ = charenc(0x20 + (((len-1)&0x07)<<1) + (inc?1:0));
DBGPRINTF("%c\n", ptr[-1]);
} else {
*ptr++ = charenc(0x30 + (((len-9)>>5)&0x0e) + (inc?1:0));
*ptr++ = charenc( (len-9) & 0x03f);
DBGPRINTF("%c%c\n", ptr[-2], ptr[-1]);
*ptr++ = charenc(0x30 + (((len-8)>>5)&0x0e) + (inc?1:0));
*ptr++ = charenc( (len-8) & 0x03f);
}
 
return ptr;
433,7 → 403,7
}
 
void TTYBUS::readv(const TTYBUS::BUSW a, const int inc, const int len, TTYBUS::BUSW *buf) {
const int READAHEAD = 0, READBLOCK=(MAXRDLEN/2>512)?512:MAXRDLEN/2;
const int READAHEAD = MAXRDLEN/2, READBLOCK=MAXRDLEN/2;
int cmdrd = 0, nread = 0;
// TTYBUS::BUSW addr = a;
char *ptr = m_buf;
459,28 → 429,23
*ptr++ = '\n'; *ptr = '\0';
m_dev->write(m_buf, (ptr-m_buf));
 
// DBGPRINTF("Reading %d words\n", (cmdrd-nread));
while(nread<(cmdrd-READAHEAD)) {
buf[nread++] = readword();
} ptr = m_buf;
} // DBGPRINTF("Reading %d words, to end the read\n", len-nread);
while(nread<len) {
} while(nread<len) {
buf[nread++] = readword();
}
} catch(BUSERR b) {
DBGPRINTF("READV::BUSERR trying to read %08x\n", a+((inc)?nread:0));
throw BUSERR(a+((inc)?(nread<<2):0));
throw BUSERR(a+((inc)?nread:0));
}
 
if ((unsigned)m_lastaddr != (a+((inc)?(len<<2):0))) {
DBGPRINTF("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len<<2, m_lastaddr, a, (inc)?(len<<2):0);
printf("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len<<2, m_lastaddr, a, (inc)?(len<<2):0);
if ((unsigned)m_lastaddr != (a+((inc)?(len):0))) {
DBGPRINTF("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len, m_lastaddr, a, (inc)?(len):0);
printf("TTYBUS::READV(a=%08x,inc=%d,len=%4x,x) ERR: (Last) %08x != %08x + %08x (Expected)\n", a, inc, len, m_lastaddr, a, (inc)?(len):0);
sleep(1);
assert((int)m_lastaddr == (a+(inc)?(len<<2):0));
assert((int)m_lastaddr == (a+(inc)?(len):0));
exit(-3);
}
 
DBGPRINTF("READV::COMPLETE\n");
}
 
void TTYBUS::readi(const TTYBUS::BUSW a, const int len, TTYBUS::BUSW *buf) {
504,7 → 469,6
do {
nr = lclreadcode(&m_buf[0], 1);
} while (nr < 1);
DBGPRINTF("READWORD: -- lclreadcode, nr = %d, m_buf[0] = %c\n", nr, m_buf[0]);
 
sixbits = chardec(m_buf[0]);
 
519,7 → 483,6
case 2: break; // Write acknowledgement, ignore it here
case 3:
m_bus_err = true;
DBGPRINTF("READWORD::BUSRESET (unknown addr)\n");
throw BUSERR(0);
break;
case 4:
526,7 → 489,6
m_interrupt_flag = true;
break;
case 5:
DBGPRINTF("READWORD::BUSERR (unknown addr)\n");
m_bus_err = true;
throw BUSERR(0);
break;
544,9 → 506,9
val = (val<<6) | (chardec(m_buf[5]) & 0x03f);
 
m_addr_set = true;
m_lastaddr = val<<2;
m_lastaddr = val;
 
DBGPRINTF("RCVD ADDR: 0x%08x\n", val<<2);
DBGPRINTF("RCVD ADDR: 0x%08x\n", val);
} else if (0x0c == (sixbits & 0x03c)) { // Set 32-bit address,compressed
int nw = (sixbits & 0x03) + 2;
do {
570,8 → 532,8
}
 
m_addr_set = true;
m_lastaddr = val<<2;
DBGPRINTF("RCVD ADDR: 0x%08x (%d bytes)\n", val<<2, nw+1);
m_lastaddr = val;
DBGPRINTF("RCVD ADDR: 0x%08x (%d bytes)\n", val, nw+1);
} else
found_start = true;
} while(!found_start);
582,8 → 544,8
if (0x06 == (sixbits & 0x03e)) { // Tbl read, last value
rdaddr = (m_rdaddr-1)&0x03ff;
val = m_readtbl[rdaddr];
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-WORD() -- repeat last value, %08x, A= %08x\n", val, m_lastaddr);
m_lastaddr += (sixbits&1);
DBGPRINTF("READ-WORD() -- repeat last value, %08x\n", val);
} else if (0x10 == (sixbits & 0x030)) { // Tbl read, up to 521 into past
int idx;
do {
594,17 → 556,15
idx = ((idx<<6) | (chardec(m_buf[1]) & 0x03f)) + 2 + 8;
rdaddr = (m_rdaddr-idx)&0x03ff;
val = m_readtbl[rdaddr];
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-WORD() -- long table value[%3d], %08x, A=%08x\n", idx, val, m_lastaddr);
m_lastaddr += (sixbits&1);
DBGPRINTF("READ-WORD() -- long table value[%3d], %08x\n", idx, val);
} else if (0x20 == (sixbits & 0x030)) { // Tbl read, 2-9 into past
int idx;
idx = (((sixbits>>1)&0x07)+2);
rdaddr = (m_rdaddr - idx) & 0x03ff;
rdaddr = (m_rdaddr - (((sixbits>>1)&0x07)+2)) & 0x03ff;
val = m_readtbl[rdaddr];
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-WORD() -- short table value[%3d], %08x, A=%08x\n", idx, val, m_lastaddr);
m_lastaddr += (sixbits&1);
DBGPRINTF("READ-WORD() -- short table value[%3d], %08x\n", rdaddr, val);
} else if (0x38 == (sixbits & 0x038)) { // Raw read
// DBGPRINTF("READ-WORD() -- RAW-READ, nr = %d\n", nr);
DBGPRINTF("READ-WORD() -- RAW-READ, nr = %d\n", nr);
do {
nr += lclreadcode(&m_buf[nr], 6-nr);
} while (nr < 6);
617,10 → 577,10
val = (val<<6) | (chardec(m_buf[5]) & 0x03f);
 
m_readtbl[m_rdaddr++] = val; m_rdaddr &= 0x03ff;
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-WORD() -- RAW-READ %02x:%02x:%02x:%02x:%02x:%02x -- %08x, A=%08x\n",
m_lastaddr += (sixbits&1);
DBGPRINTF("READ-WORD() -- RAW-READ %02x:%02x:%02x:%02x:%02x:%02x -- %08x\n",
m_buf[0], m_buf[1], m_buf[2], m_buf[3],
m_buf[4], m_buf[5], val, m_lastaddr);
m_buf[4], m_buf[5], val);
} else
DBGPRINTF("READ-WORD() -- Unknown character, %02x\n", sixbits);
 
627,146 → 587,6
return val;
}
 
void TTYBUS::readidle(void) {
TTYBUS::BUSW val = 0;
int nr;
unsigned sixbits;
bool found_start = false;
 
DBGPRINTF("READ-IDLE()\n");
 
while((!found_start)&&(m_dev->available())
&&((nr=lclreadcode(&m_buf[0], 1))>0)) {
nr = lclreadcode(&m_buf[0], 1);
sixbits = chardec(m_buf[0]);
 
if (sixbits&(~0x03f)) {
// Ignore new lines, unprintables, and characters
// not a part of our code
;
} else if (sixbits < 6) {
switch(sixbits) {
case 0: break; // Idle -- ignore
case 1: break; // Idle, but the bus is busy
case 2:
// Write acknowledgement, ignore it here
// This is one of the big reasons why we are
// doing this.
break;
case 3:
m_bus_err = true;
DBGPRINTF("READ-IDLE() - BUSERR\n");
throw BUSERR(0);
break;
case 4:
m_interrupt_flag = true;
break;
case 5:
m_bus_err = true;
DBGPRINTF("READ-IDLE() - BUS RESET\n");
throw BUSERR(0);
break;
}
} else if (0x08 == (sixbits & 0x3c)) { // Set 32-bit address
do {
nr += lclreadcode(&m_buf[nr], 6-nr);
} while (nr < 6);
 
val = chardec(m_buf[0]) & 0x03;
val = (val<<6) | (chardec(m_buf[1]) & 0x03f);
val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
val = (val<<6) | (chardec(m_buf[4]) & 0x03f);
val = (val<<6) | (chardec(m_buf[5]) & 0x03f);
 
/* Ignore the address, as we are in readidle();
m_addr_set = true;
m_lastaddr = val;
*/
 
DBGPRINTF("RCVD IDLE-ADDR: 0x%08x\n", val);
} else if (0x0c == (sixbits & 0x03c)) { // Set 32-bit address,compressed
int nw = (sixbits & 0x03) + 2;
do {
nr += lclreadcode(&m_buf[nr], nw-nr);
} while (nr < nw);
 
if (nw == 2) {
val = chardec(m_buf[1]);
} else if (nw == 3) {
val = chardec(m_buf[1]);
val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
} else if (nw == 4) {
val = chardec(m_buf[1]);
val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
} else { // if (nw == 5)
val = chardec(m_buf[1]);
val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
val = (val<<6) | (chardec(m_buf[4]) & 0x03f);
}
 
/* Ignore address, we are in readidle();
m_addr_set = true;
m_lastaddr = val;
*/
DBGPRINTF("RCVD IDLE-ADDR: 0x%08x (%d bytes)\n", val, nw+1);
} else
found_start = true;
}
 
if (found_start) {
// We're in readidle(). We don't expect to find any data.
// But ... we did. So, just read it off and ignore it.
int rdaddr;
 
DBGPRINTF("READ-IDLE() PANIC! -- sixbits = %02x\n", sixbits);
if (0x06 == (sixbits & 0x03e)) { // Tbl read, last value
rdaddr = (m_rdaddr-1)&0x03ff;
val = m_readtbl[rdaddr];
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-IDLE() -- repeat last value, %08x\n", val);
} else if (0x10 == (sixbits & 0x030)) { // Tbl read, up to 521 into past
int idx;
do {
nr += lclreadcode(&m_buf[nr], 2-nr);
} while (nr < 2);
 
idx = (chardec(m_buf[0])>>1) & 0x07;
idx = ((idx<<6) | (chardec(m_buf[1]) & 0x03f)) + 2 + 8;
rdaddr = (m_rdaddr-idx)&0x03ff;
val = m_readtbl[rdaddr];
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-IDLE() -- long table value[%3d], %08x\n", idx, val);
} else if (0x20 == (sixbits & 0x030)) { // Tbl read, 2-9 into past
rdaddr = (m_rdaddr - (((sixbits>>1)&0x07)+2)) & 0x03ff;
val = m_readtbl[rdaddr];
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-IDLE() -- short table value[%3d], %08x\n", rdaddr, val);
} else if (0x38 == (sixbits & 0x038)) { // Raw read
do {
nr += lclreadcode(&m_buf[nr], 6-nr);
} while (nr < 6);
val = (chardec(m_buf[0])>>1) & 0x03;
val = (val<<6) | (chardec(m_buf[1]) & 0x03f);
val = (val<<6) | (chardec(m_buf[2]) & 0x03f);
val = (val<<6) | (chardec(m_buf[3]) & 0x03f);
val = (val<<6) | (chardec(m_buf[4]) & 0x03f);
val = (val<<6) | (chardec(m_buf[5]) & 0x03f);
 
m_readtbl[m_rdaddr++] = val; m_rdaddr &= 0x03ff;
m_lastaddr += (sixbits&1)?4:0;
DBGPRINTF("READ-IDLE() -- RAW-READ %02x:%02x:%02x:%02x:%02x:%02x -- %08x\n",
m_buf[0], m_buf[1], m_buf[2], m_buf[3],
m_buf[4], m_buf[5], val);
} else
DBGPRINTF("READ-IDLE() -- Unknown character, %02x\n", sixbits);
 
}
}
 
void TTYBUS::usleep(unsigned ms) {
if (m_dev->poll(ms)) {
int nr;
/sw/host/regdefs.cpp
78,14 → 78,16
{ R_QSPI_IDREG, "QSPIID" },
{ R_QSPI_IDREG, "QSPII" },
//
// The real-time-clock registers have been removed
// (they never fit in the core)
//
// The real-time-date register has been removed
// (it never fit either)
//
// The wishbone scope
//
{ R_CLOCK, "CLOCK" },
{ R_CLOCK, "TIME" },
{ R_TIMER, "TIMER" },
{ R_STOPWATCH, "STOPWACH" },
{ R_STOPWATCH, "STOPWATCH" },
{ R_CKALARM, "CKALARM" },
{ R_CKALARM, "ALARM" },
// { R_DATE, "DATE" },
// Scopes are defined and come and go. Be aware, therefore, not all
// of these scopes may be defined at the same time.
{ R_SCOPE, "SCOPE" },
{ R_SCOPE, "SCOP" },
{ R_SCOPED, "SCOPDATA" },
93,8 → 95,44
{ R_SCOPED, "SCOPED" },
{ R_SCOPED, "SCOPD" },
//
// The ICAPE interface registers have been removed.
// For working with the ICAPE interface ... if I can ever get a
// testing environment suitable to prove that it works.
//
{ R_CFG_CRC, "FPGACRC" },
{ R_CFG_FAR_MAJ, "FPGAFARH" },
{ R_CFG_FAR_MIN, "FPGAFARL" },
{ R_CFG_FDRI, "FPGAFDRI" },
{ R_CFG_FDRO, "FPGAFDRO" },
{ R_CFG_CMD, "FPGACMD" },
{ R_CFG_CTL, "FPGACTL" },
{ R_CFG_MASK, "FPGAMASK" },
{ R_CFG_STAT, "FPGASTAT" },
{ R_CFG_LOUT, "FPGALOUT" },
{ R_CFG_COR1, "FPGACOR1" },
{ R_CFG_COR2, "FPGACOR2" },
{ R_CFG_PWRDN, "FPGAPWRDN" },
{ R_CFG_FLR, "FPGAFLR" },
{ R_CFG_IDCODE, "FPGAIDCODE" },
{ R_CFG_CWDT, "FPGACWDT" },
{ R_CFG_HCOPT, "FPGAHCOPT" },
{ R_CFG_CSBO, "FPGACSBO" },
{ R_CFG_GEN1, "FPGAGEN1" },
{ R_CFG_GEN2, "FPGAGEN2" },
{ R_CFG_GEN3, "FPGAGEN3" },
{ R_CFG_GEN4, "FPGAGEN4" },
{ R_CFG_GEN5, "FPGAGEN5" },
{ R_CFG_MODE, "FPGAMODE" },
{ R_CFG_GWE, "FPGAGWE" },
{ R_CFG_GTS, "FPGAGTS" },
{ R_CFG_MFWR, "FPGAMFWR" },
{ R_CFG_CCLK, "FPGACCLK" },
{ R_CFG_SEU, "FPGASEU" },
{ R_CFG_EXP, "FPGAEXP" },
{ R_CFG_RDBK, "FPGARDBK" },
{ R_CFG_BOOTSTS, "BOOTSTS" },
{ R_CFG_EYE, "FPGAEYE" },
{ R_CFG_CBC, "FPGACBC" },
//
{ RAMBASE, "MEM" },
{ SPIFLASH, "FLASH" }
};
/sw/dev/keypad.h
11,7 → 11,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
/sw/dev/kptest.c
11,7 → 11,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
38,14 → 38,31
#include "asmstartup.h"
#include "board.h"
#include "keypad.h"
#include "txfns.h"
 
void txchr(char v) {
volatile IOSPACE *sys = (IOSPACE *)IOADDR;
if (v < 10)
return;
v &= 0x07f;
sys->io_pic = INT_UARTTX;
while((sys->io_pic&INT_UARTTX)==0)
;
sys->io_uart = v;
}
 
void txstr(const char *str) {
const char *ptr = str;
while(*ptr) {
txchr(*ptr++);
}
}
 
void entry(void) {
register volatile IOSPACE *const sys = _sys;
register IOSPACE *sys = (IOSPACE *)0x0100;
 
sys->io_pic = 0x07fffffff; // Acknowledge and turn off all interrupts
sys->io_spio = 0x0f0;
sys->io_timer = 100000 | TM_REPEAT;
sys->io_tima = 100000 | TM_REPEAT;
 
txstr("Press any keypad button for test.\r\n");
 
53,15 → 70,15
int ch;
while(0 == (sys->io_pic & INT_KEYPAD))
;
sys->io_pic = INT_KEYPAD | INT_TIMER;
sys->io_pic = INT_KEYPAD | INT_TIMA;
// Wait 5 ms
for(int i=0; i<5; i++) {
while(0 == (sys->io_pic & INT_TIMER))
while(0 == (sys->io_pic & INT_TIMA))
;
}
sys->io_spio = 0x011;
ch = keypadread();
if ((ch < 0)||(ch == -1))
if (ch < 0)
; // txstr("Unknown key pressed or error\n");
else if (ch < 10)
txchr(ch+'0');
69,9 → 86,7
txstr("F\r\n");
else if (ch < 15)
txchr(ch+'A'-10);
else {
txstr("Unknown key pressed\r\n");
}
else txstr("Unknown key pressed\n");
keypad_wait_for_release();
sys->io_spio = 0x010;
}
/sw/dev/Makefile
46,7 → 46,7
##
##
all:
PROGRAMS := helloworld doorbell doorbell2 kptest blinky
PROGRAMS := helloworld doorbell doorbell2 kptest
all: $(OBJDIR)/ $(PROGRAMS)
 
 
60,66 → 60,47
 
# Not for build, for for building tags and dependency files, we need to know
# what the sources and headers are
DEVDRVR:= keypad.c display.c rtcsim.c txfns.c
DEVDRVR:= keypad.c display.c rtcsim.c
SOURCES:= helloworld.c doorbell.c doorbell2.c kptest.c $(DEVDRVR)
HEADERS:= board.h
# OBJECTS:= $(addprefix $(OBJDIR)/,$(subst .cpp,.o,$(SOURCES)))
OBJDRVR := $(addprefix $(OBJDIR)/,$(subst .c,.o,$(DEVDRVR)))
 
 
CPPFLAGS := -I../zipos -I.
DUMPFLAGS := # -fdump-rtl-all
CFLAGS := $(CPPFLAGS) $(DUMPFLAGS) -O3 -Wall -Wextra -nostdlib -fno-builtin -Wa,-nocis
CFLAGS := -O3 -Wall -Wextra -nostdlib -fno-builtin
LDFLAGS = -T cmod.ld -Wl,-Map,$(OBJDIR)/$@.map -Wl,--unresolved-symbols=report-all -nostdlib
 
$(OBJDIR)/:
$(mk-objdir)
@bash -c "if [ ! -e $(OBJDIR) ]; then mkdir -p $(OBJDIR); fi"
 
%.o: $(OBJDIR)/%.o
 
$(OBJDIR)/%.o: %.c
$(mk-objdir)
$(CC) $(CFLAGS) -c $< -o $@
$(OBJDIR)/%.o: ../zipos/%.c
$(mk-objdir)
$(CC) $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/%.s: %.c
$(mk-objdir)
$(CC) -S $(CFLAGS) -c $< -o $@
 
$(OBJDIR)/%.txt: $(OBJDIR)/%.o
$(mk-objdir)
$(OBJDUMP) -dr $^ > $@
%.txt: %
$(OBJDUMP) -Dr $< > $@
 
 
helloworld: $(OBJDIR)/helloworld.o cmod.ld
helloworld: $(OBJDIR)/ $(OBJDIR)/helloworld.o cmod.ld
$(CC) $(LDFLAGS) $(OBJDIR)/helloworld.o -o $@
$(OBJDIR)/helloworld.txt: helloworld
$(OBJDUMP) -dr $^ > $@
 
doorbell: $(OBJDIR)/doorbell.o cmod.ld
$(CC) $(LDFLAGS) $(OBJDIR)/doorbell.o -o $@
 
doorbell2: $(OBJDIR)/doorbell2.o $(OBJDRVR) $(OBJDIR)/string.o cmod.ld
$(CC) $(LDFLAGS) $(OBJDIR)/doorbell2.o $(OBJDRVR) $(OBJDIR)/string.o -o $@
doorbell2: $(OBJDIR)/ $(OBJDIR)/doorbell2.o $(OBJDRVR) cmod.ld
$(CC) $(LDFLAGS) $(OBJDIR)/doorbell2.o $(OBJDRVR) -o $@
$(OBJDIR)/doorbell2.txt: doorbell2
$(OBJDUMP) -dr $^ > $@
 
KPSRCS := kptest.c keypad.c txfns.c
KPOBJS := $(addprefix $(OBJDIR)/,$(subst .c,.o,$(KPSRCS)))
kptest: $(KPOBJS) cmod.ld
$(CC) $(LDFLAGS) $(KPOBJS) -o $@
kptest: $(OBJDIR)/ $(OBJDIR)/kptest.o $(OBJDRVR) cmod.ld
$(CC) $(LDFLAGS) $(OBJDIR)/kptest.o $(OBJDRVR) -o $@
$(OBJDIR)/kptest.txt: kptest
$(OBJDUMP) -dr $^ > $@
 
blinky: $(OBJDIR)/blinky.o cmod.ld
$(CC) $(LDFLAGS) $(OBJDIR)/blinky.o -o $@
 
define mk-objdir
@bash -c "if [ ! -e $(OBJDIR) ]; then mkdir -p $(OBJDIR); fi"
endef
 
define build-depends
@echo "Building dependency file(s)"
$(CC) $(CPPFLAGS) -MM $(SOURCES) > $(OBJDIR)/xdep.txt
/sw/dev/keypad.c
11,7 → 11,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
41,7 → 41,7
#include "../zipos/kfildes.h"
#endif
 
static const char keymap[] = {
static const int keymap[] = {
0x01,0x02,0x03,0x0a,
0x04,0x05,0x06,0x0b,
0x07,0x08,0x09,0x0c,
50,7 → 50,7
 
int keypadread(void) {
int row, col, key;
volatile IOSPACE *const sys = _sys;
IOSPACE *sys = (IOSPACE *)IOADDR;
 
row = sys->io_spio & 0x0f00;
if (row != 0x0f00) {
113,7 → 113,7
}
 
void keypad_wait_for_release(void) {
volatile IOSPACE * const sys = _sys;
IOSPACE *sys = (IOSPACE *)IOADDR;
sys->io_spio = 0x0f00;
while((sys->io_spio & 0x0f00)!=0x0f00)
#ifdef ZIPOS
125,17 → 125,14
 
#ifdef ZIPOS
void keypad_task(void) {
clear(INT_KEYPAD, 0);
clear(INT_KEYPAD);
while(1) {
int key; char ch;
int key;
wait(INT_KEYPAD,-1); // Automatically clears
key = keypadread();
if (key >= 0) {
ch = key;
write(FILENO_STDOUT, &ch, 1);
}
write(FILENO_STDOUT, &key, 1);
// Prepare for the next key
clear(INT_KEYPAD, 0);
clear(INT_KEYPAD);
}
}
#endif
/sw/dev/rtcsim.c
62,10 → 62,11
}
}
}
 
return now;
}
 
static const char days_per_month[] = {
static const int days_per_month[] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
 
73,7 → 74,7
int dy, mo;
 
dy = (today&0x0f)+((today>>4)&0x03)*10;
mo = ((today>>8)&0x0f)+((today&0x0100)?10:0);
mo = ((today>>8)&0x0f)+(today&0x0100)?10:0;
dy = dy+1;
if ((mo>12)||(dy > days_per_month[mo-1])) {
if (mo == 2) {
121,6 → 122,7
if ((today & 0x0f)>=0x0a)
today += 0x06;
}
 
return today;
}
 
131,7 → 133,7
 
void rtctask(void) {
// IOSPACE *sys = (IOSPACE *)IOADDR;
rtcdate = 0x20170408;
rtcdate = 0x20160504;
rtcclock = 0;
while(1) {
unsigned event = wait(SWINT_CLOCK,-1);
/sw/dev/display.c
13,7 → 13,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
55,29 → 55,43
} while(i-->0);
}
 
void dispchar(char ch) {
void dispchar(int ch) {
if (!ch) // Don't display null characters
return;
int ich = ch;
 
// Send the character
for(int i=0; i<8; i++) {
int gpiov = GPOCLRV(GPO_MOSI|GPO_SCK|GPO_SS);
if (ich&0x80)
gpiov |= GPOSETV(GPO_MOSI);
_sys->io_gpio = gpiov;
if (ch&(~0x0ff)) { // Multiple characters to display
int v = (ch>>24)&0x0ff;
if (v) {
dispchar(v);
v = (ch>>16)&0x0ff;
if (v) {
dispchar(v);
v = (ch>> 8)&0x0ff;
if (v) {
dispchar(v);
dispchar(ch&0x0ff);
}
}
}
} else {
IOSPACE *sys = (IOSPACE *)IOADDR;
// Send the character
for(int i=0; i<8; i++) {
int gpiov = GPOCLRV(GPO_MOSI|GPO_SCK|GPO_SS);
if (ch&0x80)
gpiov |= GPOSETV(GPO_MOSI);
sys->io_gpio = gpiov;
dispwait();
sys->io_gpio = GPOSETV(GPO_SCK);
dispwait();
ch<<=1;
}
// Turn off the clock
sys->io_gpio = GPOCLRV(GPO_SCK);
dispwait();
_sys->io_gpio = GPOSETV(GPO_SCK);
// Then the port
sys->io_gpio = GPOSETV(GPO_SS);
dispwait();
ich<<=1;
}
 
// Turn off the clock
_sys->io_gpio = GPOCLRV(GPO_SCK);
dispwait();
// Then the port
_sys->io_gpio = GPOSETV(GPO_SS);
dispwait();
}
 
#ifdef ZIPOS
85,7 → 99,7
#include "../zipos/kfildes.h"
void display_task(void) {
while(1) {
char ch;
int ch;
read(FILENO_STDIN, &ch, 1);
dispchar(ch);
}
/sw/dev/display.h
13,7 → 13,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
40,7 → 40,8
#ifndef DISPLAY_H
#define DISPLAY_H
 
extern void dispchar(char ch);
#define PACK(A,B,C,D) (((A)<<24)|((B)<<16)|((C)<<8)|(D))
extern void dispchar(int ch);
 
#ifdef ZIPOS
extern void displaytask(void);
/sw/dev/cmod.ld
34,18 → 34,18
 
MEMORY
{
blkram (wx) : ORIGIN = 0x0004000, LENGTH = 0x0004000
flash (rx) : ORIGIN = 0x1000000, LENGTH = 0x1000000
blkram (wx) : ORIGIN = 0x002000, LENGTH = 0x001000
flash (rx) : ORIGIN = 0x400000, LENGTH = 0x400000
}
 
_top_of_stack = ORIGIN(blkram) + LENGTH(blkram) - 4;
_top_of_stack = ORIGIN(blkram) + LENGTH(blkram) - 1;
 
SECTIONS
{
. = 0x1200000;
.rocode 0x1200000 : { *(.start) *(.text*)
*(.rodata*)
*(.strings*) } > flash
.data : { *(.fixdata*) *(.data*) *(COMMON*) *(.bss*) } > blkram
. = 0x0480000;
.rocode 0x0480000 : { *(.start) *(.text)
*(.rodata)
*(.strings) } > flash
.data : { *(.fixdata) *(.data) *(COMMON) *(.bss) } > blkram
_top_of_heap = .;
}
/sw/dev/doorbell.c
12,7 → 12,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
44,9 → 44,9
const char msg[] = "Doorbell!\r\n\r\n";
 
void entry(void) {
register volatile IOSPACE *const sys = _sys;
register IOSPACE *sys = (IOSPACE *)0x0100;
 
sys->io_watchdog = 0;
sys->io_timb = 0;
sys->io_pic = 0x07fffffff; // Acknowledge and turn off all interrupts
 
sys->io_spio = 0x0f4;
53,31 → 53,43
sys->io_pwm_audio = 0x0110000;
while(1) {
int seconds = 0, pic;
const unsigned short *ptr;
const int *ptr;
const char *mptr = msg;
sys->io_timer = TM_ONE_SECOND | TM_REPEAT; // Ticks per second, 80M
sys->io_tima = TM_ONE_SECOND | TM_REPEAT; // Ticks per second, 80M
 
sys->io_spio = 0x0f0;
ptr = (const unsigned short *)sound_data;
ptr = sound_data;
sys->io_pwm_audio = 0x0310000;
sys->io_spio = 0x0f1;
while(ptr <(const unsigned short *)&sound_data[NSAMPLE_WORDS]) {
unsigned this_sample;
if (ptr == sound_data)
sys->io_spio = 0x0f1;
while(ptr < &sound_data[NSAMPLE_WORDS]) {
sys->io_spio = 0x022;
do {
pic = sys->io_pic;
if (pic & INT_TIMER)
if (pic & INT_TIMA)
seconds++;
if ((pic & INT_UARTTX)&&(*mptr))
sys->io_uart = *mptr++;
sys->io_pic = (pic & 0x07fff);
} while((pic & INT_AUDIO)==0);
this_sample = (*ptr++); // & 0x0ffff;
sys->io_pwm_audio = this_sample;
sys->io_pwm_audio = (*ptr >> 16)&0x0ffff;
// Now, turn off the audio interrupt since it doesn't
// reset itself ...
sys->io_pic = INT_AUDIO;
} if (ptr >= (const unsigned short *)&sound_data[NSAMPLE_WORDS])
 
do {
pic = sys->io_pic;
if (pic & INT_TIMA)
seconds++;
if ((pic & INT_UARTTX)&&(*mptr))
sys->io_uart = *mptr++;
sys->io_pic = (pic & 0x07fff);
} while((pic & INT_AUDIO)==0);
sys->io_pwm_audio = (*ptr++) & 0x0ffff;
 
// and turn off the audio interrupt again ...
sys->io_pic = INT_AUDIO;
} if (ptr >= &sound_data[NSAMPLE_WORDS])
sys->io_spio = 0x044;
 
sys->io_spio = 0x088;
84,7 → 96,7
sys->io_pwm_audio = 0;
while(seconds < 10) {
pic = sys->io_pic;
if (pic & INT_TIMER)
if (pic & INT_TIMA)
seconds++;
sys->io_pic = (pic & 0x07fff);
}
/sw/dev/doorbell2.c
4,9 → 4,8
//
// Project: CMod S6 System on a Chip, ZipCPU demonstration project
//
// Purpose: A modification to the original doorbell.c program that played
// a doorbell sound every ten seconds. Listening to that test is
// ... getting old.
// Purpose: A modification to the original doorbell.c program.
// seconds. Listening to that test is ... getting old.
//
// Let's let this one do the following:
// 1. Display the time on the display (it will be impossible to
26,7 → 25,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
54,8 → 53,6
#include "board.h"
#include "rtcsim.h"
#include "display.h"
#include "string.h"
#include "txfns.h"
 
#include "samples.c"
 
64,31 → 61,14
void build_dpymsg(char *msg, unsigned clkval);
void build_uartmsg(char *msg, unsigned clkval);
void showval(int val);
void txval(int val);
 
#define CLEAR_WATCHDOG _sys->io_watchdog = 0
#define TOUCH_WATCHDOG _sys->io_watchdog = 500000
 
void entry(void) {
register volatile IOSPACE *const sys = _sys;
char dpymsg[64], *dpyptr;
char uartmsg[160], *uartptr;
register IOSPACE *sys = (IOSPACE *)0x0100;
char dpymsg[16], *dpyptr;
char uartmsg[40], *uartptr;
int newmsgtime = 0, leastmsgtime = -1, lstmsgtime = 0;
 
CLEAR_WATCHDOG;
 
txstr("\r\nREBOOT!\r\n");
txstr("Scope Control = "); txval(_scope->s_ctrl);
if (_scope->s_ctrl & WBSCOPE_STOPPED) {
int ln = WBSCOPE_LENGTH(_scope->s_ctrl);
for(int i=0; i<ln; i++)
txval(_scope->s_data);
txval((int)_sys->io_buserr);
txstr("\r\n\r\nEndScope\r\n");
} else {
txstr("\r\n");
_scope->s_ctrl = 20;
}
 
dpymsg[0] = 0;
dpyptr = dpymsg;
 
96,16 → 76,16
build_uartmsg(uartmsg, 0);
uartptr = uartmsg;
 
sys->io_watchdog = 0;
sys->io_pic = INT_CLEARPIC; // Acknowledge and turn off all interrupts
sys->io_timb = 0;
sys->io_pic = 0x07fffffff; // Acknowledge and turn off all interrupts
 
sys->io_spio = 0x0f4;
newmsgtime = sys->io_timer;
newmsgtime = sys->io_tima;
leastmsgtime = -1;
lstmsgtime = newmsgtime;
while(1) {
int seconds, pic;
const short *sptr;
const int *sptr;
 
// LED's off ... nothing to report
sys->io_spio = 0x0f0;
114,14 → 94,16
sys->io_pwm_audio = 0x0018000;
 
// Set for one ticks per second, 80M clocks per tick
sys->io_timer = TM_ONE_SECOND | TM_REPEAT;
sys->io_tima = TM_ONE_SECOND | TM_REPEAT;
 
// We start by waiting for a doorbell
while(((pic=sys->io_pic) & INT_BUTTON)==0) {
TOUCH_WATCHDOG;
 
if (pic & INT_TIMER) {// top of second
sys->io_pic = INT_TIMER;
if (uartmsg[10] == 0) {
sys->io_spio = 0x0fe;
zip_halt();
}
if (pic & INT_TIMA) {// top of second
sys->io_pic = INT_TIMA;
rtcclock = rtcnext(rtcclock);
 
// Turn all LED off (again)
136,27 → 118,53
 
// Turn one LED on--top of minute
sys->io_spio = 0x0f1;
newmsgtime = sys->io_timer;
newmsgtime = sys->io_tima;
lstmsgtime = -1;
leastmsgtime = -1;
}
}
 
/*
if (uartmsg[10] == 0) {
sys->io_spio = 0x0fc;
zip_halt();
}
*/
if (*uartptr) {
if (pic & INT_UARTTX) {
sys->io_uart = *uartptr++;
sys->io_spio = 0x22;
sys->io_pic = INT_UARTTX;
if (uartptr > &uartmsg[13]) {
sys->io_spio = 0x0fd;
zip_halt();
}
 
if (lstmsgtime != -1) {
int tmp;
tmp = (lstmsgtime-sys->io_timer);
tmp = (lstmsgtime-sys->io_tima);
if ((leastmsgtime<0)||(tmp<leastmsgtime))
leastmsgtime = tmp;
} lstmsgtime = sys->io_timer;
} lstmsgtime = sys->io_tima;
}
} else {
sys->io_spio = 0x20;
/*
if (newmsgtime != 0) {
int thistime = sys->io_tima;
thistime = newmsgtime - thistime;
showval(thistime);
txval(thistime);
txval(leastmsgtime);
txval(lstmsgtime);
zip_halt();
newmsgtime = 0;
}
for(int i=0; i<12; i++)
if (uartmsg[i] == 0) {
sys->io_spio = i+0xf0;
zip_halt();
}
*/
}
if (*dpyptr) {
// This will take a long time. It should be an
166,18 → 174,31
sys->io_spio = 0x44;
} else {
sys->io_spio = 0x40;
} // sys->io_pic = (pic & (INT_TIMER|INT_UARTTX));
} // sys->io_pic = (pic & (INT_TIMA|INT_UARTTX));
}
 
TOUCH_WATCHDOG;
// DOORBELL!!!!!!
// Set the Display message
strcpy(dpymsg, "a[jDoorbell!");
dpymsg[0] = 0x1b;
dpymsg[0] = (0x1b<<24)|('['<<16)|('j'<<8)|'D';
dpymsg[1] = ('o'<<24)|('o'<<16)|('r'<<8)|'b';
dpymsg[2] = ('e'<<24)|('l'<<16)|('l'<<8)|'!';
dpymsg[3] = 0;
dpyptr = dpymsg;
// And the UART message / 18 characters
uartptr = uartmsg;
strcat(uartptr, "\r\nDoorbell!\r\n\r\n");
*uartptr++ = '\r'; *uartptr++ = '\n';
*uartptr++ = 'D';
*uartptr++ = 'o';
*uartptr++ = 'o';
*uartptr++ = 'r';
*uartptr++ = 'b';
*uartptr++ = 'e';
*uartptr++ = 'l';
*uartptr++ = 'l';
*uartptr++ = '!';
*uartptr++ = '\r'; *uartptr++ = '\n';
*uartptr++ = '\r'; *uartptr++ = '\n';
*uartptr++ = '\0';
uartptr = uartmsg;
 
 
187,10 → 208,9
sys->io_pwm_audio = 0x0310000; // Turn on the audio
while(sptr < &sound_data[NSAMPLE_WORDS]) {
do {
TOUCH_WATCHDOG;
pic = sys->io_pic;
if (pic & INT_TIMER) {
sys->io_pic = INT_TIMER;
if (pic & INT_TIMA) {
sys->io_pic = INT_TIMA;
seconds++;
rtcclock = rtcnext(rtcclock);
} if ((pic & INT_UARTTX)&&(*uartptr)) {
204,26 → 224,50
// interruptable task ... but, sigh, we're not
// there yet.
dispchar(*dpyptr++);
sys->io_spio = 0x45;
sys->io_spio = 0x44;
} else
sys->io_spio = 0x40;
} while((pic & INT_AUDIO)==0);
sys->io_pwm_audio = (*sptr++) & 0x0ffff;
sys->io_pwm_audio = (*sptr >> 16)&0x0ffff;
// Now, turn off the audio interrupt since it doesn't
// reset itself ...
sys->io_pic = INT_AUDIO;
 
do {
pic = sys->io_pic;
 
if (pic & INT_TIMA) {
sys->io_pic = INT_TIMA;
seconds++;
rtcclock = rtcnext(rtcclock);
} if ((pic & INT_UARTTX)&&(*uartptr)) {
sys->io_uart = *uartptr++;
sys->io_pic = INT_UARTTX;
sys->io_spio = 0x22;
} else if (!*uartptr)
sys->io_spio = 0x20;
if (*dpyptr) {
// This will take a long time. It should be an
// interruptable task ... but, sigh, we're not
// there yet.
dispchar(*dpyptr++);
sys->io_spio = 0x44;
} else
sys->io_spio = 0x40;
} while((pic & INT_AUDIO)==0);
sys->io_pwm_audio = (*sptr++) & 0x0ffff;
 
// and turn off the audio interrupt again ...
sys->io_pic = INT_AUDIO;
} sys->io_pic = INT_BUTTON;
sys->io_spio = 0x10;
 
TOUCH_WATCHDOG;
// Now we wait for the end of our 30 second window
sys->io_spio = 0x0f8;
sys->io_pwm_audio = 0x018000; // Turn off the Audio device
while(seconds < 30) {
TOUCH_WATCHDOG;
pic = sys->io_pic;
if (pic & INT_TIMER) {
sys->io_pic = INT_TIMER;
if (pic & INT_TIMA) {
sys->io_pic = INT_TIMA;
seconds++;
rtcclock = rtcnext(rtcclock);
} if (pic & INT_BUTTON) {
231,32 → 275,37
seconds = 0;
}
} sys->io_pic = INT_BUTTON;
TOUCH_WATCHDOG;
}
}
 
void build_dpymsg(char *msg, unsigned clk) {
msg[0] = 0x1b;
strcpy(++msg, "[jClock : ");
msg += strlen(msg);
 
*msg++ = (0x1b<<24)|('['<<16)|('j'<<8)|'C'; // Clear, and start 'C'
*msg++ = ('l'<<24)|('o'<<16)|('c'<<8)|'k';
*msg = (' '<<24)|(':'<<16)|(' '<<8);
if ((clk>>20)&0x0f)
*msg++ |= (((clk>>20)&0x0f)+'0');
else
*msg++ |= ' ';
*msg++ = (((clk>>16)&0x0f)+'0');
*msg++ = ':';
*msg++ = (((clk>>12)&0x0f)+'0');
*msg++ = (((clk>> 8)&0x0f)+'0');
*msg++ = ':';
*msg++ = (((clk>> 4)&0x0f)+'0');
*msg++ = (((clk )&0x0f)+'0');
*msg++ = ((((clk>>16)&0x0f)+'0')<<24)
|(':'<<16)
|((((clk>>12)&0x0f)+'0')<< 8) // Minutes
|((((clk>> 8)&0x0f)+'0') );
*msg++ = (':'<<24)
|((((clk>> 4)&0x0f)+'0')<<16) // Seconds
|((((clk )&0x0f)+'0')<< 8);
*msg++ = 0;
*msg++ = 0;
*msg++ = 0;
*msg++ = 0;
}
 
void build_uartmsg(char *msg, unsigned clk) {
strcpy(msg, "Time: ");
msg += strlen(msg);
*msg++ = 'T'; // 0
*msg++ = 'i'; // 1
*msg++ = 'm'; // 2
*msg++ = 'e'; // 3
*msg++ = ':'; // 4
*msg++ = ' ';
*msg++ = ((clk>>20)&0x03)+'0'; // Hrs
*msg++ = ((clk>>16)&0x0f)+'0';
*msg++ = ':';
280,3 → 329,40
dispchar(ch);
}
}
 
void txch(int val) {
register IOSPACE *sys = (IOSPACE *)0x0100;
 
// To read whether or not the transmitter is ready, you must first
// clear the interrupt bit.
sys->io_pic = INT_UARTTX;
for(int i=0; i<5000; i++)
asm("noop");
sys->io_pic = INT_UARTTX;
// If the interrupt bit sets itself again immediately, the transmitter
// is ready. Otherwise, wait until the transmitter becomes ready.
while((sys->io_pic&INT_UARTTX)==0)
;
sys->io_uart = (val&0x0ff);
// Give the transmitter a chance to finish, and then to create an
// interrupt when done
sys->io_pic = INT_UARTTX;
}
 
void txval(int val) {
txch('\r');
txch('\n');
txch('0');
txch('x');
for(int i=28; i>=0; i-=4) {
int ch = ((val>>i)&0x0f)+'0';
if (ch > '9')
ch = ch - '0'+'A'-10;
txch(ch);
}
}
 
// PPONP16P
// 00120O91
// 00120NM3
// 00120E91 = 1183377 ~= 91029 / char, at 0x208d 8333/baud, 83,330 per char
/sw/dev/board.h
59,8 → 59,9
#define INT_BUTTON 0x001
#define INT_BUSERR 0x002 // Kind of useless, a buserr will kill us anyway
#define INT_SCOPE 0x004
#define INT_TIMER 0x010
//#define INT_WATCHDOG 0x020 // Catching a watchdog/reset interrupt makes no sense
#define INT_RTC 0x008 // May not be available, due to lack of space
#define INT_TIMA 0x010
#define INT_TIMB 0x020
#define INT_UARTRX 0x040
#define INT_UARTTX 0x080
#define INT_KEYPAD 0x100
68,10 → 69,8
#define INT_GPIO 0x400
// #define INT_FLASH 0x800 // Not available due to lack of space
#define INT_ENABLEV(IN) (INT_ENABLE|((IN)<<16))
#define INT_DISABLEV(IN) ((IN)<<16)
#define INT_DISABLEV(IN) (INT_ENABLE|((IN)<<16))
#define INT_CLEAR(IN) (IN)
#define INT_CLEARPIC 0x7fff7fff
#define INT_DALLPIC 0x7fff0000
 
// Clocks per second, for use with the timer
#define TM_ONE_SECOND 80000000
78,44 → 77,42
#define TM_REPEAT 0x80000000
 
typedef struct {
int io_pic;
unsigned *io_buserr;
int io_timer, io_watchdog;
unsigned io_pwm_audio;
unsigned io_spio; // aka keypad, buttons, and keyboard
unsigned io_gpio;
unsigned io_uart;
unsigned io_version;
volatile int io_pic;
volatile unsigned *io_buserr;
volatile int io_tima, io_timb;
volatile unsigned io_pwm_audio;
volatile unsigned io_spio; // aka keypad, buttons, and keyboard
volatile unsigned io_gpio;
volatile unsigned io_uart;
volatile unsigned io_version;
} IOSPACE;
 
typedef struct {
volatile unsigned s_control, s_data;
} SCOPE;
 
#define WBSCOPE_NO_RESET 0x80000000
#define WBSCOPE_MANUAL WBSCOPE_TRIGGER
//
#define WBSCOPE_STOPPED 0x40000000
#define WBSCOPE_TRIGGERED 0x20000000
#define WBSCOPE_PRIMED 0x10000000
#define WBSCOPE_TRIGGER (0x08000000|WBSCOPE_NO_RESET)
#define WBSCOPE_DISABLED 0x04000000
#define WBSCOPE_DISABLE 0x04000000 // Disable the scope trigger
#define WBSCOPE_RZERO 0x02000000 // Unused,true if ptd at begning
#define WBSCOPE_LGLEN(A) ((A>>20)&0x01f)
#define WBSCOPE_LENGTH(A) (1<<(WBSCOPE_LGLEN(A)))
typedef struct {
volatile unsigned f_crc, f_far_maj, f_far_min, f_fdri,
f_fdro, f_cmd, f_ctl, f_mask,
f_stat, f_lout, f_cor1, f_cor2,
f_pwrdn, f_flr, f_idcode, f_cwdt,
f_hcopt, f_csbo, f_gen1, f_gen2,
f_gen3, f_gen4, f_gen5, f_mode,
f_gwe, f_mfwr, f_cclk, f_seu, f_exp, f_rdbk,
f_bootsts, f_eye, f_cbc;
} FPGACONFIG;
 
typedef struct WBSCOPE_S {
unsigned s_ctrl, s_data;
} WBSCOPE;
typedef struct {
volatile unsigned c_clock, c_timer, c_stopwatch, c_alarm;
} RTCCLOCK;
 
#define IOADDR 0x000400
#define SCOPEADDR 0x000800
// #define FCTLADDR 0x000c00 // Flash control, depends upon write capability
#define RAMADDR 0x004000
#define RAMSZ (RAMADDR)
#define FLASHADDR 0x1000000
#define RESET_ADDR 0x1200000
#define FLASHSZ (FLASHADDR)
#define IOADDR 0x000100
#define SCOPEADDR 0x000200
// #define FCTLADDR 0x000300 // Flash control, depends upon write capability
#define CONFIGADDR 0x000400
// #define RTCADDR 0x000800 // Disabled for lack of space on device
#define RAMADDR 0x002000
#define FLASHADDR 0x400000
#define RESET_ADDR 0x480000
 
static volatile IOSPACE *const _sys = (IOSPACE *)IOADDR;
static volatile WBSCOPE *const _scope = (WBSCOPE *)SCOPEADDR;
 
#endif
/sw/dev/samples.c
1,1650 → 1,1614
////////////////////////////////////////////////////////////////////////////////
// This file should be copyrighted but I can't find
// the copyright statement.
//
// Filename: samples.cpp
//
// Project: CMod S6 System on a Chip, ZipCPU demonstration project
//
// Purpose: This file defines an array of 16-bit samples that define a
// doorbell sound. Sending these values into a 16-bit sound card
// should therefore produce a pleasant doorbell ding-dong.
//
// Creator: Dan Gisselquist, Ph.D.
// Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.) If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License: GPL, v3, as defined and found on www.gnu.org,
// http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
//
// This file is computer generated--DO NOT EDIT IT! The generator file can
// be found in trunk/sw/host/buildsamples.cpp
// be found in trunk/sw/host/host/buildsamples.cpp
//
//
#ifndef SOUND_DATA_H
#define SOUND_DATA_H
 
const short sound_data[] = {
0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000, 0xffff,
0x0000, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0001, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0001, 0x0000, 0x0000, 0xffff, 0x0000, 0xffff, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0xffff,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0001, 0x0000, 0x0000,
0x0001, 0xffff, 0x0001, 0x0000, 0x0000, 0xffff, 0x0000, 0xffff,
0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
0xffff, 0x0000, 0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0x0000,
0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0xffff,
0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0001, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0001,
0x0001, 0x0000, 0x0000, 0xffff, 0xffff, 0x0001, 0x0000, 0x0000,
0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0xffff, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0001, 0x0000, 0xffff, 0xffff, 0x0001, 0xffff, 0x0000, 0xffff,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0001, 0x0000, 0x0000,
0xffff, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0xffff,
0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000, 0xffff, 0xffff,
0x0001, 0x0000, 0x0000, 0x0000, 0xffff, 0x0001, 0xffff, 0xffff,
0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000,
0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000,
0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0001,
0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000,
0x0000, 0xffff, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000,
0x0000, 0x0001, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0xffff, 0x0000, 0x0001, 0x0001, 0x0000, 0x0000,
0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
0x0000, 0x0001, 0x0001, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000,
0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0xffff, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0xffff, 0xffff, 0xffff, 0x0000, 0x0001, 0x0000, 0x0001, 0x0001,
0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0001,
0xffff, 0xfffe, 0xfffc, 0x0001, 0x0001, 0x0000, 0x0003, 0x0003,
0xfff7, 0xfffc, 0xfffd, 0x0005, 0xfffd, 0xffff, 0x0003, 0x0002,
0x0000, 0x0000, 0xffff, 0x0006, 0xfffd, 0xfffb, 0x000f, 0xfffc,
0xffee, 0xffdb, 0x0007, 0x0015, 0x0005, 0x000e, 0x001e, 0xffda,
0xffdb, 0xffe7, 0x0022, 0xfffb, 0xffda, 0x0010, 0x0010, 0xfffc,
0xffff, 0xfffe, 0x002a, 0x0017, 0xffdd, 0x0030, 0xfff6, 0xffa8,
0xff18, 0xffc7, 0x00c3, 0x0038, 0x0038, 0x00b0, 0xff45, 0xfec6,
0xff3a, 0x0091, 0x00a2, 0xff65, 0x006a, 0x0090, 0xffac, 0x0016,
0xfff6, 0x00dd, 0xffe1, 0xfda5, 0x005f, 0x0140, 0xfe6a, 0xfecb,
0x00b2, 0x009f, 0x0003, 0x00f5, 0x0215, 0xffd2, 0xfdcf, 0xff3c,
0xff89, 0xfd94, 0xff09, 0x0188, 0x01d2, 0x00d7, 0xff74, 0xfedb,
0x0052, 0x014a, 0x033f, 0x01e4, 0xfe77, 0xffa2, 0x0013, 0xfca7,
0xfd74, 0x00f9, 0x0156, 0xfee4, 0xfe78, 0x029f, 0x0145, 0xfd72,
0x02b3, 0x0427, 0xfcdb, 0xfe0b, 0xffe1, 0xfeeb, 0x005e, 0xff99,
0x0011, 0xff57, 0xfa27, 0xfdb5, 0x03bc, 0x03e6, 0x00fb, 0xfd1c,
0xfe6b, 0xfe62, 0xfc0d, 0xfe56, 0xfcbb, 0xf907, 0xfb92, 0xf59b,
0xf60b, 0xfbda, 0x0151, 0x0866, 0x0238, 0xf9cd, 0xfbf7, 0x02fc,
0x037a, 0xfeb0, 0xfec1, 0x0462, 0xfefd, 0xfb06, 0xfdcf, 0xf461,
0xb8d0, 0xd21d, 0x4f19, 0x5ff8, 0x251e, 0x018b, 0xe058, 0xc045,
0xc924, 0xed7f, 0x0da9, 0x1088, 0x1414, 0x32d2, 0x2199, 0xee71,
0xd406, 0xd240, 0xd9b1, 0xd716, 0xf884, 0x1695, 0x251a, 0x2240,
0x1eeb, 0x0522, 0xd02b, 0xc9b8, 0xca02, 0xdffe, 0xfbc6, 0x1929,
0x381b, 0x396e, 0x1e44, 0x098d, 0xf6e0, 0xe0c5, 0xc389, 0xc8c2,
0xf916, 0x13c4, 0x3238, 0x3c90, 0x3c78, 0x19cc, 0xdaed, 0xce05,
0xcfa0, 0xd99a, 0xe37f, 0x036d, 0x2b01, 0x2bc6, 0x2181, 0x1463,
0x0383, 0xd658, 0xc419, 0xcfbf, 0xe21f, 0xf3e7, 0x1428, 0x2976,
0x2dda, 0x1c1d, 0xfb98, 0xe786, 0xc4d3, 0xc791, 0xd573, 0xfd7f,
0x1c6e, 0x2b67, 0x329a, 0x1c12, 0x0a4e, 0xea33, 0xd1ad, 0xd23b,
0xd376, 0xeb17, 0x0bb1, 0x24d3, 0x3c05, 0x3323, 0x1498, 0xf14c,
0xce4f, 0xd159, 0xda08, 0xea13, 0x07f1, 0x2819, 0x3fde, 0x2a87,
0x13ad, 0xf0b0, 0xdca7, 0xc5cc, 0xc148, 0xe5fd, 0xfb32, 0x13ea,
0x2e9d, 0x351f, 0x2021, 0xf568, 0xd957, 0xd5de, 0xc9b1, 0xcb69,
0xf359, 0x1948, 0x2fd1, 0x2d1b, 0x21ff, 0x130b, 0xf178, 0xd511,
0xcfdc, 0xd906, 0xec0d, 0x0b40, 0x24a5, 0x3812, 0x2989, 0x1230,
0xf638, 0xd9b7, 0xc2d0, 0xc566, 0xe079, 0x0128, 0x1fcf, 0x311c,
0x342f, 0x1be7, 0xf51b, 0xdbb1, 0xcc40, 0xc213, 0xd54d, 0xf95e,
0x2302, 0x3314, 0x33ce, 0x237e, 0x04a6, 0xe178, 0xcde9, 0xcd84,
0xd727, 0xf0e6, 0x12b9, 0x3332, 0x3787, 0x2dc0, 0x0f99, 0xec26,
0xd448, 0xc91b, 0xd615, 0xecb1, 0x0ad0, 0x2706, 0x3333, 0x28b6,
0x15c8, 0xf768, 0xd9dc, 0xc218, 0xc0ed, 0xdb49, 0xfbce, 0x1f0d,
0x2e54, 0x3156, 0x1e0a, 0xfea7, 0xe01f, 0xcc96, 0xc61f, 0xd804,
0xfa3b, 0x1b4e, 0x33e5, 0x362a, 0x2cbf, 0x0ae0, 0xe2cb, 0xc719,
0xc203, 0xd012, 0xe884, 0x0e80, 0x2d49, 0x36c4, 0x2a56, 0x11f2,
0xf274, 0xd5f2, 0xc7c8, 0xd3f7, 0xef58, 0x0779, 0x2402, 0x3574,
0x3510, 0x1c0c, 0xf907, 0xdbee, 0xc8e6, 0xc734, 0xda1b, 0xff02,
0x1d0d, 0x2f8f, 0x2f17, 0x1d3c, 0xfc8d, 0xdc29, 0xca39, 0xc701,
0xd79c, 0xf541, 0x1972, 0x3207, 0x34de, 0x2433, 0x0a49, 0xe81e,
0xc998, 0xc067, 0xcdaa, 0xec2d, 0x0dc7, 0x28ed, 0x33cb, 0x2ce4,
0x1434, 0xf5dd, 0xdbb6, 0xca97, 0xcdcc, 0xe58f, 0x0820, 0x23f4,
0x33f3, 0x32e0, 0x1d97, 0xfbd5, 0xd86e, 0xc87d, 0xcd3a, 0xdfd3,
0x00a7, 0x1fc9, 0x3284, 0x31f0, 0x1edd, 0x05df, 0xe63d, 0xcd0b,
0xca7d, 0xda99, 0xf793, 0x1600, 0x2d88, 0x33da, 0x250f, 0x082a,
0xe633, 0xcdc2, 0xc354, 0xcc8a, 0xec47, 0x0cff, 0x23ff, 0x306a,
0x29ea, 0x1245, 0xf120, 0xd581, 0xc906, 0xcd1d, 0xe32a, 0x0710,
0x2686, 0x3536, 0x314f, 0x1bc4, 0xfa5b, 0xd893, 0xc75b, 0xca8e,
0xdf23, 0x013d, 0x2360, 0x35fa, 0x34a5, 0x21b7, 0x047d, 0xe1fa,
0xcabe, 0xc946, 0xdb23, 0xfa22, 0x1918, 0x30c1, 0x3884, 0x272e,
0x064d, 0xe44d, 0xcd1f, 0xc61d, 0xd1eb, 0xefd2, 0x107c, 0x2970,
0x31d4, 0x298e, 0x0f76, 0xeb88, 0xce2a, 0xc482, 0xce56, 0xe6a0,
0x07db, 0x25f6, 0x3646, 0x326b, 0x1c3f, 0xf8bd, 0xd986, 0xc66b,
0xca3c, 0xe3f3, 0x028a, 0x22f4, 0x38c5, 0x39db, 0x2021, 0xfd92,
0xe1d7, 0xcb65, 0xc31c, 0xd560, 0xf941, 0x1931, 0x2cb6, 0x3293,
0x264f, 0x0576, 0xe13d, 0xca97, 0xc538, 0xcef2, 0xeca7, 0x11c4,
0x2ec5, 0x3799, 0x2d60, 0x13d3, 0xf0e0, 0xd2c0, 0xc5cd, 0xcf07,
0xe936, 0x07a1, 0x2717, 0x399f, 0x340d, 0x1af9, 0xf882, 0xdd5a,
0xcabe, 0xcb7b, 0xdedc, 0x00e3, 0x1f5e, 0x3182, 0x312b, 0x1f32,
0xfe07, 0xdc7c, 0xc9d7, 0xc865, 0xd6c0, 0xf3f9, 0x1923, 0x2f7d,
0x35b9, 0x25a7, 0x0885, 0xe650, 0xcb57, 0xc568, 0xd321, 0xef86,
0x1118, 0x2b7c, 0x34fb, 0x2a94, 0x0f6a, 0xed8d, 0xd162, 0xc493,
0xccc0, 0xe674, 0x0805, 0x25a7, 0x3381, 0x2ebe, 0x1888, 0xf702,
0xd754, 0xc4fd, 0xc7ac, 0xddab, 0xfdec, 0x1f39, 0x3395, 0x331d,
0x207f, 0x0224, 0xe289, 0xcd8a, 0xc97e, 0xdaec, 0xf95b, 0x17f7,
0x2fb6, 0x3575, 0x26c1, 0x0877, 0xe66e, 0xce7e, 0xc6f7, 0xd3ac,
0xef48, 0x125d, 0x2e80, 0x3757, 0x2c77, 0x1252, 0xf0bb, 0xd1c6,
0xc584, 0xce0e, 0xe635, 0x0616, 0x236d, 0x3445, 0x2e36, 0x1577,
0xf533, 0xd806, 0xc6d4, 0xc78a, 0xdda5, 0x0011, 0x1df5, 0x2fea,
0x3129, 0x1ddc, 0xfc1c, 0xdb67, 0xc7bd, 0xc681, 0xd7aa, 0xf717,
0x18b7, 0x30db, 0x36b3, 0x27be, 0x09fa, 0xe6c6, 0xcdbe, 0xc75a,
0xd4a2, 0xefbf, 0x11b9, 0x2cb4, 0x3673, 0x2ccc, 0x1187, 0xf033,
0xd2f7, 0xc3f7, 0xcb23, 0xe4df, 0x06b3, 0x24fb, 0x36f3, 0x343a,
0x1baf, 0xfab2, 0xdbe3, 0xc9fe, 0xcc85, 0xdff8, 0xff5f, 0x1f72,
0x3351, 0x326a, 0x209d, 0x0158, 0xdf6c, 0xcb54, 0xc8cb, 0xda42,
0xf6e6, 0x1753, 0x3011, 0x357e, 0x24b1, 0x05ba, 0xe4f8, 0xccae,
0xc4dc, 0xcffc, 0xedb9, 0x0e9d, 0x27e0, 0x3209, 0x275a, 0x0d5d,
0xede1, 0xd29d, 0xc741, 0xcf95, 0xe843, 0x08a6, 0x24f0, 0x338e,
0x2e69, 0x1888, 0xf753, 0xda6a, 0xca56, 0xcbda, 0xe044, 0x007a,
0x209b, 0x3288, 0x33be, 0x21fc, 0x01ab, 0xe19c, 0xcc8b, 0xca2b,
0xd9db, 0xf678, 0x17dc, 0x2ef0, 0x3515, 0x264a, 0x08d3, 0xe73a,
0xce8b, 0xc78a, 0xd3c6, 0xf02f, 0x1131, 0x2bd2, 0x3556, 0x29ec,
0x0f0b, 0xeda2, 0xd249, 0xc6d0, 0xcd21, 0xe528, 0x05c0, 0x244b,
0x32fa, 0x2ef7, 0x1852, 0xf6ec, 0xda85, 0xc8ab, 0xcaaa, 0xe09c,
0xffd5, 0x1f4a, 0x32ad, 0x3248, 0x1f77, 0x000f, 0xe0d2, 0xcbbd,
0xc9a7, 0xdabd, 0xf985, 0x1a82, 0x2ffc, 0x3423, 0x251b, 0x082a,
0xe71b, 0xced2, 0xc7e0, 0xd4e6, 0xf082, 0x1135, 0x2af0, 0x349e,
0x2b25, 0x0fd2, 0xef25, 0xd379, 0xc7cf, 0xcfb3, 0xe994, 0x09c1,
0x258e, 0x32e5, 0x2ca9, 0x1561, 0xf425, 0xd6c7, 0xc6c2, 0xcad6,
0xdf14, 0x0040, 0x1ee9, 0x3193, 0x30f9, 0x1e95, 0xfe94, 0xdec4,
0xcc14, 0xcac0, 0xdd4e, 0xfb00, 0x1b24, 0x303e, 0x3298, 0x2264,
0x04ef, 0xe4b3, 0xcdae, 0xc7fe, 0xd6e3, 0xf29f, 0x1439, 0x2d2b,
0x3545, 0x2978, 0x0f98, 0xeebe, 0xd2d9, 0xc86a, 0xd0e1, 0xe96e,
0x09d2, 0x25b5, 0x328b, 0x2c63, 0x154b, 0xf568, 0xd7af, 0xc888,
0xcc34, 0xe460, 0x02ff, 0x1ffd, 0x31bc, 0x3052, 0x1cfb, 0xfd64,
0xdeba, 0xcb1c, 0xca41, 0xdc83, 0xfaa6, 0x1958, 0x2e4e, 0x3261,
0x2253, 0x0490, 0xe399, 0xcc89, 0xc896, 0xd6d9, 0xf28b, 0x1242,
0x2b92, 0x3386, 0x287d, 0x0da9, 0xecdd, 0xd345, 0xc8d2, 0xd22c,
0xeb7e, 0x0a32, 0x2674, 0x34b6, 0x2e71, 0x1636, 0xf5cb, 0xd8df,
0xc938, 0xcc8d, 0xe1fa, 0x024d, 0x2114, 0x33c1, 0x321b, 0x1d4d,
0xfd9e, 0xdf0f, 0xcb53, 0xcbdc, 0xddc4, 0xfbed, 0x1b20, 0x2e8f,
0x3214, 0x216e, 0x03de, 0xe431, 0xccd1, 0xc6ad, 0xd451, 0xf0cc,
0x11f8, 0x2bd9, 0x347f, 0x2946, 0x0dc8, 0xec37, 0xd13e, 0xc640,
0xcffe, 0xea0f, 0x0a64, 0x268c, 0x343b, 0x2e84, 0x17c9, 0xf672,
0xd9d2, 0xcaed, 0xcf3d, 0xe4e1, 0x03f5, 0x21ee, 0x32a2, 0x30da,
0x1bfd, 0xfcf0, 0xddfd, 0xcaf8, 0xca8d, 0xdd0d, 0xfaa7, 0x1948,
0x2f2a, 0x3320, 0x22fa, 0x0546, 0xe549, 0xce12, 0xc988, 0xd7b6,
0xf2e2, 0x132d, 0x2c4e, 0x3437, 0x2843, 0x0c62, 0xec03, 0xd292,
0xc7ca, 0xd111, 0xeb53, 0x0c04, 0x27db, 0x34b7, 0x2d85, 0x155f,
0xf569, 0xd916, 0xcb0a, 0xcf56, 0xe519, 0x048e, 0x1fa3, 0x2f75,
0x2dd3, 0x1a35, 0xfb9d, 0xdd42, 0xcbb1, 0xcb85, 0xdea7, 0xfca0,
0x1b7e, 0x2fd8, 0x3236, 0x21b5, 0x0270, 0xe25b, 0xcc73, 0xc894,
0xd7e1, 0xf418, 0x138f, 0x2c2f, 0x33b3, 0x274a, 0x0bd0, 0xeb09,
0xd231, 0xc90c, 0xd2ce, 0xecb0, 0x0d35, 0x28d0, 0x33e1, 0x2bb5,
0x1354, 0xf2d3, 0xd67e, 0xc8f9, 0xce7d, 0xe504, 0x04e7, 0x2261,
0x32ac, 0x309b, 0x1c19, 0xfc53, 0xde26, 0xcae4, 0xcc39, 0xdfa1,
0xfe0f, 0x1cfc, 0x30f0, 0x32ef, 0x20d9, 0x0299, 0xe381, 0xce15,
0xc9eb, 0xd968, 0xf559, 0x143e, 0x2b8e, 0x3245, 0x24e7, 0x0842,
0xe855, 0xcf3e, 0xc621, 0xd1df, 0xed12, 0x0d9b, 0x291b, 0x34a8,
0x2b87, 0x1251, 0xf29a, 0xd5ab, 0xc83d, 0xcef4, 0xe57f, 0x05e8,
0x2138, 0x30e4, 0x2e2f, 0x190f, 0xfabe, 0xdcde, 0xcb02, 0xcce3,
0xe0d8, 0xfe6b, 0x1d84, 0x3172, 0x335b, 0x21e2, 0x0353, 0xe366,
0xcc6d, 0xc756, 0xd68f, 0xf372, 0x1358, 0x2bc7, 0x31d9, 0x2527,
0x0a3c, 0xe9ab, 0xd111, 0xc94a, 0xd55b, 0xef62, 0x0f6e, 0x2930,
0x3465, 0x2b2d, 0x10ef, 0xf070, 0xd3d3, 0xc74e, 0xce7c, 0xe5f3,
0x06a8, 0x256b, 0x34aa, 0x312d, 0x1b04, 0xfa45, 0xdc1c, 0xcad4,
0xcc55, 0xe003, 0xfdd2, 0x1a16, 0x2df6, 0x2ed0, 0x1dc0, 0xffb8,
0xe0a0, 0xcc63, 0xc840, 0xd923, 0xf650, 0x17da, 0x2ec0, 0x348c,
0x26bb, 0x0a1c, 0xe9af, 0xcfc7, 0xc8cc, 0xd2c8, 0xed42, 0x0e1c,
0x2795, 0x3267, 0x28b8, 0x0fd1, 0xf044, 0xd4bf, 0xc8d2, 0xcf5e,
0xe745, 0x0862, 0x2539, 0x33cb, 0x2eab, 0x18cf, 0xf8d7, 0xda83,
0xcb14, 0xcc8d, 0xe002, 0xfea9, 0x1def, 0x3081, 0x3126, 0x1ff1,
0x015f, 0xe2ec, 0xcc85, 0xca21, 0xdab5, 0xf727, 0x1635, 0x2d01,
0x327e, 0x2529, 0x09b1, 0xe913, 0xcfe1, 0xc79d, 0xd379, 0xee3d,
0x0e19, 0x27cf, 0x32fd, 0x291b, 0x0f92, 0xeef6, 0xd390, 0xc6b1,
0xcd90, 0xe658, 0x0736, 0x240d, 0x3336, 0x2fb8, 0x19fb, 0xfa97,
0xdc63, 0xcb04, 0xcd2d, 0xe0bd, 0xfe0f, 0x1bd3, 0x2f09, 0x3008,
0x1daf, 0x0041, 0xe0b8, 0xcc2d, 0xc951, 0xd899, 0xf5b2, 0x1675,
0x2d9d, 0x345f, 0x2711, 0x0ad5, 0xeb01, 0xd1d4, 0xc9cd, 0xd44f,
0xeeef, 0x0d30, 0x2697, 0x31a0, 0x293c, 0x0f98, 0xeff0, 0xd583,
0xc9a0, 0xcfd3, 0xe7c8, 0x083d, 0x2480, 0x3369, 0x2dc3, 0x185b,
0xf874, 0xdb58, 0xca82, 0xcc38, 0xe0c4, 0xfe69, 0x1c4e, 0x2ffd,
0x30be, 0x1f03, 0x011b, 0xe288, 0xcd13, 0xc9be, 0xd933, 0xf672,
0x14bc, 0x29f5, 0x3064, 0x2299, 0x072c, 0xe7bb, 0xd01b, 0xc7a4,
0xd335, 0xee16, 0x0e7b, 0x27af, 0x31cb, 0x2909, 0x100e, 0xf040,
0xd4e8, 0xc92a, 0xd0ce, 0xe801, 0x06da, 0x2340, 0x3174, 0x2cca,
0x16d1, 0xf866, 0xdb57, 0xcafc, 0xcdb2, 0xe14c, 0xfffd, 0x1ed0,
0x30c5, 0x31b3, 0x1ec6, 0x0008, 0xe131, 0xcc6e, 0xc9ff, 0xd9ca,
0xf65d, 0x1449, 0x2c36, 0x323e, 0x2529, 0x09ab, 0xe9b6, 0xd16a,
0xc94f, 0xd4a7, 0xee56, 0x0cf7, 0x267a, 0x3193, 0x285f, 0x1010,
0xf0df, 0xd5ce, 0xca55, 0xd08c, 0xe781, 0x07c1, 0x23b9, 0x3261,
0x2cf0, 0x16cf, 0xf76e, 0xda29, 0xc91d, 0xcb22, 0xdff3, 0xfec1,
0x1cdf, 0x2f7b, 0x2f9e, 0x1de1, 0x0027, 0xe1f8, 0xceef, 0xcc0d,
0xdbcd, 0xf850, 0x1744, 0x2c9b, 0x3278, 0x2434, 0x079c, 0xe823,
0xd032, 0xca85, 0xd506, 0xf012, 0x0fb7, 0x2929, 0x344d, 0x2a18,
0x1248, 0xf2a4, 0xd771, 0xcb71, 0xd16d, 0xe86a, 0x06a6, 0x2156,
0x2fc5, 0x2bcc, 0x16a2, 0xf769, 0xda4a, 0xca09, 0xce07, 0xe26b,
0x0233, 0x206c, 0x3278, 0x3312, 0x1f4e, 0x0118, 0xe19c, 0xcd70,
0xcaed, 0xda78, 0xf727, 0x15d2, 0x2c80, 0x3263, 0x24be, 0x08e0,
0xe8dc, 0xd202, 0xc9ca, 0xd556, 0xf034, 0x0f0b, 0x27dc, 0x318d,
0x27b2, 0x0de1, 0xee8c, 0xd44f, 0xc918, 0xcfda, 0xe7e0, 0x069c,
0x22c3, 0x30a2, 0x2cca, 0x177d, 0xf776, 0xdabc, 0xc9b3, 0xccad,
0xe195, 0xffb2, 0x1d20, 0x3051, 0x3026, 0x1db6, 0xff4d, 0xe14e,
0xcd8c, 0xcbfb, 0xdc1e, 0xf8a9, 0x1839, 0x2d7a, 0x3254, 0x23bb,
0x07ab, 0xe814, 0xcf83, 0xc861, 0xd48e, 0xef95, 0x0f1d, 0x27ce,
0x324f, 0x27da, 0x0eea, 0xefea, 0xd580, 0xc9e1, 0xd250, 0xea78,
0x0916, 0x241e, 0x3192, 0x2d05, 0x170f, 0xf6e5, 0xda3f, 0xcafd,
0xce9d, 0xe347, 0x01d3, 0x20cf, 0x3158, 0x30a3, 0x1ce2, 0xfdc7,
0xdef5, 0xcac4, 0xc8d4, 0xd948, 0xf75a, 0x169c, 0x2c59, 0x3186,
0x246b, 0x0894, 0xe92c, 0xd112, 0xca5e, 0xd6a1, 0xf086, 0x1084,
0x27a8, 0x310c, 0x279f, 0x0de1, 0xee26, 0xd3d9, 0xc99b, 0xd1c5,
0xe9e6, 0x0993, 0x24a8, 0x324f, 0x2db8, 0x173d, 0xf901, 0xdc07,
0xcbf8, 0xcdc0, 0xe285, 0x0170, 0x1e1b, 0x2f80, 0x2ecd, 0x1b2f,
0xfcfb, 0xdf42, 0xcbf4, 0xcb31, 0xdd32, 0xfacd, 0x19b2, 0x2f00,
0x32e2, 0x24c2, 0x095d, 0xe932, 0xd0c5, 0xcb26, 0xd5d5, 0xf0ac,
0x0ecd, 0x273b, 0x30fc, 0x27b4, 0x0e10, 0xef2f, 0xd55b, 0xca0f,
0xd220, 0xe93d, 0x088d, 0x2273, 0x2fbb, 0x2a71, 0x157f, 0xf6ef,
0xdbd1, 0xca82, 0xcda5, 0xe2a6, 0x0192, 0x1dfc, 0x2fbd, 0x2f59,
0x1c45, 0xffb8, 0xe1c9, 0xcec8, 0xcd43, 0xde8d, 0xfa76, 0x1893,
0x2d54, 0x3299, 0x22bb, 0x0719, 0xe81f, 0xd0c5, 0xcb50, 0xd669,
0xf117, 0x1093, 0x284f, 0x31fc, 0x27f9, 0x0f86, 0xefec, 0xd54f,
0xca59, 0xd1e5, 0xea91, 0x0941, 0x2435, 0x31fa, 0x2d21, 0x16bd,
0xf924, 0xdc5b, 0xcc44, 0xcef7, 0xe3e8, 0x0268, 0x1e34, 0x2fdb,
0x2f03, 0x1cf8, 0xff71, 0xe1a5, 0xce2c, 0xccea, 0xdd3d, 0xf9c8,
0x1976, 0x2e69, 0x3298, 0x22c1, 0x0651, 0xe775, 0xd039, 0xc9c7,
0xd5fd, 0xf031, 0x0ee1, 0x2772, 0x30a3, 0x277e, 0x0eea, 0xeffb,
0xd651, 0xcba7, 0xd39a, 0xebc1, 0x0a2d, 0x2413, 0x3119, 0x2d20,
0x172b, 0xf860, 0xdbaa, 0xcbb3, 0xcdda, 0xe239, 0x00a5, 0x1d69,
0x2feb, 0x2ea7, 0x1d2a, 0xff98, 0xe1de, 0xcf65, 0xceea, 0xdf6f,
0xfc27, 0x1a22, 0x2df5, 0x30fe, 0x204e, 0x057e, 0xe6da, 0xd048,
0xcabc, 0xd706, 0xf2b0, 0x1116, 0x29ed, 0x32d4, 0x28cb, 0x0fbf,
0xef67, 0xd639, 0xcb65, 0xd4d7, 0xec89, 0x0a05, 0x240e, 0x30bf,
0x2a9f, 0x1409, 0xf53c, 0xd8a9, 0xca78, 0xce4c, 0xe28e, 0x01b8,
0x1e5c, 0x2f46, 0x2e64, 0x1b81, 0xff08, 0xe14b, 0xcda0, 0xcbe7,
0xdce3, 0xf9a5, 0x177e, 0x2c52, 0x2f7e, 0x2031, 0x046a, 0xe4e5,
0xce24, 0xc9af, 0xd717, 0xf1e1, 0x1186, 0x28c6, 0x317e, 0x2685,
0x0d0f, 0xeecb, 0xd4af, 0xcae5, 0xd383, 0xeb67, 0x0a88, 0x2574,
0x32d8, 0x2cd0, 0x15df, 0xf6cc, 0xd9ff, 0xcae9, 0xce2e, 0xe3f4,
0x0238, 0x1ec5, 0x3022, 0x2e3b, 0x1c5c, 0xfeed, 0xe156, 0xcd98,
0xcd09, 0xdd8b, 0xf9d5, 0x1811, 0x2b7c, 0x300c, 0x20e0, 0x052b,
0xe754, 0xd111, 0xcbbb, 0xd821, 0xf24f, 0x1173, 0x28bd, 0x3173,
0x26ee, 0x0dab, 0xedf6, 0xd3ee, 0xca18, 0xd2a7, 0xea57, 0x0957,
0x242f, 0x3028, 0x29bc, 0x135a, 0xf51b, 0xd8c9, 0xc9d3, 0xcdb9,
0xe27a, 0x009a, 0x1d3b, 0x2ec5, 0x2e61, 0x1c99, 0xff0d, 0xe041,
0xccd2, 0xcb8e, 0xdcca, 0xf8cf, 0x1793, 0x2d06, 0x31b5, 0x22ab,
0x07e3, 0xeaac, 0xd309, 0xcd74, 0xd943, 0xf351, 0x1182, 0x28b0,
0x3154, 0x260c, 0x0c6f, 0xeda5, 0xd41d, 0xc907, 0xd053, 0xe846,
0x0863, 0x2321, 0x2fbf, 0x2be5, 0x160e, 0xf7a0, 0xdbe5, 0xcc1c,
0xd08a, 0xe4b7, 0x0179, 0x1ded, 0x2f26, 0x2e5e, 0x1b91, 0xfe82,
0xe0e1, 0xcd64, 0xcca6, 0xdc1b, 0xf72a, 0x1512, 0x2978, 0x2dc4,
0x1fe2, 0x05e9, 0xe7fa, 0xd1e1, 0xcb87, 0xd710, 0xf0ba, 0x0e8c,
0x2543, 0x2ca7, 0x234e, 0x0c0f, 0xed56, 0xd3b3, 0xc906, 0xd111,
0xe8fe, 0x07ce, 0x2276, 0x2fea, 0x2a02, 0x1431, 0xf6bb, 0xdad7,
0xcc26, 0xced9, 0xe3d1, 0x0177, 0x1d0c, 0x2da4, 0x2d17, 0x1a82,
0xfd95, 0xe0a2, 0xcd84, 0xcc18, 0xdc23, 0xf83f, 0x15fe, 0x2af7,
0x2f73, 0x217e, 0x06be, 0xe8eb, 0xd248, 0xcc1c, 0xd721, 0xf156,
0x0efd, 0x2609, 0x2fd8, 0x2617, 0x0f9d, 0xf094, 0xd62b, 0xcb1b,
0xd244, 0xe986, 0x07ba, 0x22f2, 0x2f38, 0x2ada, 0x149e, 0xf612,
0xd9d9, 0xc98d, 0xcda6, 0xe194, 0x00b1, 0x1ca6, 0x2ce3, 0x2c27,
0x1ad8, 0xfeaa, 0xe034, 0xcd5f, 0xcb04, 0xdb5b, 0xf7e7, 0x1574,
0x2a6c, 0x3021, 0x2254, 0x07f9, 0xe9f7, 0xd2af, 0xcbe3, 0xd7cc,
0xf17f, 0x0f42, 0x2712, 0x2fd4, 0x2687, 0x0d89, 0xeff0, 0xd6de,
0xcbf1, 0xd423, 0xebe7, 0x0a24, 0x2378, 0x30e7, 0x2c3e, 0x15a2,
0xf74e, 0xdbee, 0xcc4f, 0xcf26, 0xe3c7, 0x01ee, 0x1d49, 0x2d88,
0x2dd2, 0x1c3c, 0x0007, 0xe18a, 0xce4e, 0xcdf0, 0xde7b, 0xfa60,
0x1735, 0x2bdf, 0x306f, 0x2233, 0x064b, 0xe894, 0xd219, 0xcb39,
0xd785, 0xf119, 0x0ede, 0x26fa, 0x2fda, 0x26ca, 0x0ebb, 0xf1ea,
0xd94e, 0xcda7, 0xd4be, 0xeb3c, 0x09b6, 0x22a6, 0x2f69, 0x2aca,
0x14c7, 0xf69f, 0xdae0, 0xcc20, 0xcf70, 0xe2ef, 0x00a2, 0x1d0a,
0x2e0e, 0x2e19, 0x1c2a, 0xff7e, 0xe29a, 0xcfcc, 0xce0e, 0xde10,
0xf977, 0x168d, 0x2b62, 0x3051, 0x220e, 0x06bb, 0xe84b, 0xd1cb,
0xcbbd, 0xd67b, 0xf07b, 0x0ff0, 0x2781, 0x300a, 0x26a4, 0x0f9d,
0xf159, 0xd72a, 0xcbd9, 0xd2fc, 0xe9e6, 0x0714, 0x21e1, 0x2f94,
0x2a5e, 0x1562, 0xf80a, 0xdcc4, 0xccf1, 0xce77, 0xe28e, 0x004f,
0x1ca8, 0x2d65, 0x2d20, 0x1b9b, 0xfea8, 0xe219, 0xce98, 0xccbe,
0xdce1, 0xf80c, 0x165c, 0x2bb9, 0x2fbc, 0x225d, 0x0780, 0xe9ba,
0xd223, 0xcb39, 0xd658, 0xefec, 0x0e55, 0x258b, 0x2fb6, 0x276f,
0x0fd8, 0xf0b6, 0xd7f4, 0xcc34, 0xd33d, 0xe97a, 0x0731, 0x217f,
0x2ea9, 0x2ab2, 0x15b9, 0xf7e6, 0xdc72, 0xcd80, 0xcf39, 0xe30f,
0x0131, 0x1ddb, 0x2df7, 0x2ea4, 0x1d35, 0x0120, 0xe3d8, 0xcf66,
0xccf2, 0xdd4a, 0xf923, 0x15a5, 0x29cd, 0x2f7e, 0x2243, 0x071a,
0xe99b, 0xd2df, 0xcda9, 0xd8a2, 0xf165, 0x0f2d, 0x2792, 0x308a,
0x26f5, 0x0edb, 0xf114, 0xd715, 0xcb99, 0xd214, 0xe71b, 0x051e,
0x1f03, 0x2da5, 0x2a1a, 0x14bb, 0xf846, 0xdd6e, 0xcd6d, 0xcf83,
0xe2c0, 0x0097, 0x1acf, 0x2be9, 0x2c5b, 0x1b1b, 0xfe54, 0xdfe4,
0xcd66, 0xcba9, 0xdbdf, 0xf6b9, 0x13ed, 0x29dd, 0x2ee6, 0x2186,
0x07d9, 0xe9ee, 0xd3b6, 0xccc7, 0xd6f9, 0xefb6, 0x0d93, 0x25fd,
0x2ede, 0x2602, 0x0eb9, 0xf0f3, 0xd82f, 0xcc5f, 0xd1fd, 0xe8d8,
0x0745, 0x20f0, 0x2e33, 0x2a69, 0x15da, 0xf8f7, 0xdd9e, 0xcdb1,
0xcf9d, 0xe235, 0xfe86, 0x1a40, 0x2c34, 0x2cbf, 0x1be7, 0x00d1,
0xe4ac, 0xd111, 0xcf30, 0xddf4, 0xf843, 0x153a, 0x2a10, 0x2ee4,
0x2193, 0x079e, 0xea2a, 0xd2ff, 0xcba8, 0xd6ce, 0xeec3, 0x0d70,
0x2531, 0x2e2b, 0x25e9, 0x0e96, 0xf155, 0xd7dd, 0xcb8b, 0xd12b,
0xe7f4, 0x0584, 0x1fc6, 0x2e3d, 0x2bf8, 0x1882, 0xfb16, 0xdfab,
0xce57, 0xcfea, 0xe246, 0xff58, 0x1aab, 0x2c2f, 0x2de3, 0x1d2d,
0x01af, 0xe487, 0xd08b, 0xcd3a, 0xdc09, 0xf6aa, 0x142a, 0x299d,
0x2ea7, 0x21d9, 0x08a1, 0xeb58, 0xd3f9, 0xccef, 0xd799, 0xf02e,
0x0eda, 0x25b4, 0x2fc3, 0x26ff, 0x0f95, 0xf1c5, 0xd848, 0xccce,
0xd302, 0xe9bc, 0x079f, 0x2266, 0x2f34, 0x2cb5, 0x1744, 0xf969,
0xddf2, 0xcd51, 0xcedb, 0xe064, 0xfc0c, 0x16f6, 0x2984, 0x2b38,
0x1c12, 0x007b, 0xe482, 0xd11d, 0xce42, 0xdde4, 0xf871, 0x15a8,
0x2955, 0x2e9b, 0x2175, 0x0751, 0xea71, 0xd38a, 0xcbdb, 0xd6e9,
0xeeeb, 0x0cb5, 0x24b6, 0x2d6f, 0x25a4, 0x0f3c, 0xf22d, 0xd8c0,
0xcd93, 0xd2eb, 0xe875, 0x0629, 0x2035, 0x2e36, 0x2b7d, 0x17da,
0xfae1, 0xdfe8, 0xcef4, 0xd028, 0xe0ac, 0xfcae, 0x19c6, 0x2b2f,
0x2d5a, 0x1d7b, 0x0227, 0xe636, 0xd1f1, 0xcf00, 0xdcec, 0xf62c,
0x129e, 0x276a, 0x2e18, 0x2266, 0x09a3, 0xeccc, 0xd4e1, 0xcc2a,
0xd726, 0xef0d, 0x0cb4, 0x2469, 0x2d86, 0x266b, 0x0f06, 0xf117,
0xd7de, 0xcc59, 0xd27e, 0xe70c, 0x058b, 0x2185, 0x2efb, 0x2bbf,
0x1816, 0xfc5e, 0xdf7d, 0xcd7b, 0xcf02, 0xe024, 0xfc2f, 0x1886,
0x2aec, 0x2da5, 0x1e17, 0x0214, 0xe5d2, 0xd1ba, 0xce5a, 0xdca8,
0xf63f, 0x148d, 0x2ac0, 0x30ae, 0x24f1, 0x0b12, 0xecb4, 0xd543,
0xccfb, 0xd73a, 0xef0d, 0x0c6b, 0x247b, 0x2e69, 0x281a, 0x12cb,
0xf50d, 0xdb7d, 0xceca, 0xd315, 0xe941, 0x06bc, 0x208e, 0x2e46,
0x2bab, 0x1852, 0xfaf8, 0xdf89, 0xd020, 0xd129, 0xe174, 0xfd44,
0x19f6, 0x2c61, 0x2eb3, 0x1f06, 0x04c1, 0xe848, 0xd376, 0xcf3c,
0xda90, 0xf398, 0x0fbb, 0x255a, 0x2cbb, 0x21da, 0x0a6a, 0xed53,
0xd610, 0xcde2, 0xd707, 0xee14, 0x0b57, 0x2375, 0x2ee3, 0x28a1,
0x12d3, 0xf524, 0xda2d, 0xcd17, 0xd21f, 0xe638, 0x02a2, 0x1cda,
0x2ac6, 0x2a0a, 0x17e1, 0xfc99, 0xe23b, 0xd0b1, 0xd0ca, 0xe153,
0xfc44, 0x1870, 0x2b22, 0x2d5e, 0x1e2c, 0x0367, 0xe777, 0xd2d1,
0xce9a, 0xdaf6, 0xf433, 0x1116, 0x262d, 0x2dee, 0x2349, 0x0b54,
0xee59, 0xd70b, 0xce5b, 0xd73c, 0xeccb, 0x08fb, 0x217c, 0x2d37,
0x26a8, 0x1183, 0xf582, 0xdc41, 0xcfa0, 0xd263, 0xe6f1, 0x02ad,
0x1c96, 0x2b68, 0x2a21, 0x17b0, 0xfc33, 0xe097, 0xce77, 0xce87,
0xdea8, 0xfa2d, 0x160d, 0x2903, 0x2c59, 0x1fac, 0x05a0, 0xe8ef,
0xd3af, 0xce6f, 0xd99d, 0xf131, 0x0e23, 0x238e, 0x2c6c, 0x230f,
0x0b0b, 0xee5d, 0xd6db, 0xcd64, 0xd519, 0xeb8e, 0x084c, 0x2146,
0x2cfb, 0x27c1, 0x1376, 0xf6df, 0xdcab, 0xceae, 0xd202, 0xe4d6,
0x0102, 0x1bef, 0x2b1f, 0x29c6, 0x186d, 0xfcd3, 0xe220, 0xd0d0,
0xcfb9, 0xe04b, 0xfb34, 0x17e1, 0x2b1f, 0x2e64, 0x1fed, 0x05ba,
0xe94a, 0xd320, 0xcdce, 0xd991, 0xf210, 0x0e42, 0x2513, 0x2d5a,
0x24a4, 0x0dd3, 0xf0f6, 0xd959, 0xcf1b, 0xd635, 0xebce, 0x06dd,
0x1e53, 0x2b2c, 0x25de, 0x122e, 0xf59a, 0xdc48, 0xce57, 0xd1cf,
0xe5cf, 0x01bd, 0x1bcb, 0x2bc0, 0x2afb, 0x193d, 0xfe46, 0xe241,
0xd083, 0xcf61, 0xde5a, 0xf8fd, 0x15cc, 0x28a3, 0x2beb, 0x1e0a,
0x0507, 0xe8be, 0xd3ec, 0xceff, 0xda03, 0xf2cc, 0x0fe5, 0x25e4,
0x2d52, 0x240c, 0x0d7b, 0xf00c, 0xd875, 0xcef4, 0xd4f9, 0xea9d,
0x0716, 0x1e7e, 0x2bbf, 0x2757, 0x1465, 0xf8ff, 0xdf21, 0xd14d,
0xd336, 0xe636, 0x0035, 0x1a2d, 0x2a2f, 0x2b01, 0x1a76, 0xffa0,
0xe4b1, 0xd23e, 0xd071, 0xdeb8, 0xf8e3, 0x140a, 0x268a, 0x2b52,
0x1e10, 0x0477, 0xe867, 0xd2fc, 0xcda5, 0xd85f, 0xf075, 0x0d80,
0x2431, 0x2c89, 0x2530, 0x0e24, 0xf298, 0xdb2e, 0xcf52, 0xd545,
0xeab1, 0x0668, 0x1e19, 0x2b4e, 0x26b0, 0x1457, 0xf8cc, 0xdea0,
0xd016, 0xd270, 0xe41e, 0xffb4, 0x1a84, 0x2a92, 0x2a95, 0x1b94,
0x0138, 0xe55c, 0xd3eb, 0xd0d5, 0xde87, 0xf817, 0x13a3, 0x26e0,
0x2c19, 0x1f3e, 0x05fa, 0xeaca, 0xd556, 0xcfba, 0xdab0, 0xf2ec,
0x0ef0, 0x24f2, 0x2e5b, 0x260a, 0x1018, 0xf2da, 0xdb19, 0xcf7e,
0xd54d, 0xea23, 0x055b, 0x1dd5, 0x2b71, 0x27d1, 0x1574, 0xfab5,
0xe078, 0xd144, 0xd1a5, 0xe300, 0xfd99, 0x17b5, 0x27d5, 0x291a,
0x18ac, 0xffc5, 0xe5d4, 0xd2fa, 0xd00f, 0xdd85, 0xf81d, 0x1313,
0x2729, 0x2c63, 0x2061, 0x08b2, 0xec54, 0xd66c, 0xcfaf, 0xda5b,
0xf08c, 0x0cea, 0x2394, 0x2c6e, 0x24bb, 0x0ec3, 0xf367, 0xdb61,
0xd07f, 0xd62c, 0xe9f2, 0x0576, 0x1ea5, 0x2cc5, 0x29b3, 0x1776,
0xfc47, 0xe22e, 0xd1b6, 0xd250, 0xe322, 0xfcbb, 0x17cb, 0x27f7,
0x2a2a, 0x1b4a, 0x0311, 0xe7ce, 0xd502, 0xd179, 0xddae, 0xf65d,
0x1139, 0x25aa, 0x2b82, 0x214a, 0x098e, 0xef1f, 0xd920, 0xd0ec,
0xd967, 0xefe8, 0x0b3e, 0x2294, 0x2cec, 0x2537, 0x101b, 0xf351,
0xdb43, 0xcf78, 0xd3cb, 0xe7b5, 0x02a7, 0x1c71, 0x29df, 0x2880,
0x1726, 0xfc5d, 0xe31e, 0xd1e6, 0xd2a4, 0xe32b, 0xfc3b, 0x1622,
0x2761, 0x292f, 0x1b36, 0x01dc, 0xe6d1, 0xd3ae, 0xcfe7, 0xdb5c,
0xf3a2, 0x0f4d, 0x2486, 0x2b51, 0x222c, 0x0cad, 0xf0ed, 0xdaff,
0xd20c, 0xd9c8, 0xef09, 0x0956, 0x20f6, 0x2abc, 0x2424, 0x111c,
0xf52f, 0xdc9f, 0xd03c, 0xd4d6, 0xe7f9, 0x041b, 0x1e1a, 0x2be4,
0x2a5d, 0x1909, 0xfd99, 0xe362, 0xd2fb, 0xd309, 0xe1fe, 0xfbfa,
0x15c1, 0x278c, 0x2a63, 0x1cb6, 0x04d2, 0xe8d5, 0xd631, 0xd16c,
0xdcaf, 0xf411, 0x0ecc, 0x2242, 0x290b, 0x2026, 0x0a19, 0xeec8,
0xd7ed, 0xceb2, 0xd6c3, 0xecc5, 0x0966, 0x1fc8, 0x2995, 0x247a,
0x11dc, 0xf723, 0xddb7, 0xd20c, 0xd571, 0xe82a, 0x034b, 0x1b9d,
0x29dd, 0x28b1, 0x17c6, 0xfd58, 0xe31e, 0xd291, 0xd14a, 0xe17d,
0xfaa6, 0x1538, 0x27f7, 0x2a7c, 0x1d22, 0x0518, 0xeade, 0xd66d,
0xd0d1, 0xdb1a, 0xf2a0, 0x0dcd, 0x2190, 0x28d6, 0x2090, 0x0c13,
0xf122, 0xda1c, 0xd18e, 0xd8a7, 0xecc1, 0x0792, 0x1ef5, 0x2a7b,
0x25e5, 0x12cb, 0xf8e7, 0xdfd7, 0xd296, 0xd542, 0xe6b5, 0x00f8,
0x19ce, 0x27ef, 0x26af, 0x17c8, 0xfe28, 0xe334, 0xd187, 0xd05d,
0xdda2, 0xf7a7, 0x12b4, 0x24d5, 0x28a1, 0x1cc2, 0x05b4, 0xeb97,
0xd79c, 0xd0f0, 0xdb96, 0xf1ed, 0x0d0b, 0x2109, 0x290c, 0x219b,
0x0c26, 0xf135, 0xdb2b, 0xd144, 0xd6fe, 0xeb64, 0x065a, 0x1dd4,
0x2a56, 0x2622, 0x13a6, 0xf9f8, 0xe1fb, 0xd501, 0xd61a, 0xe775,
0x007a, 0x19bf, 0x2774, 0x25e1, 0x1750, 0xfdee, 0xe441, 0xd28b,
0xd1bb, 0xdfb3, 0xf9ab, 0x1385, 0x265c, 0x2b69, 0x1f45, 0x07fa,
0xeb4b, 0xd82a, 0xd24b, 0xdc4d, 0xf2bc, 0x0ca1, 0x20dc, 0x28ee,
0x218a, 0x0be4, 0xf0fa, 0xdb10, 0xd20a, 0xd80b, 0xeb08, 0x04c8,
0x1bd5, 0x2795, 0x23ba, 0x11af, 0xf836, 0xdfe8, 0xd216, 0xd440,
0xe54c, 0xff16, 0x17ac, 0x2684, 0x27ab, 0x17fa, 0xffad, 0xe6c7,
0xd5b9, 0xd489, 0xe18a, 0xf9e1, 0x134d, 0x25b6, 0x2a1b, 0x1df8,
0x0695, 0xec6b, 0xd870, 0xd255, 0xdb97, 0xf123, 0x0c75, 0x216b,
0x29a1, 0x22c4, 0x0e52, 0xf37a, 0xdc41, 0xd209, 0xd780, 0xeaf3,
0x0558, 0x1c18, 0x277e, 0x247f, 0x13f2, 0xfaa4, 0xe313, 0xd497,
0xd690, 0xe6ca, 0xffc0, 0x1820, 0x267f, 0x2790, 0x1905, 0x01a6,
0xe84f, 0xd64b, 0xd3e6, 0xe0d4, 0xf7fd, 0x11a8, 0x239c, 0x2853,
0x1d4e, 0x06b3, 0xebfa, 0xd6c0, 0xd0f8, 0xdaa8, 0xeffd, 0x099f,
0x1ea8, 0x27dc, 0x20fc, 0x0e0e, 0xf3dd, 0xdd32, 0xd2de, 0xd7bc,
0xebe5, 0x0539, 0x1be0, 0x27dd, 0x263a, 0x1508, 0xfb99, 0xe32b,
0xd443, 0xd59b, 0xe4c3, 0xfda8, 0x165a, 0x25c6, 0x26d2, 0x1936,
0x0180, 0xe940, 0xd740, 0xd57a, 0xe111, 0xf77c, 0x1274, 0x2468,
0x28f4, 0x1de8, 0x081e, 0xedcc, 0xd8e5, 0xd149, 0xda01, 0xf047,
0x0ac2, 0x205a, 0x2b0a, 0x244e, 0x1082, 0xf6f7, 0xdfac, 0xd441,
0xd86a, 0xeb43, 0x03d6, 0x1b0b, 0x276a, 0x2524, 0x154a, 0xfb73,
0xe3c3, 0xd53c, 0xd618, 0xe493, 0xfbfe, 0x14d0, 0x246b, 0x2671,
0x18cb, 0x0181, 0xe870, 0xd736, 0xd339, 0xdf01, 0xf67f, 0x1013,
0x2332, 0x277d, 0x1da3, 0x08fa, 0xeedd, 0xda7d, 0xd3a1, 0xdba5,
0xf137, 0x0b38, 0x209c, 0x2913, 0x2267, 0x0f6f, 0xf624, 0xdf06,
0xd3b5, 0xd7ef, 0xe92e, 0x02e5, 0x19f0, 0x2702, 0x249b, 0x14d7,
0xfc87, 0xe512, 0xd5e4, 0xd5ab, 0xe458, 0xfb67, 0x13f6, 0x238f,
0x25b7, 0x1977, 0x0398, 0xeb15, 0xd901, 0xd542, 0xe0da, 0xf6e5,
0x0f5a, 0x2227, 0x2852, 0x1f6f, 0x0a73, 0xf08a, 0xdbe8, 0xd32e,
0xdb4a, 0xef47, 0x0800, 0x1d6d, 0x2769, 0x21dd, 0x0e44, 0xf565,
0xdef8, 0xd314, 0xd610, 0xe797, 0x0179, 0x18c4, 0x258f, 0x2428,
0x1528, 0xfdb1, 0xe5f4, 0xd527, 0xd456, 0xe39d, 0xface, 0x13ab,
0x2498, 0x2803, 0x1c75, 0x06a4, 0xeca3, 0xda50, 0xd501, 0xdeb6,
0xf48c, 0x0cae, 0x1fb6, 0x26a8, 0x1ec2, 0x0a11, 0xf12c, 0xdcf3,
0xd569, 0xdbcc, 0xef41, 0x07b1, 0x1d38, 0x27c7, 0x21f0, 0x104c,
0xf805, 0xe094, 0xd46f, 0xd789, 0xe8a6, 0x0168, 0x187b, 0x265a,
0x252c, 0x16b3, 0xfe42, 0xe622, 0xd665, 0xd500, 0xe338, 0xfa09,
0x1309, 0x2324, 0x25d0, 0x1b03, 0x04a6, 0xebb7, 0xd8f7, 0xd37f,
0xdd2a, 0xf346, 0x0c91, 0x1fd7, 0x2805, 0x20fa, 0x0cdd, 0xf407,
0xdf46, 0xd53d, 0xda4b, 0xed72, 0x0676, 0x1beb, 0x26e3, 0x220d,
0x10b7, 0xf80a, 0xe0c2, 0xd4db, 0xd812, 0xe851, 0x0015, 0x17ae,
0x2637, 0x25fa, 0x1863, 0x0067, 0xe774, 0xd762, 0xd455, 0xe09f,
0xf79a, 0x1086, 0x21de, 0x2622, 0x1a9a, 0x0515, 0xece8, 0xda1d,
0xd467, 0xdde8, 0xf2f2, 0x0b9f, 0x1eb3, 0x273c, 0x1faf, 0x0c68,
0xf447, 0xdeef, 0xd593, 0xda67, 0xec63, 0x04a5, 0x1a6f, 0x2655,
0x24a4, 0x1362, 0xf9cd, 0xe289, 0xd5ba, 0xd739, 0xe6cc, 0xfdb2,
0x14de, 0x2323, 0x23c1, 0x1747, 0xfff7, 0xe7a3, 0xd8e5, 0xd7a1,
0xe4d7, 0xfa49, 0x11fb, 0x21ff, 0x25d2, 0x1b3a, 0x05af, 0xef67,
0xdbdc, 0xd68f, 0xdfee, 0xf432, 0x0c1d, 0x1ea6, 0x25e8, 0x1f96,
0x0c26, 0xf39f, 0xde7f, 0xd58d, 0xdb5e, 0xed78, 0x04ee, 0x1a6e,
0x2541, 0x217a, 0x114f, 0xf87c, 0xe189, 0xd3ee, 0xd727, 0xe74e,
0xfe7d, 0x1509, 0x2343, 0x24c7, 0x1931, 0x0198, 0xe998, 0xd86b,
0xd57e, 0xe160, 0xf6ce, 0x0eb5, 0x1ec9, 0x234d, 0x1aef, 0x0998,
0xf172, 0xde6f, 0xd7a0, 0xddd8, 0xf0bf, 0x096a, 0x1caf, 0x2438,
0x1d20, 0x0bb6, 0xf4c3, 0xdfb7, 0xd56d, 0xd978, 0xea0c, 0x0371,
0x18fd, 0x2510, 0x2324, 0x1307, 0xfcce, 0xe604, 0xda6c, 0xd8c9,
0xe5f1, 0xfb34, 0x10e5, 0x2218, 0x2448, 0x18d0, 0x01e7, 0xe96c,
0xd979, 0xd5ad, 0xe214, 0xf637, 0x0e54, 0x1eaf, 0x235b, 0x1b1f,
0x0760, 0xf2ac, 0xde2b, 0xd8b3, 0xde90, 0xef13, 0x0703, 0x1a27,
0x254d, 0x201f, 0x0da7, 0xf655, 0xe00f, 0xd6a6, 0xdadc, 0xec07,
0x033b, 0x188d, 0x24f4, 0x237b, 0x137d, 0xfc04, 0xe5b2, 0xd715,
0xd8f0, 0xe60d, 0xfd36, 0x13b8, 0x21f9, 0x248e, 0x1801, 0x01a1,
0xead0, 0xdb73, 0xd8fd, 0xe3a7, 0xf744, 0x0d06, 0x1fc1, 0x24f8,
0x1b4d, 0x0720, 0xefcf, 0xddd5, 0xd6a1, 0xde27, 0xef8d, 0x0715,
0x1b2c, 0x25f8, 0x2069, 0x0e94, 0xf63f, 0xe173, 0xd742, 0xda48,
0xeb29, 0x0312, 0x18b5, 0x2301, 0x2152, 0x1361, 0xfd8f, 0xe7e7,
0xda32, 0xdb14, 0xe841, 0xfcc7, 0x1240, 0x2259, 0x2532, 0x185a,
0x026e, 0xe8e3, 0xdaa9, 0xd7e5, 0xe2db, 0xf7f3, 0x0e26, 0x203c,
0x25a7, 0x1dc7, 0x0a16, 0xf1d2, 0xded8, 0xd764, 0xdd2f, 0xef52,
0x07ba, 0x1da5, 0x26dd, 0x20cb, 0x0eba, 0xf88d, 0xe38c, 0xd93a,
0xdb20, 0xea4c, 0x03a1, 0x1858, 0x25f8, 0x24cc, 0x14be, 0xfd2a,
0xe5b1, 0xd8f6, 0xd7df, 0xe52b, 0xfb3b, 0x136d, 0x2363, 0x2395,
0x1799, 0x0150, 0xea69, 0xd9bc, 0xd942, 0xe41d, 0xfa27, 0x10cf,
0x20bf, 0x263c, 0x1b7b, 0x08a8, 0xefff, 0xdc7c, 0xd462, 0xdbb5,
0xedee, 0x07e3, 0x1cd2, 0x2625, 0x25a4, 0x14eb, 0xfcc3, 0xe208,
0xd3cf, 0xd6b9, 0xe668, 0x023e, 0x185f, 0x280a, 0x25a4, 0x1710,
0xfee6, 0xe57c, 0xd880, 0xd724, 0xe4a6, 0xf8c4, 0x106d, 0x2052,
0x246d, 0x19e9, 0x05c9, 0xeecd, 0xde7f, 0xd9ca, 0xe128, 0xf36a,
0x0832, 0x1a81, 0x211e, 0x1bcd, 0x0d28, 0xea23, 0xd915, 0xe815,
0xfe98, 0x0cf9, 0xfe24, 0xf909, 0xfb84, 0xf7d4, 0x01d9, 0xfa04,
0xf946, 0xee46, 0xe835, 0x1980, 0x2e9f, 0x2102, 0x0aea, 0xfb83,
0xe615, 0xd195, 0xcee4, 0xcecb, 0xe794, 0x0359, 0x29a1, 0x4654,
0x408c, 0x3591, 0x0d34, 0xe46e, 0xc7f8, 0xaeeb, 0xb792, 0xcc07,
0xf0f6, 0x212f, 0x3eae, 0x4a27, 0x3ea1, 0x2754, 0xfedb, 0xd252,
0xc061, 0xbb79, 0xd39a, 0xf6ea, 0x1659, 0x241a, 0x20de, 0x1cee,
0x087f, 0xf7e7, 0xea20, 0xeaad, 0xf2f3, 0xf6f2, 0x0591, 0x0999,
0x070b, 0x021e, 0xef93, 0xdeb5, 0xd9a9, 0xe629, 0xffd0, 0x15e5,
0x26d7, 0x2d88, 0x2886, 0x12c6, 0xeafb, 0xcd9c, 0xb969, 0xc09d,
0xda27, 0xf912, 0x1ec7, 0x383f, 0x4a7d, 0x3dd1, 0x1cf5, 0xf377,
0xc863, 0xb518, 0xb4cb, 0xcd0a, 0xf37d, 0x15b1, 0x3288, 0x39b3,
0x313d, 0x2425, 0x0718, 0xe8e1, 0xd454, 0xd136, 0xdecf, 0xecae,
0x0356, 0x0fa1, 0x1218, 0x108b, 0x03f7, 0xfd20, 0xfeef, 0x0393,
0x0db4, 0x15a8, 0x0f7c, 0x0522, 0xf46e, 0xe339, 0xd152, 0xcb6f,
0xd555, 0xeda3, 0x1873, 0x36a9, 0x4ae8, 0x45ba, 0x2710, 0x0249,
0xd7c4, 0xb4ea, 0x9f52, 0xafdb, 0xda68, 0x0e73, 0x361d, 0x43dd,
0x4e57, 0x3db8, 0x11a7, 0xe23f, 0xbe49, 0xb5a7, 0xc2d8, 0xdcd1,
0xf9d7, 0x141b, 0x2ad1, 0x309a, 0x2622, 0x0ca5, 0xf2fb, 0xe62e,
0xe06c, 0xe585, 0xe8f6, 0xf6f4, 0x021c, 0x07e8, 0x0dd7, 0xff04,
0xf680, 0xf711, 0x0337, 0x0fd6, 0x15ff, 0x1b0f, 0x10bf, 0x0035,
0xe417, 0xd1de, 0xcbb9, 0xcd60, 0xe373, 0x03ef, 0x29f7, 0x3e16,
0x3d53, 0x2c31, 0x0aea, 0xe88b, 0xcb7f, 0xb9d1, 0xbb30, 0xd24e,
0xf9e2, 0x1980, 0x2eb4, 0x37a2, 0x2dc6, 0x1a4a, 0xfb20, 0xdf87,
0xd0a1, 0xd1b0, 0xe116, 0xf301, 0x0728, 0x13c6, 0x1925, 0x1425,
0x08af, 0xfffa, 0xf85c, 0xf5de, 0xf6f5, 0xfc17, 0x014d, 0x05ed,
0x01f1, 0xf934, 0xf1da, 0xed01, 0xeccd, 0xf56e, 0x09e2, 0x1ff5,
0x2ba5, 0x2401, 0x12d7, 0xf7bf, 0xda00, 0xcbc6, 0xc737, 0xd168,
0xee7b, 0x1210, 0x301e, 0x3d74, 0x37ee, 0x2262, 0x01e0, 0xdf09,
0xc3c6, 0xb73d, 0xc148, 0xdf60, 0x0458, 0x204c, 0x354e, 0x3aaa,
0x2890, 0x0c72, 0xef58, 0xdb43, 0xd498, 0xd9d5, 0xe7aa, 0xfa92,
0x0c17, 0x175e, 0x14bc, 0x09d1, 0xfeda, 0xf430, 0xf0ab, 0xf81d,
0x0241, 0x0583, 0x0683, 0x0280, 0xf3ce, 0xe6ae, 0xe0e3, 0xe629,
0xf21d, 0x0461, 0x1978, 0x28bb, 0x2ebb, 0x221c, 0x05d7, 0xe5ac,
0xce10, 0xc293, 0xc6e9, 0xdd12, 0xff55, 0x22da, 0x3983, 0x3e78,
0x318f, 0x133c, 0xef3d, 0xce63, 0xbb6c, 0xbd2d, 0xd09f, 0xef0b,
0x1008, 0x2a17, 0x33c8, 0x2b89, 0x171a, 0xfffe, 0xea90, 0xdb09,
0xdac5, 0xe3e3, 0xf14f, 0x00c2, 0x06f6, 0x0745, 0x0472, 0x0051,
0xfc05, 0xfbab, 0x0219, 0x0afa, 0x11c3, 0x0e44, 0x0369, 0xf5ab,
0xe300, 0xd666, 0xd4f1, 0xe1ea, 0xfb40, 0x1731, 0x2f98, 0x382f,
0x305f, 0x1a12, 0xf8b3, 0xd865, 0xc1e0, 0xbdf5, 0xcd4d, 0xebe3,
0x12cb, 0x3170, 0x42a7, 0x3f2b, 0x2728, 0x0532, 0xe06c, 0xc7f0,
0xc162, 0xca52, 0xe198, 0xfdab, 0x1753, 0x27ef, 0x2a00, 0x1f89,
0x0abb, 0xf715, 0xeaf2, 0xe5f8, 0xe914, 0xf1de, 0xfc49, 0x00b1,
0xffe9, 0xfc42, 0xf585, 0xf42c, 0xfa97, 0x06e6, 0x125d, 0x17f6,
0x18eb, 0x0e4d, 0xfa50, 0xe479, 0xd30a, 0xcbf2, 0xd3df, 0xeac3,
0x091f, 0x28a6, 0x3c38, 0x3a92, 0x295c, 0x0931, 0xe374, 0xc593,
0xb65e, 0xbdc6, 0xd6e3, 0xfc6c, 0x20ad, 0x39c6, 0x425f, 0x34b2,
0x18b6, 0xf5ec, 0xd883, 0xc961, 0xc8b9, 0xd866, 0xf1bc, 0x0adc,
0x1c31, 0x1f60, 0x1afe, 0x0fb4, 0x00a6, 0xf49a, 0xef90, 0xf31b,
0xf98b, 0x0003, 0x00fa, 0xfd92, 0xf6bf, 0xf14f, 0xefa4, 0xf299,
0xff17, 0x10e5, 0x1e42, 0x231a, 0x1d53, 0x0b14, 0xf1da, 0xd921,
0xc8f2, 0xc779, 0xd8e7, 0xf68e, 0x18d7, 0x3414, 0x40cb, 0x38e7,
0x1dba, 0xf971, 0xd549, 0xbed6, 0xbbbc, 0xcbfa, 0xea3e, 0x0ba9,
0x281e, 0x3910, 0x37b6, 0x2557, 0x07ea, 0xea67, 0xd62d, 0xd05f,
0xd79f, 0xe91e, 0xff23, 0x113b, 0x19bd, 0x179b, 0x0d93, 0x03b3,
0xfc1e, 0xf8b8, 0xfbb0, 0x0129, 0x054a, 0x0278, 0xfb82, 0xf1ca,
0xe8db, 0xe4c1, 0xe847, 0xf5e4, 0x0a5d, 0x1eee, 0x2c53, 0x2a85,
0x1a1f, 0xff1f, 0xe1cb, 0xcb72, 0xc160, 0xca9e, 0xe40f, 0x0699,
0x288a, 0x3d05, 0x3fe6, 0x2e20, 0x0e5a, 0xeac5, 0xcc40, 0xbe90,
0xc418, 0xdb14, 0xf9ea, 0x1955, 0x2e26, 0x338d, 0x29fc, 0x13af,
0xf954, 0xe38d, 0xda94, 0xdcca, 0xe640, 0xf6bb, 0x05c8, 0x0d5d,
0x0d73, 0x0772, 0x008e, 0xfc2d, 0xfe6a, 0x0376, 0x09d1, 0x0d61,
0x08df, 0xff59, 0xf112, 0xe2c2, 0xdb89, 0xde04, 0xec1a, 0x0274,
0x1b66, 0x2f75, 0x353f, 0x2844, 0x0e17, 0xece4, 0xd008, 0xbf5f,
0xbeef, 0xd290, 0xf3d7, 0x1906, 0x34c2, 0x3fe5, 0x38aa, 0x1feb,
0xfd39, 0xdc5f, 0xc60d, 0xc0ea, 0xce65, 0xe88e, 0x0691, 0x1fd5,
0x2bfc, 0x2a3f, 0x1b99, 0x070e, 0xf2df, 0xe5e3, 0xe380, 0xe818,
0xf22e, 0xfc18, 0x0379, 0x042f, 0x011d, 0xfbc1, 0xf905, 0xfc86,
0x0528, 0x0f22, 0x14ff, 0x135e, 0x0820, 0xf78e, 0xe4ec, 0xd50c,
0xd099, 0xda57, 0xf223, 0x0f98, 0x2916, 0x3909, 0x3655, 0x22e2,
0x0271, 0xdeab, 0xc548, 0xbc8b, 0xc5cb, 0xdf39, 0x03b4, 0x2719,
0x3ca8, 0x4017, 0x2ed7, 0x11dd, 0xf0c5, 0xd625, 0xc7bd, 0xc9ca,
0xdba8, 0xf521, 0x0e7e, 0x1d13, 0x21de, 0x1b15, 0x0d4c, 0xfdb9,
0xf26c, 0xed7e, 0xef7b, 0xf5db, 0xfbae, 0xfdb5, 0xfb4b, 0xf62c,
0xf295, 0xf2e3, 0xf8b3, 0x0599, 0x1572, 0x1ffe, 0x20cb, 0x1638,
0x01cf, 0xea5e, 0xd4d0, 0xc97b, 0xcd21, 0xe02a, 0xfe60, 0x200f,
0x375c, 0x3e72, 0x325d, 0x1669, 0xf310, 0xd04f, 0xbc33, 0xbc08,
0xcf23, 0xef48, 0x1258, 0x2de6, 0x3a2d, 0x3450, 0x1fe7, 0x0299,
0xe6fb, 0xd49e, 0xd00b, 0xd99a, 0xeafd, 0x0116, 0x1108, 0x18b7,
0x150d, 0x0c5c, 0x03e2, 0xfbdb, 0xf8f8, 0xfa8c, 0xff72, 0x014c,
0x00e6, 0xfa31, 0xf0eb, 0xe842, 0xe531, 0xec8d, 0xfb8e, 0x0ff5,
0x2261, 0x2a4e, 0x24b8, 0x12fe, 0xf87b, 0xdc90, 0xc866, 0xc418,
0xd004, 0xebd8, 0x0da3, 0x2c45, 0x3ea8, 0x3c9c, 0x27c2, 0x06cd,
0xe387, 0xc919, 0xbe44, 0xc547, 0xde2e, 0xfe57, 0x1d3d, 0x3066,
0x327d, 0x2618, 0x1033, 0xf698, 0xe217, 0xd883, 0xda68, 0xe6f9,
0xf775, 0x0509, 0x0b6a, 0x0b1d, 0x0627, 0xffb5, 0xfc53, 0xfe20,
0x01c3, 0x0848, 0x0a0b, 0x0550, 0xfc35, 0xef0b, 0xe32d, 0xdc87,
0xe0a1, 0xeeac, 0x05e3, 0x1d9f, 0x2e76, 0x3044, 0x229a, 0x087e,
0xe7e9, 0xcd61, 0xbefb, 0xc2c4, 0xd7c1, 0xf835, 0x1aa7, 0x3504,
0x3e9d, 0x34ef, 0x1a7e, 0xf79d, 0xd847, 0xc462, 0xc2ae, 0xd2aa,
0xec9a, 0x0945, 0x202a, 0x2a8a, 0x2738, 0x17d5, 0x03f6, 0xf1bc,
0xe6f2, 0xe512, 0xeb3b, 0xf56c, 0xfebe, 0x03aa, 0x01e9, 0xfd38,
0xf980, 0xf969, 0xfe1b, 0x0691, 0x0f84, 0x15ff, 0x12b3, 0x06c4,
0xf463, 0xe0b4, 0xd44d, 0xd219, 0xddfb, 0xf5b9, 0x1122, 0x2a11,
0x370e, 0x3185, 0x1ab5, 0xfa68, 0xda81, 0xc463, 0xbdf8, 0xca7a,
0xe7a9, 0x09c4, 0x297f, 0x3b09, 0x3b0e, 0x29e3, 0x0c09, 0xeb46,
0xd223, 0xc8c2, 0xcf66, 0xe31f, 0xfb7c, 0x11fb, 0x2016, 0x214c,
0x18b1, 0x0b1f, 0xfcff, 0xf2db, 0xef0d, 0xf100, 0xf6bf, 0xfc48,
0xfd39, 0xfa2a, 0xf4d0, 0xf185, 0xf279, 0xf9d9, 0x05cb, 0x1430,
0x1dca, 0x1da3, 0x13ff, 0xff70, 0xe884, 0xd5b0, 0xccd3, 0xd1eb,
0xe5c6, 0x034a, 0x20ca, 0x35a3, 0x3a73, 0x2bd0, 0x0ebc, 0xed2e,
0xceb7, 0xbdf2, 0xc017, 0xd4af, 0xf45d, 0x150f, 0x2e17, 0x373a,
0x30eb, 0x1a1b, 0xfcac, 0xe2d4, 0xd219, 0xd010, 0xdb4e, 0xef58,
0x035c, 0x1310, 0x18f5, 0x15a1, 0x0c42, 0x0167, 0xfa49, 0xf6e2,
0xf93a, 0xfd17, 0xff3b, 0xfe92, 0xf8a0, 0xf0b9, 0xea00, 0xe9d8,
0xf23b, 0x0058, 0x126e, 0x21ec, 0x2616, 0x1ef8, 0x0c63, 0xf244,
0xd921, 0xc86f, 0xc7fd, 0xd68c, 0xf20f, 0x1276, 0x2e19, 0x3c38,
0x371c, 0x2198, 0x0079, 0xdedf, 0xc739, 0xbf7d, 0xcadc, 0xe360,
0x02a5, 0x1e99, 0x2f6f, 0x3012, 0x2234, 0x0cac, 0xf474, 0xe1da,
0xd9ed, 0xddb2, 0xeabb, 0xfaf1, 0x0840, 0x0ead, 0x0dfa, 0x0a0e,
0x0213, 0xfde4, 0xfe55, 0x016e, 0x05bd, 0x05c7, 0x02e5, 0xfa8e,
0xee8a, 0xe3f8, 0xe0ba, 0xe6ab, 0xf57f, 0x0aca, 0x1fb2, 0x2c8b,
0x2bc0, 0x1d0a, 0x02ce, 0xe4ad, 0xcd83, 0xc3a6, 0xca4a, 0xe124,
0x00f7, 0x2122, 0x370f, 0x3c70, 0x2fdd, 0x1408, 0xf224, 0xd587,
0xc4b8, 0xc64a, 0xd827, 0xf353, 0x0fdf, 0x237e, 0x2be3, 0x24e8,
0x1350, 0xfed2, 0xecc3, 0xe25a, 0xe21f, 0xe97a, 0xf63f, 0x0187,
0x066c, 0x05e8, 0x0180, 0xfd90, 0xfbf1, 0xfef7, 0x0500, 0x0ce9,
0x10d9, 0x0d09, 0x00e5, 0xf1d3, 0xe2ef, 0xd848, 0xd975, 0xe545,
0xfc0b, 0x1643, 0x2a2d, 0x3245, 0x2ac8, 0x1475, 0xf6bd, 0xd88a,
0xc4ba, 0xc2cb, 0xd1be, 0xedad, 0x0d5c, 0x287d, 0x3695, 0x333c,
0x20ba, 0x03ae, 0xe5e4, 0xd133, 0xca22, 0xd453, 0xe871, 0x0096,
0x1619, 0x2229, 0x2192, 0x1731, 0x0892, 0xf8a3, 0xeef3, 0xebff,
0xf077, 0xf789, 0xfe70, 0x01fa, 0xffa0, 0xfaee, 0xf5d8, 0xf486,
0xfa8a, 0x0464, 0x0f46, 0x17ea, 0x174f, 0x0e40, 0xfd2b, 0xe992,
0xd8a9, 0xd277, 0xd9f4, 0xed2f, 0x0899, 0x228f, 0x33aa, 0x34ef,
0x2516, 0x07f6, 0xe7d9, 0xcd2f, 0xc144, 0xc7bb, 0xde3b, 0xfd7f,
0x1c16, 0x31dd, 0x3734, 0x2be1, 0x1459, 0xf809, 0xdf0a, 0xd16f,
0xd179, 0xde3d, 0xf2d3, 0x07c0, 0x155d, 0x1949, 0x1533, 0x0a13,
0xfe46, 0xf6c0, 0xf3a2, 0xf6dd, 0xfc31, 0xffaa, 0xffe9, 0xfaff,
0xf496, 0xee4f, 0xed71, 0xf487, 0x016b, 0x1102, 0x1c60, 0x1fe5,
0x1859, 0x05fa, 0xef08, 0xda48, 0xcdfa, 0xd00d, 0xe104, 0xfbd2,
0x190c, 0x302e, 0x38d6, 0x2fc0, 0x176a, 0xf75c, 0xd954, 0xc51a,
0xc352, 0xd218, 0xeb82, 0x0a20, 0x233b, 0x30a4, 0x2da5, 0x1ce3,
0x05ad, 0xed42, 0xde16, 0xd964, 0xdf63, 0xee49, 0xfee2, 0x0bd2,
0x11a4, 0x0fcb, 0x08e4, 0x00fa, 0xfb87, 0xfade, 0xfed8, 0x041c,
0x05a3, 0x023b, 0xfb06, 0xf118, 0xe78c, 0xe432, 0xe861, 0xf6da,
0x0aa3, 0x1c84, 0x262b, 0x2334, 0x136d, 0xfbfb, 0xe290, 0xcea6,
0xc806, 0xd199, 0xe9b6, 0x0809, 0x2442, 0x35e1, 0x365a, 0x266f,
0x0aa9, 0xead3, 0xd285, 0xc778, 0xccf6, 0xdefe, 0xfa72, 0x14bb,
0x262b, 0x2abd, 0x21c9, 0x0f33, 0xf952, 0xe8ac, 0xe00b, 0xe200,
0xea01, 0xf60b, 0x0201, 0x06f0, 0x05e5, 0x01e6, 0xfd2c, 0xfc9b,
0xff43, 0x04bd, 0x0a43, 0x0c35, 0x08fa, 0xfe88, 0xf034, 0xe2f3,
0xdc64, 0xdf4c, 0xecf6, 0x01ce, 0x1897, 0x2a2b, 0x2e37, 0x2367,
0x0bdb, 0xef2e, 0xd53d, 0xc6af, 0xc8d4, 0xdae2, 0xf71f, 0x1638,
0x2e01, 0x3716, 0x2f3e, 0x1833, 0xfa9c, 0xdd9d, 0xcc6e, 0xca13,
0xd693, 0xede7, 0x0708, 0x1a74, 0x2362, 0x20fd, 0x1514, 0x0489,
0xf55a, 0xeb7d, 0xea1a, 0xef4d, 0xf620, 0xfd6b, 0x00cc, 0x007b,
0xfc4b, 0xf803, 0xf843, 0xfe38, 0x06c4, 0x102d, 0x14f7, 0x120e,
0x07e3, 0xf5cd, 0xe4c6, 0xd823, 0xd563, 0xe039, 0xf4e8, 0x0eeb,
0x252e, 0x30ce, 0x2d05, 0x1a2f, 0xfe14, 0xdfb5, 0xca55, 0xc39d,
0xce0b, 0xe6c9, 0x04ab, 0x1fb1, 0x30c2, 0x31fe, 0x242f, 0x0bc6,
0xeef6, 0xd909, 0xcf80, 0xd34a, 0xe40c, 0xf9f4, 0x0d99, 0x195a,
0x1af1, 0x14ae, 0x0831, 0xfc63, 0xf4d2, 0xf1bb, 0xf37e, 0xf82f,
0xfc8f, 0xfcd4, 0xf99e, 0xf45e, 0xf091, 0xf1a8, 0xf91c, 0x04d1,
0x126d, 0x1c73, 0x1ce1, 0x13cc, 0x011b, 0xea92, 0xd7ff, 0xcf18,
0xd4df, 0xe769, 0x01e5, 0x1de7, 0x3132, 0x3695, 0x2ab9, 0x116c,
0xf229, 0xd613, 0xc66f, 0xc7ea, 0xd921, 0xf3e0, 0x108d, 0x2630,
0x2fa2, 0x29a0, 0x1747, 0xfe9c, 0xe72c, 0xd9ae, 0xd7b2, 0xe0c6,
0xf1ef, 0x0323, 0x0f76, 0x144c, 0x10b0, 0x086e, 0x0068, 0xfa90,
0xf9fc, 0xfc77, 0xffad, 0x01a9, 0x0013, 0xf9a7, 0xf168, 0xead2,
0xe8e4, 0xf0b8, 0xfeea, 0x1023, 0x1fa0, 0x25ab, 0x1f8a, 0x0e51,
0xf538, 0xdd5d, 0xcd76, 0xca78, 0xd738, 0xf01f, 0x0e97, 0x285d,
0x365d, 0x3471, 0x2183, 0x04ae, 0xe528, 0xcee5, 0xc7d5, 0xd050,
0xe6a4, 0x0132, 0x19a8, 0x2897, 0x29c7, 0x1e09, 0x0a5a, 0xf4f4,
0xe4f6, 0xdef6, 0xe211, 0xed47, 0xfb7f, 0x0645, 0x0b3d, 0x0957,
0x03fa, 0xfecd, 0xfcaf, 0xfe51, 0x0210, 0x0721, 0x0828, 0x0448,
0xfaff, 0xef12, 0xe4a9, 0xe03b, 0xe4e2, 0xf3bf, 0x0894, 0x1c91,
0x2abd, 0x2a49, 0x1c14, 0x03ce, 0xe8c0, 0xd1c4, 0xc845, 0xcddd,
0xe160, 0xfeed, 0x1bb6, 0x3019, 0x3514, 0x2a6a, 0x12eb, 0xf545,
0xda66, 0xcc5c, 0xce35, 0xdd1f, 0xf460, 0x0bb4, 0x1ce2, 0x2450,
0x1ec6, 0x1134, 0x0063, 0xf161, 0xe951, 0xe8f7, 0xef1e, 0xf83d,
0xffc8, 0x02c2, 0x01f5, 0xfdc3, 0xf9e6, 0xfb4e, 0x0072, 0x0859,
0x103c, 0x12c7, 0x0ea1, 0x03b6, 0xf392, 0xe433, 0xdaab, 0xda7c,
0xe683, 0xfb21, 0x131c, 0x26ee, 0x2f94, 0x278a, 0x12e3, 0xf723,
0xdb98, 0xc959, 0xc755, 0xd469, 0xed39, 0x0c3f, 0x256c, 0x336a,
0x31ef, 0x215e, 0x0741, 0xebb5, 0xd7ae, 0xd0b1, 0xd691, 0xe867,
0xfdad, 0x1014, 0x1a24, 0x1b0a, 0x13c2, 0x0748, 0xfaf7, 0xf3a7,
0xf1e1, 0xf415, 0xfa6e, 0xfe72, 0xff6e, 0xfca7, 0xf78b, 0xf2db,
0xf37a, 0xfa87, 0x0693, 0x12dc, 0x1a32, 0x197f, 0x0ede, 0xfcda,
0xe94f, 0xd969, 0xd2e2, 0xdab9, 0xee26, 0x07ea, 0x20b3, 0x312f,
0x31a4, 0x2329, 0x097a, 0xeac3, 0xd1b1, 0xc55d, 0xcb5c, 0xdf2b,
0xfa5c, 0x1765, 0x2b40, 0x307b, 0x27d1, 0x1449, 0xfaaf, 0xe499,
0xd8cb, 0xd8c5, 0xe36f, 0xf44f, 0x0536, 0x107f, 0x1379, 0x0fd0,
0x082d, 0xffaf, 0xfa8f, 0xf925, 0xfbd6, 0xffe6, 0x0164, 0xfea5,
0xf98e, 0xf178, 0xebbf, 0xebc0, 0xf2c1, 0x011e, 0x1051, 0x1c91,
0x2090, 0x1a92, 0x08b7, 0xf160, 0xdcd5, 0xd042, 0xd05b, 0xdeb5,
0xf774, 0x12e1, 0x29e5, 0x3443, 0x2e17, 0x1978, 0xfc43, 0xe047,
0xcd34, 0xc8a7, 0xd4a5, 0xeb30, 0x0634, 0x1d4f, 0x2a2e, 0x28f0,
0x1b76, 0x06ff, 0xf1d6, 0xe37f, 0xdedb, 0xe3b6, 0xef14, 0xfd33,
0x07b9, 0x0bc3, 0x0a49, 0x05b2, 0x0102, 0xfe3b, 0xffec, 0x02e6,
0x068f, 0x0792, 0x0223, 0xf97b, 0xef0f, 0xe5b3, 0xe21e, 0xe861,
0xf6e9, 0x0a6b, 0x1bc0, 0x2628, 0x2533, 0x172f, 0xfffa, 0xe5c3,
0xd322, 0xcbd9, 0xd32b, 0xe7bd, 0x0397, 0x1e68, 0x2fc2, 0x32a0,
0x2537, 0x0c6c, 0xf040, 0xd90d, 0xccea, 0xd070, 0xe0aa, 0xf83c,
0x0fcf, 0x1fc1, 0x248e, 0x1d7d, 0x0e99, 0xfcf6, 0xee77, 0xe6ad,
0xe7ea, 0xef0c, 0xf816, 0x000e, 0x03c9, 0x02fe, 0xff51, 0xfcea,
0xfd38, 0x01c6, 0x0820, 0x0e28, 0x105e, 0x0ba9, 0x00b7, 0xf132,
0xe3ab, 0xdba0, 0xdd83, 0xea17, 0xfedc, 0x1579, 0x273e, 0x2d0c,
0x23e7, 0x0f80, 0xf464, 0xdbee, 0xcce7, 0xcc3a, 0xda47, 0xf418,
0x1005, 0x2688, 0x3039, 0x2b24, 0x1960, 0xfee9, 0xe66c, 0xd645,
0xd263, 0xdb14, 0xed96, 0x0262, 0x132d, 0x1abd, 0x1958, 0x1002,
0x02df, 0xf75b, 0xf0ee, 0xf055, 0xf41d, 0xfa17, 0xfee6, 0xffed,
0xfc99, 0xf6d7, 0xf3b2, 0xf5f9, 0xfc38, 0x0638, 0x0faf, 0x16a0,
0x144d, 0x098e, 0xf89e, 0xe6c8, 0xda4a, 0xd716, 0xdfd8, 0xf33d,
0x0ba0, 0x21af, 0x2e64, 0x2bf4, 0x1d20, 0x0352, 0xe7de, 0xd205,
0xca28, 0xd15f, 0xe602, 0x00ff, 0x19a5, 0x29c2, 0x2bbd, 0x21d1,
0x0cf7, 0xf53b, 0xe2f9, 0xda1e, 0xdca1, 0xe86a, 0xf937, 0x08ea,
0x1248, 0x141f, 0x0ea7, 0x05d9, 0xfcdb, 0xf780, 0xf72d, 0xfa9b,
0xfe2f, 0xfffe, 0xfdb1, 0xf846, 0xf2f3, 0xee5c, 0xef7a, 0xf7e4,
0x0493, 0x1240, 0x1c44, 0x1e20, 0x152d, 0x0377, 0xedb9, 0xdacd,
0xd0d8, 0xd3ed, 0xe523, 0xfd4c, 0x17b8, 0x2b1a, 0x3194, 0x2903,
0x12e1, 0xf75d, 0xdcfa, 0xcd8a, 0xcc11, 0xd8dd, 0xf084, 0x0a0c,
0x1f0f, 0x2885, 0x24d8, 0x1699, 0x0218, 0xee7c, 0xe2c0, 0xdfef,
0xe51c, 0xf13b, 0xfe8a, 0x084e, 0x0c9e, 0x0ae5, 0x05a7, 0x001d,
0xfdbc, 0xfe50, 0x004f, 0x03af, 0x03ed, 0xffb2, 0xf763, 0xee6e,
0xe6f4, 0xe666, 0xede9, 0xfbfb, 0x0db4, 0x1bd1, 0x23b3, 0x1f85,
0x103e, 0xf9d8, 0xe23e, 0xd1d1, 0xcded, 0xd789, 0xecc1, 0x082d,
0x20af, 0x2f60, 0x2fa3, 0x20f6, 0x0906, 0xed68, 0xd844, 0xcdbb,
0xd1ee, 0xe287, 0xf8f1, 0x0fe4, 0x1f27, 0x244b, 0x1b92, 0x0d7b,
0xfc66, 0xee23, 0xe695, 0xe747, 0xee19, 0xf796, 0x0061, 0x03da,
0x037a, 0x005b, 0xfe79, 0xfd26, 0x0035, 0x0572, 0x0abc, 0x0bcb,
0x070a, 0xfd61, 0xefd7, 0xe4ee, 0xdfaf, 0xe266, 0xefd4, 0x0408,
0x176a, 0x250c, 0x2787, 0x1cc4, 0x0804, 0xee25, 0xd7bf, 0xcc26,
0xcf21, 0xe01d, 0xf93d, 0x147c, 0x2883, 0x2f70, 0x27c8, 0x136c,
0xf9ae, 0xe26f, 0xd3c3, 0xd2e7, 0xdda0, 0xf0f4, 0x05d3, 0x15de,
0x1d3e, 0x1a13, 0x0f93, 0x01c6, 0xf6a4, 0xef84, 0xef1d, 0xf307,
0xf8f2, 0xfe1e, 0xff07, 0xfc46, 0xf8e4, 0xf70c, 0xf860, 0xfe9b,
0x07c8, 0x1129, 0x147c, 0x115d, 0x0656, 0xf5c6, 0xe648, 0xdb7d,
0xda49, 0xe413, 0xf7e3, 0x0efe, 0x2249, 0x2c40, 0x280d, 0x1634,
0xfcb8, 0xe259, 0xd04d, 0xcb87, 0xd5bc, 0xeb6d, 0x064d, 0x1f1c,
0x2c52, 0x2c4b, 0x1e99, 0x090d, 0xf174, 0xdf35, 0xd809, 0xdc58,
0xe987, 0xfb4f, 0x0b37, 0x13d9, 0x15d4, 0x0fad, 0x05e2, 0xfc40,
0xf6c1, 0xf54f, 0xf821, 0xfc3d, 0xfd30, 0xfd25, 0xf88e, 0xf352,
0xefb3, 0xf0ef, 0xf885, 0x03b0, 0x10ab, 0x189d, 0x1943, 0x106a,
0xff04, 0xeaf4, 0xdb6e, 0xd4a4, 0xda7c, 0xeb68, 0x0250, 0x1a76,
0x29a0, 0x2d47, 0x22a4, 0x0bd3, 0xf0c6, 0xd933, 0xcce5, 0xcf20,
0xdf89, 0xf736, 0x0fdb, 0x22ab, 0x29bc, 0x22ff, 0x129e, 0xfdb1,
0xeb20, 0xe07e, 0xde8f, 0xe618, 0xf385, 0x016d, 0x0ace, 0x0d45,
0x0b77, 0x058e, 0xffaa, 0xfc98, 0xfcc4, 0xfffa, 0x0236, 0x0319,
0xfe45, 0xf794, 0xefc3, 0xe9e3, 0xe97e, 0xf13e, 0xff20, 0x0dc7,
0x1c12, 0x21ac, 0x1ca9, 0x0cf4, 0xf747, 0xe207, 0xd478, 0xd2b2,
0xdea2, 0xf388, 0x0cc2, 0x2293, 0x2cc7, 0x2924, 0x18ed, 0x00c8,
0xe6ef, 0xd510, 0xcf8f, 0xd8ac, 0xeb63, 0x038c, 0x1644, 0x20f4,
0x222b, 0x1813, 0x0893, 0xf762, 0xea1e, 0xe4fd, 0xe906, 0xf12f,
0xfb88, 0x0307, 0x05b6, 0x0578, 0x02d1, 0xfefb, 0xfdb2, 0x00b3,
0x04be, 0x081d, 0x091a, 0x04f9, 0xfb23, 0xef06, 0xe55e, 0xe1fb,
0xe760, 0xf4b6, 0x07b8, 0x19ba, 0x2472, 0x24b9, 0x18c3, 0x03a5,
0xec46, 0xd88a, 0xd01d, 0xd581, 0xe6c1, 0xff9d, 0x177b, 0x280f,
0x2c12, 0x227b, 0x0ebc, 0xf69e, 0xe0c1, 0xd510, 0xd713, 0xe44f,
0xf72f, 0x0b6a, 0x184c, 0x1cce, 0x17b4, 0x0bdb, 0xfe28, 0xf252,
0xed17, 0xed62, 0xf356, 0xfb57, 0x0042, 0x0116, 0xfede, 0xfa73,
0xf9af, 0xfac6, 0x000e, 0x06f9, 0x0e2b, 0x11a1, 0x0cf5, 0x02d8,
0xf362, 0xe4a8, 0xdd30, 0xdeab, 0xea24, 0xfcc7, 0x11c1, 0x22c7,
0x2936, 0x2429, 0x1163, 0xf941, 0xe160, 0xd199, 0xd00e, 0xdb60,
0xf12d, 0x09c9, 0x1ee9, 0x29e9, 0x2744, 0x18f2, 0x0405, 0xed9a,
0xde09, 0xd9ce, 0xe057, 0xefba, 0x00ea, 0x0ecd, 0x15de, 0x1494,
0x0dd3, 0x035e, 0xf9e5, 0xf44a, 0xf422, 0xf7cd, 0xfbf3, 0xff43,
0xfe08, 0xfa3f, 0xf4e0, 0xf25f, 0xf411, 0xfaf4, 0x0576, 0x0f72,
0x166a, 0x154d, 0x0b51, 0xfac9, 0xe914, 0xdaff, 0xd706, 0xde3d,
0xeee1, 0x05d0, 0x1b2b, 0x288d, 0x2a2b, 0x1d64, 0x06aa, 0xec8f,
0xd865, 0xcf0b, 0xd4a2, 0xe638, 0xfcd7, 0x1302, 0x2263, 0x26ea,
0x1eaf, 0x0ef6, 0xfa32, 0xe980, 0xe107, 0xe198, 0xeaf3, 0xf8ad,
0x052d, 0x0d0d, 0x0e69, 0x0aa7, 0x04a5, 0xfd6e, 0xfa07, 0xf9b6,
0xfc28, 0x005e, 0x00c1, 0xfce0, 0xf734, 0xf03b, 0xebb0, 0xed15,
0xf497, 0x0043, 0x0e24, 0x1930, 0x1ce0, 0x15d5, 0x05be, 0xf1b5,
0xdeeb, 0xd4d7, 0xd693, 0xe3f4, 0xfa26, 0x12cc, 0x2579, 0x2c79,
0x25cf, 0x14a4, 0xfbfa, 0xe49a, 0xd607, 0xd2a3, 0xdcf9, 0xf118,
0x0639, 0x1800, 0x20f8, 0x1ea1, 0x146c, 0x038b, 0xf347, 0xe81f,
0xe559, 0xea67, 0xf460, 0xfeaf, 0x0521, 0x077f, 0x05d9, 0x0299,
0xffb1, 0xfe3f, 0x000f, 0x04bf, 0x07c4, 0x07e0, 0x0298, 0xf9fe,
0xefad, 0xe763, 0xe581, 0xeb69, 0xf943, 0x0ac2, 0x1a66, 0x21d9,
0x2023, 0x1320, 0xfdda, 0xe7cc, 0xd7a4, 0xd1d9, 0xd95f, 0xebdd,
0x0413, 0x1a78, 0x289a, 0x29b7, 0x1db0, 0x0967, 0xf0a1, 0xdd50,
0xd3e7, 0xd8af, 0xe6be, 0xfa1a, 0x0dcf, 0x18d7, 0x1c9e, 0x1617,
0x0941, 0xfb01, 0xefc5, 0xeb8b, 0xecda, 0xf28b, 0xf9ff, 0xff7c,
0x0104, 0xfe1d, 0xfa2f, 0xf8f0, 0xf97a, 0xff0d, 0x05ff, 0x0b66,
0x0d9a, 0x09ae, 0x001b, 0xf284, 0xe5c1, 0xdfd3, 0xe21c, 0xed56,
0x006a, 0x129d, 0x20bb, 0x24d1, 0x1c71, 0x0a3d, 0xf36a, 0xde40,
0xd261, 0xd337, 0xe0b3, 0xf6be, 0x0ebd, 0x21ce, 0x28d7, 0x2471,
0x1407, 0xfe29, 0xe8fc, 0xdbb2, 0xd998, 0xe1db, 0xf07b, 0x016b,
0x0ec6, 0x14e6, 0x141b, 0x0c45, 0x0275, 0xf926, 0xf439, 0xf413,
0xf814, 0xfbb6, 0xfedf, 0xff05, 0xfbaf, 0xf7da, 0xf462, 0xf78b,
0xfdc7, 0x0685, 0x1035, 0x14df, 0x1335, 0x087b, 0xf9de, 0xea6b,
0xdee0, 0xdc83, 0xe362, 0xf4ea, 0x09ec, 0x1cc0, 0x26bb, 0x2444,
0x16bb, 0x0094, 0xea1c, 0xd875, 0xd20b, 0xd941, 0xea41, 0x0119,
0x1634, 0x230d, 0x2533, 0x1c53, 0x0a2a, 0xf54c, 0xe61e, 0xdfb0,
0xe1da, 0xeba6, 0xfab0, 0x0722, 0x0ea0, 0x1005, 0x0b1a, 0x045d,
0xfd4b, 0xf98d, 0xf929, 0xfca5, 0xffd9, 0x0095, 0xfe23, 0xf900,
0xf333, 0xef9e, 0xf098, 0xf7dc, 0x03a0, 0x1059, 0x197f, 0x19f9,
0x12ab, 0x0321, 0xf071, 0xe0bb, 0xd8c1, 0xdb02, 0xe8e6, 0xfd9b,
0x13b6, 0x2476, 0x287a, 0x208e, 0x0f60, 0xf799, 0xe228, 0xd5bf,
0xd5f0, 0xe1c9, 0xf488, 0x0950, 0x197a, 0x20bb, 0x1d90, 0x10e7,
0xfefb, 0xf016, 0xe68a, 0xe4ee, 0xeab1, 0xf4be, 0xffe2, 0x0731,
0x0a00, 0x07ce, 0x0312, 0xff0b, 0xfd5c, 0xfe64, 0x01e7, 0x050d,
0x0402, 0x005e, 0xf8bd, 0xf03d, 0xea27, 0xe95e, 0xefe7, 0xfd4e,
0x0d2d, 0x19ea, 0x2066, 0x1c07, 0x0efb, 0xfb1c, 0xe673, 0xd93a,
0xd53c, 0xddd7, 0xefb9, 0x065e, 0x1b41, 0x2654, 0x25a7, 0x18a3,
0x0571, 0xeeba, 0xde41, 0xd822, 0xdd78, 0xeb98, 0xfedd, 0x1075,
0x1a2e, 0x1c16, 0x1420, 0x074f, 0xf946, 0xef21, 0xeaf4, 0xecfb,
0xf2e8, 0xfb0e, 0x012d, 0x0385, 0x029d, 0xff5e, 0xfd59, 0xfdb2,
0x0151, 0x0749, 0x0b99, 0x0b9a, 0x066f, 0xfd9c, 0xf18c, 0xe834,
0xe300, 0xe5ce, 0xf1c2, 0x01d4, 0x131b, 0x1f28, 0x20b6, 0x17b1,
0x05aa, 0xeffb, 0xde91, 0xd44d, 0xd82e, 0xe55c, 0xfa72, 0x1175,
0x2115, 0x265b, 0x1ff2, 0x0f34, 0xf979, 0xe6ac, 0xdc3e, 0xdb45,
0xe514, 0xf503, 0x056c, 0x11af, 0x16f0, 0x14ae, 0x0a93, 0x0061,
0xf64c, 0xf244, 0xf263, 0xf678, 0xfb50, 0xfea4, 0xffbd, 0xfce5,
0xf939, 0xf6fa, 0xf905, 0xfe05, 0x0631, 0x0d46, 0x11fa, 0x0f51,
0x0580, 0xf804, 0xea42, 0xe153, 0xe02a, 0xe904, 0xf9f6, 0x0d9c,
0x1dcc, 0x2511, 0x208d, 0x11a6, 0xfc25, 0xe644, 0xd6b1, 0xd2c3,
0xdb6a, 0xedaf, 0x0388, 0x1703, 0x22fa, 0x22b5, 0x17bb, 0x06a4,
0xf2e2, 0xe51f, 0xe039, 0xe349, 0xef30, 0xfc68, 0x08d7, 0x0f50,
0x0f89, 0x0b30, 0x0304, 0xfc5b, 0xf91b, 0xf90a, 0xfabc, 0xfe4c,
0xffe9, 0xfe31, 0xf9a3, 0xf519, 0xf1fe, 0xf3df, 0xfae2, 0x046b,
0x0df6, 0x1528, 0x14d8, 0x0ccc, 0xfdda, 0xed09, 0xe0e5, 0xdb52,
0xe0ec, 0xeefb, 0x0363, 0x16ec, 0x2502, 0x27a5, 0x1da7, 0x0b5e,
0xf406, 0xe006, 0xd6c1, 0xd8a7, 0xe4ee, 0xf891, 0x0c29, 0x1b2b,
0x1f60, 0x1a89, 0x0e09, 0xfd46, 0xee76, 0xe5a6, 0xe4e3, 0xeaa5,
0xf647, 0x00da, 0x076b, 0x0847, 0x058c, 0x0150, 0xfce0, 0xfb22,
0xfc8d, 0xfff8, 0x0293, 0x03db, 0xff83, 0xf8ed, 0xf152, 0xec63,
0xecff, 0xf35e, 0xfeaf, 0x0c61, 0x171f, 0x1ae1, 0x1687, 0x086b,
0xf651, 0xe467, 0xda65, 0xd973, 0xe32b, 0xf5cb, 0x0b9b, 0x1d72,
0x25bd, 0x22b0, 0x13e6, 0xff34, 0xead1, 0xdbce, 0xd773, 0xdf3a,
0xef96, 0x024b, 0x1255, 0x1b59, 0x1bcb, 0x138f, 0x055e, 0xf7b7,
0xeea2, 0xeb78, 0xec5e, 0xf2db, 0xfb36, 0x00f5, 0x020a, 0x014f,
0xfeea, 0xfd2c, 0xfd6b, 0x006d, 0x05c1, 0x08b9, 0x0939, 0x053d,
0xfcad, 0xf1b9, 0xe956, 0xe5dc, 0xe934, 0xf4d5, 0x0538, 0x1432,
0x1d7d, 0x1db1, 0x1335, 0x00e4, 0xed5a, 0xddc9, 0xd6fc, 0xdc38,
0xead3, 0xff74, 0x14b3, 0x22ae, 0x258d, 0x1c9e, 0x0b80, 0xf61d,
0xe450, 0xdb50, 0xdbd6, 0xe713, 0xf77a, 0x080b, 0x135a, 0x1834,
0x146c, 0x0b20, 0xffe0, 0xf635, 0xf250, 0xf247, 0xf511, 0xfa1f,
0xfe06, 0xfded, 0xfcf8, 0xf9a2, 0xf88c, 0xfa5d, 0xff93, 0x073d,
0x0d96, 0x1024, 0x0bdc, 0x028d, 0xf58e, 0xe960, 0xe25a, 0xe259,
0xebc3, 0xfc8c, 0x0ded, 0x1c77, 0x213e, 0x1bf4, 0x0d4d, 0xf93e,
0xe614, 0xd9d7, 0xd86d, 0xe1d8, 0xf3f9, 0x080c, 0x18d7, 0x20e6,
0x1ff3, 0x1352, 0x00ff, 0xef8c, 0xe331, 0xdfaa, 0xe3fe, 0xefd1,
0xfe2e, 0x0a3a, 0x0f22, 0x0f32, 0x0a24, 0x01a3, 0xfaee, 0xf6f3,
0xf775, 0xfa7c, 0xfd21, 0xfdff, 0xfd9c, 0xf9dc, 0xf593, 0xf370,
0xf606, 0xfd07, 0x058c, 0x0e9c, 0x13da, 0x1261, 0x094c, 0xfb12,
0xebfa, 0xe175, 0xddca, 0xe3b5, 0xf2c3, 0x0600, 0x175b, 0x22a6,
0x221c, 0x1723, 0x054d, 0xf080, 0xdfa2, 0xd764, 0xdbfe, 0xea60,
0xfd5f, 0x0fb8, 0x1c5d, 0x1f16, 0x1877, 0x0a5c, 0xfa05, 0xec6f,
0xe5a7, 0xe5ce, 0xecae, 0xf85c, 0x02d4, 0x095a, 0x0ae6, 0x07df,
0x0312, 0xff2a, 0xfb5f, 0xfb93, 0xff1f, 0x014f, 0x00b0, 0xfd08,
0xf7c1, 0xf150, 0xed4c, 0xee7c, 0xf5d4, 0x017f, 0x0d67, 0x1744,
0x1947, 0x1291, 0x04eb, 0xf2f7, 0xe398, 0xdb17, 0xdbf1, 0xe6fd,
0xf952, 0x0e02, 0x1e63, 0x24dc, 0x1fbe, 0x10ac, 0xfcee, 0xe9e8,
0xdcc1, 0xda62, 0xe30a, 0xf388, 0x0579, 0x1475, 0x1ac4, 0x1984,
0x10fc, 0x0234, 0xf549, 0xebb2, 0xe9aa, 0xecf8, 0xf494, 0xfdaf,
0x03ea, 0x05e4, 0x044d, 0x01eb, 0xff5b, 0xfe15, 0x000b, 0x03e3,
0x05a8, 0x05d6, 0x01a1, 0xf993, 0xf1c3, 0xeb3d, 0xe8f3, 0xedea,
0xf939, 0x084a, 0x15df, 0x1cca, 0x1b78, 0x1012, 0xfe22, 0xea82,
0xdcc3, 0xd8bb, 0xddf8, 0xee90, 0x0263, 0x15fe, 0x2172, 0x2276,
0x1988, 0x0710, 0xf392, 0xe30d, 0xdbeb, 0xde3c, 0xea21, 0xfac1,
0x0a71, 0x14a8, 0x17a7, 0x1246, 0x0838, 0xfd29, 0xf3f8, 0xeffc,
0xf0f5, 0xf600, 0xfb86, 0x0079, 0x0130, 0xffb0, 0xfc8a, 0xfa95,
0xfb9a, 0x0034, 0x0599, 0x0abf, 0x0c02, 0x07a3, 0xff0f, 0xf3bc,
0xe9ab, 0xe406, 0xe5d3, 0xeff2, 0x000c, 0x0fd5, 0x1c94, 0x1fb3,
0x19f6, 0x09d8, 0xf5d7, 0xe3a2, 0xd93f, 0xdad2, 0xe5d4, 0xf8be,
0x0c92, 0x1bfb, 0x225a, 0x1e96, 0x10dc, 0xfe7d, 0xed77, 0xe2b0,
0xe005, 0xe663, 0xf31b, 0x007e, 0x0ba1, 0x105e, 0x0ee3, 0x0924,
0x007e, 0xfa0c, 0xf65b, 0xf671, 0xf963, 0xfc4b, 0xfe81, 0xfdf7,
0xfaec, 0xf7b1, 0xf666, 0xf8a4, 0xfead, 0x063c, 0x0dd1, 0x11f2,
0x0f55, 0x06fc, 0xfa3c, 0xeca5, 0xe32f, 0xe1a6, 0xe8b8, 0xf7e8,
0x09b1, 0x1951, 0x211e, 0x1f45, 0x1334, 0x00b0, 0xed77, 0xddb3,
0xd910, 0xddf7, 0xed8d, 0x0081, 0x1220, 0x1d42, 0x1e8f, 0x1732,
0x079f, 0xf6fa, 0xea0f, 0xe489, 0xe62f, 0xeee0, 0xfaab, 0x04d6,
0x0b00, 0x0b71, 0x083a, 0x02a2, 0xfda8, 0xfabf, 0xfb11, 0xfd95,
0x0061, 0x00a5, 0xfdd6, 0xf972, 0xf3c8, 0xf04d, 0xf16e, 0xf834,
0x024a, 0x0e0b, 0x152f, 0x15ae, 0x0ee3, 0x01a2, 0xf10d, 0xe3bb,
0xdd73, 0xe076, 0xecb7, 0xff52, 0x120c, 0x1ece, 0x2375, 0x1be6,
0x0be3, 0xf760, 0xe5f4, 0xdb89, 0xdb81, 0xe58b, 0xf6c3, 0x080f,
0x1586, 0x1bf4, 0x1863, 0x0e37, 0xffbe, 0xf320, 0xeb1a, 0xe9f9,
0xee2a, 0xf6a4, 0xff63, 0x0491, 0x0625, 0x046c, 0x0141, 0xfdbb,
0xfd78, 0xff12, 0x0213, 0x04a5, 0x041b, 0x0068, 0xf946, 0xf138,
0xeba3, 0xeb77, 0xf0ff, 0xfc33, 0x0a0f, 0x161c, 0x1a8f, 0x1748,
0x0ba6, 0xfa39, 0xe9c5, 0xdd80, 0xdaf2, 0xe22f, 0xf246, 0x05bf,
0x16e3, 0x20dd, 0x1faa, 0x14bb, 0x01c5, 0xefaf, 0xe101, 0xdb8d,
0xe074, 0xed4d, 0xfe54, 0x0ca4, 0x16c7, 0x17cd, 0x1149, 0x05c6,
0xfa88, 0xf255, 0xef07, 0xf0b7, 0xf5d3, 0xfbd1, 0x00bc, 0x018c,
0x007e, 0xfe76, 0xfccd, 0xfe11, 0x0199, 0x06d1, 0x0b03, 0x0b3b,
0x0613, 0xfe04, 0xf28b, 0xe9cf, 0xe5b3, 0xe8b3, 0xf2e4, 0x01c6,
0x10de, 0x1bbf, 0x1d96, 0x14d8, 0x05b6, 0xf314, 0xe2df, 0xdb44,
0xde59, 0xea01, 0xfc80, 0x0f6d, 0x1d86, 0x212a, 0x1b9b, 0x0cfc,
0xfa7c, 0xeacf, 0xe189, 0xe15d, 0xe934, 0xf6ec, 0x04c3, 0x0f96,
0x1326, 0x10a4, 0x09a0, 0x0074, 0xf934, 0xf571, 0xf52d, 0xf841,
0xfb38, 0xfd34, 0xfd0d, 0xfae0, 0xf86f, 0xf6a5, 0xf946, 0xfeea,
0x061a, 0x0cdb, 0x0fcc, 0x0d18, 0x0498, 0xf7dc, 0xeb37, 0xe379,
0xe305, 0xeb75, 0xfa60, 0x0bd2, 0x19ed, 0x1f39, 0x1b2a, 0x0ea8,
0xfc68, 0xe9fc, 0xdde4, 0xdb0a, 0xe22c, 0xf1ae, 0x0501, 0x144b,
0x1dd6, 0x1da1, 0x1374, 0x0443, 0xf374, 0xe7db, 0xe3d3, 0xe70d,
0xf05d, 0xfc5b, 0x06fd, 0x0c97, 0x0cc0, 0x08c7, 0x0243, 0xfd70,
0xfa2a, 0xfaa7, 0xfd07, 0xffcd, 0xffd5, 0xfd40, 0xf962, 0xf479,
0xf2aa, 0xf4a2, 0xfb26, 0x0475, 0x0e26, 0x13ea, 0x133c, 0x0b92,
0xfe88, 0xeeea, 0xe2ea, 0xde25, 0xe2b3, 0xef52, 0x012a, 0x1376,
0x1ead, 0x201b, 0x17a9, 0x0765, 0xf474, 0xe425, 0xdb63, 0xdd7c,
0xe88e, 0xfa3e, 0x0be9, 0x1818, 0x1b75, 0x16bb, 0x0be4, 0xfcfb,
0xf0e7, 0xea0a, 0xea92, 0xef94, 0xf87c, 0x01f6, 0x06b4, 0x088b,
0x0619, 0x0211, 0xfe8a, 0xfd56, 0xfe10, 0x0095, 0x0205, 0x0201,
0xfead, 0xf827, 0xf250, 0xeda7, 0xeda4, 0xf407, 0xff55, 0x0bd0,
0x160c, 0x197a, 0x1407, 0x0713, 0xf740, 0xe730, 0xde43, 0xde00,
0xe6b5, 0xf6e1, 0x09b2, 0x19e8, 0x20f2, 0x1e09, 0x113d, 0x0070,
0xeddd, 0xe0f9, 0xde0a, 0xe3af, 0xf17f, 0x0128, 0x0e8f, 0x1626,
0x1534, 0x0e2d, 0x034c, 0xf780, 0xeff6, 0xecab, 0xefa7, 0xf634,
0xfcc6, 0x0179, 0x01e7, 0x011a, 0xff4f, 0xfd54, 0xfd80, 0x0096,
0x042b, 0x0750, 0x077a, 0x0381, 0xfb19, 0xf131, 0xeaba, 0xe8bb,
0xece7, 0xf7dd, 0x062b, 0x135a, 0x1b0b, 0x1a58, 0x10bf, 0x009b,
0xefb8, 0xe11c, 0xdb9c, 0xe033, 0xed29, 0xff78, 0x1137, 0x1cd2,
0x1ec4, 0x183c, 0x08cd, 0xf676, 0xe85c, 0xe0f9, 0xe1e9, 0xea3f,
0xf889, 0x057e, 0x0e9c, 0x12d8, 0x0f6b, 0x07b7, 0xfe87, 0xf73f,
0xf412, 0xf4c0, 0xf7f8, 0xfc09, 0xfdc2, 0xfdfb, 0xfc1b, 0xf96b,
0xf91c, 0xfb6b, 0xffac, 0x064a, 0x0b4d, 0x0cdb, 0x09b3, 0x0092,
0xf661, 0xeb70, 0xe528, 0xe6c7, 0xef74, 0xfdb5, 0x0d1d, 0x19c8,
0x1d9e, 0x184f, 0x0aa5, 0xf815, 0xe7cb, 0xdd28, 0xdc37, 0xe537,
0xf508, 0x07c3, 0x16ed, 0x1e31, 0x1cbd, 0x11d8, 0x0203, 0xf1d2,
0xe75b, 0xe417, 0xe81b, 0xf21b, 0xfe8d, 0x07fd, 0x0c1a, 0x0c3d,
0x07f1, 0x01f8, 0xfbd0, 0xf9b9, 0xf9f8, 0xfbd8, 0xfd30, 0xfe90,
0xfd3f, 0xf9c5, 0xf5dd, 0xf3ad, 0xf652, 0xfb9f, 0x0505, 0x0c7c,
0x10d5, 0x0fde, 0x081b, 0xfc13, 0xee5d, 0xe465, 0xe1f1, 0xe710,
0xf46a, 0x0584, 0x14d7, 0x1dba, 0x1d7a, 0x134b, 0x01ba, 0xf00a,
0xe1ee, 0xdba7, 0xdf06, 0xeb62, 0xfcdf, 0x0db2, 0x18c8, 0x1adb,
0x1497, 0x08cd, 0xfa9b, 0xef8a, 0xea3a, 0xeacf, 0xf062, 0xfa0c,
0x0217, 0x07ba, 0x08b1, 0x0668, 0x02a4, 0xfe99, 0xfd68, 0xfded,
0x00c3, 0x0122, 0x0139, 0xfd9c, 0xf7c5, 0xf27d, 0xeee9, 0xf045,
0xf620, 0x00d6, 0x0ba0, 0x12d8, 0x1593, 0x0fdf, 0x02ee, 0xf474,
0xe703, 0xdf42, 0xe098, 0xeb09, 0xfae9, 0x0c2b, 0x1a35, 0x1e81,
0x1a12, 0x0d28, 0xfae6, 0xeab2, 0xe048, 0xde94, 0xe5db, 0xf45e,
0x04fd, 0x1176, 0x171d, 0x1535, 0x0cf6, 0x016e, 0xf575, 0xeeca,
0xec7d, 0xeecf, 0xf5e4, 0xfcf6, 0x01b2, 0x03e2, 0x0259, 0xffb8,
0xfdf3, 0xfdf2, 0x0067, 0x03f6, 0x05db, 0x05ab, 0x01e4, 0xfa2e,
0xf1e0, 0xec2f, 0xeb83, 0xefd6, 0xfb57, 0x07d5, 0x1443, 0x1a47,
0x185c, 0x0e03, 0xfe7b, 0xee48, 0xe236, 0xdfb7, 0xe418, 0xf2b5,
0x0450, 0x1474, 0x1de8, 0x1da5, 0x14dc, 0x04eb, 0xf393, 0xe658,
0xe0d0, 0xe372, 0xee26, 0xfcf3, 0x0a2e, 0x1220, 0x13f7, 0x1057,
0x0795, 0xfd31, 0xf5bb, 0xf2c4, 0xf35d, 0xf743, 0xfb87, 0xfe69,
0xfe82, 0xfd40, 0xfb00, 0xfa1d, 0xfd02, 0x0137, 0x05b7, 0x0a61,
0x0b80, 0x0681, 0xfe79, 0xf3f5, 0xeb29, 0xe653, 0xe867, 0xf231,
0x0076, 0x0e87, 0x1861, 0x1b60, 0x1484, 0x0720, 0xf5cd, 0xe667,
0xdefb, 0xdecc, 0xe988, 0xf9d6, 0x0b47, 0x1928, 0x1dcb, 0x1a35,
0x0dd4, 0xfde5, 0xeeec, 0xe619, 0xe48e, 0xea5f, 0xf689, 0x01e5,
0x0aa2, 0x0eba, 0x0d78, 0x0896, 0x00f5, 0xfadf, 0xf782, 0xf7c1,
0xf9ea, 0xfca3, 0xfda4, 0xfcb3, 0xfa11, 0xf6b7, 0xf5df, 0xf845,
0xfeee, 0x06d2, 0x0ddc, 0x105c, 0x0e19, 0x05b7, 0xf9f1, 0xed27,
0xe50f, 0xe3f2, 0xe9f5, 0xf892, 0x0849, 0x16ec, 0x1d93, 0x1b62,
0x0ffc, 0xff45, 0xedd6, 0xe0bd, 0xdce4, 0xe280, 0xef48, 0xffe8,
0x0f95, 0x186c, 0x19fe, 0x11ca, 0x052b, 0xf6eb, 0xec4a, 0xe84e,
0xea49, 0xf1e1, 0xfc08, 0x04ae, 0x09ba, 0x0a0a, 0x060b, 0x01f4,
0xfdd2, 0xfb1b, 0xfb7e, 0xfe9b, 0xffce, 0xff7f, 0xfd0d, 0xf839,
0xf469, 0xf1a7, 0xf3ac, 0xf9ea, 0x03e5, 0x0d9f, 0x134b, 0x1426,
0x0d26, 0x00dc, 0xf1dc, 0xe551, 0xdfee, 0xe2a7, 0xede3, 0xfe61,
0x0f25, 0x1bda, 0x1ecf, 0x17e3, 0x0a0f, 0xf8bf, 0xe8fe, 0xe092,
0xe01c, 0xe831, 0xf775, 0x06db, 0x123d, 0x16ae, 0x1378, 0x0ae4,
0xfed5, 0xf353, 0xed2e, 0xec2b, 0xf0dd, 0xf841, 0xff32, 0x0379,
0x0572, 0x0303, 0x0096, 0xfdad, 0xfca4, 0xff40, 0x0138, 0x03f9,
0x0348, 0xff83, 0xf951, 0xf299, 0xed4d, 0xedaa, 0xf323, 0xfd5b,
0x09fa, 0x1372, 0x17c2, 0x1486, 0x09ab, 0xfae7, 0xeba5, 0xe1a7,
0xdff0, 0xe71e, 0xf56c, 0x06a5, 0x154d, 0x1da8, 0x1cd0, 0x11e1,
0x01ad, 0xf051, 0xe4ab, 0xe040, 0xe478, 0xefc2, 0xfe51, 0x0aef,
0x11f9, 0x135e, 0x0d54, 0x03e3, 0xfab5, 0xf361, 0xf199, 0xf353,
0xf7ec, 0xfd36, 0x005f, 0x0125, 0xff4c, 0xfc19, 0xfad9, 0xfc64,
0x0093, 0x054f, 0x0848, 0x08b8, 0x04ca, 0xfd56, 0xf3c1, 0xecd0,
0xe924, 0xec90, 0xf6d6, 0x0346, 0x1054, 0x1892, 0x18af, 0x10aa,
0x0215, 0xf272, 0xe423, 0xddcc, 0xe12b, 0xeb86, 0xfcf2, 0x0dd3,
0x198b, 0x1d5e, 0x179f, 0x0b1b, 0xfb88, 0xecaa, 0xe4f6, 0xe44a,
0xeb52, 0xf7ef, 0x0336, 0x0c33, 0x0ff6, 0x0ddb, 0x07ce, 0xfff2,
0xfa00, 0xf68a, 0xf750, 0xfa59, 0xfcda, 0xfe42, 0xfdcb, 0xfb6d,
0xf7ef, 0xf751, 0xf986, 0xfe8a, 0x0505, 0x0b23, 0x0d34, 0x0b00,
0x02ae, 0xf7cb, 0xee09, 0xe68e, 0xe6e7, 0xee04, 0xfb1b, 0x0a2b,
0x1674, 0x1b10, 0x1785, 0x0abf, 0xfae8, 0xeaad, 0xe058, 0xdec8,
0xe591, 0xf432, 0x03b0, 0x1303, 0x1a33, 0x1923, 0x1014, 0x0287,
0xf471, 0xeb48, 0xe7e7, 0xe9ef, 0xf298, 0xfcf9, 0x0531, 0x0918,
0x094c, 0x056a, 0x00f9, 0xfc3f, 0xfa2f, 0xfb4d, 0xfd42, 0xff62,
0xff65, 0xfcb4, 0xf92d, 0xf502, 0xf2ed, 0xf4f8, 0xfaf5, 0x03e1,
0x0b79, 0x1197, 0x1070, 0x0982, 0xfe8f, 0xf08b, 0xe75e, 0xe3d0,
0xe6bc, 0xf229, 0x01fa, 0x1120, 0x1a05, 0x1b61, 0x1403, 0x04be,
0xf458, 0xe6e6, 0xe03b, 0xe225, 0xec2f, 0xfaa0, 0x0a0a, 0x1378,
0x1740, 0x1331, 0x0879, 0xfbe0, 0xf165, 0xec59, 0xec73, 0xf13e,
0xf83f, 0x00a4, 0x04af, 0x0570, 0x040f, 0x00b3, 0xfdc5, 0xfd7d,
0xff98, 0x0134, 0x0243, 0x01a2, 0xfdba, 0xf824, 0xf178, 0xeefa,
0xef69, 0xf4f9, 0xffb4, 0x09db, 0x1210, 0x140a, 0x100b, 0x05d6,
0xf7a4, 0xeac8, 0xe320, 0xe2e2, 0xeb26, 0xf960, 0x09d4, 0x1630,
0x1bef, 0x18a3, 0x0d34, 0xfd9e, 0xef04, 0xe53a, 0xe2ae, 0xe8e3,
0xf4c0, 0x0211, 0x0d2e, 0x1335, 0x11ef, 0x0bc4, 0x01fa, 0xf824,
0xf1cf, 0xefb8, 0xf201, 0xf70c, 0xfca0, 0xffe0, 0x00cb, 0xff75,
0xfd67, 0xfcfd, 0xfdbc, 0x00be, 0x047f, 0x075f, 0x06da, 0x02fc,
0xfb10, 0xf279, 0xecd1, 0xeb14, 0xeeeb, 0xf8bd, 0x0572, 0x103a,
0x169b, 0x155e, 0x0d96, 0x0009, 0xf176, 0xe56b, 0xe0e7, 0xe51b,
0xf0ad, 0x006b, 0x0ee1, 0x1914, 0x1928, 0x12e5, 0x059d, 0xf6ac,
0xeb3c, 0xe509, 0xe71e, 0xee76, 0xfb02, 0x0583, 0x0d0a, 0x0f23,
0x0c1a, 0x05dd, 0xfdbe, 0xf7ad, 0xf560, 0xf6a6, 0xf972, 0xfd32,
0xff06, 0xff31, 0xfcc0, 0xfa6b, 0xf9c0, 0xfb72, 0xffb6, 0x0503,
0x0a34, 0x0b48, 0x082d, 0x00af, 0xf640, 0xed9e, 0xe8c7, 0xe985,
0xf202, 0xfeca, 0x0be8, 0x15d3, 0x196a, 0x1451, 0x07a0, 0xf8d9,
0xeb1e, 0xe25f, 0xe172, 0xe962, 0xf6cd, 0x062e, 0x126b, 0x17d5,
0x152d, 0x0ba4, 0xfed5, 0xf1fe, 0xea7c, 0xe8a1, 0xec93, 0xf4ed,
0xffa4, 0x07a7, 0x0b0f, 0x092b, 0x0469, 0xfff9, 0xfb57, 0xf9d6,
0xfac7, 0xfd4c, 0xff5c, 0x000f, 0xfde8, 0xfb10, 0xf749, 0xf629,
0xf926, 0xfe5f, 0x0635, 0x0c3c, 0x0fb9, 0x0d78, 0x05e0, 0xfb02,
0xf003, 0xe774, 0xe53b, 0xeac3, 0xf709, 0x05e5, 0x1303, 0x1a29,
0x1929, 0x106e, 0x01ad, 0xf2c0, 0xe6d3, 0xe205, 0xe4d3, 0xf086,
0xfe58, 0x0aa8, 0x13f0, 0x1530, 0x0fa8, 0x0573, 0xfa5d, 0xf1e6,
0xedec, 0xef8c, 0xf514, 0xfd0f, 0x0376, 0x05f8, 0x05c5, 0x0396,
0xfff7, 0xfd0c, 0xfc9c, 0xfd61, 0x004f, 0x0145, 0x0171, 0xfe8b,
0xf95f, 0xf501, 0xf26d, 0xf33b, 0xf904, 0x01fd, 0x0a04, 0x1122,
0x1187, 0x0c72, 0x022e, 0xf426, 0xe989, 0xe3e4, 0xe5e2, 0xee6c,
0xfb97, 0x0a7c, 0x15a4, 0x1a13, 0x1588, 0x09e2, 0xfb86, 0xeecd,
0xe6a1, 0xe5d4, 0xebd6, 0xf793, 0x0448, 0x0ddb, 0x1255, 0x110f,
0x098c, 0x0042, 0xf7cd, 0xf311, 0xf27d, 0xf522, 0xf9df, 0xfea8,
0x01e1, 0x0190, 0x0063, 0xfdc9, 0xfc84, 0xfd14, 0xffc1, 0x02f8,
0x04c9, 0x0454, 0x00ec, 0xfa0a, 0xf3e4, 0xeec4, 0xee55, 0xf2b0,
0xfb6f, 0x0690, 0x0fd8, 0x144c, 0x11c6, 0x091f, 0xfbde, 0xef30,
0xe634, 0xe479, 0xe8f9, 0xf4f4, 0x0353, 0x107e, 0x181d, 0x17d9,
0x0f3e, 0x01e3, 0xf491, 0xe9ff, 0xe57e, 0xe853, 0xf184, 0xfd13,
0x0695, 0x0d12, 0x0eb1, 0x0a74, 0x0408, 0xfc5e, 0xf7cb, 0xf5fd,
0xf820, 0xfa6b, 0xfd27, 0xffbc, 0xfebf, 0xfced, 0xfab6, 0xf9fd,
0xfb92, 0x0006, 0x053a, 0x0902, 0x096c, 0x05d5, 0xfee8, 0xf619,
0xee8f, 0xec21, 0xed50, 0xf554, 0x00f5, 0x0bfd, 0x145a, 0x15eb,
0x0fb9, 0x0408, 0xf73d, 0xea67, 0xe468, 0xe569, 0xeecd, 0xfbde,
0x0938, 0x131c, 0x1757, 0x138c, 0x08c4, 0xfc7b, 0xf07e, 0xeade,
0xe925, 0xee28, 0xf707, 0x00e2, 0x077e, 0x0a61, 0x092e, 0x0439,
0xff53, 0xfa47, 0xf93f, 0xf9a6, 0xfc4f, 0xfde2, 0xfe75, 0xfd26,
0xfa3b, 0xf7aa, 0xf5ec, 0xf810, 0xfca8, 0x03cf, 0x0920, 0x0bc4,
0x0aa1, 0x03bd, 0xfa11, 0xf103, 0xea53, 0xe89f, 0xee8c, 0xf984,
0x0602, 0x1149, 0x16de, 0x1579, 0x0c02, 0xfe62, 0xf15a, 0xe778,
0xe3fe, 0xe969, 0xf42e, 0x013a, 0x0dc9, 0x1343, 0x1377, 0x0c4a,
0x0221, 0xf811, 0xef2a, 0xec13, 0xee72, 0xf452, 0xfc24, 0x02ed,
0x0547, 0x04f6, 0x0285, 0xffa0, 0xfcbd, 0xfbb3, 0xfd91, 0xffcf,
0x00bc, 0x007b, 0xfe23, 0xf8ea, 0xf410, 0xf2c7, 0xf4c5, 0xfabe,
0x022d, 0x0a05, 0x0f87, 0x0f74, 0x0a30, 0xff23, 0xf3aa, 0xea2c,
0xe615, 0xe91a, 0xf214, 0xff10, 0x0bec, 0x1494, 0x16f1, 0x1188,
0x0613, 0xf88d, 0xed27, 0xe61c, 0xe727, 0xeeac, 0xfa68, 0x0656,
0x0e8e, 0x121c, 0x0e36, 0x0729, 0xfd39, 0xf586, 0xf0c4, 0xf0ff,
0xf55b, 0xfa9f, 0xff8f, 0x02c8, 0x037c, 0x00e5, 0xff31, 0xfd8a,
0xfea1, 0x008a, 0x021b, 0x0407, 0x0377, 0xffe5, 0xf9ac, 0xf3f4,
0xefcd, 0xf068, 0xf582, 0xfe0b, 0x0801, 0x0fb0, 0x133e, 0x1093,
0x07a5, 0xfabc, 0xef76, 0xe71e, 0xe577, 0xec36, 0xf75d, 0x04ca,
0x0f93, 0x15a6, 0x1412, 0x0aa9, 0xff09, 0xf218, 0xea12, 0xe7b8,
0xebe1, 0xf4f5, 0x0094, 0x09f1, 0x0eb1, 0x0e5a, 0x08d2, 0x0206,
0xfa92, 0xf5d7, 0xf3b1, 0xf6ba, 0xfa6e, 0xfdfb, 0x005d, 0x00ee,
0xff04, 0xfd9a, 0xfd4b, 0xfe14, 0x01d5, 0x0589, 0x0833, 0x077e,
0x038c, 0xfd44, 0xf64c, 0xee7b, 0xec48, 0xef45, 0xf713, 0x0323,
0x0d26, 0x135a, 0x13c5, 0x0db9, 0x0298, 0xf5b0, 0xea9a, 0xe508,
0xe80e, 0xf1a1, 0xfe4f, 0x0b2d, 0x141a, 0x15ae, 0x0f81, 0x0555,
0xf9f2, 0xeff1, 0xea4e, 0xeac0, 0xf0e5, 0xfa86, 0x031f, 0x0843,
0x0a4a, 0x085d, 0x0411, 0xfdc3, 0xf9ca, 0xf953, 0xf96c, 0xfbbc,
0xfdfb, 0xffcb, 0xfe9b, 0xfb77, 0xf98b, 0xf90f, 0xfa53, 0xff8a,
0x04d2, 0x090f, 0x0b34, 0x07e7, 0x01f7, 0xf7cd, 0xef2a, 0xea17,
0xea85, 0xf182, 0xfcfc, 0x091b, 0x12cb, 0x15fc, 0x11e8, 0x089b,
0xfc00, 0xf030, 0xe79c, 0xe5ec, 0xec06, 0xf7fd, 0x04b2, 0x0f22,
0x13dd, 0x12d6, 0x0ba0, 0x018d, 0xf75b, 0xf076, 0xeebe, 0xf093,
0xf73b, 0xff86, 0x04b6, 0x065c, 0x0618, 0x02d2, 0xfed0, 0xfc0a,
0xfa9f, 0xfc3a, 0xfe86, 0x0057, 0xffd7, 0xfd68, 0xfa5f, 0xf706,
0xf5de, 0xf75c, 0xfc5b, 0x02fc, 0x0906, 0x0d35, 0x0bb5, 0x0579,
0xfd49, 0xf25d, 0xeafc, 0xe7f5, 0xec4e, 0xf633, 0x02c6, 0x0e0a,
0x14dc, 0x163c, 0x0ee0, 0x0382, 0xf610, 0xebca, 0xe64d, 0xe87a,
0xf0f4, 0xfcee, 0x07d6, 0x0e81, 0x10ad, 0x0d6e, 0x0582, 0xfbfe,
0xf50a, 0xf17d, 0xf2aa, 0xf68c, 0xfc48, 0x0195, 0x0458, 0x03fd,
0x01ee, 0xff57, 0xfd5b, 0xfd53, 0xff55, 0x0160, 0x0208, 0x01da,
0xfefb, 0xf956, 0xf475, 0xf23a, 0xf298, 0xf797, 0xffa1, 0x0845,
0x0e54, 0x1081, 0x0cb7, 0x0304, 0xf822, 0xed8c, 0xe82e, 0xe87e,
0xefc2, 0xfbc2, 0x0804, 0x11cb, 0x15fc, 0x11f2, 0x0897, 0xfd03,
0xf0ee, 0xea24, 0xe88e, 0xee9c, 0xf80e, 0x02ee, 0x0ad2, 0x0e5d,
0x0d7a, 0x077d, 0x006b, 0xf95b, 0xf49a, 0xf409, 0xf6bd, 0xfa2c,
0xfdd7, 0x000d, 0x0029, 0xfe1d, 0xfc73, 0xfba3, 0xfdb8, 0x00f2,
0x042e, 0x062b, 0x0562, 0x0260, 0xfc37, 0xf5d0, 0xf10b, 0xef8b,
0xf2fe, 0xfb25, 0x04c7, 0x0d8b, 0x1339, 0x10f0, 0x09f3, 0xff69,
0xf34f, 0xeafa, 0xe7f7, 0xec30, 0xf57f, 0x01ee, 0x0d0f, 0x133f,
0x13b6, 0x0dfb, 0x0376, 0xf834, 0xef48, 0xea75, 0xec4f, 0xf26f,
0xfbc6, 0x0430, 0x094a, 0x0b37, 0x07b3, 0x0359, 0xfe21, 0xfa44,
0xf92a, 0xfa74, 0xfc1b, 0xfe60, 0xff35, 0xfd98, 0xfbd3, 0xf9a5,
0xf96b, 0xfaf1, 0xff98, 0x0455, 0x082c, 0x0985, 0x0733, 0x002f,
0xf816, 0xf0eb, 0xecaf, 0xee50, 0xf49d, 0xff4f, 0x0927, 0x10bf,
0x128b, 0x0da8, 0x051e, 0xf932, 0xeea0, 0xe8c5, 0xe8a6, 0xef81,
0xfa76, 0x060c, 0x0ede, 0x134a, 0x10d0, 0x08de, 0xfe06, 0xf562,
0xefcd, 0xee07, 0xf23b, 0xf8ac, 0x00b5, 0x04db, 0x06ff, 0x063e,
0x0319, 0xff93, 0xfb59, 0xfb05, 0xfc7b, 0xfe1f, 0xffea, 0xff77,
0xfcf9, 0xf9e2, 0xf6f9, 0xf61c, 0xf81e, 0xfd65, 0x0380, 0x08cc,
0x0c3b, 0x0ab3, 0x0482, 0xfc33, 0xf2b3, 0xec36, 0xeb2b, 0xef02,
0xf8ea, 0x0382, 0x0d62, 0x12eb, 0x1211, 0x0ae8, 0xff73, 0xf44c,
0xeb8e, 0xe8e6, 0xec50, 0xf4ec, 0xff9f, 0x09cb, 0x0f25, 0x0f61,
0x0a46, 0x0287, 0xfa0a, 0xf313, 0xf0ec, 0xf265, 0xf6d3, 0xfcf1,
0x01ad, 0x048f, 0x042f, 0x0247, 0xffb0, 0xfe1f, 0xfe04, 0xfe8b,
0x00ae, 0x0119, 0x0069, 0xfcc7, 0xf8f6, 0xf4e2, 0xf312, 0xf4bb,
0xfa17, 0x01ea, 0x095f, 0x0e68, 0x0eb0, 0x0a1f, 0x01e2, 0xf76c,
0xee08, 0xea95, 0xebc0, 0xf271, 0xfd42, 0x0891, 0x10b7, 0x12fe,
0x0f0f, 0x05fb, 0xfa4b, 0xf024, 0xeb38, 0xebbb, 0xf0c6, 0xfa65,
0x041f, 0x0ad3, 0x0d06, 0x0ba3, 0x059b, 0xfe5e, 0xf881, 0xf465,
0xf4ea, 0xf716, 0xfc0f, 0x0005, 0x0172, 0x0168, 0x000d, 0xfe58,
0xfd7c, 0xff24, 0x0117, 0x0370, 0x049e, 0x036c, 0x0082, 0xfa91,
0xf4d6, 0xf0b3, 0xf00b, 0xf400, 0xfc05, 0x0542, 0x0c71, 0x1008,
0x0dad, 0x0687, 0xfc3d, 0xf241, 0xeabd, 0xe8fb, 0xedf3, 0xf773,
0x0218, 0x0c83, 0x1276, 0x11a8, 0x0b57, 0x0152, 0xf714, 0xeeca,
0xec1c, 0xeef8, 0xf5ec, 0xfed5, 0x05ef, 0x09a9, 0x09b2, 0x05e0,
0x0123, 0xfb87, 0xf7a4, 0xf702, 0xf882, 0xfb90, 0xfddc, 0xfe40,
0xfdf7, 0xfc9b, 0xfa8c, 0xfae7, 0xfc6b, 0x003f, 0x04a6, 0x073e,
0x073d, 0x0432, 0xfe4f, 0xf726, 0xf122, 0xef25, 0xf0da, 0xf7ee,
0x0119, 0x0928, 0x1044, 0x10cf, 0x0bf5, 0x01e3, 0xf6b4, 0xedbf,
0xe8d2, 0xea1d, 0xf1e7, 0xfc5e, 0x06c8, 0x0eed, 0x1172, 0x0dc4,
0x06b4, 0xfcdd, 0xf406, 0xef65, 0xef55, 0xf43b, 0xfb45, 0x01f3,
0x05ef, 0x0827, 0x0629, 0x02ec, 0xfef0, 0xfb5b, 0xf9fd, 0xfb7b,
0xfd63, 0xff8f, 0x001b, 0xfe2e, 0xfb3c, 0xf909, 0xf8ef, 0xfa8b,
0xfeda, 0x02ed, 0x0783, 0x08b5, 0x06d8, 0x01b7, 0xf9fe, 0xf237,
0xed76, 0xee3d, 0xf32b, 0xfc4d, 0x0649, 0x0e97, 0x12ff, 0x1020,
0x0883, 0xfdac, 0xf2de, 0xec11, 0xea7a, 0xeea3, 0xf751, 0x01a7,
0x09fa, 0x0f39, 0x0ebd, 0x08e8, 0x0166, 0xf9c9, 0xf382, 0xf21e,
0xf3ff, 0xf88c, 0xfe78, 0x0289, 0x0488, 0x036b, 0x0179, 0xfe7f,
0xfcfd, 0xfd09, 0xfe06, 0x0074, 0x0116, 0x00b7, 0xfdd8, 0xf98e,
0xf686, 0xf5c2, 0xf74d, 0xfc06, 0x01d5, 0x07d7, 0x0bf0, 0x0b88,
0x06e9, 0xfeb5, 0xf5be, 0xee9b, 0xeb74, 0xee3d, 0xf5d6, 0x00c3,
0x0a6f, 0x1117, 0x1275, 0x0c64, 0x0340, 0xf83c, 0xeffe, 0xeb45,
0xebcc, 0xf1f1, 0xfbcc, 0x049b, 0x0a8b, 0x0c51, 0x0a07, 0x0466,
0xfd52, 0xf79f, 0xf41d, 0xf421, 0xf758, 0xfc04, 0xff33, 0x0111,
0x00bb, 0x000f, 0xfe1e, 0xfd56, 0xfe02, 0x0064, 0x02f5, 0x0427,
0x0349, 0xffea, 0xfb7f, 0xf567, 0xf31e, 0xf2f3, 0xf6d1, 0xfde3,
0x05cb, 0x0c50, 0x0de6, 0x0b76, 0x0486, 0xfa17, 0xf118, 0xec50,
0xebf7, 0xf182, 0xfa39, 0x058c, 0x0d36, 0x11a5, 0x0f06, 0x07ad,
0xfea6, 0xf498, 0xedff, 0xec79, 0xf098, 0xf78c, 0x00d9, 0x07a6,
0x0a9a, 0x099d, 0x060a, 0x0069, 0xfb80, 0xf7f9, 0xf725, 0xf8da,
0xfc14, 0xfddf, 0xff7e, 0xfe69, 0xfc84, 0xfb21, 0xfb59, 0xfdc8,
0x000a, 0x0444, 0x0621, 0x0620, 0x032b, 0xfdbc, 0xf6cb, 0xf252,
0xf091, 0xf307, 0xf9d5, 0x0245, 0x0a3b, 0x0edf, 0x0e53, 0x08a4,
0xff57, 0xf62b, 0xee8e, 0xeb62, 0xee60, 0xf5f7, 0xff8b, 0x08b7,
0x0f69, 0x0f50, 0x0ab7, 0x02cc, 0xf9a8, 0xf2bf, 0xef55, 0xf01d,
0xf584, 0xfbd9, 0x0309, 0x06d5, 0x07ee, 0x059a, 0x01d3, 0xfe11,
0xfb2b, 0xfae9, 0xfb5b, 0xfd70, 0xfebb, 0xff42, 0xfdbe, 0xfb45,
0xf968, 0xf9a2, 0xfb63, 0x0032, 0x04d8, 0x0878, 0x0970, 0x0753,
0x01a8, 0xf97e, 0xf2e4, 0xeed4, 0xef0c, 0xf49a, 0xfd2c, 0x05e6,
0x0d6a, 0x0f5f, 0x0c0b, 0x040f, 0xfa4a, 0xf0ce, 0xeb83, 0xec07,
0xf164, 0xfaaa, 0x03ff, 0x0afc, 0x0e7d, 0x0cd9, 0x0669, 0xfead,
0xf750, 0xf2e2, 0xf233, 0xf4f3, 0xfb0f, 0x00f7, 0x042e, 0x0513,
0x0462, 0x026e, 0xfebe, 0xfcc7, 0xfcab, 0xfd89, 0xffc9, 0x0011,
0xff58, 0xfcba, 0xf9f3, 0xf785, 0xf654, 0xf8cc, 0xfde1, 0x030a,
0x07e0, 0x0b1b, 0x0997, 0x0524, 0xfca8, 0xf3e6, 0xeeaf, 0xed5a,
0xf095, 0xf873, 0x01bc, 0x0ae6, 0x1052, 0x0fe5, 0x0a08, 0x00c3,
0xf74a, 0xefee, 0xed2a, 0xef47, 0xf6e7, 0xfe6b, 0x0650, 0x0be9,
0x0bdc, 0x085c, 0x016b, 0xfb3f, 0xf633, 0xf415, 0xf542, 0xf888,
0xfdad, 0x010b, 0x024b, 0x01ef, 0x00b2, 0xfe61, 0xfdaa, 0xfe03,
0xffcb, 0x01a2, 0x01e9, 0x0103, 0xfd9c, 0xf9d4, 0xf608, 0xf3a7,
0xf51c, 0xf9f3, 0x0061, 0x06e6, 0x0b95, 0x0c61, 0x08d2, 0x0160,
0xf84c, 0xf0a6, 0xebdb, 0xed33, 0xf3bc, 0xfd3a, 0x0682, 0x0d79,
0x103f, 0x0cfb, 0x05ca, 0xfcfc, 0xf47e, 0xefdf, 0xef58, 0xf3a8,
0xfa58, 0x0216, 0x080c, 0x0958, 0x0862, 0x03c9, 0xfe61, 0xfa1d,
0xf73c, 0xf730, 0xf968, 0xfc24, 0xff41, 0x002b, 0xffd9, 0xfd90,
0xfcb7, 0xfcea, 0xfd8d, 0x0030, 0x0289, 0x040e, 0x03eb, 0x00b0,
0xfb75, 0xf688, 0xf2d7, 0xf287, 0xf5cf, 0xfcf2, 0x047e, 0x0ac4,
0x0d8d, 0x0c0b, 0x05cb, 0xfd8c, 0xf4af, 0xee24, 0xec14, 0xf039,
0xf88f, 0x0132, 0x0a30, 0x0ea9, 0x0ec8, 0x0962, 0x0139, 0xf931,
0xf293, 0xf07a, 0xf221, 0xf70f, 0xfdb8, 0x03b3, 0x05d3, 0x05d3,
0x03f5, 0xfff3, 0xfc24, 0xfa4b, 0xfa5d, 0xfb28, 0xfd4d, 0xff01,
0xffcd, 0xfe05, 0xfbd4, 0xfa96, 0xfa6d, 0xfcb5, 0x00a7, 0x045e,
0x06cc, 0x06f7, 0x041e, 0xff48, 0xf8b0, 0xf338, 0xf1ca, 0xf35a,
0xf8e4, 0x00eb, 0x0847, 0x0dc6, 0x0e60, 0x0a37, 0x0298, 0xf8c2,
0xf02d, 0xec6d, 0xeccc, 0xf350, 0xfc3b, 0x0528, 0x0b78, 0x0d47,
0x0b48, 0x0503, 0xfd97, 0xf678, 0xf38e, 0xf324, 0xf632, 0xfb45,
0xfff5, 0x039e, 0x04b5, 0x03a5, 0x0139, 0xfeb1, 0xfd2c, 0xfda2,
0xfe93, 0x006d, 0x014f, 0x004d, 0xfe20, 0xfac2, 0xf8bd, 0xf8b3,
0xf9d9, 0xfe33, 0x029d, 0x071d, 0x0936, 0x06b3, 0x0289, 0xfad8,
0xf3dc, 0xefe6, 0xef58, 0xf37c, 0xfbaa, 0x042b, 0x0b57, 0x0f03,
0x0ceb, 0x076b, 0xfe1b, 0xf52d, 0xef9c, 0xed2a, 0xf0c7, 0xf7d0,
0xffae, 0x0763, 0x0bcc, 0x0b5a, 0x074c, 0x011f, 0xfb01, 0xf61a,
0xf459, 0xf5b6, 0xf940, 0xfdf3, 0x00b0, 0x01c4, 0x0132, 0xff7f,
0xfd55, 0xfcf2, 0xfd51, 0xff68, 0x013d, 0x015c, 0x00be, 0xfde3,
0xfa96, 0xf6df, 0xf59c, 0xf6ed, 0xfaf8, 0x010e, 0x06a7, 0x0a7b,
0x0ab3, 0x06ce, 0x0036, 0xf88c, 0xf1e3, 0xeef0, 0xf084, 0xf6d2,
0xff14, 0x0791, 0x0c96, 0x0d64, 0x09b9, 0x0260, 0xf9c7, 0xf32c,
0xef65, 0xef8e, 0xf557, 0xfd5f, 0x0419, 0x08b7, 0x0afd, 0x0776,
0x039f, 0xfe6e, 0xf96d, 0xf747, 0xf7a3, 0xfa2e, 0xfcee, 0xffc4,
0x00d9, 0x0052, 0xff5a, 0xfe20, 0xfdd2, 0xff60, 0x013f, 0x03b1,
0x04c3, 0x0333, 0xff8d, 0xfb35, 0xf6f9, 0xf39d, 0xf324, 0xf76d,
0xfd52, 0x045c, 0x0a57, 0x0c59, 0x0a68, 0x042b, 0xfc61, 0xf494,
0xefe1, 0xef80, 0xf2d4, 0xfb37, 0x0378, 0x09e0, 0x0d50, 0x0bab,
0x066d, 0xfe6d, 0xf767, 0xf202, 0xf120, 0xf3a7, 0xf962, 0x0067,
0x0541, 0x07d1, 0x07a6, 0x047a, 0x00c0, 0xfca0, 0xf9d2, 0xfa00,
0xfaf7, 0xfd16, 0xfdea, 0xfe18, 0xfdc0, 0xfc38, 0xfae4, 0xfb4a,
0xfdaa, 0x0118, 0x038d, 0x059d, 0x0572, 0x02b1, 0xfdfc, 0xf7f1,
0xf3be, 0xf209, 0xf3ec, 0xf9f8, 0x017d, 0x0875, 0x0ca4, 0x0c63,
0x087e, 0x00b1, 0xf7b3, 0xf0fc, 0xeeee, 0xf0a4, 0xf689, 0xff13,
0x0626, 0x0b13, 0x0bea, 0x0903, 0x026a, 0xfadb, 0xf5a7, 0xf29d,
0xf306, 0xf77a, 0xfcb5, 0x0228, 0x04bc, 0x0540, 0x03d2, 0x00cb,
0xfe44, 0xfbe6, 0xfcd4, 0xfcf9, 0xff62, 0x0071, 0x002a, 0xfddb,
0xfad2, 0xfa17, 0xf9f1, 0xfb58, 0xffa4, 0x0426, 0x06b0, 0x080c,
0x0556, 0x0161, 0xf9b0, 0xf42a, 0xf0be, 0xf17e, 0xf5c6, 0xfce9,
0x05e1, 0x0b7b, 0x0d39, 0x0a75, 0x04cb, 0xfcce, 0xf5a2, 0xf073,
0xf096, 0xf3de, 0xfabd, 0x02a7, 0x07e3, 0x0b17, 0x0a4b, 0x04c4,
0xfea8, 0xf971, 0xf62a, 0xf645, 0xf75a, 0xfbd0, 0x0072, 0x020d,
0x0247, 0x01c5, 0x0000, 0xfd78, 0xfcad, 0xfce8, 0xfd8f, 0xff94,
0x0041, 0xff14, 0xfd29, 0xfa6b, 0xf7c1, 0xf6fc, 0xf94d, 0xfd3a,
0x024d, 0x073a, 0x09ae, 0x0890, 0x04b2, 0xfdba, 0xf65b, 0xf13e,
0xf010, 0xf2a3, 0xf867, 0x016f, 0x08a9, 0x0cb8, 0x0c91, 0x085b,
0x018a, 0xf9c0, 0xf369, 0xf085, 0xf298, 0xf719, 0xfe8f, 0x0456,
0x07bc, 0x0901, 0x0598, 0x013c, 0xfc45, 0xf8be, 0xf6b2, 0xf80b,
0xfaaf, 0xfe0b, 0x00ed, 0x0130, 0x00e3, 0xfebc, 0xfd6b, 0xfce1,
0xfe04, 0xfffc, 0x01ca, 0x0214, 0x015a, 0xfe9f, 0xfa5e, 0xf777,
0xf4a3, 0xf63d, 0xf950, 0xff48, 0x0546, 0x08ff, 0x0aac, 0x072a,
0x01cd, 0xfa4a, 0xf3fe, 0xf058, 0xf0ff, 0xf4fc, 0xfc4c, 0x0454,
0x0a38, 0x0c97, 0x09df, 0x04ef, 0xfd0a, 0xf605, 0xf240, 0xf241,
0xf4bb, 0xfa93, 0x00a0, 0x051c, 0x0713, 0x0618, 0x03e2, 0xff34,
0xfb94, 0xf9f6, 0xfa50, 0xfbf2, 0xfe65, 0xffb9, 0x0078, 0xfece,
0xfd43, 0xfc4b, 0xfc19, 0xfdca, 0x000b, 0x02ff, 0x04d0, 0x04a6,
0x020b, 0xfd3e, 0xf8bb, 0xf515, 0xf40b, 0xf7b3, 0xfc83, 0x030c,
0x08c4, 0x0c09, 0x0abb, 0x05d6, 0xfe4d, 0xf6cc, 0xf154, 0xef7a,
0xf298, 0xf937, 0x0120, 0x0733, 0x0bbf, 0x0b8b, 0x07ca, 0x0134,
0xfa23, 0xf4cb, 0xf2c3, 0xf34c, 0xf780, 0xfd7e, 0x0191, 0x0439,
0x04ab, 0x0312, 0x0011, 0xfdde, 0xfc57, 0xfc9e, 0xfd93, 0xff27,
0x0022, 0xff8f, 0xfddb, 0xfb96, 0xfa32, 0xfa21, 0xfbca, 0xff92,
0x0352, 0x058d, 0x0608, 0x03d8, 0xffc4, 0xf9aa, 0xf507, 0xf273,
0xf3e3, 0xf877, 0xfefd, 0x0644, 0x0ad7, 0x0c7a, 0x08d6, 0x02d8,
0xfa53, 0xf362, 0xf026, 0xf097, 0xf4f1, 0xfc07, 0x0394, 0x0868,
0x0b44, 0x0917, 0x03f2, 0xfe5b, 0xf91c, 0xf67b, 0xf636, 0xf7a9,
0xfb90, 0xffc1, 0x0261, 0x0272, 0x0197, 0xffd4, 0xfda5, 0xfd48,
0xfd65, 0xfeba, 0x0036, 0x003e, 0xffa0, 0xfd3e, 0xfabb, 0xf85d,
0xf79b, 0xf9e6, 0xfd98, 0x01cd, 0x057f, 0x07cd, 0x06ca, 0x0270,
0xfca9, 0xf64a, 0xf277, 0xf220, 0xf481, 0xfb3a, 0x01f2, 0x07f0,
0x0b8d, 0x0a97, 0x0546, 0xfee8, 0xf7db, 0xf2b8, 0xf1d6, 0xf397,
0xf992, 0x0000, 0x0589, 0x08d3, 0x087c, 0x0578, 0x0099, 0xfc27,
0xf87f, 0xf6f0, 0xf83a, 0xfa6e, 0xfd94, 0x004a, 0x00be, 0x006d,
0xfee0, 0xfdd6, 0xfe4f, 0xfebc, 0x00b9, 0x019a, 0x0277, 0x010b,
0xfe4c, 0xfb34, 0xf775, 0xf5f4, 0xf6eb, 0xfb29, 0x0098, 0x04ed,
0x0811, 0x0945, 0x05c1, 0x0098, 0xfa0e, 0xf468, 0xf219, 0xf30f,
0xf78b, 0xff25, 0x0564, 0x0a1d, 0x0b4f, 0x078c, 0x0223, 0xfb15,
0xf55a, 0xf221, 0xf318, 0xf71f, 0xfc8d, 0x0296, 0x0670, 0x075d,
0x056f, 0x01fd, 0xfe54, 0xfa67, 0xfa64, 0xf9d9, 0xfb80, 0xfd9a,
0xfed7, 0x0054, 0xfeab, 0xfdd4, 0xfd35, 0xfd31, 0xfe93, 0x00bc,
0x025e, 0x0422, 0x02bb, 0xffdb, 0xfc08, 0xf815, 0xf4a2, 0xf4c6,
0xf88b, 0xfc9d, 0x032b, 0x07aa, 0x0930, 0x086b, 0x03b3, 0xfd31,
0xf69f, 0xf258, 0xf232, 0xf524, 0xfb68, 0x020f, 0x06e7, 0x0a87,
0x0983, 0x0500, 0xff5f, 0xf8e6, 0xf4a9, 0xf399, 0xf631, 0xfa48,
0xff69, 0x039e, 0x051a, 0x04e3, 0x026c, 0xfeee, 0xfc3a, 0xfa6f,
0xfa4a, 0xfc2f, 0xfdfa, 0xfe2d, 0xfe49, 0xfdc4, 0xfb74, 0xfb2c,
0xfb35, 0xfce4, 0xfffa, 0x02ce, 0x0489, 0x04d7, 0x0332, 0xfde1,
0xf956, 0xf53a, 0xf3e6, 0xf60d, 0xfab8, 0x005a, 0x06de, 0x0a90,
0x0a4a, 0x0679, 0x00ba, 0xfa27, 0xf3be, 0xf216, 0xf2d3, 0xf795,
0xfe4f, 0x03db, 0x079b, 0x093e, 0x062b, 0x0172, 0xfbf3, 0xf7d8,
0xf599, 0xf6a3, 0xf9ca, 0xfdbd, 0x00f4, 0x0274, 0x038a, 0x0142,
0xff73, 0xfd19, 0xfd01, 0xfcde, 0xfe9a, 0xffd3, 0x003c, 0xffa4,
0xfdd0, 0xfb72, 0xfa15, 0xf9df, 0xfbc2, 0xffa1, 0x0226, 0x05c9,
0x0607, 0x04ee, 0x008f, 0xfb6f, 0xf5b1, 0xf2f7, 0xf32f, 0xf6db,
0xfd7c, 0x03a5, 0x0938, 0x0b21, 0x0906, 0x041e, 0xfdbb, 0xf798,
0xf3a3, 0xf275, 0xf5dd, 0xfacb, 0x0094, 0x059f, 0x0823, 0x06c3,
0x0424, 0xff95, 0xfad7, 0xf908, 0xf8c1, 0xf995, 0xfc79, 0xffb0,
0x013f, 0x01d4, 0x0116, 0xff61, 0xfda3, 0xfd61, 0xfdaf, 0xff3d,
0x00c5, 0x0131, 0x003a, 0xfdc4, 0xfb01, 0xf88c, 0xf8aa, 0xf91d,
0xfc8e, 0x017b, 0x054e, 0x080d, 0x0705, 0x0382, 0xfe44, 0xf865,
0xf37b, 0xf2a8, 0xf466, 0xf953, 0xffc2, 0x057a, 0x08dd, 0x0999,
0x0675, 0x00d5, 0xfaba, 0xf586, 0xf328, 0xf3ad, 0xf84e, 0xfd54,
0x027e, 0x0546, 0x0632, 0x04a0, 0x0156, 0xfd46, 0xf9d6, 0xf9b9,
0xf9e8, 0xfc0b, 0xfe53, 0x0005, 0x0052, 0xff76, 0xfe12, 0xfd18,
0xfd73, 0xfec4, 0x00f6, 0x01fa, 0x020f, 0x01da, 0x001b, 0xfc5e,
0xf887, 0xf618, 0xf700, 0xfa16, 0xfe65, 0x0357, 0x06c9, 0x084a,
0x066d, 0x0105, 0xfb85, 0xf57e, 0xf2bc, 0xf326, 0xf692, 0xfd51,
0x0318, 0x0785, 0x0a4d, 0x087e, 0x03af, 0xfdfd, 0xf80f, 0xf4c7,
0xf3db, 0xf712, 0xfad3, 0xffe7, 0x03cb, 0x0548, 0x0486, 0x01da,
0xff0d, 0xfcb2, 0xfb2f, 0xfbc2, 0xfd97, 0xfe79, 0x006a, 0xff91,
0xfe0f, 0xfc4d, 0xfabd, 0xfb7f, 0xfd3b, 0xff7b, 0x0276, 0x03f4,
0x03d1, 0x011d, 0xfce6, 0xf921, 0xf66b, 0xf62e, 0xf717, 0xfc22,
0x018c, 0x05f7, 0x08c5, 0x07fb, 0x0466, 0xff34, 0xf89f, 0xf3d7,
0xf329, 0xf4fc, 0xfa58, 0xffb2, 0x0510, 0x0869, 0x086c, 0x0596,
0x0158, 0xfbf7, 0xf789, 0xf5f0, 0xf746, 0xf9bf, 0xfd23, 0x00c2,
0x01f9, 0x01de, 0x0133, 0xff85, 0xfd71, 0xfcdd, 0xfd16, 0xfdbd,
0xfe4d, 0x0004, 0xfe4a, 0xfcb5, 0xfb08, 0xf9a4, 0xfa64, 0xfc20,
0xff50, 0x0289, 0x04dc, 0x04eb, 0x039a, 0xffce, 0xfa96, 0xf66b,
0xf3fb, 0xf4be, 0xf8e6, 0xfdfa, 0x0419, 0x0806, 0x08ed, 0x0641,
0x0224, 0xfc19, 0xf6c7, 0xf34d, 0xf39a, 0xf795, 0xfbf9, 0x01df,
0x0556, 0x0763, 0x063d, 0x02b8, 0xfe8e, 0xfac6, 0xf890, 0xf87c,
0xf9f3, 0xfd3a, 0xffd0, 0x0135, 0x01e0, 0x00ac, 0x0001, 0xfe9f,
0xfd8a, 0xfe8d, 0xffcc, 0x009c, 0x009f, 0xfeda, 0xfcb6, 0xfa28,
0xf8ea, 0xf8ff, 0xf9f8, 0xfc99, 0x0148, 0x04e6, 0x0611, 0x0571,
0x029c, 0xfdda, 0xf985, 0xf572, 0xf3af, 0xf6b5, 0xfbca, 0x01bf,
0x062a, 0x08ec, 0x0830, 0x04a6, 0xffe1, 0xfa28, 0xf5c4, 0xf469,
0xf621, 0xfa5e, 0xff31, 0x0386, 0x05a0, 0x055d, 0x02d4, 0xff4a,
0xfb9c, 0xf9b2, 0xf950, 0xf9a6, 0xfba8, 0xfdc5, 0xffb8, 0xffc7,
0xffe9, 0xfeca, 0xfdff, 0xfe51, 0xff64, 0x00df, 0x01c1, 0x0208,
0x0143, 0xfeb2, 0xfbe1, 0xf8e9, 0xf744, 0xf8f0, 0xfaab, 0xffc3,
0x03b8, 0x067f, 0x076f, 0x0403, 0x00a5, 0xfb12, 0xf619, 0xf3d8,
0xf4d6, 0xf8a7, 0xfdf1, 0x031a, 0x069d, 0x07f5, 0x05e2, 0x01fa,
0xfcbd, 0xf85e, 0xf5d6, 0xf60e, 0xf8ce, 0xfcd0, 0x0094, 0x03b9,
0x04bb, 0x0316, 0x00e4, 0xfe10, 0xfb77, 0xfa52, 0xfab6, 0xfbf0,
0xfde0, 0xfdfa, 0xfdbf, 0xfd8e, 0xfcd6, 0xfd2f, 0xfcad, 0xfe56,
0x0047, 0x0209, 0x03fb, 0x0277, 0x007d, 0xfca1, 0xf8a7, 0xf64c,
0xf64a, 0xf8e0, 0xfd4d, 0x0257, 0x05ce, 0x086b, 0x06b3, 0x0301,
0xfe57, 0xf837, 0xf45c, 0xf356, 0xf67c, 0xfaff, 0x009c, 0x04fb,
0x082d, 0x0769, 0x03a5, 0x0013, 0xfabe, 0xf829, 0xf6af, 0xf84f,
0xfa81, 0xff02, 0x0193, 0x0360, 0x0334, 0x00dd, 0xff4a, 0xfd1d,
0xfd1e, 0xfce2, 0xfdb8, 0xfdcc, 0xff99, 0xfe3b, 0xfd70, 0xfc55,
0xfae2, 0xfb8d, 0xfd37, 0xffb8, 0x024d, 0x0436, 0x03f6, 0x0252,
0xfe6e, 0xfa7a, 0xf6fb, 0xf607, 0xf753, 0xfb0b, 0xfffd, 0x054a,
0x0786, 0x080e, 0x05c9, 0x011b, 0xfbad, 0xf6d5, 0xf492, 0xf475,
0xf8d9, 0xfd61, 0x02c5, 0x05fc, 0x0609, 0x053d, 0x01b1, 0xfdc5,
0xf9fb, 0xf8b0, 0xf922, 0xfa57, 0xfdb2, 0x0044, 0x01ac, 0x013e,
0x00ff, 0xffcb, 0xfdfd, 0xfe3b, 0xfdc4, 0xff0e, 0x0009, 0xfffa,
0xffe9, 0xfdf9, 0xfbe5, 0xfa2a, 0xfa08, 0xfb84, 0xfe2f, 0x0138,
0x03e8, 0x0501, 0x03a2, 0x00d7, 0xfc54, 0xf7e6, 0xf4c2, 0xf4dc,
0xf78d, 0xfc90, 0x016d, 0x0572, 0x07df, 0x0699, 0x0320, 0xfe34,
0xf9b8, 0xf641, 0xf5b4, 0xf760, 0xfb32, 0xffbd, 0x038c, 0x0529,
0x0515, 0x0271, 0xffbb, 0xfc27, 0xfa17, 0xfa6b, 0xfa83, 0xfd2d,
0xfeef, 0x00b2, 0x00f8, 0x00b1, 0xff1d, 0xfe07, 0xfe06, 0xfe67,
0x0073, 0x00e5, 0x0126, 0x0056, 0xfe42, 0xfbab, 0xf993, 0xf953,
0xf9a5, 0xfcc5, 0x00e3, 0x03e1, 0x0566, 0x05e9, 0x03e3, 0xff07,
0xfb0c, 0xf786, 0xf601, 0xf702, 0xfaa0, 0xffa6, 0x0428, 0x073c,
0x07bf, 0x04d8, 0x0114, 0xfc3d, 0xf7f3, 0xf649, 0xf69d, 0xf9c2,
0xfdb9, 0x0168, 0x035a, 0x044b, 0x031b, 0x005b, 0xfdd4, 0xfbba,
0xfada, 0xfbe2, 0xfd78, 0xfe02, 0xffec, 0xffbb, 0xfe32, 0xfd81,
0xfd00, 0xfd79, 0xfe66, 0x0024, 0x01b2, 0x01fa, 0x0181, 0xffcf,
0xfc9c, 0xfa1e, 0xf777, 0xf7b9, 0xfa6a, 0xfd36, 0x027c, 0x0500,
0x0607, 0x04cf, 0x0101, 0xfcc0, 0xf7cd, 0xf61e, 0xf603, 0xf87a,
0xfd1d, 0x01ff, 0x0528, 0x078f, 0x05f1, 0x032b, 0xfed3, 0xfa3b,
0xf7b6, 0xf6cb, 0xf902, 0xfb99, 0xffc0, 0x019d, 0x0403, 0x02d0,
0x0165, 0xff9c, 0xfd30, 0xfcf1, 0xfcb3, 0xfde9, 0xfdf7, 0xfe5a,
0xfe27, 0xfd79, 0xfb32, 0xfb17, 0xfb34, 0xfd04, 0x0024, 0x00d4,
0x0393, 0x0276, 0x0117, 0xfdd6, 0xf9df, 0xf7a7, 0xf6bb, 0xf8e0,
0xfc08, 0x009a, 0x046a, 0x060f, 0x05c3, 0x0393, 0xff0b, 0xfa23,
0xf6c0, 0xf5ff, 0xf6c7, 0xfa5b, 0xfe74, 0x0357, 0x0578, 0x05ac,
0x0390, 0xffae, 0xfbe2, 0xf95c, 0xf8ff, 0xf91c, 0xfae3, 0xfdb9,
0x008e, 0x0135, 0x0140, 0x00ff, 0xff46, 0xfdc8, 0xfe50, 0xfdb1,
0xff1d, 0xfff3, 0xfff5, 0xfe4b, 0xfd46, 0xfbec, 0xfab3, 0xfb15,
0xfbf3, 0xff78, 0x0127, 0x03f1, 0x04c9, 0x0307, 0xffc2, 0xfbb7,
0xf811, 0xf5d1, 0xf6cb, 0xf9a6, 0xfd81, 0x0277, 0x05cb, 0x0605,
0x0511, 0x01f2, 0xfcc0, 0xf90a, 0xf620, 0xf6ac, 0xf8dc, 0xfc6a,
0x018a, 0x03ba, 0x0569, 0x03f9, 0x015b, 0xfde4, 0xfa7e, 0xf9ca,
0xf9a7, 0xfaf7, 0xfd09, 0xff01, 0x010e, 0x0129, 0x00bf, 0xff49,
0xfdfb, 0xfdc0, 0xfea7, 0x000c, 0x0092, 0x00fb, 0xff4f, 0xfd0f,
0xfb41, 0xf9df, 0xf974, 0xfa93, 0xfd9c, 0x0158, 0x03b5, 0x055f,
0x04ca, 0x02e2, 0xff06, 0xfa86, 0xf7cc, 0xf657, 0xf7ba, 0xfb35,
0x008c, 0x0421, 0x0624, 0x05e7, 0x03ec, 0x000c, 0xfb44, 0xf804,
0xf713, 0xf8b0, 0xfba9, 0xff5e, 0x0253, 0x03ef, 0x0425, 0x02ae,
0x001a, 0xfd39, 0xfae4, 0xfadb, 0xfad9, 0xfcb6, 0xfe2d, 0xfff9,
0x0016, 0xfe57, 0xfe27, 0xfdd1, 0xfdf0, 0xfeef, 0x0080, 0x013f,
0x0203, 0x00fb, 0xff49, 0xfc32, 0xf97b, 0xf8ef, 0xf951, 0xfbb5,
0xff96, 0x0316, 0x057a, 0x05da, 0x03df, 0x0009, 0xfbea, 0xf837,
0xf591, 0xf6bd, 0xf95f, 0xfd76, 0x022b, 0x0520, 0x0601, 0x042d,
0x00e1, 0xfcb9, 0xf9d2, 0xf883, 0xf84d, 0xfa39, 0xfcd6, 0x006e,
0x0222, 0x0237, 0x01e8, 0x0062, 0xfe68, 0xfccb, 0xfcfe, 0xfcca,
0xfd8c, 0xfe60, 0x0055, 0xffc9, 0xfde6, 0xfd5e, 0xfcd5, 0xfced,
0xfde4, 0x005c, 0x0154, 0x027d, 0x01c6, 0x0061, 0xfcdf, 0xf9c0,
0xf7d3, 0xf712, 0xf9f4, 0xfd75, 0x01b8, 0x04b7, 0x0638, 0x0521,
0x01df, 0xfe17, 0xf9f1, 0xf6a7, 0xf594, 0xf7c0, 0xfb10, 0xfff3,
0x03d6, 0x0564, 0x0558, 0x02df, 0x008c, 0xfc93, 0xfa33, 0xf9e7,
0xf9c1, 0xfc46, 0xff3b, 0x013e, 0x01af, 0x0120, 0x0052, 0xfef2,
0xfd49, 0xfceb, 0xfd91, 0xfe0f, 0xff27, 0x002a, 0xff2f, 0xfd8a,
0xfc99, 0xfab3, 0xfb91, 0xfd79, 0x001a, 0x01ab, 0x0372, 0x03c1,
0x017f, 0xff27, 0xfb50, 0xf85d, 0xf694, 0xf873, 0xfb6d, 0xff6e,
0x034a, 0x05c4, 0x062a, 0x0440, 0x003f, 0xfc4b, 0xf86a, 0xf68e,
0xf772, 0xf91b, 0xfce0, 0x00ea, 0x03a1, 0x047a, 0x0313, 0x00d2,
0xfe17, 0xfb2f, 0xfa12, 0xf9e0, 0xfb63, 0xfda3, 0xff2a, 0x004a,
0x0063, 0xfff4, 0xff20, 0xfdf1, 0xfe31, 0xfdfe, 0xff76, 0x0007,
0xfff6, 0xffcb, 0xfd97, 0xfb93, 0xfa3e, 0xfa22, 0xfb21, 0xfe6b,
0x0122, 0x032e, 0x049a, 0x0335, 0x00c4, 0xfd8e, 0xf999, 0xf76d,
0xf72d, 0xf991, 0xfd19, 0x0158, 0x04ab, 0x0623, 0x053f, 0x026a,
0xfe03, 0xfa88, 0xf84f, 0xf737, 0xf8bd, 0xfc32, 0xffac, 0x01f2,
0x0438, 0x0372, 0x019e, 0xffb0, 0xfcd6, 0xfb22, 0xfadb, 0xfb42,
0xfcfc, 0xfe14, 0xffe4, 0xff46, 0xfdd4, 0xfdbd, 0xfcd1, 0xfd4e,
0xfe7f, 0x003c, 0x00e6, 0x00f1, 0x00ce, 0xfebd, 0xfc61, 0xfa7f,
0xfa14, 0xfa64, 0xfc67, 0x000d, 0x0233, 0x04da, 0x0480, 0x0270,
0xff76, 0xfb4f, 0xf85a, 0xf6c7, 0xf825, 0xfb47, 0xff1d, 0x02cf,
0x04f1, 0x0543, 0x03e1, 0x007c, 0xfc26, 0xf97f, 0xf7c8, 0xf876,
0xfa8b, 0xfd34, 0x0098, 0x020b, 0x023d, 0x01c1, 0x00f1, 0xfeca,
0xfd2f, 0xfc7d, 0xfd1e, 0xfdd4, 0xff6a, 0x0035, 0xfed4, 0xfe23,
0xfd73, 0xfcef, 0xfd11, 0xfec9, 0x0053, 0x0159, 0x0239, 0x0196,
0xfffe, 0xfd24, 0xfa89, 0xf915, 0xf931, 0xfaf9, 0xfe07, 0x01e3,
0x03b4, 0x054c, 0x0391, 0x0154, 0xfd7f, 0xf995, 0xf795, 0xf710,
0xf9c7, 0xfd22, 0x0102, 0x031c, 0x051d, 0x03af, 0x01e3, 0xfe64,
0xfaf1, 0xf965, 0xf906, 0xfa02, 0xfc25, 0xfecd, 0x00b9, 0x01af,
0x016e, 0x00a1, 0xfe78, 0xfd7c, 0xfd03, 0xfda3, 0xfe35, 0xffd5,
0x000c, 0xfe8b, 0xfdad, 0xfcb3, 0xfb15, 0xfc6b, 0xfe0d, 0x0009,
0x01a3, 0x0237, 0x0262, 0x0109, 0xfeb9, 0xfacb, 0xf986, 0xf8ea,
0xf9e9, 0xfc4d, 0xfff6, 0x035e, 0x04cf, 0x04c0, 0x0343, 0xff63,
0xfba1, 0xf921, 0xf781, 0xf878, 0xfb29, 0xff2c, 0x0176, 0x0384,
0x03e6, 0x01ff, 0x0000, 0xfc74, 0xfa25, 0xf9ad, 0xfa45, 0xfc53,
0xfebb, 0x003e, 0x016f, 0x00fd, 0x0062, 0xfeaf, 0xfdc4, 0xfdc0,
0xfdad, 0xffa1, 0xffe1, 0x0056, 0xfebf, 0xfda2, 0xfc46, 0xfae9,
0xfb72, 0xfcd0, 0xff6a, 0x0116, 0x0359, 0x0442, 0x02b0, 0x0062,
0xfc85, 0xf9af, 0xf8f0, 0xf922, 0xfa74, 0xfe08, 0x0149, 0x0383,
0x0551, 0x03d7, 0x01e0, 0xfd7d, 0xfaaf, 0xf922, 0xf8f2, 0xf9d3,
0xfcbe, 0x007e, 0x0252, 0x043d, 0x02b9, 0x010b, 0xfeeb, 0xfc73,
0xfb25, 0xfae0, 0xfc2f, 0xfdff, 0xff90, 0x003f, 0xffed, 0xffbb,
0xfdf1, 0xfe2f, 0xfddb, 0xfe27, 0xffd6, 0x0054, 0x00bb, 0xff9c,
0xfdb7, 0xfb53, 0xfa12, 0xf99f, 0xfb4c, 0xfd7c, 0x0043, 0x0250,
0x044a, 0x036b, 0x0171, 0xfef9, 0xfa99, 0xf915, 0xf8e8, 0xf960,
0xfbd5, 0x0009, 0x038c, 0x050b, 0x0498, 0x0338, 0xffd4, 0xfcb2,
0xfa0c, 0xf953, 0xf9c4, 0xfb57, 0xfe30, 0x00b1, 0x022e, 0x0230,
0x0141, 0xff47, 0xfdeb, 0xfc47, 0xfcaf, 0xfd08, 0xfda0, 0xff29,
0x0028, 0xff86, 0xfded, 0xfd4c, 0xfd11, 0xfdfe, 0xfe9a, 0x0084,
0x010a, 0x011d, 0x00f2, 0xff80, 0xfd0a, 0xfa2c, 0xf9f1, 0xfa16,
0xfc54, 0xff50, 0x01e0, 0x03c2, 0x041c, 0x02d3, 0xfff3, 0xfc8d,
0xf94f, 0xf7eb, 0xf833, 0xfa22, 0xfd9b, 0x00e1, 0x0346, 0x0451,
0x0364, 0x00f7, 0xfe1c, 0xfb42, 0xf9bc, 0xf9d0, 0xfac5, 0xfdb2,
0x0066, 0x0130, 0x0107, 0x00d4, 0xff7d, 0xfdcc, 0xfd4a, 0xfd1e,
0xfde9, 0xfe3a, 0xff78, 0x0053, 0xfea6, 0xfd7a, 0xfcdb, 0xfcfb,
0xfd08, 0xfde2, 0xffab, 0x014f, 0x0212, 0x01de, 0x002e, 0xfdd6,
0xfb89, 0xf9d5, 0xf9d0, 0xfadc, 0xfe1a, 0x011a, 0x03b7, 0x05a6,
0x0405, 0x025b, 0xff09, 0xfb10, 0xf972, 0xf8bd, 0xf964, 0xfbf4,
0xffbb, 0x01b5, 0x0415, 0x040a, 0x01fb, 0xffe6, 0xfd25, 0xfb1f,
0xfa4a, 0xfb39, 0xfd10, 0xfeb9, 0x002c, 0x0098, 0x0073, 0xff78,
0xfe53, 0xfd91, 0xfd28, 0xfdae, 0xfebd, 0x0016, 0x001c, 0xff19,
0xfd9b, 0xfceb, 0xfb4e, 0xfb65, 0xfd5c, 0xffb1, 0x011e, 0x01d7,
0x0214, 0x013c, 0xff1e, 0xfc06, 0xfa13, 0xf8c7, 0xf9c0, 0xfb26,
0xfe86, 0x01e7, 0x03c0, 0x0491, 0x0308, 0x0090, 0xfcf2, 0xfa4f,
0xf953, 0xf97f, 0xfaee, 0xfdec, 0x00b2, 0x01d0, 0x01f3, 0x01ca,
0x0052, 0xfe75, 0xfc37, 0xfabd, 0xfb5a, 0xfd46, 0xfe7b, 0xffd2,
0x003c, 0x0025, 0xffb9, 0xfdf8, 0xfe29, 0xfd7d, 0xfee3, 0x0018,
0x00f7, 0x00c4, 0xffc9, 0xfeb3, 0xfc09, 0xfb23, 0xfaca, 0xfb9e,
0xfd98, 0x002d, 0x019f, 0x023a, 0x01df, 0x008c, 0xfdd4, 0xfaa5,
0xf977, 0xf908, 0xfa6c, 0xfd45, 0x0041, 0x02c3, 0x0428, 0x0346,
0x013c, 0xfed9, 0xfb56, 0xf9da, 0xf934, 0xfa80, 0xfce1, 0xffab,
0x01a4, 0x0210, 0x01d2, 0x00a2, 0xff8b, 0xfd1a, 0xfcdf, 0xfccb,
0xfd26, 0xfe12, 0xff1f, 0x0049, 0xfec9, 0xfdd8, 0xfe14, 0xfdc4,
0xfe48, 0xff83, 0x008a, 0x00d4, 0x00d2, 0x0116, 0xff16, 0xfd2c,
0xfb49, 0xfa4c, 0xfb11, 0xfc8a, 0xff9f, 0x015c, 0x0312, 0x0404,
0x01da, 0xffc2, 0xfc7f, 0xf9e0, 0xf907, 0xf9af, 0xfba7, 0xfee3,
0x0187, 0x0338, 0x0413, 0x0176, 0x004d, 0xfcb9, 0xfa95, 0xfa0a,
0xfa4d, 0xfbc2, 0xfdd1, 0x00d4, 0x00e5, 0x0112, 0x00f7, 0xffc5,
0xfde3, 0xfd7e, 0xfcaf, 0xfddf, 0xfdad, 0xfeb3, 0xffad, 0xfe1d,
0xfdeb, 0xfd24, 0xfd33, 0xfd35, 0xfe79, 0x0042, 0x00e2, 0x00e5,
0x012f, 0xff80, 0xfd71, 0xfb56, 0xfa14, 0xfa07, 0xfb3d, 0xfde5,
0x0041, 0x0275, 0x0415, 0x0321, 0x010d, 0xfeb8, 0xfb4d, 0xf9f4,
0xfa14, 0xfaf3, 0xfd60, 0x008b, 0x019b, 0x0386, 0x02df, 0x00b6,
0xff24, 0xfc9a, 0xfb53, 0xfa80, 0xfc2a, 0xfdb4, 0xff56, 0x00db,
0x012b, 0x00d5, 0xffbc, 0xfe39, 0xfdbb, 0xfd60, 0xfe10, 0xfdc3,
0xfeee, 0x0017, 0xfdf4, 0xfdfc, 0xfcdf, 0xfd07, 0xfcee, 0xfd88,
0xffde, 0x0131, 0x01e3, 0x01e9, 0x00dc, 0xfe63, 0xfc3f, 0xfa44,
0xf9e2, 0xfa87, 0xfcdd, 0xffa6, 0x0187, 0x039c, 0x043f, 0x0252,
0x0014, 0xfd3c, 0xfa8b, 0xf9f6, 0xfa73, 0xfc27, 0xfef4, 0x00f2,
0x01e2, 0x01e5, 0x0151, 0xff6d, 0xfd55, 0xfc57, 0xfac7, 0xfbba,
0xfd8c, 0xfe53, 0xffef, 0x0025, 0xffd5, 0x001b, 0xfe3d, 0xfdfe,
0xfddf, 0xfebf, 0x003b, 0xffe3, 0x006b, 0xfed5, 0xfd9d, 0xfc33,
0xfadf, 0xfb80, 0xfd3d, 0xfebb, 0x00ed, 0x0201, 0x01f2, 0x01b3,
0x0033, 0xfdcd, 0xfab9, 0xf9d9, 0xfa0b, 0xfaea, 0xfd7b, 0x00af,
0x022d, 0x03d6, 0x026f, 0x00db, 0xfec5, 0xfbb3, 0xfa73, 0xf9d2,
0xfbea, 0xfda4, 0x0004, 0x0108, 0x015a, 0x010f, 0xfffe, 0xfe6b,
0xfd21, 0xfcf7, 0xfccc, 0xfd73, 0xfdd7, 0xff24, 0x0049, 0xff8d,
0xfe13, 0xfdc6, 0xfe18, 0xfdcc, 0xfeb7, 0x003b, 0x0066, 0x00af,
0xffbd, 0xfe61, 0xfc97, 0xfafd, 0xfaea, 0xfc1a, 0xfd91, 0xffa4,
0x01f3, 0x01e4, 0x021f, 0x0114, 0xff28, 0xfc6d, 0xfa3c, 0xf9b9,
0xfa0d, 0xfc78, 0xff1f, 0x0104, 0x02e3, 0x02dd, 0x0180, 0xfff8,
0xfcf8, 0xfafa, 0xf9d4, 0xfa9b, 0xfcc2, 0xfece, 0x0063, 0x00e7,
0x00fa, 0x0066, 0xff51, 0xfddd, 0xfcfe, 0xfd2f, 0xfd92, 0xfea2,
0x0014, 0x0067, 0xfec5, 0xfdfa, 0xfdf2, 0xfd4f, 0xfdda, 0xfe8d,
0x0011, 0x00bc, 0x0129, 0x00cc, 0xff44, 0xfda9, 0xfb84, 0xfa99,
0xfae2, 0xfc65, 0xfeb4, 0x0162, 0x020c, 0x020a, 0x01ec, 0x001d,
0xfd74, 0xface, 0xf9d7, 0xf9ea, 0xfaf0, 0xfdc4, 0x0066, 0x01c8,
0x0222, 0x019e, 0x00b3, 0xfeb2, 0xfcad, 0xfae3, 0xfb36, 0xfcb9,
0xfdff, 0xff7a, 0x007a, 0x0046, 0xffe4, 0xff81, 0xfe00, 0xfe0a,
0xfe3f, 0xfe03, 0xfed9, 0xffed, 0x0000, 0xff05, 0xfe0f, 0xfd63,
0xfd0b, 0xfd48, 0xfe4b, 0xffd1, 0x00b7, 0x00dd, 0x00ff, 0x0060,
0xfe2c, 0xfbe5, 0xfab1, 0xfa3c, 0xfb85, 0xfd62, 0xfffb, 0x01c9,
0x01ce, 0x01d7, 0x0114, 0xff7b, 0xfc6e, 0xfa53, 0xf9ce, 0xfaf5,
0xfd17, 0xff41, 0x0124, 0x020f, 0x01e6, 0x00f8, 0xff20, 0xfd47,
0xfd2a, 0xfbab, 0xfc7f, 0xfdb7, 0xfe7e, 0x0059, 0xffde, 0x0015,
0xff5c, 0xfdfc, 0xfe20, 0xfe13, 0xfdff, 0xff95, 0xfff4, 0x0022,
0xff84, 0xfdb3, 0xfd31, 0xfcff, 0xfd18, 0xfcff, 0xfec2, 0x0069,
0x0143, 0x0183, 0x012f, 0xff2f, 0xfcf4, 0xfb16, 0xfa09, 0xfaa6,
0xfc3c, 0xfe6d, 0x0077, 0x022f, 0x021e, 0x015d, 0xffab, 0xfda8,
0xfb97, 0xfa64, 0xfaa7, 0xfc11, 0xfdfb, 0x0047, 0x0111, 0x01db,
0x011f, 0x004e, 0xfee9, 0xfcd9, 0xfd4c, 0xfcd5, 0xfddf, 0xfe45,
0xffeb, 0x004d, 0xffd3, 0xfe5f, 0xfdb8, 0xfe34, 0xfe88, 0x002b,
0xfff4, 0x0138, 0x008b, 0xfff8, 0xfe97, 0xfdad, 0xfbf1, 0xfb19,
0xfcbf, 0xfdf2, 0xffee, 0x0109, 0x01d4, 0x01cb, 0x0104, 0xfed3,
0xfc95, 0xfb3c, 0xfafa, 0xfb17, 0xfdeb, 0x0033, 0x014e, 0x01ea,
0x01e2, 0x00cc, 0xfea4, 0xfd02, 0xfbae, 0xfad3, 0xfbb5, 0xfdb1,
0xff02, 0x00e0, 0x00c6, 0x00fe, 0x0098, 0xff09, 0xfe1e, 0xfd91,
0xfcd8, 0xfde1, 0xfe65, 0xfe14, 0xfe22, 0xfe1d, 0xfe40, 0xfdf8,
0xfe5c, 0xfdd0, 0xfe9e, 0xffac, 0x005c, 0x00e7, 0x007c, 0xfead,
0xfd97, 0xfc7b, 0xfb0d, 0xfbc0, 0xfdb4, 0xff87, 0x00ab, 0x01c6,
0x01f9, 0x0153, 0x0016, 0xfd91, 0xfb48, 0xfb2b, 0xfb31, 0xfc59,
0xff2d, 0x00e4, 0x01a4, 0x0208, 0x0169, 0x008c, 0xfe62, 0xfcf3,
0xfb1c, 0xfb2b, 0xfcfb, 0xfe26, 0xfffe, 0x00b1, 0x00b8, 0xfffe,
0xff42, 0xfe0f, 0xfe0f, 0xfdfd, 0xfe34, 0xfe7d, 0xffde, 0xffd2,
0xfe45, 0xfe43, 0xfd45, 0xfd6c, 0xfdec, 0xfe9c, 0xffd1, 0x00a9,
0x00df, 0x00d5, 0xff94, 0xfdcc, 0xfc26, 0xfaf2, 0xfaf6, 0xfbcc,
0xfe14, 0xffe4, 0x0188, 0x021d, 0x01c8, 0x00a6, 0xff1f, 0xfd00,
0xfaf9, 0xfad4, 0xfb54, 0xfd71, 0xff6a, 0x0104, 0x01a7, 0x014f,
0x0082, 0xfec2, 0xfd5b, 0xfd02, 0xfcc7, 0xfce1, 0xfdda, 0xff8f,
0x002a, 0xffea, 0xffd1, 0xff64, 0xfe24, 0xfdbe, 0xfe02, 0xfdf6,
0xffbc, 0xffc1, 0xfff5, 0xff15, 0xfdde, 0xfd68, 0xfcca, 0xfd10,
0xfdf0, 0xffdd, 0x0099, 0x00c9, 0x00db, 0x00be, 0xff7e, 0xfd72,
0xfb54, 0xfad6, 0xfb76, 0xfd36, 0xfed5, 0x00cb, 0x01a8, 0x018d,
0x012d, 0xff66, 0xfdb9, 0xfc02, 0xfae0, 0xfb36, 0xfd17, 0xfe72,
0x0068, 0x010c, 0x0125, 0x00c5, 0xffbc, 0xfe0a, 0xfd3d, 0xfcd3,
0xfce2, 0xfd9d, 0xfebd, 0x002c, 0xffd1, 0x0020, 0xfe8c, 0xfde4,
0xfe17, 0xfdba, 0xfe93, 0x001d, 0xffee, 0x0009, 0x0011, 0xfe2e,
0xfd1a, 0xfcbc, 0xfcef, 0xfd16, 0xfeac, 0x0047, 0x00ea, 0x010b,
0x010a, 0xfffe, 0xfdee, 0xfc7e, 0xfaf8, 0xfaf0, 0xfc39, 0xfde8,
0xffad, 0x0111, 0x01c0, 0x00fb, 0x0050, 0xfe3a, 0xfce8, 0xfb8b,
0xfb19, 0xfcd9, 0xfda6, 0xff41, 0x00a1, 0x0128, 0x00a9, 0x0028,
0xfe8b, 0xfdd3, 0xfdee, 0xfdaa, 0xfe4d, 0xfe38, 0xff8b, 0x0046,
0xfec1, 0xfdea, 0xfde9, 0xfde3, 0xfe0e, 0xfe20, 0xffef, 0x002a,
0x000b, 0x0025, 0xfe49, 0xfdb5, 0xfcc5, 0xfcec, 0xfca4, 0xfdd9,
0xfff1, 0x00d1, 0x00d8, 0x0103, 0x00db, 0xfeef, 0xfd2a, 0xfbba,
0xfacd, 0xfb97, 0xfcdf, 0xfe8e, 0x007a, 0x00fd, 0x012a, 0x00ff,
0xffef, 0xfdf0, 0xfd06, 0xfbed, 0xfc84, 0xfd46, 0xfe68, 0xffde,
0xffce, 0xffe3, 0x0013, 0xfee3, 0xfde9, 0xfe12, 0xfe0f, 0xfddf,
0xff91, 0x0000, 0x0019, 0xff2f, 0xfda7, 0xfe05, 0xfdcc, 0xfe28,
0xfe4a, 0xff81, 0x0044, 0x00be, 0x006b, 0xff9c, 0xfd89, 0xfd29,
0xfc08, 0xfbeb, 0xfd43, 0xfe89, 0x005c, 0x00d1, 0x0101, 0x0112,
0x0049, 0xfdb3, 0xfbe9, 0xfb06, 0xfaf4, 0xfc0a, 0xfdd3, 0xff61,
0x00f2, 0x0106, 0x0123, 0x0045, 0xfea0, 0xfd34, 0xfd39, 0xfcea,
0xfd12, 0xfdcc, 0xff17, 0x0027, 0xffbe, 0x0067, 0xff46, 0xfe08,
0xfdfe, 0xfe11, 0xfde1, 0xffbd, 0xffd5, 0xffef, 0xfea2, 0xfdcd,
0xfdd5, 0xfcc1, 0xfdd8, 0xfddc, 0xff82, 0x0048, 0x013b, 0x00b1,
0x003d, 0xfe8e, 0xfd4d, 0xfc15, 0xfaa4, 0xfcdd, 0xfd88, 0xff63,
0x00ee, 0x010f, 0x00b5, 0x00ec, 0xfec2, 0xfd9a, 0xfc12, 0xfafe,
0xfcd9, 0xfd83, 0xff61, 0x00de, 0x0109, 0x00e0, 0x009d, 0xff6e,
0xfe03, 0xfd4f, 0xfd05, 0xfd0d, 0xfd96, 0xfe44, 0x0003, 0xffe0,
0x0013, 0xff4c, 0xfd95, 0xfe62, 0xfde4, 0xfef8, 0x0046, 0xffdc,
0x003f, 0xfef7, 0xfde2, 0xfd7c, 0xfcd9, 0xfcf8, 0xfd9a, 0xff58,
0x0035, 0x013c, 0x010c, 0x0104, 0xffae, 0xfd7a, 0xfd13, 0xfb33,
0xfbf5, 0xfd40, 0xfe1c, 0x0081, 0x013b, 0x00e6, 0x009e, 0xffe0,
0xfe00, 0xfce5, 0xfce3, 0xfce6, 0xfd11, 0xfe59, 0x0052, 0x00d9,
0x010d, 0x00d9, 0xfffb, 0xfe7f, 0xfe14, 0xfe23, 0xfde5, 0xfe0d,
0xfe03, 0xffd9, 0x0015, 0xfe47, 0xfdff, 0xfdee, 0xfe17, 0xfdd0,
0xfed4, 0x0099, 0x0005, 0x0016, 0xffc1, 0xfe5c, 0xfd53, 0xfd1e,
0xfd2d, 0xfd1a, 0xfe25, 0xffa4, 0x00e0, 0x00f1, 0x00c9, 0x0044,
0xfe33, 0xfd74, 0xfc4d, 0xfc06, 0xfcf3, 0xfdab, 0xfff9, 0x00bf,
0x00ff, 0x00b8, 0x0047, 0xfec5, 0xfd62, 0xfd4a, 0xfce8, 0xfcfd,
0xfd8f, 0xff7a, 0x002f, 0x000d, 0x0038, 0xffe0, 0xfea0, 0xfddb,
0xfe05, 0xfde5, 0xfe76, 0xfe05, 0xff9a, 0xffed, 0xfded, 0xfe06,
0xfe02, 0xfe02, 0xfdfb, 0xff16, 0x0018, 0x0027, 0xffd9, 0xffe6,
0xff46, 0xfd77, 0xfce9, 0xfcd7, 0xfce1, 0xfd38, 0xfea5, 0x0098,
0x0121, 0x0112, 0x00b6, 0xff7d, 0xfd8c, 0xfd31, 0xfb8d, 0xfc24,
0xfd82, 0xfe1e, 0xffdd, 0x007d, 0x013f, 0x00a5, 0xffb6, 0xfe29,
0xfd83, 0xfcf7, 0xfcfd, 0xfdae, 0xfea4, 0xfffc, 0x0006, 0xffbf,
0x001b, 0xfede, 0xfdf5, 0xfe09, 0xfe12, 0xfdbd, 0xfead, 0xffec,
0xfff8, 0xff0a, 0xfdc4, 0xfe37, 0xfe10, 0xfdcf, 0xff0d, 0x0034,
0x004a, 0x00e6, 0x0077, 0xffed, 0xfe3d, 0xfd04, 0xfd20, 0xfd17,
0xfd1b, 0xfdb4, 0xffaf, 0x0120, 0x014d, 0x0122, 0x0046, 0xfe67,
0xfd42, 0xfd0d, 0xfcf5, 0xfcff, 0xfdda, 0xff68, 0x0034, 0x0122,
0x0098, 0x002f, 0xff16, 0xfdb9, 0xfd7c, 0xfcff, 0xfe59, 0xfddb,
0xff78, 0x0011, 0xffff, 0xffcb, 0xfe30, 0xfe06, 0xfe30, 0xfe45,
0xfe44, 0xffeb, 0xffaf, 0x0007, 0xfe87, 0xfe09, 0xfe0f, 0xfd0d,
0xfdc5, 0xfe6c, 0x0036, 0x0046, 0x010b, 0x010f, 0x004e, 0xff37,
0xfd79, 0xfcfd, 0xfd54, 0xfd04, 0xfda0, 0xff60, 0x0090, 0x012d,
0x0121, 0x00c9, 0xff54, 0xfdd7, 0xfd06, 0xfd10, 0xfd32, 0xfd99,
0xfe59, 0xffa0, 0x003f, 0xffe5, 0xffef, 0xffc7, 0xfe4a, 0xfe0b,
0xfdff, 0xfe24, 0xfe15, 0xff0c, 0x001c, 0xffee, 0xffb4, 0xfded,
0xfe2f, 0xfe24, 0xfdd5, 0xfec8, 0xffe7, 0xffd6, 0x0020, 0xff9f,
0xfe18, 0xfe12, 0xfd17, 0xfcfe, 0xfdc7, 0xfe96, 0xffbd, 0x004b,
0x00fc, 0x00ab, 0xff40, 0xfe0c, 0xfd4b, 0xfcfd, 0xfcfb, 0xfd3b,
0xfe6a, 0xffea, 0x00bc, 0x014d, 0x00d8, 0x0038, 0xfe92, 0xfda8,
0xfcf7, 0xfcde, 0xfd7c, 0xfdfa, 0xffb5, 0x0019, 0xfff5, 0x000e,
0x0023, 0xfeff, 0xfe07, 0xfe2f, 0xfe52, 0xfe1c, 0xff52, 0x0017,
0xffec, 0xfe93, 0xfdf2, 0xfe5d, 0xfe1b, 0xfdf5, 0xfe07, 0xffdb,
0x003c, 0x0005, 0x0046, 0xfedf, 0xfde1, 0xfd58, 0xfce7, 0xfd4b,
0xfde8, 0xffbc, 0x001a, 0x00b6, 0x00bf, 0x0001, 0xfedf, 0xfd9a,
0xfd05, 0xfcfe, 0xfcec, 0xfd55, 0xff80, 0x0061, 0x010d, 0x010a,
0x00a2, 0xffa8, 0xfe0b, 0xfd24, 0xfd1f, 0xfce6, 0xfdb5, 0xfe62,
0xffed, 0x0028, 0xfff0, 0x000d, 0xfe13, 0xfdcb, 0xfe0b, 0xfdf0,
0xfdf0, 0xff2e, 0x005f, 0xffd0, 0xfe26, 0xfe19, 0xfde8, 0xfe11,
0xfdff, 0xfe77, 0xffdd, 0xffef, 0xffec, 0x002d, 0xffcc, 0xfe0b,
0xfdd6, 0xfd18, 0xfd06, 0xfd8c, 0xfee2, 0x0020, 0x003b, 0x0112,
0x002e, 0xffeb, 0xfe80, 0xfd04, 0xfd04, 0xfcf3, 0xfdae, 0xfe5d,
0xffb4, 0x006c, 0x0112, 0x0097, 0xfff2, 0xfeb3, 0xfde7, 0xfd7d,
0xfd38, 0xfe3c, 0xfd79, 0xff34, 0x002e, 0x001c, 0x000b, 0xfe68,
0xfdbf, 0xfe02, 0xfdef, 0xfdf9, 0xff98, 0x007c, 0xff9e, 0xfdfe,
0xfdfc, 0xfdf3, 0xfdeb, 0xfdf3, 0xfdda, 0xff3f, 0x0038, 0x0044,
0x000d, 0x0028, 0xfedf, 0xfdba, 0xfd3e, 0xfcfc, 0xfd4f, 0xfded,
0xff85, 0xfff2, 0x011d, 0x00e4, 0x0024, 0xff7f, 0xfdc3, 0xfd43,
0xfce8, 0xfdad, 0xfe00, 0xff4c, 0x0066, 0xfffc, 0x0007, 0x0015,
0xff12, 0xfde3, 0xfe4a, 0xfdc8, 0xfe26, 0xfe11, 0xfebd, 0x004a,
0x0004, 0x0039, 0xfe77, 0xfdce, 0xfe04, 0xfe55, 0xffc5, 0x0010,
0x001e, 0x004f, 0xff5d, 0xfe02, 0xfe0e, 0xfde0, 0xfe08, 0xfdc9,
0xfe6d, 0xffe3, 0x007b, 0x0132, 0x0024, 0xff9c, 0xfe27, 0xfdad,
0xfd18, 0xfcd7, 0xfda6, 0xfe89, 0x0022, 0x0011, 0x00fa, 0x002a,
0xfff9, 0xfe56, 0xfdb3, 0xfd46, 0xfcee, 0xfde1, 0xfe88, 0x0009,
0x0024, 0xfffa, 0x0017, 0xffe0, 0xfe20, 0xfde0, 0xfe12, 0xfe13,
0xfdc0, 0xff27, 0x0053, 0x001b, 0xff83, 0xfdfb, 0xfe05, 0xfdcd,
0xfdee, 0xffb3, 0xfff5, 0xfff4, 0x001c, 0x0001, 0xfe8c, 0xfdf1,
0xfd5f, 0xfd01, 0xfe4e, 0xfdaf, 0xff6e, 0x0004, 0xffdd, 0x001e,
0xffed, 0xff22, 0xfd9f, 0xfd5e, 0xfccb, 0xfd57, 0xfdf5, 0xff9b,
0xffeb, 0x001a, 0x0031, 0x0019, 0xff31, 0xfdaf, 0xfe31, 0xfd7b,
0xfde4, 0xfe16, 0xff22, 0x0048, 0xffce, 0x0007, 0xffe1, 0xfe57,
0xfdb9, 0xfde4, 0xfe42, 0xfde9, 0xfedd, 0x0019, 0x0011, 0xff07,
0xfdf6, 0xfe0a, 0xfe02, 0xfdd2, 0xfee2, 0x0016, 0xffe7, 0x000c,
0x0011, 0xff3b, 0xfdca, 0xfe14, 0xfcd5, 0xfdc7, 0xfdd7, 0xff06,
0x0031, 0x0009, 0x00c0, 0xffb8, 0xffd6, 0xfe11, 0xfdc2, 0xfcfa,
0xfce9, 0xfda2, 0xfe16, 0xff91, 0x0006, 0xfff0, 0x0003, 0x0001,
0xfe7c, 0xfe0d, 0xfe43, 0xfdcd, 0xfdde, 0xfed5, 0x0050, 0xffc1,
0x0012, 0xffee, 0xfe1b, 0xfdc3, 0xfdf7, 0xfe2f, 0xfdec, 0xfefc,
0x0029, 0xffe3, 0xfe30, 0xfde3, 0xfe01, 0xfde4, 0xfe0d, 0xfe2f,
0xffc0, 0xffe4, 0xffe6, 0x000c, 0xffa6, 0xfdfd, 0xfdb1, 0xfd39,
0xfcbc, 0xfde0, 0xfe4d, 0x0008, 0xffdb, 0x000d, 0xffe1, 0x0009,
0xfefb, 0xfda7, 0xfde4, 0xfcc1, 0xfe01, 0xfdd2, 0xff78, 0x0013,
0x001a, 0x000d, 0xffef, 0xff7a, 0xfdb8, 0xfe4b, 0xfdac, 0xfe29,
0xfdc8, 0xff24, 0xfffa, 0x0006, 0xff7a, 0xfe0a, 0xfe29, 0xfdc7,
0xfdda, 0xfee1, 0x0018, 0xffd7, 0x003a, 0xfee9, 0xfdc5, 0xfe3a,
0xfdc9, 0xfe25, 0xfd91, 0xfead, 0xfff4, 0xfffd, 0xffed, 0xffd0,
0xff52, 0xfde6, 0xfdba, 0xfd16, 0xfe41, 0xfe11, 0xff04, 0x000d,
0xffb4, 0xffd3, 0xffca, 0xffc5, 0xfdf5, 0xfe06, 0xfd2b, 0xfdc2,
0xfe21, 0xfdda, 0xffa4, 0x0027, 0xffe6, 0x0048, 0xffb3, 0xfe37,
0xfe0f, 0xfdd2, 0xfdde, 0xfe09, 0xfe76, 0x000d, 0xff6d, 0xfe1f,
0xfdf5, 0xfe2c, 0xfdfb, 0xfe1e, 0xffcf, 0xffe4, 0x0017, 0xfff0,
0x0019, 0xfee9, 0xfe02, 0xfe33, 0xfdf2, 0xfe0a, 0xfe64, 0x002a,
0x0014, 0xfffc, 0xffce, 0x0025, 0xfea9, 0xfdd7, 0xfe2f, 0xfe16,
0xfe05, 0xfdea, 0xfff6, 0xffe3, 0xffd7, 0xfff1, 0x002c, 0xff00,
0xfdec, 0xfe68, 0xfe2d, 0xfe03, 0xfdd6, 0xfeb3, 0xffc7, 0xfff3,
0x003a, 0x0014, 0xfe7e, 0xfdc2, 0xfdcd, 0xfdf7, 0xfdc9, 0xfede,
0x0005, 0xff44, 0xfd9b, 0xfdf5, 0xfe0d, 0xfddc, 0xfdea, 0xfe50,
0xffc9, 0xfffa, 0x0003, 0x000d, 0xff54, 0xfddd, 0xfe20, 0xfde4,
0xfe08, 0xfdcc, 0xff62, 0x0021, 0xffeb, 0x0024, 0xfff7, 0xff80,
0xfe1d, 0xfe08, 0xfdb4, 0xfe5b, 0xfd9a, 0xfef7, 0xffc3, 0xffef,
0x0008, 0xffe8, 0xff6a, 0xfd97, 0xfe53, 0xfdc6, 0xfe17, 0xfdac,
0xfe66, 0xffef, 0xffea, 0x002b, 0xfff0, 0xfe79, 0xfda8, 0xfe6d,
0xfd54, 0xfe36, 0xfe52, 0x0069, 0xff1c, 0xfe76, 0xfd94, 0xff63,
0x0376, 0xff8a, 0x000d, 0xffd4, 0x0020, 0x001e, 0xffeb, 0xfff9,
0xffdf, 0x0037, 0xffec, 0xfff4, 0x000b, 0xfff7, 0xffbd, 0xffe6,
0x0001, 0x0031, 0xffcf, 0x000b, 0xffb9, 0xffe2, 0xfff8, 0xffd3,
0x0027, 0x0001, 0xfff0, 0x0014, 0x0011, 0xffea, 0xffd7, 0xffd9,
0xfff7, 0x0072, 0x0035, 0x0009, 0x001a, 0x005d, 0x000d, 0xffda,
0xffeb, 0xfff1, 0x0039, 0x0015, 0xffe5, 0xffd6, 0xfff8, 0xfff0,
0xfff2, 0xfff4, 0xffd7, 0xffd2, 0x0017, 0x0017, 0xffdb, 0x0010,
0xfffe, 0xfffa, 0xffeb, 0x0012, 0x0005, 0xffcb, 0x0008, 0xfff2,
0xfff5, 0xfff9, 0x001c, 0x0013, 0xfff9, 0xffd6, 0x0018, 0x0037,
0x0022, 0x0000, 0x0000, 0x0026, 0xfff4, 0x0009, 0x0019, 0xffed,
0x000d, 0x000f, 0xffff, 0xffd0, 0xffd8, 0x0012, 0x0005, 0xfffd,
0xffed, 0xfff9, 0xfff5, 0xfff9, 0xfff2, 0x0021, 0xfffe, 0xfff7,
0xfffb, 0x0005, 0x0004, 0xfff1, 0x0009, 0xfffe, 0xfff8, 0xfffd,
0x0003, 0xfffe, 0x0001, 0xfff5, 0x0000, 0x0001, 0x0008, 0x0005,
0xffff, 0xfffb, 0xffff, 0x0004, 0x0007, 0x0000, 0xffff, 0xffff,
0x0000, 0x0003, 0xfffe, 0x0000, 0x0001, 0x0001, 0xffff, 0x0001,
0xffff, 0x0001, 0xfffd, 0x0000, 0xffff, 0x0001, 0x0001, 0x0000,
0xfffe, 0xffff, 0x0000, 0x0001, 0x0001, 0xffff, 0x0001, 0xffff,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0xffff,
0x0000, 0x0000, 0x0000, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0001, 0xffff,
const int sound_data[] = {
0x00000000, 0x0000ffff, 0x00000000, 0x0000ffff,
0x0000ffff, 0x00000000, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0xffff0000, 0x00000000,
0x00000000, 0x00010001, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00010000, 0x0000ffff, 0x0000ffff, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0xffff0001, 0x00000000,
0x0001ffff, 0x00010000, 0x0000ffff, 0x0000ffff,
0x00000000, 0x00000001, 0x00000000, 0x00000000,
0xffff0000, 0x0000ffff, 0xffff0000, 0x00000000,
0xffff0000, 0x00000000, 0x00000000, 0x00000000,
0xffff0000, 0x00000000, 0x0000ffff, 0x0000ffff,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0x00010000, 0x00000001, 0x00000000, 0x00000001,
0x00010000, 0x0000ffff, 0xffff0001, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0xffff0001, 0x00000000, 0x00000000, 0x00000000,
0xffff0000, 0x00000000, 0x00000000, 0x00000001,
0x00010000, 0x00000000, 0x00000000, 0x00000001,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00010000, 0xffffffff, 0x0001ffff, 0x0000ffff,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0xffff0001, 0x00000000,
0xffff0000, 0x00010000, 0x00000000, 0x00000000,
0x00000000, 0x00000001, 0x00000000, 0x0000ffff,
0x00000000, 0xffff0000, 0x00000000, 0xffffffff,
0x00010000, 0x00000000, 0xffff0001, 0xffffffff,
0x00000001, 0x00000000, 0x00000000, 0xffff0000,
0x0000ffff, 0xffff0000, 0x00000001, 0x00000000,
0x00010000, 0x00000000, 0x00000001, 0x00000001,
0x00000000, 0x00000000, 0x00010000, 0x00010000,
0x0000ffff, 0xffff0000, 0x00000000, 0x00000001,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00010000, 0x00000000, 0x00000000, 0x00010000,
0x00000001, 0x00000000, 0xffff0000, 0x00000000,
0x00000000, 0x00000000, 0xffff0000, 0x00000000,
0x00000000, 0xffff0000, 0x00010001, 0x00000000,
0xffff0000, 0xffff0000, 0xffff0000, 0x00000000,
0x00000001, 0x00010000, 0xffff0000, 0x00000000,
0x00010000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0xffff0001, 0x00000000, 0x00000000,
0x00000001, 0x00000000, 0x00000000, 0x00000000,
0xffff0000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0xffff0000, 0x00000000, 0x00000000,
0xffffffff, 0xffff0000, 0x00010000, 0x00010001,
0x00000000, 0x00000000, 0x00010000, 0x00000001,
0xfffffffe, 0xfffc0001, 0x00010000, 0x00030003,
0xfff7fffc, 0xfffd0005, 0xfffdffff, 0x00030002,
0x00000000, 0xffff0006, 0xfffdfffb, 0x000ffffc,
0xffeeffdb, 0x00070015, 0x0005000e, 0x001effda,
0xffdbffe7, 0x0022fffb, 0xffda0010, 0x0010fffc,
0xfffffffe, 0x002a0017, 0xffdd0030, 0xfff6ffa8,
0xff18ffc7, 0x00c30038, 0x003800b0, 0xff45fec6,
0xff3a0091, 0x00a2ff65, 0x006a0090, 0xffac0016,
0xfff600dd, 0xffe1fda5, 0x005f0140, 0xfe6afecb,
0x00b2009f, 0x000300f5, 0x0215ffd2, 0xfdcfff3c,
0xff89fd94, 0xff090188, 0x01d200d7, 0xff74fedb,
0x0052014a, 0x033f01e4, 0xfe77ffa2, 0x0013fca7,
0xfd7400f9, 0x0156fee4, 0xfe78029f, 0x0145fd72,
0x02b30427, 0xfcdbfe0b, 0xffe1feeb, 0x005eff99,
0x0011ff57, 0xfa27fdb5, 0x03bc03e6, 0x00fbfd1c,
0xfe6bfe62, 0xfc0dfe56, 0xfcbbf907, 0xfb92f59b,
0xf60bfbda, 0x01510866, 0x0238f9cd, 0xfbf702fc,
0x037afeb0, 0xfec10462, 0xfefdfb06, 0xfdcff461,
0xb8d0d21d, 0x4f195ff8, 0x251e018b, 0xe058c045,
0xc924ed7f, 0x0da91088, 0x141432d2, 0x2199ee71,
0xd406d240, 0xd9b1d716, 0xf8841695, 0x251a2240,
0x1eeb0522, 0xd02bc9b8, 0xca02dffe, 0xfbc61929,
0x381b396e, 0x1e44098d, 0xf6e0e0c5, 0xc389c8c2,
0xf91613c4, 0x32383c90, 0x3c7819cc, 0xdaedce05,
0xcfa0d99a, 0xe37f036d, 0x2b012bc6, 0x21811463,
0x0383d658, 0xc419cfbf, 0xe21ff3e7, 0x14282976,
0x2dda1c1d, 0xfb98e786, 0xc4d3c791, 0xd573fd7f,
0x1c6e2b67, 0x329a1c12, 0x0a4eea33, 0xd1add23b,
0xd376eb17, 0x0bb124d3, 0x3c053323, 0x1498f14c,
0xce4fd159, 0xda08ea13, 0x07f12819, 0x3fde2a87,
0x13adf0b0, 0xdca7c5cc, 0xc148e5fd, 0xfb3213ea,
0x2e9d351f, 0x2021f568, 0xd957d5de, 0xc9b1cb69,
0xf3591948, 0x2fd12d1b, 0x21ff130b, 0xf178d511,
0xcfdcd906, 0xec0d0b40, 0x24a53812, 0x29891230,
0xf638d9b7, 0xc2d0c566, 0xe0790128, 0x1fcf311c,
0x342f1be7, 0xf51bdbb1, 0xcc40c213, 0xd54df95e,
0x23023314, 0x33ce237e, 0x04a6e178, 0xcde9cd84,
0xd727f0e6, 0x12b93332, 0x37872dc0, 0x0f99ec26,
0xd448c91b, 0xd615ecb1, 0x0ad02706, 0x333328b6,
0x15c8f768, 0xd9dcc218, 0xc0eddb49, 0xfbce1f0d,
0x2e543156, 0x1e0afea7, 0xe01fcc96, 0xc61fd804,
0xfa3b1b4e, 0x33e5362a, 0x2cbf0ae0, 0xe2cbc719,
0xc203d012, 0xe8840e80, 0x2d4936c4, 0x2a5611f2,
0xf274d5f2, 0xc7c8d3f7, 0xef580779, 0x24023574,
0x35101c0c, 0xf907dbee, 0xc8e6c734, 0xda1bff02,
0x1d0d2f8f, 0x2f171d3c, 0xfc8ddc29, 0xca39c701,
0xd79cf541, 0x19723207, 0x34de2433, 0x0a49e81e,
0xc998c067, 0xcdaaec2d, 0x0dc728ed, 0x33cb2ce4,
0x1434f5dd, 0xdbb6ca97, 0xcdcce58f, 0x082023f4,
0x33f332e0, 0x1d97fbd5, 0xd86ec87d, 0xcd3adfd3,
0x00a71fc9, 0x328431f0, 0x1edd05df, 0xe63dcd0b,
0xca7dda99, 0xf7931600, 0x2d8833da, 0x250f082a,
0xe633cdc2, 0xc354cc8a, 0xec470cff, 0x23ff306a,
0x29ea1245, 0xf120d581, 0xc906cd1d, 0xe32a0710,
0x26863536, 0x314f1bc4, 0xfa5bd893, 0xc75bca8e,
0xdf23013d, 0x236035fa, 0x34a521b7, 0x047de1fa,
0xcabec946, 0xdb23fa22, 0x191830c1, 0x3884272e,
0x064de44d, 0xcd1fc61d, 0xd1ebefd2, 0x107c2970,
0x31d4298e, 0x0f76eb88, 0xce2ac482, 0xce56e6a0,
0x07db25f6, 0x3646326b, 0x1c3ff8bd, 0xd986c66b,
0xca3ce3f3, 0x028a22f4, 0x38c539db, 0x2021fd92,
0xe1d7cb65, 0xc31cd560, 0xf9411931, 0x2cb63293,
0x264f0576, 0xe13dca97, 0xc538cef2, 0xeca711c4,
0x2ec53799, 0x2d6013d3, 0xf0e0d2c0, 0xc5cdcf07,
0xe93607a1, 0x2717399f, 0x340d1af9, 0xf882dd5a,
0xcabecb7b, 0xdedc00e3, 0x1f5e3182, 0x312b1f32,
0xfe07dc7c, 0xc9d7c865, 0xd6c0f3f9, 0x19232f7d,
0x35b925a7, 0x0885e650, 0xcb57c568, 0xd321ef86,
0x11182b7c, 0x34fb2a94, 0x0f6aed8d, 0xd162c493,
0xccc0e674, 0x080525a7, 0x33812ebe, 0x1888f702,
0xd754c4fd, 0xc7acddab, 0xfdec1f39, 0x3395331d,
0x207f0224, 0xe289cd8a, 0xc97edaec, 0xf95b17f7,
0x2fb63575, 0x26c10877, 0xe66ece7e, 0xc6f7d3ac,
0xef48125d, 0x2e803757, 0x2c771252, 0xf0bbd1c6,
0xc584ce0e, 0xe6350616, 0x236d3445, 0x2e361577,
0xf533d806, 0xc6d4c78a, 0xdda50011, 0x1df52fea,
0x31291ddc, 0xfc1cdb67, 0xc7bdc681, 0xd7aaf717,
0x18b730db, 0x36b327be, 0x09fae6c6, 0xcdbec75a,
0xd4a2efbf, 0x11b92cb4, 0x36732ccc, 0x1187f033,
0xd2f7c3f7, 0xcb23e4df, 0x06b324fb, 0x36f3343a,
0x1baffab2, 0xdbe3c9fe, 0xcc85dff8, 0xff5f1f72,
0x3351326a, 0x209d0158, 0xdf6ccb54, 0xc8cbda42,
0xf6e61753, 0x3011357e, 0x24b105ba, 0xe4f8ccae,
0xc4dccffc, 0xedb90e9d, 0x27e03209, 0x275a0d5d,
0xede1d29d, 0xc741cf95, 0xe84308a6, 0x24f0338e,
0x2e691888, 0xf753da6a, 0xca56cbda, 0xe044007a,
0x209b3288, 0x33be21fc, 0x01abe19c, 0xcc8bca2b,
0xd9dbf678, 0x17dc2ef0, 0x3515264a, 0x08d3e73a,
0xce8bc78a, 0xd3c6f02f, 0x11312bd2, 0x355629ec,
0x0f0beda2, 0xd249c6d0, 0xcd21e528, 0x05c0244b,
0x32fa2ef7, 0x1852f6ec, 0xda85c8ab, 0xcaaae09c,
0xffd51f4a, 0x32ad3248, 0x1f77000f, 0xe0d2cbbd,
0xc9a7dabd, 0xf9851a82, 0x2ffc3423, 0x251b082a,
0xe71bced2, 0xc7e0d4e6, 0xf0821135, 0x2af0349e,
0x2b250fd2, 0xef25d379, 0xc7cfcfb3, 0xe99409c1,
0x258e32e5, 0x2ca91561, 0xf425d6c7, 0xc6c2cad6,
0xdf140040, 0x1ee93193, 0x30f91e95, 0xfe94dec4,
0xcc14cac0, 0xdd4efb00, 0x1b24303e, 0x32982264,
0x04efe4b3, 0xcdaec7fe, 0xd6e3f29f, 0x14392d2b,
0x35452978, 0x0f98eebe, 0xd2d9c86a, 0xd0e1e96e,
0x09d225b5, 0x328b2c63, 0x154bf568, 0xd7afc888,
0xcc34e460, 0x02ff1ffd, 0x31bc3052, 0x1cfbfd64,
0xdebacb1c, 0xca41dc83, 0xfaa61958, 0x2e4e3261,
0x22530490, 0xe399cc89, 0xc896d6d9, 0xf28b1242,
0x2b923386, 0x287d0da9, 0xecddd345, 0xc8d2d22c,
0xeb7e0a32, 0x267434b6, 0x2e711636, 0xf5cbd8df,
0xc938cc8d, 0xe1fa024d, 0x211433c1, 0x321b1d4d,
0xfd9edf0f, 0xcb53cbdc, 0xddc4fbed, 0x1b202e8f,
0x3214216e, 0x03dee431, 0xccd1c6ad, 0xd451f0cc,
0x11f82bd9, 0x347f2946, 0x0dc8ec37, 0xd13ec640,
0xcffeea0f, 0x0a64268c, 0x343b2e84, 0x17c9f672,
0xd9d2caed, 0xcf3de4e1, 0x03f521ee, 0x32a230da,
0x1bfdfcf0, 0xddfdcaf8, 0xca8ddd0d, 0xfaa71948,
0x2f2a3320, 0x22fa0546, 0xe549ce12, 0xc988d7b6,
0xf2e2132d, 0x2c4e3437, 0x28430c62, 0xec03d292,
0xc7cad111, 0xeb530c04, 0x27db34b7, 0x2d85155f,
0xf569d916, 0xcb0acf56, 0xe519048e, 0x1fa32f75,
0x2dd31a35, 0xfb9ddd42, 0xcbb1cb85, 0xdea7fca0,
0x1b7e2fd8, 0x323621b5, 0x0270e25b, 0xcc73c894,
0xd7e1f418, 0x138f2c2f, 0x33b3274a, 0x0bd0eb09,
0xd231c90c, 0xd2ceecb0, 0x0d3528d0, 0x33e12bb5,
0x1354f2d3, 0xd67ec8f9, 0xce7de504, 0x04e72261,
0x32ac309b, 0x1c19fc53, 0xde26cae4, 0xcc39dfa1,
0xfe0f1cfc, 0x30f032ef, 0x20d90299, 0xe381ce15,
0xc9ebd968, 0xf559143e, 0x2b8e3245, 0x24e70842,
0xe855cf3e, 0xc621d1df, 0xed120d9b, 0x291b34a8,
0x2b871251, 0xf29ad5ab, 0xc83dcef4, 0xe57f05e8,
0x213830e4, 0x2e2f190f, 0xfabedcde, 0xcb02cce3,
0xe0d8fe6b, 0x1d843172, 0x335b21e2, 0x0353e366,
0xcc6dc756, 0xd68ff372, 0x13582bc7, 0x31d92527,
0x0a3ce9ab, 0xd111c94a, 0xd55bef62, 0x0f6e2930,
0x34652b2d, 0x10eff070, 0xd3d3c74e, 0xce7ce5f3,
0x06a8256b, 0x34aa312d, 0x1b04fa45, 0xdc1ccad4,
0xcc55e003, 0xfdd21a16, 0x2df62ed0, 0x1dc0ffb8,
0xe0a0cc63, 0xc840d923, 0xf65017da, 0x2ec0348c,
0x26bb0a1c, 0xe9afcfc7, 0xc8ccd2c8, 0xed420e1c,
0x27953267, 0x28b80fd1, 0xf044d4bf, 0xc8d2cf5e,
0xe7450862, 0x253933cb, 0x2eab18cf, 0xf8d7da83,
0xcb14cc8d, 0xe002fea9, 0x1def3081, 0x31261ff1,
0x015fe2ec, 0xcc85ca21, 0xdab5f727, 0x16352d01,
0x327e2529, 0x09b1e913, 0xcfe1c79d, 0xd379ee3d,
0x0e1927cf, 0x32fd291b, 0x0f92eef6, 0xd390c6b1,
0xcd90e658, 0x0736240d, 0x33362fb8, 0x19fbfa97,
0xdc63cb04, 0xcd2de0bd, 0xfe0f1bd3, 0x2f093008,
0x1daf0041, 0xe0b8cc2d, 0xc951d899, 0xf5b21675,
0x2d9d345f, 0x27110ad5, 0xeb01d1d4, 0xc9cdd44f,
0xeeef0d30, 0x269731a0, 0x293c0f98, 0xeff0d583,
0xc9a0cfd3, 0xe7c8083d, 0x24803369, 0x2dc3185b,
0xf874db58, 0xca82cc38, 0xe0c4fe69, 0x1c4e2ffd,
0x30be1f03, 0x011be288, 0xcd13c9be, 0xd933f672,
0x14bc29f5, 0x30642299, 0x072ce7bb, 0xd01bc7a4,
0xd335ee16, 0x0e7b27af, 0x31cb2909, 0x100ef040,
0xd4e8c92a, 0xd0cee801, 0x06da2340, 0x31742cca,
0x16d1f866, 0xdb57cafc, 0xcdb2e14c, 0xfffd1ed0,
0x30c531b3, 0x1ec60008, 0xe131cc6e, 0xc9ffd9ca,
0xf65d1449, 0x2c36323e, 0x252909ab, 0xe9b6d16a,
0xc94fd4a7, 0xee560cf7, 0x267a3193, 0x285f1010,
0xf0dfd5ce, 0xca55d08c, 0xe78107c1, 0x23b93261,
0x2cf016cf, 0xf76eda29, 0xc91dcb22, 0xdff3fec1,
0x1cdf2f7b, 0x2f9e1de1, 0x0027e1f8, 0xceefcc0d,
0xdbcdf850, 0x17442c9b, 0x32782434, 0x079ce823,
0xd032ca85, 0xd506f012, 0x0fb72929, 0x344d2a18,
0x1248f2a4, 0xd771cb71, 0xd16de86a, 0x06a62156,
0x2fc52bcc, 0x16a2f769, 0xda4aca09, 0xce07e26b,
0x0233206c, 0x32783312, 0x1f4e0118, 0xe19ccd70,
0xcaedda78, 0xf72715d2, 0x2c803263, 0x24be08e0,
0xe8dcd202, 0xc9cad556, 0xf0340f0b, 0x27dc318d,
0x27b20de1, 0xee8cd44f, 0xc918cfda, 0xe7e0069c,
0x22c330a2, 0x2cca177d, 0xf776dabc, 0xc9b3ccad,
0xe195ffb2, 0x1d203051, 0x30261db6, 0xff4de14e,
0xcd8ccbfb, 0xdc1ef8a9, 0x18392d7a, 0x325423bb,
0x07abe814, 0xcf83c861, 0xd48eef95, 0x0f1d27ce,
0x324f27da, 0x0eeaefea, 0xd580c9e1, 0xd250ea78,
0x0916241e, 0x31922d05, 0x170ff6e5, 0xda3fcafd,
0xce9de347, 0x01d320cf, 0x315830a3, 0x1ce2fdc7,
0xdef5cac4, 0xc8d4d948, 0xf75a169c, 0x2c593186,
0x246b0894, 0xe92cd112, 0xca5ed6a1, 0xf0861084,
0x27a8310c, 0x279f0de1, 0xee26d3d9, 0xc99bd1c5,
0xe9e60993, 0x24a8324f, 0x2db8173d, 0xf901dc07,
0xcbf8cdc0, 0xe2850170, 0x1e1b2f80, 0x2ecd1b2f,
0xfcfbdf42, 0xcbf4cb31, 0xdd32facd, 0x19b22f00,
0x32e224c2, 0x095de932, 0xd0c5cb26, 0xd5d5f0ac,
0x0ecd273b, 0x30fc27b4, 0x0e10ef2f, 0xd55bca0f,
0xd220e93d, 0x088d2273, 0x2fbb2a71, 0x157ff6ef,
0xdbd1ca82, 0xcda5e2a6, 0x01921dfc, 0x2fbd2f59,
0x1c45ffb8, 0xe1c9cec8, 0xcd43de8d, 0xfa761893,
0x2d543299, 0x22bb0719, 0xe81fd0c5, 0xcb50d669,
0xf1171093, 0x284f31fc, 0x27f90f86, 0xefecd54f,
0xca59d1e5, 0xea910941, 0x243531fa, 0x2d2116bd,
0xf924dc5b, 0xcc44cef7, 0xe3e80268, 0x1e342fdb,
0x2f031cf8, 0xff71e1a5, 0xce2cccea, 0xdd3df9c8,
0x19762e69, 0x329822c1, 0x0651e775, 0xd039c9c7,
0xd5fdf031, 0x0ee12772, 0x30a3277e, 0x0eeaeffb,
0xd651cba7, 0xd39aebc1, 0x0a2d2413, 0x31192d20,
0x172bf860, 0xdbaacbb3, 0xcddae239, 0x00a51d69,
0x2feb2ea7, 0x1d2aff98, 0xe1decf65, 0xceeadf6f,
0xfc271a22, 0x2df530fe, 0x204e057e, 0xe6dad048,
0xcabcd706, 0xf2b01116, 0x29ed32d4, 0x28cb0fbf,
0xef67d639, 0xcb65d4d7, 0xec890a05, 0x240e30bf,
0x2a9f1409, 0xf53cd8a9, 0xca78ce4c, 0xe28e01b8,
0x1e5c2f46, 0x2e641b81, 0xff08e14b, 0xcda0cbe7,
0xdce3f9a5, 0x177e2c52, 0x2f7e2031, 0x046ae4e5,
0xce24c9af, 0xd717f1e1, 0x118628c6, 0x317e2685,
0x0d0feecb, 0xd4afcae5, 0xd383eb67, 0x0a882574,
0x32d82cd0, 0x15dff6cc, 0xd9ffcae9, 0xce2ee3f4,
0x02381ec5, 0x30222e3b, 0x1c5cfeed, 0xe156cd98,
0xcd09dd8b, 0xf9d51811, 0x2b7c300c, 0x20e0052b,
0xe754d111, 0xcbbbd821, 0xf24f1173, 0x28bd3173,
0x26ee0dab, 0xedf6d3ee, 0xca18d2a7, 0xea570957,
0x242f3028, 0x29bc135a, 0xf51bd8c9, 0xc9d3cdb9,
0xe27a009a, 0x1d3b2ec5, 0x2e611c99, 0xff0de041,
0xccd2cb8e, 0xdccaf8cf, 0x17932d06, 0x31b522ab,
0x07e3eaac, 0xd309cd74, 0xd943f351, 0x118228b0,
0x3154260c, 0x0c6feda5, 0xd41dc907, 0xd053e846,
0x08632321, 0x2fbf2be5, 0x160ef7a0, 0xdbe5cc1c,
0xd08ae4b7, 0x01791ded, 0x2f262e5e, 0x1b91fe82,
0xe0e1cd64, 0xcca6dc1b, 0xf72a1512, 0x29782dc4,
0x1fe205e9, 0xe7fad1e1, 0xcb87d710, 0xf0ba0e8c,
0x25432ca7, 0x234e0c0f, 0xed56d3b3, 0xc906d111,
0xe8fe07ce, 0x22762fea, 0x2a021431, 0xf6bbdad7,
0xcc26ced9, 0xe3d10177, 0x1d0c2da4, 0x2d171a82,
0xfd95e0a2, 0xcd84cc18, 0xdc23f83f, 0x15fe2af7,
0x2f73217e, 0x06bee8eb, 0xd248cc1c, 0xd721f156,
0x0efd2609, 0x2fd82617, 0x0f9df094, 0xd62bcb1b,
0xd244e986, 0x07ba22f2, 0x2f382ada, 0x149ef612,
0xd9d9c98d, 0xcda6e194, 0x00b11ca6, 0x2ce32c27,
0x1ad8feaa, 0xe034cd5f, 0xcb04db5b, 0xf7e71574,
0x2a6c3021, 0x225407f9, 0xe9f7d2af, 0xcbe3d7cc,
0xf17f0f42, 0x27122fd4, 0x26870d89, 0xeff0d6de,
0xcbf1d423, 0xebe70a24, 0x237830e7, 0x2c3e15a2,
0xf74edbee, 0xcc4fcf26, 0xe3c701ee, 0x1d492d88,
0x2dd21c3c, 0x0007e18a, 0xce4ecdf0, 0xde7bfa60,
0x17352bdf, 0x306f2233, 0x064be894, 0xd219cb39,
0xd785f119, 0x0ede26fa, 0x2fda26ca, 0x0ebbf1ea,
0xd94ecda7, 0xd4beeb3c, 0x09b622a6, 0x2f692aca,
0x14c7f69f, 0xdae0cc20, 0xcf70e2ef, 0x00a21d0a,
0x2e0e2e19, 0x1c2aff7e, 0xe29acfcc, 0xce0ede10,
0xf977168d, 0x2b623051, 0x220e06bb, 0xe84bd1cb,
0xcbbdd67b, 0xf07b0ff0, 0x2781300a, 0x26a40f9d,
0xf159d72a, 0xcbd9d2fc, 0xe9e60714, 0x21e12f94,
0x2a5e1562, 0xf80adcc4, 0xccf1ce77, 0xe28e004f,
0x1ca82d65, 0x2d201b9b, 0xfea8e219, 0xce98ccbe,
0xdce1f80c, 0x165c2bb9, 0x2fbc225d, 0x0780e9ba,
0xd223cb39, 0xd658efec, 0x0e55258b, 0x2fb6276f,
0x0fd8f0b6, 0xd7f4cc34, 0xd33de97a, 0x0731217f,
0x2ea92ab2, 0x15b9f7e6, 0xdc72cd80, 0xcf39e30f,
0x01311ddb, 0x2df72ea4, 0x1d350120, 0xe3d8cf66,
0xccf2dd4a, 0xf92315a5, 0x29cd2f7e, 0x2243071a,
0xe99bd2df, 0xcda9d8a2, 0xf1650f2d, 0x2792308a,
0x26f50edb, 0xf114d715, 0xcb99d214, 0xe71b051e,
0x1f032da5, 0x2a1a14bb, 0xf846dd6e, 0xcd6dcf83,
0xe2c00097, 0x1acf2be9, 0x2c5b1b1b, 0xfe54dfe4,
0xcd66cba9, 0xdbdff6b9, 0x13ed29dd, 0x2ee62186,
0x07d9e9ee, 0xd3b6ccc7, 0xd6f9efb6, 0x0d9325fd,
0x2ede2602, 0x0eb9f0f3, 0xd82fcc5f, 0xd1fde8d8,
0x074520f0, 0x2e332a69, 0x15daf8f7, 0xdd9ecdb1,
0xcf9de235, 0xfe861a40, 0x2c342cbf, 0x1be700d1,
0xe4acd111, 0xcf30ddf4, 0xf843153a, 0x2a102ee4,
0x2193079e, 0xea2ad2ff, 0xcba8d6ce, 0xeec30d70,
0x25312e2b, 0x25e90e96, 0xf155d7dd, 0xcb8bd12b,
0xe7f40584, 0x1fc62e3d, 0x2bf81882, 0xfb16dfab,
0xce57cfea, 0xe246ff58, 0x1aab2c2f, 0x2de31d2d,
0x01afe487, 0xd08bcd3a, 0xdc09f6aa, 0x142a299d,
0x2ea721d9, 0x08a1eb58, 0xd3f9ccef, 0xd799f02e,
0x0eda25b4, 0x2fc326ff, 0x0f95f1c5, 0xd848ccce,
0xd302e9bc, 0x079f2266, 0x2f342cb5, 0x1744f969,
0xddf2cd51, 0xcedbe064, 0xfc0c16f6, 0x29842b38,
0x1c12007b, 0xe482d11d, 0xce42dde4, 0xf87115a8,
0x29552e9b, 0x21750751, 0xea71d38a, 0xcbdbd6e9,
0xeeeb0cb5, 0x24b62d6f, 0x25a40f3c, 0xf22dd8c0,
0xcd93d2eb, 0xe8750629, 0x20352e36, 0x2b7d17da,
0xfae1dfe8, 0xcef4d028, 0xe0acfcae, 0x19c62b2f,
0x2d5a1d7b, 0x0227e636, 0xd1f1cf00, 0xdcecf62c,
0x129e276a, 0x2e182266, 0x09a3eccc, 0xd4e1cc2a,
0xd726ef0d, 0x0cb42469, 0x2d86266b, 0x0f06f117,
0xd7decc59, 0xd27ee70c, 0x058b2185, 0x2efb2bbf,
0x1816fc5e, 0xdf7dcd7b, 0xcf02e024, 0xfc2f1886,
0x2aec2da5, 0x1e170214, 0xe5d2d1ba, 0xce5adca8,
0xf63f148d, 0x2ac030ae, 0x24f10b12, 0xecb4d543,
0xccfbd73a, 0xef0d0c6b, 0x247b2e69, 0x281a12cb,
0xf50ddb7d, 0xcecad315, 0xe94106bc, 0x208e2e46,
0x2bab1852, 0xfaf8df89, 0xd020d129, 0xe174fd44,
0x19f62c61, 0x2eb31f06, 0x04c1e848, 0xd376cf3c,
0xda90f398, 0x0fbb255a, 0x2cbb21da, 0x0a6aed53,
0xd610cde2, 0xd707ee14, 0x0b572375, 0x2ee328a1,
0x12d3f524, 0xda2dcd17, 0xd21fe638, 0x02a21cda,
0x2ac62a0a, 0x17e1fc99, 0xe23bd0b1, 0xd0cae153,
0xfc441870, 0x2b222d5e, 0x1e2c0367, 0xe777d2d1,
0xce9adaf6, 0xf4331116, 0x262d2dee, 0x23490b54,
0xee59d70b, 0xce5bd73c, 0xeccb08fb, 0x217c2d37,
0x26a81183, 0xf582dc41, 0xcfa0d263, 0xe6f102ad,
0x1c962b68, 0x2a2117b0, 0xfc33e097, 0xce77ce87,
0xdea8fa2d, 0x160d2903, 0x2c591fac, 0x05a0e8ef,
0xd3afce6f, 0xd99df131, 0x0e23238e, 0x2c6c230f,
0x0b0bee5d, 0xd6dbcd64, 0xd519eb8e, 0x084c2146,
0x2cfb27c1, 0x1376f6df, 0xdcabceae, 0xd202e4d6,
0x01021bef, 0x2b1f29c6, 0x186dfcd3, 0xe220d0d0,
0xcfb9e04b, 0xfb3417e1, 0x2b1f2e64, 0x1fed05ba,
0xe94ad320, 0xcdced991, 0xf2100e42, 0x25132d5a,
0x24a40dd3, 0xf0f6d959, 0xcf1bd635, 0xebce06dd,
0x1e532b2c, 0x25de122e, 0xf59adc48, 0xce57d1cf,
0xe5cf01bd, 0x1bcb2bc0, 0x2afb193d, 0xfe46e241,
0xd083cf61, 0xde5af8fd, 0x15cc28a3, 0x2beb1e0a,
0x0507e8be, 0xd3ecceff, 0xda03f2cc, 0x0fe525e4,
0x2d52240c, 0x0d7bf00c, 0xd875cef4, 0xd4f9ea9d,
0x07161e7e, 0x2bbf2757, 0x1465f8ff, 0xdf21d14d,
0xd336e636, 0x00351a2d, 0x2a2f2b01, 0x1a76ffa0,
0xe4b1d23e, 0xd071deb8, 0xf8e3140a, 0x268a2b52,
0x1e100477, 0xe867d2fc, 0xcda5d85f, 0xf0750d80,
0x24312c89, 0x25300e24, 0xf298db2e, 0xcf52d545,
0xeab10668, 0x1e192b4e, 0x26b01457, 0xf8ccdea0,
0xd016d270, 0xe41effb4, 0x1a842a92, 0x2a951b94,
0x0138e55c, 0xd3ebd0d5, 0xde87f817, 0x13a326e0,
0x2c191f3e, 0x05faeaca, 0xd556cfba, 0xdab0f2ec,
0x0ef024f2, 0x2e5b260a, 0x1018f2da, 0xdb19cf7e,
0xd54dea23, 0x055b1dd5, 0x2b7127d1, 0x1574fab5,
0xe078d144, 0xd1a5e300, 0xfd9917b5, 0x27d5291a,
0x18acffc5, 0xe5d4d2fa, 0xd00fdd85, 0xf81d1313,
0x27292c63, 0x206108b2, 0xec54d66c, 0xcfafda5b,
0xf08c0cea, 0x23942c6e, 0x24bb0ec3, 0xf367db61,
0xd07fd62c, 0xe9f20576, 0x1ea52cc5, 0x29b31776,
0xfc47e22e, 0xd1b6d250, 0xe322fcbb, 0x17cb27f7,
0x2a2a1b4a, 0x0311e7ce, 0xd502d179, 0xddaef65d,
0x113925aa, 0x2b82214a, 0x098eef1f, 0xd920d0ec,
0xd967efe8, 0x0b3e2294, 0x2cec2537, 0x101bf351,
0xdb43cf78, 0xd3cbe7b5, 0x02a71c71, 0x29df2880,
0x1726fc5d, 0xe31ed1e6, 0xd2a4e32b, 0xfc3b1622,
0x2761292f, 0x1b3601dc, 0xe6d1d3ae, 0xcfe7db5c,
0xf3a20f4d, 0x24862b51, 0x222c0cad, 0xf0eddaff,
0xd20cd9c8, 0xef090956, 0x20f62abc, 0x2424111c,
0xf52fdc9f, 0xd03cd4d6, 0xe7f9041b, 0x1e1a2be4,
0x2a5d1909, 0xfd99e362, 0xd2fbd309, 0xe1fefbfa,
0x15c1278c, 0x2a631cb6, 0x04d2e8d5, 0xd631d16c,
0xdcaff411, 0x0ecc2242, 0x290b2026, 0x0a19eec8,
0xd7edceb2, 0xd6c3ecc5, 0x09661fc8, 0x2995247a,
0x11dcf723, 0xddb7d20c, 0xd571e82a, 0x034b1b9d,
0x29dd28b1, 0x17c6fd58, 0xe31ed291, 0xd14ae17d,
0xfaa61538, 0x27f72a7c, 0x1d220518, 0xeaded66d,
0xd0d1db1a, 0xf2a00dcd, 0x219028d6, 0x20900c13,
0xf122da1c, 0xd18ed8a7, 0xecc10792, 0x1ef52a7b,
0x25e512cb, 0xf8e7dfd7, 0xd296d542, 0xe6b500f8,
0x19ce27ef, 0x26af17c8, 0xfe28e334, 0xd187d05d,
0xdda2f7a7, 0x12b424d5, 0x28a11cc2, 0x05b4eb97,
0xd79cd0f0, 0xdb96f1ed, 0x0d0b2109, 0x290c219b,
0x0c26f135, 0xdb2bd144, 0xd6feeb64, 0x065a1dd4,
0x2a562622, 0x13a6f9f8, 0xe1fbd501, 0xd61ae775,
0x007a19bf, 0x277425e1, 0x1750fdee, 0xe441d28b,
0xd1bbdfb3, 0xf9ab1385, 0x265c2b69, 0x1f4507fa,
0xeb4bd82a, 0xd24bdc4d, 0xf2bc0ca1, 0x20dc28ee,
0x218a0be4, 0xf0fadb10, 0xd20ad80b, 0xeb0804c8,
0x1bd52795, 0x23ba11af, 0xf836dfe8, 0xd216d440,
0xe54cff16, 0x17ac2684, 0x27ab17fa, 0xffade6c7,
0xd5b9d489, 0xe18af9e1, 0x134d25b6, 0x2a1b1df8,
0x0695ec6b, 0xd870d255, 0xdb97f123, 0x0c75216b,
0x29a122c4, 0x0e52f37a, 0xdc41d209, 0xd780eaf3,
0x05581c18, 0x277e247f, 0x13f2faa4, 0xe313d497,
0xd690e6ca, 0xffc01820, 0x267f2790, 0x190501a6,
0xe84fd64b, 0xd3e6e0d4, 0xf7fd11a8, 0x239c2853,
0x1d4e06b3, 0xebfad6c0, 0xd0f8daa8, 0xeffd099f,
0x1ea827dc, 0x20fc0e0e, 0xf3dddd32, 0xd2ded7bc,
0xebe50539, 0x1be027dd, 0x263a1508, 0xfb99e32b,
0xd443d59b, 0xe4c3fda8, 0x165a25c6, 0x26d21936,
0x0180e940, 0xd740d57a, 0xe111f77c, 0x12742468,
0x28f41de8, 0x081eedcc, 0xd8e5d149, 0xda01f047,
0x0ac2205a, 0x2b0a244e, 0x1082f6f7, 0xdfacd441,
0xd86aeb43, 0x03d61b0b, 0x276a2524, 0x154afb73,
0xe3c3d53c, 0xd618e493, 0xfbfe14d0, 0x246b2671,
0x18cb0181, 0xe870d736, 0xd339df01, 0xf67f1013,
0x2332277d, 0x1da308fa, 0xeeddda7d, 0xd3a1dba5,
0xf1370b38, 0x209c2913, 0x22670f6f, 0xf624df06,
0xd3b5d7ef, 0xe92e02e5, 0x19f02702, 0x249b14d7,
0xfc87e512, 0xd5e4d5ab, 0xe458fb67, 0x13f6238f,
0x25b71977, 0x0398eb15, 0xd901d542, 0xe0daf6e5,
0x0f5a2227, 0x28521f6f, 0x0a73f08a, 0xdbe8d32e,
0xdb4aef47, 0x08001d6d, 0x276921dd, 0x0e44f565,
0xdef8d314, 0xd610e797, 0x017918c4, 0x258f2428,
0x1528fdb1, 0xe5f4d527, 0xd456e39d, 0xface13ab,
0x24982803, 0x1c7506a4, 0xeca3da50, 0xd501deb6,
0xf48c0cae, 0x1fb626a8, 0x1ec20a11, 0xf12cdcf3,
0xd569dbcc, 0xef4107b1, 0x1d3827c7, 0x21f0104c,
0xf805e094, 0xd46fd789, 0xe8a60168, 0x187b265a,
0x252c16b3, 0xfe42e622, 0xd665d500, 0xe338fa09,
0x13092324, 0x25d01b03, 0x04a6ebb7, 0xd8f7d37f,
0xdd2af346, 0x0c911fd7, 0x280520fa, 0x0cddf407,
0xdf46d53d, 0xda4bed72, 0x06761beb, 0x26e3220d,
0x10b7f80a, 0xe0c2d4db, 0xd812e851, 0x001517ae,
0x263725fa, 0x18630067, 0xe774d762, 0xd455e09f,
0xf79a1086, 0x21de2622, 0x1a9a0515, 0xece8da1d,
0xd467dde8, 0xf2f20b9f, 0x1eb3273c, 0x1faf0c68,
0xf447deef, 0xd593da67, 0xec6304a5, 0x1a6f2655,
0x24a41362, 0xf9cde289, 0xd5bad739, 0xe6ccfdb2,
0x14de2323, 0x23c11747, 0xfff7e7a3, 0xd8e5d7a1,
0xe4d7fa49, 0x11fb21ff, 0x25d21b3a, 0x05afef67,
0xdbdcd68f, 0xdfeef432, 0x0c1d1ea6, 0x25e81f96,
0x0c26f39f, 0xde7fd58d, 0xdb5eed78, 0x04ee1a6e,
0x2541217a, 0x114ff87c, 0xe189d3ee, 0xd727e74e,
0xfe7d1509, 0x234324c7, 0x19310198, 0xe998d86b,
0xd57ee160, 0xf6ce0eb5, 0x1ec9234d, 0x1aef0998,
0xf172de6f, 0xd7a0ddd8, 0xf0bf096a, 0x1caf2438,
0x1d200bb6, 0xf4c3dfb7, 0xd56dd978, 0xea0c0371,
0x18fd2510, 0x23241307, 0xfccee604, 0xda6cd8c9,
0xe5f1fb34, 0x10e52218, 0x244818d0, 0x01e7e96c,
0xd979d5ad, 0xe214f637, 0x0e541eaf, 0x235b1b1f,
0x0760f2ac, 0xde2bd8b3, 0xde90ef13, 0x07031a27,
0x254d201f, 0x0da7f655, 0xe00fd6a6, 0xdadcec07,
0x033b188d, 0x24f4237b, 0x137dfc04, 0xe5b2d715,
0xd8f0e60d, 0xfd3613b8, 0x21f9248e, 0x180101a1,
0xead0db73, 0xd8fde3a7, 0xf7440d06, 0x1fc124f8,
0x1b4d0720, 0xefcfddd5, 0xd6a1de27, 0xef8d0715,
0x1b2c25f8, 0x20690e94, 0xf63fe173, 0xd742da48,
0xeb290312, 0x18b52301, 0x21521361, 0xfd8fe7e7,
0xda32db14, 0xe841fcc7, 0x12402259, 0x2532185a,
0x026ee8e3, 0xdaa9d7e5, 0xe2dbf7f3, 0x0e26203c,
0x25a71dc7, 0x0a16f1d2, 0xded8d764, 0xdd2fef52,
0x07ba1da5, 0x26dd20cb, 0x0ebaf88d, 0xe38cd93a,
0xdb20ea4c, 0x03a11858, 0x25f824cc, 0x14befd2a,
0xe5b1d8f6, 0xd7dfe52b, 0xfb3b136d, 0x23632395,
0x17990150, 0xea69d9bc, 0xd942e41d, 0xfa2710cf,
0x20bf263c, 0x1b7b08a8, 0xefffdc7c, 0xd462dbb5,
0xedee07e3, 0x1cd22625, 0x25a414eb, 0xfcc3e208,
0xd3cfd6b9, 0xe668023e, 0x185f280a, 0x25a41710,
0xfee6e57c, 0xd880d724, 0xe4a6f8c4, 0x106d2052,
0x246d19e9, 0x05c9eecd, 0xde7fd9ca, 0xe128f36a,
0x08321a81, 0x211e1bcd, 0x0d28ea23, 0xd915e815,
0xfe980cf9, 0xfe24f909, 0xfb84f7d4, 0x01d9fa04,
0xf946ee46, 0xe8351980, 0x2e9f2102, 0x0aeafb83,
0xe615d195, 0xcee4cecb, 0xe7940359, 0x29a14654,
0x408c3591, 0x0d34e46e, 0xc7f8aeeb, 0xb792cc07,
0xf0f6212f, 0x3eae4a27, 0x3ea12754, 0xfedbd252,
0xc061bb79, 0xd39af6ea, 0x1659241a, 0x20de1cee,
0x087ff7e7, 0xea20eaad, 0xf2f3f6f2, 0x05910999,
0x070b021e, 0xef93deb5, 0xd9a9e629, 0xffd015e5,
0x26d72d88, 0x288612c6, 0xeafbcd9c, 0xb969c09d,
0xda27f912, 0x1ec7383f, 0x4a7d3dd1, 0x1cf5f377,
0xc863b518, 0xb4cbcd0a, 0xf37d15b1, 0x328839b3,
0x313d2425, 0x0718e8e1, 0xd454d136, 0xdecfecae,
0x03560fa1, 0x1218108b, 0x03f7fd20, 0xfeef0393,
0x0db415a8, 0x0f7c0522, 0xf46ee339, 0xd152cb6f,
0xd555eda3, 0x187336a9, 0x4ae845ba, 0x27100249,
0xd7c4b4ea, 0x9f52afdb, 0xda680e73, 0x361d43dd,
0x4e573db8, 0x11a7e23f, 0xbe49b5a7, 0xc2d8dcd1,
0xf9d7141b, 0x2ad1309a, 0x26220ca5, 0xf2fbe62e,
0xe06ce585, 0xe8f6f6f4, 0x021c07e8, 0x0dd7ff04,
0xf680f711, 0x03370fd6, 0x15ff1b0f, 0x10bf0035,
0xe417d1de, 0xcbb9cd60, 0xe37303ef, 0x29f73e16,
0x3d532c31, 0x0aeae88b, 0xcb7fb9d1, 0xbb30d24e,
0xf9e21980, 0x2eb437a2, 0x2dc61a4a, 0xfb20df87,
0xd0a1d1b0, 0xe116f301, 0x072813c6, 0x19251425,
0x08affffa, 0xf85cf5de, 0xf6f5fc17, 0x014d05ed,
0x01f1f934, 0xf1daed01, 0xeccdf56e, 0x09e21ff5,
0x2ba52401, 0x12d7f7bf, 0xda00cbc6, 0xc737d168,
0xee7b1210, 0x301e3d74, 0x37ee2262, 0x01e0df09,
0xc3c6b73d, 0xc148df60, 0x0458204c, 0x354e3aaa,
0x28900c72, 0xef58db43, 0xd498d9d5, 0xe7aafa92,
0x0c17175e, 0x14bc09d1, 0xfedaf430, 0xf0abf81d,
0x02410583, 0x06830280, 0xf3cee6ae, 0xe0e3e629,
0xf21d0461, 0x197828bb, 0x2ebb221c, 0x05d7e5ac,
0xce10c293, 0xc6e9dd12, 0xff5522da, 0x39833e78,
0x318f133c, 0xef3dce63, 0xbb6cbd2d, 0xd09fef0b,
0x10082a17, 0x33c82b89, 0x171afffe, 0xea90db09,
0xdac5e3e3, 0xf14f00c2, 0x06f60745, 0x04720051,
0xfc05fbab, 0x02190afa, 0x11c30e44, 0x0369f5ab,
0xe300d666, 0xd4f1e1ea, 0xfb401731, 0x2f98382f,
0x305f1a12, 0xf8b3d865, 0xc1e0bdf5, 0xcd4debe3,
0x12cb3170, 0x42a73f2b, 0x27280532, 0xe06cc7f0,
0xc162ca52, 0xe198fdab, 0x175327ef, 0x2a001f89,
0x0abbf715, 0xeaf2e5f8, 0xe914f1de, 0xfc4900b1,
0xffe9fc42, 0xf585f42c, 0xfa9706e6, 0x125d17f6,
0x18eb0e4d, 0xfa50e479, 0xd30acbf2, 0xd3dfeac3,
0x091f28a6, 0x3c383a92, 0x295c0931, 0xe374c593,
0xb65ebdc6, 0xd6e3fc6c, 0x20ad39c6, 0x425f34b2,
0x18b6f5ec, 0xd883c961, 0xc8b9d866, 0xf1bc0adc,
0x1c311f60, 0x1afe0fb4, 0x00a6f49a, 0xef90f31b,
0xf98b0003, 0x00fafd92, 0xf6bff14f, 0xefa4f299,
0xff1710e5, 0x1e42231a, 0x1d530b14, 0xf1dad921,
0xc8f2c779, 0xd8e7f68e, 0x18d73414, 0x40cb38e7,
0x1dbaf971, 0xd549bed6, 0xbbbccbfa, 0xea3e0ba9,
0x281e3910, 0x37b62557, 0x07eaea67, 0xd62dd05f,
0xd79fe91e, 0xff23113b, 0x19bd179b, 0x0d9303b3,
0xfc1ef8b8, 0xfbb00129, 0x054a0278, 0xfb82f1ca,
0xe8dbe4c1, 0xe847f5e4, 0x0a5d1eee, 0x2c532a85,
0x1a1fff1f, 0xe1cbcb72, 0xc160ca9e, 0xe40f0699,
0x288a3d05, 0x3fe62e20, 0x0e5aeac5, 0xcc40be90,
0xc418db14, 0xf9ea1955, 0x2e26338d, 0x29fc13af,
0xf954e38d, 0xda94dcca, 0xe640f6bb, 0x05c80d5d,
0x0d730772, 0x008efc2d, 0xfe6a0376, 0x09d10d61,
0x08dfff59, 0xf112e2c2, 0xdb89de04, 0xec1a0274,
0x1b662f75, 0x353f2844, 0x0e17ece4, 0xd008bf5f,
0xbeefd290, 0xf3d71906, 0x34c23fe5, 0x38aa1feb,
0xfd39dc5f, 0xc60dc0ea, 0xce65e88e, 0x06911fd5,
0x2bfc2a3f, 0x1b99070e, 0xf2dfe5e3, 0xe380e818,
0xf22efc18, 0x0379042f, 0x011dfbc1, 0xf905fc86,
0x05280f22, 0x14ff135e, 0x0820f78e, 0xe4ecd50c,
0xd099da57, 0xf2230f98, 0x29163909, 0x365522e2,
0x0271deab, 0xc548bc8b, 0xc5cbdf39, 0x03b42719,
0x3ca84017, 0x2ed711dd, 0xf0c5d625, 0xc7bdc9ca,
0xdba8f521, 0x0e7e1d13, 0x21de1b15, 0x0d4cfdb9,
0xf26ced7e, 0xef7bf5db, 0xfbaefdb5, 0xfb4bf62c,
0xf295f2e3, 0xf8b30599, 0x15721ffe, 0x20cb1638,
0x01cfea5e, 0xd4d0c97b, 0xcd21e02a, 0xfe60200f,
0x375c3e72, 0x325d1669, 0xf310d04f, 0xbc33bc08,
0xcf23ef48, 0x12582de6, 0x3a2d3450, 0x1fe70299,
0xe6fbd49e, 0xd00bd99a, 0xeafd0116, 0x110818b7,
0x150d0c5c, 0x03e2fbdb, 0xf8f8fa8c, 0xff72014c,
0x00e6fa31, 0xf0ebe842, 0xe531ec8d, 0xfb8e0ff5,
0x22612a4e, 0x24b812fe, 0xf87bdc90, 0xc866c418,
0xd004ebd8, 0x0da32c45, 0x3ea83c9c, 0x27c206cd,
0xe387c919, 0xbe44c547, 0xde2efe57, 0x1d3d3066,
0x327d2618, 0x1033f698, 0xe217d883, 0xda68e6f9,
0xf7750509, 0x0b6a0b1d, 0x0627ffb5, 0xfc53fe20,
0x01c30848, 0x0a0b0550, 0xfc35ef0b, 0xe32ddc87,
0xe0a1eeac, 0x05e31d9f, 0x2e763044, 0x229a087e,
0xe7e9cd61, 0xbefbc2c4, 0xd7c1f835, 0x1aa73504,
0x3e9d34ef, 0x1a7ef79d, 0xd847c462, 0xc2aed2aa,
0xec9a0945, 0x202a2a8a, 0x273817d5, 0x03f6f1bc,
0xe6f2e512, 0xeb3bf56c, 0xfebe03aa, 0x01e9fd38,
0xf980f969, 0xfe1b0691, 0x0f8415ff, 0x12b306c4,
0xf463e0b4, 0xd44dd219, 0xddfbf5b9, 0x11222a11,
0x370e3185, 0x1ab5fa68, 0xda81c463, 0xbdf8ca7a,
0xe7a909c4, 0x297f3b09, 0x3b0e29e3, 0x0c09eb46,
0xd223c8c2, 0xcf66e31f, 0xfb7c11fb, 0x2016214c,
0x18b10b1f, 0xfcfff2db, 0xef0df100, 0xf6bffc48,
0xfd39fa2a, 0xf4d0f185, 0xf279f9d9, 0x05cb1430,
0x1dca1da3, 0x13ffff70, 0xe884d5b0, 0xccd3d1eb,
0xe5c6034a, 0x20ca35a3, 0x3a732bd0, 0x0ebced2e,
0xceb7bdf2, 0xc017d4af, 0xf45d150f, 0x2e17373a,
0x30eb1a1b, 0xfcace2d4, 0xd219d010, 0xdb4eef58,
0x035c1310, 0x18f515a1, 0x0c420167, 0xfa49f6e2,
0xf93afd17, 0xff3bfe92, 0xf8a0f0b9, 0xea00e9d8,
0xf23b0058, 0x126e21ec, 0x26161ef8, 0x0c63f244,
0xd921c86f, 0xc7fdd68c, 0xf20f1276, 0x2e193c38,
0x371c2198, 0x0079dedf, 0xc739bf7d, 0xcadce360,
0x02a51e99, 0x2f6f3012, 0x22340cac, 0xf474e1da,
0xd9edddb2, 0xeabbfaf1, 0x08400ead, 0x0dfa0a0e,
0x0213fde4, 0xfe55016e, 0x05bd05c7, 0x02e5fa8e,
0xee8ae3f8, 0xe0bae6ab, 0xf57f0aca, 0x1fb22c8b,
0x2bc01d0a, 0x02cee4ad, 0xcd83c3a6, 0xca4ae124,
0x00f72122, 0x370f3c70, 0x2fdd1408, 0xf224d587,
0xc4b8c64a, 0xd827f353, 0x0fdf237e, 0x2be324e8,
0x1350fed2, 0xecc3e25a, 0xe21fe97a, 0xf63f0187,
0x066c05e8, 0x0180fd90, 0xfbf1fef7, 0x05000ce9,
0x10d90d09, 0x00e5f1d3, 0xe2efd848, 0xd975e545,
0xfc0b1643, 0x2a2d3245, 0x2ac81475, 0xf6bdd88a,
0xc4bac2cb, 0xd1beedad, 0x0d5c287d, 0x3695333c,
0x20ba03ae, 0xe5e4d133, 0xca22d453, 0xe8710096,
0x16192229, 0x21921731, 0x0892f8a3, 0xeef3ebff,
0xf077f789, 0xfe7001fa, 0xffa0faee, 0xf5d8f486,
0xfa8a0464, 0x0f4617ea, 0x174f0e40, 0xfd2be992,
0xd8a9d277, 0xd9f4ed2f, 0x0899228f, 0x33aa34ef,
0x251607f6, 0xe7d9cd2f, 0xc144c7bb, 0xde3bfd7f,
0x1c1631dd, 0x37342be1, 0x1459f809, 0xdf0ad16f,
0xd179de3d, 0xf2d307c0, 0x155d1949, 0x15330a13,
0xfe46f6c0, 0xf3a2f6dd, 0xfc31ffaa, 0xffe9faff,
0xf496ee4f, 0xed71f487, 0x016b1102, 0x1c601fe5,
0x185905fa, 0xef08da48, 0xcdfad00d, 0xe104fbd2,
0x190c302e, 0x38d62fc0, 0x176af75c, 0xd954c51a,
0xc352d218, 0xeb820a20, 0x233b30a4, 0x2da51ce3,
0x05aded42, 0xde16d964, 0xdf63ee49, 0xfee20bd2,
0x11a40fcb, 0x08e400fa, 0xfb87fade, 0xfed8041c,
0x05a3023b, 0xfb06f118, 0xe78ce432, 0xe861f6da,
0x0aa31c84, 0x262b2334, 0x136dfbfb, 0xe290cea6,
0xc806d199, 0xe9b60809, 0x244235e1, 0x365a266f,
0x0aa9ead3, 0xd285c778, 0xccf6defe, 0xfa7214bb,
0x262b2abd, 0x21c90f33, 0xf952e8ac, 0xe00be200,
0xea01f60b, 0x020106f0, 0x05e501e6, 0xfd2cfc9b,
0xff4304bd, 0x0a430c35, 0x08fafe88, 0xf034e2f3,
0xdc64df4c, 0xecf601ce, 0x18972a2b, 0x2e372367,
0x0bdbef2e, 0xd53dc6af, 0xc8d4dae2, 0xf71f1638,
0x2e013716, 0x2f3e1833, 0xfa9cdd9d, 0xcc6eca13,
0xd693ede7, 0x07081a74, 0x236220fd, 0x15140489,
0xf55aeb7d, 0xea1aef4d, 0xf620fd6b, 0x00cc007b,
0xfc4bf803, 0xf843fe38, 0x06c4102d, 0x14f7120e,
0x07e3f5cd, 0xe4c6d823, 0xd563e039, 0xf4e80eeb,
0x252e30ce, 0x2d051a2f, 0xfe14dfb5, 0xca55c39d,
0xce0be6c9, 0x04ab1fb1, 0x30c231fe, 0x242f0bc6,
0xeef6d909, 0xcf80d34a, 0xe40cf9f4, 0x0d99195a,
0x1af114ae, 0x0831fc63, 0xf4d2f1bb, 0xf37ef82f,
0xfc8ffcd4, 0xf99ef45e, 0xf091f1a8, 0xf91c04d1,
0x126d1c73, 0x1ce113cc, 0x011bea92, 0xd7ffcf18,
0xd4dfe769, 0x01e51de7, 0x31323695, 0x2ab9116c,
0xf229d613, 0xc66fc7ea, 0xd921f3e0, 0x108d2630,
0x2fa229a0, 0x1747fe9c, 0xe72cd9ae, 0xd7b2e0c6,
0xf1ef0323, 0x0f76144c, 0x10b0086e, 0x0068fa90,
0xf9fcfc77, 0xffad01a9, 0x0013f9a7, 0xf168ead2,
0xe8e4f0b8, 0xfeea1023, 0x1fa025ab, 0x1f8a0e51,
0xf538dd5d, 0xcd76ca78, 0xd738f01f, 0x0e97285d,
0x365d3471, 0x218304ae, 0xe528cee5, 0xc7d5d050,
0xe6a40132, 0x19a82897, 0x29c71e09, 0x0a5af4f4,
0xe4f6def6, 0xe211ed47, 0xfb7f0645, 0x0b3d0957,
0x03fafecd, 0xfcaffe51, 0x02100721, 0x08280448,
0xfaffef12, 0xe4a9e03b, 0xe4e2f3bf, 0x08941c91,
0x2abd2a49, 0x1c1403ce, 0xe8c0d1c4, 0xc845cddd,
0xe160feed, 0x1bb63019, 0x35142a6a, 0x12ebf545,
0xda66cc5c, 0xce35dd1f, 0xf4600bb4, 0x1ce22450,
0x1ec61134, 0x0063f161, 0xe951e8f7, 0xef1ef83d,
0xffc802c2, 0x01f5fdc3, 0xf9e6fb4e, 0x00720859,
0x103c12c7, 0x0ea103b6, 0xf392e433, 0xdaabda7c,
0xe683fb21, 0x131c26ee, 0x2f94278a, 0x12e3f723,
0xdb98c959, 0xc755d469, 0xed390c3f, 0x256c336a,
0x31ef215e, 0x0741ebb5, 0xd7aed0b1, 0xd691e867,
0xfdad1014, 0x1a241b0a, 0x13c20748, 0xfaf7f3a7,
0xf1e1f415, 0xfa6efe72, 0xff6efca7, 0xf78bf2db,
0xf37afa87, 0x069312dc, 0x1a32197f, 0x0edefcda,
0xe94fd969, 0xd2e2dab9, 0xee2607ea, 0x20b3312f,
0x31a42329, 0x097aeac3, 0xd1b1c55d, 0xcb5cdf2b,
0xfa5c1765, 0x2b40307b, 0x27d11449, 0xfaafe499,
0xd8cbd8c5, 0xe36ff44f, 0x0536107f, 0x13790fd0,
0x082dffaf, 0xfa8ff925, 0xfbd6ffe6, 0x0164fea5,
0xf98ef178, 0xebbfebc0, 0xf2c1011e, 0x10511c91,
0x20901a92, 0x08b7f160, 0xdcd5d042, 0xd05bdeb5,
0xf77412e1, 0x29e53443, 0x2e171978, 0xfc43e047,
0xcd34c8a7, 0xd4a5eb30, 0x06341d4f, 0x2a2e28f0,
0x1b7606ff, 0xf1d6e37f, 0xdedbe3b6, 0xef14fd33,
0x07b90bc3, 0x0a4905b2, 0x0102fe3b, 0xffec02e6,
0x068f0792, 0x0223f97b, 0xef0fe5b3, 0xe21ee861,
0xf6e90a6b, 0x1bc02628, 0x2533172f, 0xfffae5c3,
0xd322cbd9, 0xd32be7bd, 0x03971e68, 0x2fc232a0,
0x25370c6c, 0xf040d90d, 0xccead070, 0xe0aaf83c,
0x0fcf1fc1, 0x248e1d7d, 0x0e99fcf6, 0xee77e6ad,
0xe7eaef0c, 0xf816000e, 0x03c902fe, 0xff51fcea,
0xfd3801c6, 0x08200e28, 0x105e0ba9, 0x00b7f132,
0xe3abdba0, 0xdd83ea17, 0xfedc1579, 0x273e2d0c,
0x23e70f80, 0xf464dbee, 0xcce7cc3a, 0xda47f418,
0x10052688, 0x30392b24, 0x1960fee9, 0xe66cd645,
0xd263db14, 0xed960262, 0x132d1abd, 0x19581002,
0x02dff75b, 0xf0eef055, 0xf41dfa17, 0xfee6ffed,
0xfc99f6d7, 0xf3b2f5f9, 0xfc380638, 0x0faf16a0,
0x144d098e, 0xf89ee6c8, 0xda4ad716, 0xdfd8f33d,
0x0ba021af, 0x2e642bf4, 0x1d200352, 0xe7ded205,
0xca28d15f, 0xe60200ff, 0x19a529c2, 0x2bbd21d1,
0x0cf7f53b, 0xe2f9da1e, 0xdca1e86a, 0xf93708ea,
0x1248141f, 0x0ea705d9, 0xfcdbf780, 0xf72dfa9b,
0xfe2ffffe, 0xfdb1f846, 0xf2f3ee5c, 0xef7af7e4,
0x04931240, 0x1c441e20, 0x152d0377, 0xedb9dacd,
0xd0d8d3ed, 0xe523fd4c, 0x17b82b1a, 0x31942903,
0x12e1f75d, 0xdcfacd8a, 0xcc11d8dd, 0xf0840a0c,
0x1f0f2885, 0x24d81699, 0x0218ee7c, 0xe2c0dfef,
0xe51cf13b, 0xfe8a084e, 0x0c9e0ae5, 0x05a7001d,
0xfdbcfe50, 0x004f03af, 0x03edffb2, 0xf763ee6e,
0xe6f4e666, 0xede9fbfb, 0x0db41bd1, 0x23b31f85,
0x103ef9d8, 0xe23ed1d1, 0xcdedd789, 0xecc1082d,
0x20af2f60, 0x2fa320f6, 0x0906ed68, 0xd844cdbb,
0xd1eee287, 0xf8f10fe4, 0x1f27244b, 0x1b920d7b,
0xfc66ee23, 0xe695e747, 0xee19f796, 0x006103da,
0x037a005b, 0xfe79fd26, 0x00350572, 0x0abc0bcb,
0x070afd61, 0xefd7e4ee, 0xdfafe266, 0xefd40408,
0x176a250c, 0x27871cc4, 0x0804ee25, 0xd7bfcc26,
0xcf21e01d, 0xf93d147c, 0x28832f70, 0x27c8136c,
0xf9aee26f, 0xd3c3d2e7, 0xdda0f0f4, 0x05d315de,
0x1d3e1a13, 0x0f9301c6, 0xf6a4ef84, 0xef1df307,
0xf8f2fe1e, 0xff07fc46, 0xf8e4f70c, 0xf860fe9b,
0x07c81129, 0x147c115d, 0x0656f5c6, 0xe648db7d,
0xda49e413, 0xf7e30efe, 0x22492c40, 0x280d1634,
0xfcb8e259, 0xd04dcb87, 0xd5bceb6d, 0x064d1f1c,
0x2c522c4b, 0x1e99090d, 0xf174df35, 0xd809dc58,
0xe987fb4f, 0x0b3713d9, 0x15d40fad, 0x05e2fc40,
0xf6c1f54f, 0xf821fc3d, 0xfd30fd25, 0xf88ef352,
0xefb3f0ef, 0xf88503b0, 0x10ab189d, 0x1943106a,
0xff04eaf4, 0xdb6ed4a4, 0xda7ceb68, 0x02501a76,
0x29a02d47, 0x22a40bd3, 0xf0c6d933, 0xcce5cf20,
0xdf89f736, 0x0fdb22ab, 0x29bc22ff, 0x129efdb1,
0xeb20e07e, 0xde8fe618, 0xf385016d, 0x0ace0d45,
0x0b77058e, 0xffaafc98, 0xfcc4fffa, 0x02360319,
0xfe45f794, 0xefc3e9e3, 0xe97ef13e, 0xff200dc7,
0x1c1221ac, 0x1ca90cf4, 0xf747e207, 0xd478d2b2,
0xdea2f388, 0x0cc22293, 0x2cc72924, 0x18ed00c8,
0xe6efd510, 0xcf8fd8ac, 0xeb63038c, 0x164420f4,
0x222b1813, 0x0893f762, 0xea1ee4fd, 0xe906f12f,
0xfb880307, 0x05b60578, 0x02d1fefb, 0xfdb200b3,
0x04be081d, 0x091a04f9, 0xfb23ef06, 0xe55ee1fb,
0xe760f4b6, 0x07b819ba, 0x247224b9, 0x18c303a5,
0xec46d88a, 0xd01dd581, 0xe6c1ff9d, 0x177b280f,
0x2c12227b, 0x0ebcf69e, 0xe0c1d510, 0xd713e44f,
0xf72f0b6a, 0x184c1cce, 0x17b40bdb, 0xfe28f252,
0xed17ed62, 0xf356fb57, 0x00420116, 0xfedefa73,
0xf9affac6, 0x000e06f9, 0x0e2b11a1, 0x0cf502d8,
0xf362e4a8, 0xdd30deab, 0xea24fcc7, 0x11c122c7,
0x29362429, 0x1163f941, 0xe160d199, 0xd00edb60,
0xf12d09c9, 0x1ee929e9, 0x274418f2, 0x0405ed9a,
0xde09d9ce, 0xe057efba, 0x00ea0ecd, 0x15de1494,
0x0dd3035e, 0xf9e5f44a, 0xf422f7cd, 0xfbf3ff43,
0xfe08fa3f, 0xf4e0f25f, 0xf411faf4, 0x05760f72,
0x166a154d, 0x0b51fac9, 0xe914daff, 0xd706de3d,
0xeee105d0, 0x1b2b288d, 0x2a2b1d64, 0x06aaec8f,
0xd865cf0b, 0xd4a2e638, 0xfcd71302, 0x226326ea,
0x1eaf0ef6, 0xfa32e980, 0xe107e198, 0xeaf3f8ad,
0x052d0d0d, 0x0e690aa7, 0x04a5fd6e, 0xfa07f9b6,
0xfc28005e, 0x00c1fce0, 0xf734f03b, 0xebb0ed15,
0xf4970043, 0x0e241930, 0x1ce015d5, 0x05bef1b5,
0xdeebd4d7, 0xd693e3f4, 0xfa2612cc, 0x25792c79,
0x25cf14a4, 0xfbfae49a, 0xd607d2a3, 0xdcf9f118,
0x06391800, 0x20f81ea1, 0x146c038b, 0xf347e81f,
0xe559ea67, 0xf460feaf, 0x0521077f, 0x05d90299,
0xffb1fe3f, 0x000f04bf, 0x07c407e0, 0x0298f9fe,
0xefade763, 0xe581eb69, 0xf9430ac2, 0x1a6621d9,
0x20231320, 0xfddae7cc, 0xd7a4d1d9, 0xd95febdd,
0x04131a78, 0x289a29b7, 0x1db00967, 0xf0a1dd50,
0xd3e7d8af, 0xe6befa1a, 0x0dcf18d7, 0x1c9e1617,
0x0941fb01, 0xefc5eb8b, 0xecdaf28b, 0xf9ffff7c,
0x0104fe1d, 0xfa2ff8f0, 0xf97aff0d, 0x05ff0b66,
0x0d9a09ae, 0x001bf284, 0xe5c1dfd3, 0xe21ced56,
0x006a129d, 0x20bb24d1, 0x1c710a3d, 0xf36ade40,
0xd261d337, 0xe0b3f6be, 0x0ebd21ce, 0x28d72471,
0x1407fe29, 0xe8fcdbb2, 0xd998e1db, 0xf07b016b,
0x0ec614e6, 0x141b0c45, 0x0275f926, 0xf439f413,
0xf814fbb6, 0xfedfff05, 0xfbaff7da, 0xf462f78b,
0xfdc70685, 0x103514df, 0x1335087b, 0xf9deea6b,
0xdee0dc83, 0xe362f4ea, 0x09ec1cc0, 0x26bb2444,
0x16bb0094, 0xea1cd875, 0xd20bd941, 0xea410119,
0x1634230d, 0x25331c53, 0x0a2af54c, 0xe61edfb0,
0xe1daeba6, 0xfab00722, 0x0ea01005, 0x0b1a045d,
0xfd4bf98d, 0xf929fca5, 0xffd90095, 0xfe23f900,
0xf333ef9e, 0xf098f7dc, 0x03a01059, 0x197f19f9,
0x12ab0321, 0xf071e0bb, 0xd8c1db02, 0xe8e6fd9b,
0x13b62476, 0x287a208e, 0x0f60f799, 0xe228d5bf,
0xd5f0e1c9, 0xf4880950, 0x197a20bb, 0x1d9010e7,
0xfefbf016, 0xe68ae4ee, 0xeab1f4be, 0xffe20731,
0x0a0007ce, 0x0312ff0b, 0xfd5cfe64, 0x01e7050d,
0x0402005e, 0xf8bdf03d, 0xea27e95e, 0xefe7fd4e,
0x0d2d19ea, 0x20661c07, 0x0efbfb1c, 0xe673d93a,
0xd53cddd7, 0xefb9065e, 0x1b412654, 0x25a718a3,
0x0571eeba, 0xde41d822, 0xdd78eb98, 0xfedd1075,
0x1a2e1c16, 0x1420074f, 0xf946ef21, 0xeaf4ecfb,
0xf2e8fb0e, 0x012d0385, 0x029dff5e, 0xfd59fdb2,
0x01510749, 0x0b990b9a, 0x066ffd9c, 0xf18ce834,
0xe300e5ce, 0xf1c201d4, 0x131b1f28, 0x20b617b1,
0x05aaeffb, 0xde91d44d, 0xd82ee55c, 0xfa721175,
0x2115265b, 0x1ff20f34, 0xf979e6ac, 0xdc3edb45,
0xe514f503, 0x056c11af, 0x16f014ae, 0x0a930061,
0xf64cf244, 0xf263f678, 0xfb50fea4, 0xffbdfce5,
0xf939f6fa, 0xf905fe05, 0x06310d46, 0x11fa0f51,
0x0580f804, 0xea42e153, 0xe02ae904, 0xf9f60d9c,
0x1dcc2511, 0x208d11a6, 0xfc25e644, 0xd6b1d2c3,
0xdb6aedaf, 0x03881703, 0x22fa22b5, 0x17bb06a4,
0xf2e2e51f, 0xe039e349, 0xef30fc68, 0x08d70f50,
0x0f890b30, 0x0304fc5b, 0xf91bf90a, 0xfabcfe4c,
0xffe9fe31, 0xf9a3f519, 0xf1fef3df, 0xfae2046b,
0x0df61528, 0x14d80ccc, 0xfddaed09, 0xe0e5db52,
0xe0eceefb, 0x036316ec, 0x250227a5, 0x1da70b5e,
0xf406e006, 0xd6c1d8a7, 0xe4eef891, 0x0c291b2b,
0x1f601a89, 0x0e09fd46, 0xee76e5a6, 0xe4e3eaa5,
0xf64700da, 0x076b0847, 0x058c0150, 0xfce0fb22,
0xfc8dfff8, 0x029303db, 0xff83f8ed, 0xf152ec63,
0xecfff35e, 0xfeaf0c61, 0x171f1ae1, 0x1687086b,
0xf651e467, 0xda65d973, 0xe32bf5cb, 0x0b9b1d72,
0x25bd22b0, 0x13e6ff34, 0xead1dbce, 0xd773df3a,
0xef96024b, 0x12551b59, 0x1bcb138f, 0x055ef7b7,
0xeea2eb78, 0xec5ef2db, 0xfb3600f5, 0x020a014f,
0xfeeafd2c, 0xfd6b006d, 0x05c108b9, 0x0939053d,
0xfcadf1b9, 0xe956e5dc, 0xe934f4d5, 0x05381432,
0x1d7d1db1, 0x133500e4, 0xed5addc9, 0xd6fcdc38,
0xead3ff74, 0x14b322ae, 0x258d1c9e, 0x0b80f61d,
0xe450db50, 0xdbd6e713, 0xf77a080b, 0x135a1834,
0x146c0b20, 0xffe0f635, 0xf250f247, 0xf511fa1f,
0xfe06fded, 0xfcf8f9a2, 0xf88cfa5d, 0xff93073d,
0x0d961024, 0x0bdc028d, 0xf58ee960, 0xe25ae259,
0xebc3fc8c, 0x0ded1c77, 0x213e1bf4, 0x0d4df93e,
0xe614d9d7, 0xd86de1d8, 0xf3f9080c, 0x18d720e6,
0x1ff31352, 0x00ffef8c, 0xe331dfaa, 0xe3feefd1,
0xfe2e0a3a, 0x0f220f32, 0x0a2401a3, 0xfaeef6f3,
0xf775fa7c, 0xfd21fdff, 0xfd9cf9dc, 0xf593f370,
0xf606fd07, 0x058c0e9c, 0x13da1261, 0x094cfb12,
0xebfae175, 0xddcae3b5, 0xf2c30600, 0x175b22a6,
0x221c1723, 0x054df080, 0xdfa2d764, 0xdbfeea60,
0xfd5f0fb8, 0x1c5d1f16, 0x18770a5c, 0xfa05ec6f,
0xe5a7e5ce, 0xecaef85c, 0x02d4095a, 0x0ae607df,
0x0312ff2a, 0xfb5ffb93, 0xff1f014f, 0x00b0fd08,
0xf7c1f150, 0xed4cee7c, 0xf5d4017f, 0x0d671744,
0x19471291, 0x04ebf2f7, 0xe398db17, 0xdbf1e6fd,
0xf9520e02, 0x1e6324dc, 0x1fbe10ac, 0xfceee9e8,
0xdcc1da62, 0xe30af388, 0x05791475, 0x1ac41984,
0x10fc0234, 0xf549ebb2, 0xe9aaecf8, 0xf494fdaf,
0x03ea05e4, 0x044d01eb, 0xff5bfe15, 0x000b03e3,
0x05a805d6, 0x01a1f993, 0xf1c3eb3d, 0xe8f3edea,
0xf939084a, 0x15df1cca, 0x1b781012, 0xfe22ea82,
0xdcc3d8bb, 0xddf8ee90, 0x026315fe, 0x21722276,
0x19880710, 0xf392e30d, 0xdbebde3c, 0xea21fac1,
0x0a7114a8, 0x17a71246, 0x0838fd29, 0xf3f8effc,
0xf0f5f600, 0xfb860079, 0x0130ffb0, 0xfc8afa95,
0xfb9a0034, 0x05990abf, 0x0c0207a3, 0xff0ff3bc,
0xe9abe406, 0xe5d3eff2, 0x000c0fd5, 0x1c941fb3,
0x19f609d8, 0xf5d7e3a2, 0xd93fdad2, 0xe5d4f8be,
0x0c921bfb, 0x225a1e96, 0x10dcfe7d, 0xed77e2b0,
0xe005e663, 0xf31b007e, 0x0ba1105e, 0x0ee30924,
0x007efa0c, 0xf65bf671, 0xf963fc4b, 0xfe81fdf7,
0xfaecf7b1, 0xf666f8a4, 0xfead063c, 0x0dd111f2,
0x0f5506fc, 0xfa3ceca5, 0xe32fe1a6, 0xe8b8f7e8,
0x09b11951, 0x211e1f45, 0x133400b0, 0xed77ddb3,
0xd910ddf7, 0xed8d0081, 0x12201d42, 0x1e8f1732,
0x079ff6fa, 0xea0fe489, 0xe62feee0, 0xfaab04d6,
0x0b000b71, 0x083a02a2, 0xfda8fabf, 0xfb11fd95,
0x006100a5, 0xfdd6f972, 0xf3c8f04d, 0xf16ef834,
0x024a0e0b, 0x152f15ae, 0x0ee301a2, 0xf10de3bb,
0xdd73e076, 0xecb7ff52, 0x120c1ece, 0x23751be6,
0x0be3f760, 0xe5f4db89, 0xdb81e58b, 0xf6c3080f,
0x15861bf4, 0x18630e37, 0xffbef320, 0xeb1ae9f9,
0xee2af6a4, 0xff630491, 0x0625046c, 0x0141fdbb,
0xfd78ff12, 0x021304a5, 0x041b0068, 0xf946f138,
0xeba3eb77, 0xf0fffc33, 0x0a0f161c, 0x1a8f1748,
0x0ba6fa39, 0xe9c5dd80, 0xdaf2e22f, 0xf24605bf,
0x16e320dd, 0x1faa14bb, 0x01c5efaf, 0xe101db8d,
0xe074ed4d, 0xfe540ca4, 0x16c717cd, 0x114905c6,
0xfa88f255, 0xef07f0b7, 0xf5d3fbd1, 0x00bc018c,
0x007efe76, 0xfccdfe11, 0x019906d1, 0x0b030b3b,
0x0613fe04, 0xf28be9cf, 0xe5b3e8b3, 0xf2e401c6,
0x10de1bbf, 0x1d9614d8, 0x05b6f314, 0xe2dfdb44,
0xde59ea01, 0xfc800f6d, 0x1d86212a, 0x1b9b0cfc,
0xfa7ceacf, 0xe189e15d, 0xe934f6ec, 0x04c30f96,
0x132610a4, 0x09a00074, 0xf934f571, 0xf52df841,
0xfb38fd34, 0xfd0dfae0, 0xf86ff6a5, 0xf946feea,
0x061a0cdb, 0x0fcc0d18, 0x0498f7dc, 0xeb37e379,
0xe305eb75, 0xfa600bd2, 0x19ed1f39, 0x1b2a0ea8,
0xfc68e9fc, 0xdde4db0a, 0xe22cf1ae, 0x0501144b,
0x1dd61da1, 0x13740443, 0xf374e7db, 0xe3d3e70d,
0xf05dfc5b, 0x06fd0c97, 0x0cc008c7, 0x0243fd70,
0xfa2afaa7, 0xfd07ffcd, 0xffd5fd40, 0xf962f479,
0xf2aaf4a2, 0xfb260475, 0x0e2613ea, 0x133c0b92,
0xfe88eeea, 0xe2eade25, 0xe2b3ef52, 0x012a1376,
0x1ead201b, 0x17a90765, 0xf474e425, 0xdb63dd7c,
0xe88efa3e, 0x0be91818, 0x1b7516bb, 0x0be4fcfb,
0xf0e7ea0a, 0xea92ef94, 0xf87c01f6, 0x06b4088b,
0x06190211, 0xfe8afd56, 0xfe100095, 0x02050201,
0xfeadf827, 0xf250eda7, 0xeda4f407, 0xff550bd0,
0x160c197a, 0x14070713, 0xf740e730, 0xde43de00,
0xe6b5f6e1, 0x09b219e8, 0x20f21e09, 0x113d0070,
0xeddde0f9, 0xde0ae3af, 0xf17f0128, 0x0e8f1626,
0x15340e2d, 0x034cf780, 0xeff6ecab, 0xefa7f634,
0xfcc60179, 0x01e7011a, 0xff4ffd54, 0xfd800096,
0x042b0750, 0x077a0381, 0xfb19f131, 0xeabae8bb,
0xece7f7dd, 0x062b135a, 0x1b0b1a58, 0x10bf009b,
0xefb8e11c, 0xdb9ce033, 0xed29ff78, 0x11371cd2,
0x1ec4183c, 0x08cdf676, 0xe85ce0f9, 0xe1e9ea3f,
0xf889057e, 0x0e9c12d8, 0x0f6b07b7, 0xfe87f73f,
0xf412f4c0, 0xf7f8fc09, 0xfdc2fdfb, 0xfc1bf96b,
0xf91cfb6b, 0xffac064a, 0x0b4d0cdb, 0x09b30092,
0xf661eb70, 0xe528e6c7, 0xef74fdb5, 0x0d1d19c8,
0x1d9e184f, 0x0aa5f815, 0xe7cbdd28, 0xdc37e537,
0xf50807c3, 0x16ed1e31, 0x1cbd11d8, 0x0203f1d2,
0xe75be417, 0xe81bf21b, 0xfe8d07fd, 0x0c1a0c3d,
0x07f101f8, 0xfbd0f9b9, 0xf9f8fbd8, 0xfd30fe90,
0xfd3ff9c5, 0xf5ddf3ad, 0xf652fb9f, 0x05050c7c,
0x10d50fde, 0x081bfc13, 0xee5de465, 0xe1f1e710,
0xf46a0584, 0x14d71dba, 0x1d7a134b, 0x01baf00a,
0xe1eedba7, 0xdf06eb62, 0xfcdf0db2, 0x18c81adb,
0x149708cd, 0xfa9bef8a, 0xea3aeacf, 0xf062fa0c,
0x021707ba, 0x08b10668, 0x02a4fe99, 0xfd68fded,
0x00c30122, 0x0139fd9c, 0xf7c5f27d, 0xeee9f045,
0xf62000d6, 0x0ba012d8, 0x15930fdf, 0x02eef474,
0xe703df42, 0xe098eb09, 0xfae90c2b, 0x1a351e81,
0x1a120d28, 0xfae6eab2, 0xe048de94, 0xe5dbf45e,
0x04fd1176, 0x171d1535, 0x0cf6016e, 0xf575eeca,
0xec7deecf, 0xf5e4fcf6, 0x01b203e2, 0x0259ffb8,
0xfdf3fdf2, 0x006703f6, 0x05db05ab, 0x01e4fa2e,
0xf1e0ec2f, 0xeb83efd6, 0xfb5707d5, 0x14431a47,
0x185c0e03, 0xfe7bee48, 0xe236dfb7, 0xe418f2b5,
0x04501474, 0x1de81da5, 0x14dc04eb, 0xf393e658,
0xe0d0e372, 0xee26fcf3, 0x0a2e1220, 0x13f71057,
0x0795fd31, 0xf5bbf2c4, 0xf35df743, 0xfb87fe69,
0xfe82fd40, 0xfb00fa1d, 0xfd020137, 0x05b70a61,
0x0b800681, 0xfe79f3f5, 0xeb29e653, 0xe867f231,
0x00760e87, 0x18611b60, 0x14840720, 0xf5cde667,
0xdefbdecc, 0xe988f9d6, 0x0b471928, 0x1dcb1a35,
0x0dd4fde5, 0xeeece619, 0xe48eea5f, 0xf68901e5,
0x0aa20eba, 0x0d780896, 0x00f5fadf, 0xf782f7c1,
0xf9eafca3, 0xfda4fcb3, 0xfa11f6b7, 0xf5dff845,
0xfeee06d2, 0x0ddc105c, 0x0e1905b7, 0xf9f1ed27,
0xe50fe3f2, 0xe9f5f892, 0x084916ec, 0x1d931b62,
0x0ffcff45, 0xedd6e0bd, 0xdce4e280, 0xef48ffe8,
0x0f95186c, 0x19fe11ca, 0x052bf6eb, 0xec4ae84e,
0xea49f1e1, 0xfc0804ae, 0x09ba0a0a, 0x060b01f4,
0xfdd2fb1b, 0xfb7efe9b, 0xffceff7f, 0xfd0df839,
0xf469f1a7, 0xf3acf9ea, 0x03e50d9f, 0x134b1426,
0x0d2600dc, 0xf1dce551, 0xdfeee2a7, 0xede3fe61,
0x0f251bda, 0x1ecf17e3, 0x0a0ff8bf, 0xe8fee092,
0xe01ce831, 0xf77506db, 0x123d16ae, 0x13780ae4,
0xfed5f353, 0xed2eec2b, 0xf0ddf841, 0xff320379,
0x05720303, 0x0096fdad, 0xfca4ff40, 0x013803f9,
0x0348ff83, 0xf951f299, 0xed4dedaa, 0xf323fd5b,
0x09fa1372, 0x17c21486, 0x09abfae7, 0xeba5e1a7,
0xdff0e71e, 0xf56c06a5, 0x154d1da8, 0x1cd011e1,
0x01adf051, 0xe4abe040, 0xe478efc2, 0xfe510aef,
0x11f9135e, 0x0d5403e3, 0xfab5f361, 0xf199f353,
0xf7ecfd36, 0x005f0125, 0xff4cfc19, 0xfad9fc64,
0x0093054f, 0x084808b8, 0x04cafd56, 0xf3c1ecd0,
0xe924ec90, 0xf6d60346, 0x10541892, 0x18af10aa,
0x0215f272, 0xe423ddcc, 0xe12beb86, 0xfcf20dd3,
0x198b1d5e, 0x179f0b1b, 0xfb88ecaa, 0xe4f6e44a,
0xeb52f7ef, 0x03360c33, 0x0ff60ddb, 0x07cefff2,
0xfa00f68a, 0xf750fa59, 0xfcdafe42, 0xfdcbfb6d,
0xf7eff751, 0xf986fe8a, 0x05050b23, 0x0d340b00,
0x02aef7cb, 0xee09e68e, 0xe6e7ee04, 0xfb1b0a2b,
0x16741b10, 0x17850abf, 0xfae8eaad, 0xe058dec8,
0xe591f432, 0x03b01303, 0x1a331923, 0x10140287,
0xf471eb48, 0xe7e7e9ef, 0xf298fcf9, 0x05310918,
0x094c056a, 0x00f9fc3f, 0xfa2ffb4d, 0xfd42ff62,
0xff65fcb4, 0xf92df502, 0xf2edf4f8, 0xfaf503e1,
0x0b791197, 0x10700982, 0xfe8ff08b, 0xe75ee3d0,
0xe6bcf229, 0x01fa1120, 0x1a051b61, 0x140304be,
0xf458e6e6, 0xe03be225, 0xec2ffaa0, 0x0a0a1378,
0x17401331, 0x0879fbe0, 0xf165ec59, 0xec73f13e,
0xf83f00a4, 0x04af0570, 0x040f00b3, 0xfdc5fd7d,
0xff980134, 0x024301a2, 0xfdbaf824, 0xf178eefa,
0xef69f4f9, 0xffb409db, 0x1210140a, 0x100b05d6,
0xf7a4eac8, 0xe320e2e2, 0xeb26f960, 0x09d41630,
0x1bef18a3, 0x0d34fd9e, 0xef04e53a, 0xe2aee8e3,
0xf4c00211, 0x0d2e1335, 0x11ef0bc4, 0x01faf824,
0xf1cfefb8, 0xf201f70c, 0xfca0ffe0, 0x00cbff75,
0xfd67fcfd, 0xfdbc00be, 0x047f075f, 0x06da02fc,
0xfb10f279, 0xecd1eb14, 0xeeebf8bd, 0x0572103a,
0x169b155e, 0x0d960009, 0xf176e56b, 0xe0e7e51b,
0xf0ad006b, 0x0ee11914, 0x192812e5, 0x059df6ac,
0xeb3ce509, 0xe71eee76, 0xfb020583, 0x0d0a0f23,
0x0c1a05dd, 0xfdbef7ad, 0xf560f6a6, 0xf972fd32,
0xff06ff31, 0xfcc0fa6b, 0xf9c0fb72, 0xffb60503,
0x0a340b48, 0x082d00af, 0xf640ed9e, 0xe8c7e985,
0xf202feca, 0x0be815d3, 0x196a1451, 0x07a0f8d9,
0xeb1ee25f, 0xe172e962, 0xf6cd062e, 0x126b17d5,
0x152d0ba4, 0xfed5f1fe, 0xea7ce8a1, 0xec93f4ed,
0xffa407a7, 0x0b0f092b, 0x0469fff9, 0xfb57f9d6,
0xfac7fd4c, 0xff5c000f, 0xfde8fb10, 0xf749f629,
0xf926fe5f, 0x06350c3c, 0x0fb90d78, 0x05e0fb02,
0xf003e774, 0xe53beac3, 0xf70905e5, 0x13031a29,
0x1929106e, 0x01adf2c0, 0xe6d3e205, 0xe4d3f086,
0xfe580aa8, 0x13f01530, 0x0fa80573, 0xfa5df1e6,
0xedecef8c, 0xf514fd0f, 0x037605f8, 0x05c50396,
0xfff7fd0c, 0xfc9cfd61, 0x004f0145, 0x0171fe8b,
0xf95ff501, 0xf26df33b, 0xf90401fd, 0x0a041122,
0x11870c72, 0x022ef426, 0xe989e3e4, 0xe5e2ee6c,
0xfb970a7c, 0x15a41a13, 0x158809e2, 0xfb86eecd,
0xe6a1e5d4, 0xebd6f793, 0x04480ddb, 0x1255110f,
0x098c0042, 0xf7cdf311, 0xf27df522, 0xf9dffea8,
0x01e10190, 0x0063fdc9, 0xfc84fd14, 0xffc102f8,
0x04c90454, 0x00ecfa0a, 0xf3e4eec4, 0xee55f2b0,
0xfb6f0690, 0x0fd8144c, 0x11c6091f, 0xfbdeef30,
0xe634e479, 0xe8f9f4f4, 0x0353107e, 0x181d17d9,
0x0f3e01e3, 0xf491e9ff, 0xe57ee853, 0xf184fd13,
0x06950d12, 0x0eb10a74, 0x0408fc5e, 0xf7cbf5fd,
0xf820fa6b, 0xfd27ffbc, 0xfebffced, 0xfab6f9fd,
0xfb920006, 0x053a0902, 0x096c05d5, 0xfee8f619,
0xee8fec21, 0xed50f554, 0x00f50bfd, 0x145a15eb,
0x0fb90408, 0xf73dea67, 0xe468e569, 0xeecdfbde,
0x0938131c, 0x1757138c, 0x08c4fc7b, 0xf07eeade,
0xe925ee28, 0xf70700e2, 0x077e0a61, 0x092e0439,
0xff53fa47, 0xf93ff9a6, 0xfc4ffde2, 0xfe75fd26,
0xfa3bf7aa, 0xf5ecf810, 0xfca803cf, 0x09200bc4,
0x0aa103bd, 0xfa11f103, 0xea53e89f, 0xee8cf984,
0x06021149, 0x16de1579, 0x0c02fe62, 0xf15ae778,
0xe3fee969, 0xf42e013a, 0x0dc91343, 0x13770c4a,
0x0221f811, 0xef2aec13, 0xee72f452, 0xfc2402ed,
0x054704f6, 0x0285ffa0, 0xfcbdfbb3, 0xfd91ffcf,
0x00bc007b, 0xfe23f8ea, 0xf410f2c7, 0xf4c5fabe,
0x022d0a05, 0x0f870f74, 0x0a30ff23, 0xf3aaea2c,
0xe615e91a, 0xf214ff10, 0x0bec1494, 0x16f11188,
0x0613f88d, 0xed27e61c, 0xe727eeac, 0xfa680656,
0x0e8e121c, 0x0e360729, 0xfd39f586, 0xf0c4f0ff,
0xf55bfa9f, 0xff8f02c8, 0x037c00e5, 0xff31fd8a,
0xfea1008a, 0x021b0407, 0x0377ffe5, 0xf9acf3f4,
0xefcdf068, 0xf582fe0b, 0x08010fb0, 0x133e1093,
0x07a5fabc, 0xef76e71e, 0xe577ec36, 0xf75d04ca,
0x0f9315a6, 0x14120aa9, 0xff09f218, 0xea12e7b8,
0xebe1f4f5, 0x009409f1, 0x0eb10e5a, 0x08d20206,
0xfa92f5d7, 0xf3b1f6ba, 0xfa6efdfb, 0x005d00ee,
0xff04fd9a, 0xfd4bfe14, 0x01d50589, 0x0833077e,
0x038cfd44, 0xf64cee7b, 0xec48ef45, 0xf7130323,
0x0d26135a, 0x13c50db9, 0x0298f5b0, 0xea9ae508,
0xe80ef1a1, 0xfe4f0b2d, 0x141a15ae, 0x0f810555,
0xf9f2eff1, 0xea4eeac0, 0xf0e5fa86, 0x031f0843,
0x0a4a085d, 0x0411fdc3, 0xf9caf953, 0xf96cfbbc,
0xfdfbffcb, 0xfe9bfb77, 0xf98bf90f, 0xfa53ff8a,
0x04d2090f, 0x0b3407e7, 0x01f7f7cd, 0xef2aea17,
0xea85f182, 0xfcfc091b, 0x12cb15fc, 0x11e8089b,
0xfc00f030, 0xe79ce5ec, 0xec06f7fd, 0x04b20f22,
0x13dd12d6, 0x0ba0018d, 0xf75bf076, 0xeebef093,
0xf73bff86, 0x04b6065c, 0x061802d2, 0xfed0fc0a,
0xfa9ffc3a, 0xfe860057, 0xffd7fd68, 0xfa5ff706,
0xf5def75c, 0xfc5b02fc, 0x09060d35, 0x0bb50579,
0xfd49f25d, 0xeafce7f5, 0xec4ef633, 0x02c60e0a,
0x14dc163c, 0x0ee00382, 0xf610ebca, 0xe64de87a,
0xf0f4fcee, 0x07d60e81, 0x10ad0d6e, 0x0582fbfe,
0xf50af17d, 0xf2aaf68c, 0xfc480195, 0x045803fd,
0x01eeff57, 0xfd5bfd53, 0xff550160, 0x020801da,
0xfefbf956, 0xf475f23a, 0xf298f797, 0xffa10845,
0x0e541081, 0x0cb70304, 0xf822ed8c, 0xe82ee87e,
0xefc2fbc2, 0x080411cb, 0x15fc11f2, 0x0897fd03,
0xf0eeea24, 0xe88eee9c, 0xf80e02ee, 0x0ad20e5d,
0x0d7a077d, 0x006bf95b, 0xf49af409, 0xf6bdfa2c,
0xfdd7000d, 0x0029fe1d, 0xfc73fba3, 0xfdb800f2,
0x042e062b, 0x05620260, 0xfc37f5d0, 0xf10bef8b,
0xf2fefb25, 0x04c70d8b, 0x133910f0, 0x09f3ff69,
0xf34feafa, 0xe7f7ec30, 0xf57f01ee, 0x0d0f133f,
0x13b60dfb, 0x0376f834, 0xef48ea75, 0xec4ff26f,
0xfbc60430, 0x094a0b37, 0x07b30359, 0xfe21fa44,
0xf92afa74, 0xfc1bfe60, 0xff35fd98, 0xfbd3f9a5,
0xf96bfaf1, 0xff980455, 0x082c0985, 0x0733002f,
0xf816f0eb, 0xecafee50, 0xf49dff4f, 0x092710bf,
0x128b0da8, 0x051ef932, 0xeea0e8c5, 0xe8a6ef81,
0xfa76060c, 0x0ede134a, 0x10d008de, 0xfe06f562,
0xefcdee07, 0xf23bf8ac, 0x00b504db, 0x06ff063e,
0x0319ff93, 0xfb59fb05, 0xfc7bfe1f, 0xffeaff77,
0xfcf9f9e2, 0xf6f9f61c, 0xf81efd65, 0x038008cc,
0x0c3b0ab3, 0x0482fc33, 0xf2b3ec36, 0xeb2bef02,
0xf8ea0382, 0x0d6212eb, 0x12110ae8, 0xff73f44c,
0xeb8ee8e6, 0xec50f4ec, 0xff9f09cb, 0x0f250f61,
0x0a460287, 0xfa0af313, 0xf0ecf265, 0xf6d3fcf1,
0x01ad048f, 0x042f0247, 0xffb0fe1f, 0xfe04fe8b,
0x00ae0119, 0x0069fcc7, 0xf8f6f4e2, 0xf312f4bb,
0xfa1701ea, 0x095f0e68, 0x0eb00a1f, 0x01e2f76c,
0xee08ea95, 0xebc0f271, 0xfd420891, 0x10b712fe,
0x0f0f05fb, 0xfa4bf024, 0xeb38ebbb, 0xf0c6fa65,
0x041f0ad3, 0x0d060ba3, 0x059bfe5e, 0xf881f465,
0xf4eaf716, 0xfc0f0005, 0x01720168, 0x000dfe58,
0xfd7cff24, 0x01170370, 0x049e036c, 0x0082fa91,
0xf4d6f0b3, 0xf00bf400, 0xfc050542, 0x0c711008,
0x0dad0687, 0xfc3df241, 0xeabde8fb, 0xedf3f773,
0x02180c83, 0x127611a8, 0x0b570152, 0xf714eeca,
0xec1ceef8, 0xf5ecfed5, 0x05ef09a9, 0x09b205e0,
0x0123fb87, 0xf7a4f702, 0xf882fb90, 0xfddcfe40,
0xfdf7fc9b, 0xfa8cfae7, 0xfc6b003f, 0x04a6073e,
0x073d0432, 0xfe4ff726, 0xf122ef25, 0xf0daf7ee,
0x01190928, 0x104410cf, 0x0bf501e3, 0xf6b4edbf,
0xe8d2ea1d, 0xf1e7fc5e, 0x06c80eed, 0x11720dc4,
0x06b4fcdd, 0xf406ef65, 0xef55f43b, 0xfb4501f3,
0x05ef0827, 0x062902ec, 0xfef0fb5b, 0xf9fdfb7b,
0xfd63ff8f, 0x001bfe2e, 0xfb3cf909, 0xf8effa8b,
0xfeda02ed, 0x078308b5, 0x06d801b7, 0xf9fef237,
0xed76ee3d, 0xf32bfc4d, 0x06490e97, 0x12ff1020,
0x0883fdac, 0xf2deec11, 0xea7aeea3, 0xf75101a7,
0x09fa0f39, 0x0ebd08e8, 0x0166f9c9, 0xf382f21e,
0xf3fff88c, 0xfe780289, 0x0488036b, 0x0179fe7f,
0xfcfdfd09, 0xfe060074, 0x011600b7, 0xfdd8f98e,
0xf686f5c2, 0xf74dfc06, 0x01d507d7, 0x0bf00b88,
0x06e9feb5, 0xf5beee9b, 0xeb74ee3d, 0xf5d600c3,
0x0a6f1117, 0x12750c64, 0x0340f83c, 0xeffeeb45,
0xebccf1f1, 0xfbcc049b, 0x0a8b0c51, 0x0a070466,
0xfd52f79f, 0xf41df421, 0xf758fc04, 0xff330111,
0x00bb000f, 0xfe1efd56, 0xfe020064, 0x02f50427,
0x0349ffea, 0xfb7ff567, 0xf31ef2f3, 0xf6d1fde3,
0x05cb0c50, 0x0de60b76, 0x0486fa17, 0xf118ec50,
0xebf7f182, 0xfa39058c, 0x0d3611a5, 0x0f0607ad,
0xfea6f498, 0xedffec79, 0xf098f78c, 0x00d907a6,
0x0a9a099d, 0x060a0069, 0xfb80f7f9, 0xf725f8da,
0xfc14fddf, 0xff7efe69, 0xfc84fb21, 0xfb59fdc8,
0x000a0444, 0x06210620, 0x032bfdbc, 0xf6cbf252,
0xf091f307, 0xf9d50245, 0x0a3b0edf, 0x0e5308a4,
0xff57f62b, 0xee8eeb62, 0xee60f5f7, 0xff8b08b7,
0x0f690f50, 0x0ab702cc, 0xf9a8f2bf, 0xef55f01d,
0xf584fbd9, 0x030906d5, 0x07ee059a, 0x01d3fe11,
0xfb2bfae9, 0xfb5bfd70, 0xfebbff42, 0xfdbefb45,
0xf968f9a2, 0xfb630032, 0x04d80878, 0x09700753,
0x01a8f97e, 0xf2e4eed4, 0xef0cf49a, 0xfd2c05e6,
0x0d6a0f5f, 0x0c0b040f, 0xfa4af0ce, 0xeb83ec07,
0xf164faaa, 0x03ff0afc, 0x0e7d0cd9, 0x0669fead,
0xf750f2e2, 0xf233f4f3, 0xfb0f00f7, 0x042e0513,
0x0462026e, 0xfebefcc7, 0xfcabfd89, 0xffc90011,
0xff58fcba, 0xf9f3f785, 0xf654f8cc, 0xfde1030a,
0x07e00b1b, 0x09970524, 0xfca8f3e6, 0xeeafed5a,
0xf095f873, 0x01bc0ae6, 0x10520fe5, 0x0a0800c3,
0xf74aefee, 0xed2aef47, 0xf6e7fe6b, 0x06500be9,
0x0bdc085c, 0x016bfb3f, 0xf633f415, 0xf542f888,
0xfdad010b, 0x024b01ef, 0x00b2fe61, 0xfdaafe03,
0xffcb01a2, 0x01e90103, 0xfd9cf9d4, 0xf608f3a7,
0xf51cf9f3, 0x006106e6, 0x0b950c61, 0x08d20160,
0xf84cf0a6, 0xebdbed33, 0xf3bcfd3a, 0x06820d79,
0x103f0cfb, 0x05cafcfc, 0xf47eefdf, 0xef58f3a8,
0xfa580216, 0x080c0958, 0x086203c9, 0xfe61fa1d,
0xf73cf730, 0xf968fc24, 0xff41002b, 0xffd9fd90,
0xfcb7fcea, 0xfd8d0030, 0x0289040e, 0x03eb00b0,
0xfb75f688, 0xf2d7f287, 0xf5cffcf2, 0x047e0ac4,
0x0d8d0c0b, 0x05cbfd8c, 0xf4afee24, 0xec14f039,
0xf88f0132, 0x0a300ea9, 0x0ec80962, 0x0139f931,
0xf293f07a, 0xf221f70f, 0xfdb803b3, 0x05d305d3,
0x03f5fff3, 0xfc24fa4b, 0xfa5dfb28, 0xfd4dff01,
0xffcdfe05, 0xfbd4fa96, 0xfa6dfcb5, 0x00a7045e,
0x06cc06f7, 0x041eff48, 0xf8b0f338, 0xf1caf35a,
0xf8e400eb, 0x08470dc6, 0x0e600a37, 0x0298f8c2,
0xf02dec6d, 0xecccf350, 0xfc3b0528, 0x0b780d47,
0x0b480503, 0xfd97f678, 0xf38ef324, 0xf632fb45,
0xfff5039e, 0x04b503a5, 0x0139feb1, 0xfd2cfda2,
0xfe93006d, 0x014f004d, 0xfe20fac2, 0xf8bdf8b3,
0xf9d9fe33, 0x029d071d, 0x093606b3, 0x0289fad8,
0xf3dcefe6, 0xef58f37c, 0xfbaa042b, 0x0b570f03,
0x0ceb076b, 0xfe1bf52d, 0xef9ced2a, 0xf0c7f7d0,
0xffae0763, 0x0bcc0b5a, 0x074c011f, 0xfb01f61a,
0xf459f5b6, 0xf940fdf3, 0x00b001c4, 0x0132ff7f,
0xfd55fcf2, 0xfd51ff68, 0x013d015c, 0x00befde3,
0xfa96f6df, 0xf59cf6ed, 0xfaf8010e, 0x06a70a7b,
0x0ab306ce, 0x0036f88c, 0xf1e3eef0, 0xf084f6d2,
0xff140791, 0x0c960d64, 0x09b90260, 0xf9c7f32c,
0xef65ef8e, 0xf557fd5f, 0x041908b7, 0x0afd0776,
0x039ffe6e, 0xf96df747, 0xf7a3fa2e, 0xfceeffc4,
0x00d90052, 0xff5afe20, 0xfdd2ff60, 0x013f03b1,
0x04c30333, 0xff8dfb35, 0xf6f9f39d, 0xf324f76d,
0xfd52045c, 0x0a570c59, 0x0a68042b, 0xfc61f494,
0xefe1ef80, 0xf2d4fb37, 0x037809e0, 0x0d500bab,
0x066dfe6d, 0xf767f202, 0xf120f3a7, 0xf9620067,
0x054107d1, 0x07a6047a, 0x00c0fca0, 0xf9d2fa00,
0xfaf7fd16, 0xfdeafe18, 0xfdc0fc38, 0xfae4fb4a,
0xfdaa0118, 0x038d059d, 0x057202b1, 0xfdfcf7f1,
0xf3bef209, 0xf3ecf9f8, 0x017d0875, 0x0ca40c63,
0x087e00b1, 0xf7b3f0fc, 0xeeeef0a4, 0xf689ff13,
0x06260b13, 0x0bea0903, 0x026afadb, 0xf5a7f29d,
0xf306f77a, 0xfcb50228, 0x04bc0540, 0x03d200cb,
0xfe44fbe6, 0xfcd4fcf9, 0xff620071, 0x002afddb,
0xfad2fa17, 0xf9f1fb58, 0xffa40426, 0x06b0080c,
0x05560161, 0xf9b0f42a, 0xf0bef17e, 0xf5c6fce9,
0x05e10b7b, 0x0d390a75, 0x04cbfcce, 0xf5a2f073,
0xf096f3de, 0xfabd02a7, 0x07e30b17, 0x0a4b04c4,
0xfea8f971, 0xf62af645, 0xf75afbd0, 0x0072020d,
0x024701c5, 0x0000fd78, 0xfcadfce8, 0xfd8fff94,
0x0041ff14, 0xfd29fa6b, 0xf7c1f6fc, 0xf94dfd3a,
0x024d073a, 0x09ae0890, 0x04b2fdba, 0xf65bf13e,
0xf010f2a3, 0xf867016f, 0x08a90cb8, 0x0c91085b,
0x018af9c0, 0xf369f085, 0xf298f719, 0xfe8f0456,
0x07bc0901, 0x0598013c, 0xfc45f8be, 0xf6b2f80b,
0xfaaffe0b, 0x00ed0130, 0x00e3febc, 0xfd6bfce1,
0xfe04fffc, 0x01ca0214, 0x015afe9f, 0xfa5ef777,
0xf4a3f63d, 0xf950ff48, 0x054608ff, 0x0aac072a,
0x01cdfa4a, 0xf3fef058, 0xf0fff4fc, 0xfc4c0454,
0x0a380c97, 0x09df04ef, 0xfd0af605, 0xf240f241,
0xf4bbfa93, 0x00a0051c, 0x07130618, 0x03e2ff34,
0xfb94f9f6, 0xfa50fbf2, 0xfe65ffb9, 0x0078fece,
0xfd43fc4b, 0xfc19fdca, 0x000b02ff, 0x04d004a6,
0x020bfd3e, 0xf8bbf515, 0xf40bf7b3, 0xfc83030c,
0x08c40c09, 0x0abb05d6, 0xfe4df6cc, 0xf154ef7a,
0xf298f937, 0x01200733, 0x0bbf0b8b, 0x07ca0134,
0xfa23f4cb, 0xf2c3f34c, 0xf780fd7e, 0x01910439,
0x04ab0312, 0x0011fdde, 0xfc57fc9e, 0xfd93ff27,
0x0022ff8f, 0xfddbfb96, 0xfa32fa21, 0xfbcaff92,
0x0352058d, 0x060803d8, 0xffc4f9aa, 0xf507f273,
0xf3e3f877, 0xfefd0644, 0x0ad70c7a, 0x08d602d8,
0xfa53f362, 0xf026f097, 0xf4f1fc07, 0x03940868,
0x0b440917, 0x03f2fe5b, 0xf91cf67b, 0xf636f7a9,
0xfb90ffc1, 0x02610272, 0x0197ffd4, 0xfda5fd48,
0xfd65feba, 0x0036003e, 0xffa0fd3e, 0xfabbf85d,
0xf79bf9e6, 0xfd9801cd, 0x057f07cd, 0x06ca0270,
0xfca9f64a, 0xf277f220, 0xf481fb3a, 0x01f207f0,
0x0b8d0a97, 0x0546fee8, 0xf7dbf2b8, 0xf1d6f397,
0xf9920000, 0x058908d3, 0x087c0578, 0x0099fc27,
0xf87ff6f0, 0xf83afa6e, 0xfd94004a, 0x00be006d,
0xfee0fdd6, 0xfe4ffebc, 0x00b9019a, 0x0277010b,
0xfe4cfb34, 0xf775f5f4, 0xf6ebfb29, 0x009804ed,
0x08110945, 0x05c10098, 0xfa0ef468, 0xf219f30f,
0xf78bff25, 0x05640a1d, 0x0b4f078c, 0x0223fb15,
0xf55af221, 0xf318f71f, 0xfc8d0296, 0x0670075d,
0x056f01fd, 0xfe54fa67, 0xfa64f9d9, 0xfb80fd9a,
0xfed70054, 0xfeabfdd4, 0xfd35fd31, 0xfe9300bc,
0x025e0422, 0x02bbffdb, 0xfc08f815, 0xf4a2f4c6,
0xf88bfc9d, 0x032b07aa, 0x0930086b, 0x03b3fd31,
0xf69ff258, 0xf232f524, 0xfb68020f, 0x06e70a87,
0x09830500, 0xff5ff8e6, 0xf4a9f399, 0xf631fa48,
0xff69039e, 0x051a04e3, 0x026cfeee, 0xfc3afa6f,
0xfa4afc2f, 0xfdfafe2d, 0xfe49fdc4, 0xfb74fb2c,
0xfb35fce4, 0xfffa02ce, 0x048904d7, 0x0332fde1,
0xf956f53a, 0xf3e6f60d, 0xfab8005a, 0x06de0a90,
0x0a4a0679, 0x00bafa27, 0xf3bef216, 0xf2d3f795,
0xfe4f03db, 0x079b093e, 0x062b0172, 0xfbf3f7d8,
0xf599f6a3, 0xf9cafdbd, 0x00f40274, 0x038a0142,
0xff73fd19, 0xfd01fcde, 0xfe9affd3, 0x003cffa4,
0xfdd0fb72, 0xfa15f9df, 0xfbc2ffa1, 0x022605c9,
0x060704ee, 0x008ffb6f, 0xf5b1f2f7, 0xf32ff6db,
0xfd7c03a5, 0x09380b21, 0x0906041e, 0xfdbbf798,
0xf3a3f275, 0xf5ddfacb, 0x0094059f, 0x082306c3,
0x0424ff95, 0xfad7f908, 0xf8c1f995, 0xfc79ffb0,
0x013f01d4, 0x0116ff61, 0xfda3fd61, 0xfdafff3d,
0x00c50131, 0x003afdc4, 0xfb01f88c, 0xf8aaf91d,
0xfc8e017b, 0x054e080d, 0x07050382, 0xfe44f865,
0xf37bf2a8, 0xf466f953, 0xffc2057a, 0x08dd0999,
0x067500d5, 0xfabaf586, 0xf328f3ad, 0xf84efd54,
0x027e0546, 0x063204a0, 0x0156fd46, 0xf9d6f9b9,
0xf9e8fc0b, 0xfe530005, 0x0052ff76, 0xfe12fd18,
0xfd73fec4, 0x00f601fa, 0x020f01da, 0x001bfc5e,
0xf887f618, 0xf700fa16, 0xfe650357, 0x06c9084a,
0x066d0105, 0xfb85f57e, 0xf2bcf326, 0xf692fd51,
0x03180785, 0x0a4d087e, 0x03affdfd, 0xf80ff4c7,
0xf3dbf712, 0xfad3ffe7, 0x03cb0548, 0x048601da,
0xff0dfcb2, 0xfb2ffbc2, 0xfd97fe79, 0x006aff91,
0xfe0ffc4d, 0xfabdfb7f, 0xfd3bff7b, 0x027603f4,
0x03d1011d, 0xfce6f921, 0xf66bf62e, 0xf717fc22,
0x018c05f7, 0x08c507fb, 0x0466ff34, 0xf89ff3d7,
0xf329f4fc, 0xfa58ffb2, 0x05100869, 0x086c0596,
0x0158fbf7, 0xf789f5f0, 0xf746f9bf, 0xfd2300c2,
0x01f901de, 0x0133ff85, 0xfd71fcdd, 0xfd16fdbd,
0xfe4d0004, 0xfe4afcb5, 0xfb08f9a4, 0xfa64fc20,
0xff500289, 0x04dc04eb, 0x039affce, 0xfa96f66b,
0xf3fbf4be, 0xf8e6fdfa, 0x04190806, 0x08ed0641,
0x0224fc19, 0xf6c7f34d, 0xf39af795, 0xfbf901df,
0x05560763, 0x063d02b8, 0xfe8efac6, 0xf890f87c,
0xf9f3fd3a, 0xffd00135, 0x01e000ac, 0x0001fe9f,
0xfd8afe8d, 0xffcc009c, 0x009ffeda, 0xfcb6fa28,
0xf8eaf8ff, 0xf9f8fc99, 0x014804e6, 0x06110571,
0x029cfdda, 0xf985f572, 0xf3aff6b5, 0xfbca01bf,
0x062a08ec, 0x083004a6, 0xffe1fa28, 0xf5c4f469,
0xf621fa5e, 0xff310386, 0x05a0055d, 0x02d4ff4a,
0xfb9cf9b2, 0xf950f9a6, 0xfba8fdc5, 0xffb8ffc7,
0xffe9feca, 0xfdfffe51, 0xff6400df, 0x01c10208,
0x0143feb2, 0xfbe1f8e9, 0xf744f8f0, 0xfaabffc3,
0x03b8067f, 0x076f0403, 0x00a5fb12, 0xf619f3d8,
0xf4d6f8a7, 0xfdf1031a, 0x069d07f5, 0x05e201fa,
0xfcbdf85e, 0xf5d6f60e, 0xf8cefcd0, 0x009403b9,
0x04bb0316, 0x00e4fe10, 0xfb77fa52, 0xfab6fbf0,
0xfde0fdfa, 0xfdbffd8e, 0xfcd6fd2f, 0xfcadfe56,
0x00470209, 0x03fb0277, 0x007dfca1, 0xf8a7f64c,
0xf64af8e0, 0xfd4d0257, 0x05ce086b, 0x06b30301,
0xfe57f837, 0xf45cf356, 0xf67cfaff, 0x009c04fb,
0x082d0769, 0x03a50013, 0xfabef829, 0xf6aff84f,
0xfa81ff02, 0x01930360, 0x033400dd, 0xff4afd1d,
0xfd1efce2, 0xfdb8fdcc, 0xff99fe3b, 0xfd70fc55,
0xfae2fb8d, 0xfd37ffb8, 0x024d0436, 0x03f60252,
0xfe6efa7a, 0xf6fbf607, 0xf753fb0b, 0xfffd054a,
0x0786080e, 0x05c9011b, 0xfbadf6d5, 0xf492f475,
0xf8d9fd61, 0x02c505fc, 0x0609053d, 0x01b1fdc5,
0xf9fbf8b0, 0xf922fa57, 0xfdb20044, 0x01ac013e,
0x00ffffcb, 0xfdfdfe3b, 0xfdc4ff0e, 0x0009fffa,
0xffe9fdf9, 0xfbe5fa2a, 0xfa08fb84, 0xfe2f0138,
0x03e80501, 0x03a200d7, 0xfc54f7e6, 0xf4c2f4dc,
0xf78dfc90, 0x016d0572, 0x07df0699, 0x0320fe34,
0xf9b8f641, 0xf5b4f760, 0xfb32ffbd, 0x038c0529,
0x05150271, 0xffbbfc27, 0xfa17fa6b, 0xfa83fd2d,
0xfeef00b2, 0x00f800b1, 0xff1dfe07, 0xfe06fe67,
0x007300e5, 0x01260056, 0xfe42fbab, 0xf993f953,
0xf9a5fcc5, 0x00e303e1, 0x056605e9, 0x03e3ff07,
0xfb0cf786, 0xf601f702, 0xfaa0ffa6, 0x0428073c,
0x07bf04d8, 0x0114fc3d, 0xf7f3f649, 0xf69df9c2,
0xfdb90168, 0x035a044b, 0x031b005b, 0xfdd4fbba,
0xfadafbe2, 0xfd78fe02, 0xffecffbb, 0xfe32fd81,
0xfd00fd79, 0xfe660024, 0x01b201fa, 0x0181ffcf,
0xfc9cfa1e, 0xf777f7b9, 0xfa6afd36, 0x027c0500,
0x060704cf, 0x0101fcc0, 0xf7cdf61e, 0xf603f87a,
0xfd1d01ff, 0x0528078f, 0x05f1032b, 0xfed3fa3b,
0xf7b6f6cb, 0xf902fb99, 0xffc0019d, 0x040302d0,
0x0165ff9c, 0xfd30fcf1, 0xfcb3fde9, 0xfdf7fe5a,
0xfe27fd79, 0xfb32fb17, 0xfb34fd04, 0x002400d4,
0x03930276, 0x0117fdd6, 0xf9dff7a7, 0xf6bbf8e0,
0xfc08009a, 0x046a060f, 0x05c30393, 0xff0bfa23,
0xf6c0f5ff, 0xf6c7fa5b, 0xfe740357, 0x057805ac,
0x0390ffae, 0xfbe2f95c, 0xf8fff91c, 0xfae3fdb9,
0x008e0135, 0x014000ff, 0xff46fdc8, 0xfe50fdb1,
0xff1dfff3, 0xfff5fe4b, 0xfd46fbec, 0xfab3fb15,
0xfbf3ff78, 0x012703f1, 0x04c90307, 0xffc2fbb7,
0xf811f5d1, 0xf6cbf9a6, 0xfd810277, 0x05cb0605,
0x051101f2, 0xfcc0f90a, 0xf620f6ac, 0xf8dcfc6a,
0x018a03ba, 0x056903f9, 0x015bfde4, 0xfa7ef9ca,
0xf9a7faf7, 0xfd09ff01, 0x010e0129, 0x00bfff49,
0xfdfbfdc0, 0xfea7000c, 0x009200fb, 0xff4ffd0f,
0xfb41f9df, 0xf974fa93, 0xfd9c0158, 0x03b5055f,
0x04ca02e2, 0xff06fa86, 0xf7ccf657, 0xf7bafb35,
0x008c0421, 0x062405e7, 0x03ec000c, 0xfb44f804,
0xf713f8b0, 0xfba9ff5e, 0x025303ef, 0x042502ae,
0x001afd39, 0xfae4fadb, 0xfad9fcb6, 0xfe2dfff9,
0x0016fe57, 0xfe27fdd1, 0xfdf0feef, 0x0080013f,
0x020300fb, 0xff49fc32, 0xf97bf8ef, 0xf951fbb5,
0xff960316, 0x057a05da, 0x03df0009, 0xfbeaf837,
0xf591f6bd, 0xf95ffd76, 0x022b0520, 0x0601042d,
0x00e1fcb9, 0xf9d2f883, 0xf84dfa39, 0xfcd6006e,
0x02220237, 0x01e80062, 0xfe68fccb, 0xfcfefcca,
0xfd8cfe60, 0x0055ffc9, 0xfde6fd5e, 0xfcd5fced,
0xfde4005c, 0x0154027d, 0x01c60061, 0xfcdff9c0,
0xf7d3f712, 0xf9f4fd75, 0x01b804b7, 0x06380521,
0x01dffe17, 0xf9f1f6a7, 0xf594f7c0, 0xfb10fff3,
0x03d60564, 0x055802df, 0x008cfc93, 0xfa33f9e7,
0xf9c1fc46, 0xff3b013e, 0x01af0120, 0x0052fef2,
0xfd49fceb, 0xfd91fe0f, 0xff27002a, 0xff2ffd8a,
0xfc99fab3, 0xfb91fd79, 0x001a01ab, 0x037203c1,
0x017fff27, 0xfb50f85d, 0xf694f873, 0xfb6dff6e,
0x034a05c4, 0x062a0440, 0x003ffc4b, 0xf86af68e,
0xf772f91b, 0xfce000ea, 0x03a1047a, 0x031300d2,
0xfe17fb2f, 0xfa12f9e0, 0xfb63fda3, 0xff2a004a,
0x0063fff4, 0xff20fdf1, 0xfe31fdfe, 0xff760007,
0xfff6ffcb, 0xfd97fb93, 0xfa3efa22, 0xfb21fe6b,
0x0122032e, 0x049a0335, 0x00c4fd8e, 0xf999f76d,
0xf72df991, 0xfd190158, 0x04ab0623, 0x053f026a,
0xfe03fa88, 0xf84ff737, 0xf8bdfc32, 0xffac01f2,
0x04380372, 0x019effb0, 0xfcd6fb22, 0xfadbfb42,
0xfcfcfe14, 0xffe4ff46, 0xfdd4fdbd, 0xfcd1fd4e,
0xfe7f003c, 0x00e600f1, 0x00cefebd, 0xfc61fa7f,
0xfa14fa64, 0xfc67000d, 0x023304da, 0x04800270,
0xff76fb4f, 0xf85af6c7, 0xf825fb47, 0xff1d02cf,
0x04f10543, 0x03e1007c, 0xfc26f97f, 0xf7c8f876,
0xfa8bfd34, 0x0098020b, 0x023d01c1, 0x00f1feca,
0xfd2ffc7d, 0xfd1efdd4, 0xff6a0035, 0xfed4fe23,
0xfd73fcef, 0xfd11fec9, 0x00530159, 0x02390196,
0xfffefd24, 0xfa89f915, 0xf931faf9, 0xfe0701e3,
0x03b4054c, 0x03910154, 0xfd7ff995, 0xf795f710,
0xf9c7fd22, 0x0102031c, 0x051d03af, 0x01e3fe64,
0xfaf1f965, 0xf906fa02, 0xfc25fecd, 0x00b901af,
0x016e00a1, 0xfe78fd7c, 0xfd03fda3, 0xfe35ffd5,
0x000cfe8b, 0xfdadfcb3, 0xfb15fc6b, 0xfe0d0009,
0x01a30237, 0x02620109, 0xfeb9facb, 0xf986f8ea,
0xf9e9fc4d, 0xfff6035e, 0x04cf04c0, 0x0343ff63,
0xfba1f921, 0xf781f878, 0xfb29ff2c, 0x01760384,
0x03e601ff, 0x0000fc74, 0xfa25f9ad, 0xfa45fc53,
0xfebb003e, 0x016f00fd, 0x0062feaf, 0xfdc4fdc0,
0xfdadffa1, 0xffe10056, 0xfebffda2, 0xfc46fae9,
0xfb72fcd0, 0xff6a0116, 0x03590442, 0x02b00062,
0xfc85f9af, 0xf8f0f922, 0xfa74fe08, 0x01490383,
0x055103d7, 0x01e0fd7d, 0xfaaff922, 0xf8f2f9d3,
0xfcbe007e, 0x0252043d, 0x02b9010b, 0xfeebfc73,
0xfb25fae0, 0xfc2ffdff, 0xff90003f, 0xffedffbb,
0xfdf1fe2f, 0xfddbfe27, 0xffd60054, 0x00bbff9c,
0xfdb7fb53, 0xfa12f99f, 0xfb4cfd7c, 0x00430250,
0x044a036b, 0x0171fef9, 0xfa99f915, 0xf8e8f960,
0xfbd50009, 0x038c050b, 0x04980338, 0xffd4fcb2,
0xfa0cf953, 0xf9c4fb57, 0xfe3000b1, 0x022e0230,
0x0141ff47, 0xfdebfc47, 0xfcaffd08, 0xfda0ff29,
0x0028ff86, 0xfdedfd4c, 0xfd11fdfe, 0xfe9a0084,
0x010a011d, 0x00f2ff80, 0xfd0afa2c, 0xf9f1fa16,
0xfc54ff50, 0x01e003c2, 0x041c02d3, 0xfff3fc8d,
0xf94ff7eb, 0xf833fa22, 0xfd9b00e1, 0x03460451,
0x036400f7, 0xfe1cfb42, 0xf9bcf9d0, 0xfac5fdb2,
0x00660130, 0x010700d4, 0xff7dfdcc, 0xfd4afd1e,
0xfde9fe3a, 0xff780053, 0xfea6fd7a, 0xfcdbfcfb,
0xfd08fde2, 0xffab014f, 0x021201de, 0x002efdd6,
0xfb89f9d5, 0xf9d0fadc, 0xfe1a011a, 0x03b705a6,
0x0405025b, 0xff09fb10, 0xf972f8bd, 0xf964fbf4,
0xffbb01b5, 0x0415040a, 0x01fbffe6, 0xfd25fb1f,
0xfa4afb39, 0xfd10feb9, 0x002c0098, 0x0073ff78,
0xfe53fd91, 0xfd28fdae, 0xfebd0016, 0x001cff19,
0xfd9bfceb, 0xfb4efb65, 0xfd5cffb1, 0x011e01d7,
0x0214013c, 0xff1efc06, 0xfa13f8c7, 0xf9c0fb26,
0xfe8601e7, 0x03c00491, 0x03080090, 0xfcf2fa4f,
0xf953f97f, 0xfaeefdec, 0x00b201d0, 0x01f301ca,
0x0052fe75, 0xfc37fabd, 0xfb5afd46, 0xfe7bffd2,
0x003c0025, 0xffb9fdf8, 0xfe29fd7d, 0xfee30018,
0x00f700c4, 0xffc9feb3, 0xfc09fb23, 0xfacafb9e,
0xfd98002d, 0x019f023a, 0x01df008c, 0xfdd4faa5,
0xf977f908, 0xfa6cfd45, 0x004102c3, 0x04280346,
0x013cfed9, 0xfb56f9da, 0xf934fa80, 0xfce1ffab,
0x01a40210, 0x01d200a2, 0xff8bfd1a, 0xfcdffccb,
0xfd26fe12, 0xff1f0049, 0xfec9fdd8, 0xfe14fdc4,
0xfe48ff83, 0x008a00d4, 0x00d20116, 0xff16fd2c,
0xfb49fa4c, 0xfb11fc8a, 0xff9f015c, 0x03120404,
0x01daffc2, 0xfc7ff9e0, 0xf907f9af, 0xfba7fee3,
0x01870338, 0x04130176, 0x004dfcb9, 0xfa95fa0a,
0xfa4dfbc2, 0xfdd100d4, 0x00e50112, 0x00f7ffc5,
0xfde3fd7e, 0xfcaffddf, 0xfdadfeb3, 0xffadfe1d,
0xfdebfd24, 0xfd33fd35, 0xfe790042, 0x00e200e5,
0x012fff80, 0xfd71fb56, 0xfa14fa07, 0xfb3dfde5,
0x00410275, 0x04150321, 0x010dfeb8, 0xfb4df9f4,
0xfa14faf3, 0xfd60008b, 0x019b0386, 0x02df00b6,
0xff24fc9a, 0xfb53fa80, 0xfc2afdb4, 0xff5600db,
0x012b00d5, 0xffbcfe39, 0xfdbbfd60, 0xfe10fdc3,
0xfeee0017, 0xfdf4fdfc, 0xfcdffd07, 0xfceefd88,
0xffde0131, 0x01e301e9, 0x00dcfe63, 0xfc3ffa44,
0xf9e2fa87, 0xfcddffa6, 0x0187039c, 0x043f0252,
0x0014fd3c, 0xfa8bf9f6, 0xfa73fc27, 0xfef400f2,
0x01e201e5, 0x0151ff6d, 0xfd55fc57, 0xfac7fbba,
0xfd8cfe53, 0xffef0025, 0xffd5001b, 0xfe3dfdfe,
0xfddffebf, 0x003bffe3, 0x006bfed5, 0xfd9dfc33,
0xfadffb80, 0xfd3dfebb, 0x00ed0201, 0x01f201b3,
0x0033fdcd, 0xfab9f9d9, 0xfa0bfaea, 0xfd7b00af,
0x022d03d6, 0x026f00db, 0xfec5fbb3, 0xfa73f9d2,
0xfbeafda4, 0x00040108, 0x015a010f, 0xfffefe6b,
0xfd21fcf7, 0xfcccfd73, 0xfdd7ff24, 0x0049ff8d,
0xfe13fdc6, 0xfe18fdcc, 0xfeb7003b, 0x006600af,
0xffbdfe61, 0xfc97fafd, 0xfaeafc1a, 0xfd91ffa4,
0x01f301e4, 0x021f0114, 0xff28fc6d, 0xfa3cf9b9,
0xfa0dfc78, 0xff1f0104, 0x02e302dd, 0x0180fff8,
0xfcf8fafa, 0xf9d4fa9b, 0xfcc2fece, 0x006300e7,
0x00fa0066, 0xff51fddd, 0xfcfefd2f, 0xfd92fea2,
0x00140067, 0xfec5fdfa, 0xfdf2fd4f, 0xfddafe8d,
0x001100bc, 0x012900cc, 0xff44fda9, 0xfb84fa99,
0xfae2fc65, 0xfeb40162, 0x020c020a, 0x01ec001d,
0xfd74face, 0xf9d7f9ea, 0xfaf0fdc4, 0x006601c8,
0x0222019e, 0x00b3feb2, 0xfcadfae3, 0xfb36fcb9,
0xfdffff7a, 0x007a0046, 0xffe4ff81, 0xfe00fe0a,
0xfe3ffe03, 0xfed9ffed, 0x0000ff05, 0xfe0ffd63,
0xfd0bfd48, 0xfe4bffd1, 0x00b700dd, 0x00ff0060,
0xfe2cfbe5, 0xfab1fa3c, 0xfb85fd62, 0xfffb01c9,
0x01ce01d7, 0x0114ff7b, 0xfc6efa53, 0xf9cefaf5,
0xfd17ff41, 0x0124020f, 0x01e600f8, 0xff20fd47,
0xfd2afbab, 0xfc7ffdb7, 0xfe7e0059, 0xffde0015,
0xff5cfdfc, 0xfe20fe13, 0xfdffff95, 0xfff40022,
0xff84fdb3, 0xfd31fcff, 0xfd18fcff, 0xfec20069,
0x01430183, 0x012fff2f, 0xfcf4fb16, 0xfa09faa6,
0xfc3cfe6d, 0x0077022f, 0x021e015d, 0xffabfda8,
0xfb97fa64, 0xfaa7fc11, 0xfdfb0047, 0x011101db,
0x011f004e, 0xfee9fcd9, 0xfd4cfcd5, 0xfddffe45,
0xffeb004d, 0xffd3fe5f, 0xfdb8fe34, 0xfe88002b,
0xfff40138, 0x008bfff8, 0xfe97fdad, 0xfbf1fb19,
0xfcbffdf2, 0xffee0109, 0x01d401cb, 0x0104fed3,
0xfc95fb3c, 0xfafafb17, 0xfdeb0033, 0x014e01ea,
0x01e200cc, 0xfea4fd02, 0xfbaefad3, 0xfbb5fdb1,
0xff0200e0, 0x00c600fe, 0x0098ff09, 0xfe1efd91,
0xfcd8fde1, 0xfe65fe14, 0xfe22fe1d, 0xfe40fdf8,
0xfe5cfdd0, 0xfe9effac, 0x005c00e7, 0x007cfead,
0xfd97fc7b, 0xfb0dfbc0, 0xfdb4ff87, 0x00ab01c6,
0x01f90153, 0x0016fd91, 0xfb48fb2b, 0xfb31fc59,
0xff2d00e4, 0x01a40208, 0x0169008c, 0xfe62fcf3,
0xfb1cfb2b, 0xfcfbfe26, 0xfffe00b1, 0x00b8fffe,
0xff42fe0f, 0xfe0ffdfd, 0xfe34fe7d, 0xffdeffd2,
0xfe45fe43, 0xfd45fd6c, 0xfdecfe9c, 0xffd100a9,
0x00df00d5, 0xff94fdcc, 0xfc26faf2, 0xfaf6fbcc,
0xfe14ffe4, 0x0188021d, 0x01c800a6, 0xff1ffd00,
0xfaf9fad4, 0xfb54fd71, 0xff6a0104, 0x01a7014f,
0x0082fec2, 0xfd5bfd02, 0xfcc7fce1, 0xfddaff8f,
0x002affea, 0xffd1ff64, 0xfe24fdbe, 0xfe02fdf6,
0xffbcffc1, 0xfff5ff15, 0xfddefd68, 0xfccafd10,
0xfdf0ffdd, 0x009900c9, 0x00db00be, 0xff7efd72,
0xfb54fad6, 0xfb76fd36, 0xfed500cb, 0x01a8018d,
0x012dff66, 0xfdb9fc02, 0xfae0fb36, 0xfd17fe72,
0x0068010c, 0x012500c5, 0xffbcfe0a, 0xfd3dfcd3,
0xfce2fd9d, 0xfebd002c, 0xffd10020, 0xfe8cfde4,
0xfe17fdba, 0xfe93001d, 0xffee0009, 0x0011fe2e,
0xfd1afcbc, 0xfceffd16, 0xfeac0047, 0x00ea010b,
0x010afffe, 0xfdeefc7e, 0xfaf8faf0, 0xfc39fde8,
0xffad0111, 0x01c000fb, 0x0050fe3a, 0xfce8fb8b,
0xfb19fcd9, 0xfda6ff41, 0x00a10128, 0x00a90028,
0xfe8bfdd3, 0xfdeefdaa, 0xfe4dfe38, 0xff8b0046,
0xfec1fdea, 0xfde9fde3, 0xfe0efe20, 0xffef002a,
0x000b0025, 0xfe49fdb5, 0xfcc5fcec, 0xfca4fdd9,
0xfff100d1, 0x00d80103, 0x00dbfeef, 0xfd2afbba,
0xfacdfb97, 0xfcdffe8e, 0x007a00fd, 0x012a00ff,
0xffeffdf0, 0xfd06fbed, 0xfc84fd46, 0xfe68ffde,
0xffceffe3, 0x0013fee3, 0xfde9fe12, 0xfe0ffddf,
0xff910000, 0x0019ff2f, 0xfda7fe05, 0xfdccfe28,
0xfe4aff81, 0x004400be, 0x006bff9c, 0xfd89fd29,
0xfc08fbeb, 0xfd43fe89, 0x005c00d1, 0x01010112,
0x0049fdb3, 0xfbe9fb06, 0xfaf4fc0a, 0xfdd3ff61,
0x00f20106, 0x01230045, 0xfea0fd34, 0xfd39fcea,
0xfd12fdcc, 0xff170027, 0xffbe0067, 0xff46fe08,
0xfdfefe11, 0xfde1ffbd, 0xffd5ffef, 0xfea2fdcd,
0xfdd5fcc1, 0xfdd8fddc, 0xff820048, 0x013b00b1,
0x003dfe8e, 0xfd4dfc15, 0xfaa4fcdd, 0xfd88ff63,
0x00ee010f, 0x00b500ec, 0xfec2fd9a, 0xfc12fafe,
0xfcd9fd83, 0xff6100de, 0x010900e0, 0x009dff6e,
0xfe03fd4f, 0xfd05fd0d, 0xfd96fe44, 0x0003ffe0,
0x0013ff4c, 0xfd95fe62, 0xfde4fef8, 0x0046ffdc,
0x003ffef7, 0xfde2fd7c, 0xfcd9fcf8, 0xfd9aff58,
0x0035013c, 0x010c0104, 0xffaefd7a, 0xfd13fb33,
0xfbf5fd40, 0xfe1c0081, 0x013b00e6, 0x009effe0,
0xfe00fce5, 0xfce3fce6, 0xfd11fe59, 0x005200d9,
0x010d00d9, 0xfffbfe7f, 0xfe14fe23, 0xfde5fe0d,
0xfe03ffd9, 0x0015fe47, 0xfdfffdee, 0xfe17fdd0,
0xfed40099, 0x00050016, 0xffc1fe5c, 0xfd53fd1e,
0xfd2dfd1a, 0xfe25ffa4, 0x00e000f1, 0x00c90044,
0xfe33fd74, 0xfc4dfc06, 0xfcf3fdab, 0xfff900bf,
0x00ff00b8, 0x0047fec5, 0xfd62fd4a, 0xfce8fcfd,
0xfd8fff7a, 0x002f000d, 0x0038ffe0, 0xfea0fddb,
0xfe05fde5, 0xfe76fe05, 0xff9affed, 0xfdedfe06,
0xfe02fe02, 0xfdfbff16, 0x00180027, 0xffd9ffe6,
0xff46fd77, 0xfce9fcd7, 0xfce1fd38, 0xfea50098,
0x01210112, 0x00b6ff7d, 0xfd8cfd31, 0xfb8dfc24,
0xfd82fe1e, 0xffdd007d, 0x013f00a5, 0xffb6fe29,
0xfd83fcf7, 0xfcfdfdae, 0xfea4fffc, 0x0006ffbf,
0x001bfede, 0xfdf5fe09, 0xfe12fdbd, 0xfeadffec,
0xfff8ff0a, 0xfdc4fe37, 0xfe10fdcf, 0xff0d0034,
0x004a00e6, 0x0077ffed, 0xfe3dfd04, 0xfd20fd17,
0xfd1bfdb4, 0xffaf0120, 0x014d0122, 0x0046fe67,
0xfd42fd0d, 0xfcf5fcff, 0xfddaff68, 0x00340122,
0x0098002f, 0xff16fdb9, 0xfd7cfcff, 0xfe59fddb,
0xff780011, 0xffffffcb, 0xfe30fe06, 0xfe30fe45,
0xfe44ffeb, 0xffaf0007, 0xfe87fe09, 0xfe0ffd0d,
0xfdc5fe6c, 0x00360046, 0x010b010f, 0x004eff37,
0xfd79fcfd, 0xfd54fd04, 0xfda0ff60, 0x0090012d,
0x012100c9, 0xff54fdd7, 0xfd06fd10, 0xfd32fd99,
0xfe59ffa0, 0x003fffe5, 0xffefffc7, 0xfe4afe0b,
0xfdfffe24, 0xfe15ff0c, 0x001cffee, 0xffb4fded,
0xfe2ffe24, 0xfdd5fec8, 0xffe7ffd6, 0x0020ff9f,
0xfe18fe12, 0xfd17fcfe, 0xfdc7fe96, 0xffbd004b,
0x00fc00ab, 0xff40fe0c, 0xfd4bfcfd, 0xfcfbfd3b,
0xfe6affea, 0x00bc014d, 0x00d80038, 0xfe92fda8,
0xfcf7fcde, 0xfd7cfdfa, 0xffb50019, 0xfff5000e,
0x0023feff, 0xfe07fe2f, 0xfe52fe1c, 0xff520017,
0xffecfe93, 0xfdf2fe5d, 0xfe1bfdf5, 0xfe07ffdb,
0x003c0005, 0x0046fedf, 0xfde1fd58, 0xfce7fd4b,
0xfde8ffbc, 0x001a00b6, 0x00bf0001, 0xfedffd9a,
0xfd05fcfe, 0xfcecfd55, 0xff800061, 0x010d010a,
0x00a2ffa8, 0xfe0bfd24, 0xfd1ffce6, 0xfdb5fe62,
0xffed0028, 0xfff0000d, 0xfe13fdcb, 0xfe0bfdf0,
0xfdf0ff2e, 0x005fffd0, 0xfe26fe19, 0xfde8fe11,
0xfdfffe77, 0xffddffef, 0xffec002d, 0xffccfe0b,
0xfdd6fd18, 0xfd06fd8c, 0xfee20020, 0x003b0112,
0x002effeb, 0xfe80fd04, 0xfd04fcf3, 0xfdaefe5d,
0xffb4006c, 0x01120097, 0xfff2feb3, 0xfde7fd7d,
0xfd38fe3c, 0xfd79ff34, 0x002e001c, 0x000bfe68,
0xfdbffe02, 0xfdeffdf9, 0xff98007c, 0xff9efdfe,
0xfdfcfdf3, 0xfdebfdf3, 0xfddaff3f, 0x00380044,
0x000d0028, 0xfedffdba, 0xfd3efcfc, 0xfd4ffded,
0xff85fff2, 0x011d00e4, 0x0024ff7f, 0xfdc3fd43,
0xfce8fdad, 0xfe00ff4c, 0x0066fffc, 0x00070015,
0xff12fde3, 0xfe4afdc8, 0xfe26fe11, 0xfebd004a,
0x00040039, 0xfe77fdce, 0xfe04fe55, 0xffc50010,
0x001e004f, 0xff5dfe02, 0xfe0efde0, 0xfe08fdc9,
0xfe6dffe3, 0x007b0132, 0x0024ff9c, 0xfe27fdad,
0xfd18fcd7, 0xfda6fe89, 0x00220011, 0x00fa002a,
0xfff9fe56, 0xfdb3fd46, 0xfceefde1, 0xfe880009,
0x0024fffa, 0x0017ffe0, 0xfe20fde0, 0xfe12fe13,
0xfdc0ff27, 0x0053001b, 0xff83fdfb, 0xfe05fdcd,
0xfdeeffb3, 0xfff5fff4, 0x001c0001, 0xfe8cfdf1,
0xfd5ffd01, 0xfe4efdaf, 0xff6e0004, 0xffdd001e,
0xffedff22, 0xfd9ffd5e, 0xfccbfd57, 0xfdf5ff9b,
0xffeb001a, 0x00310019, 0xff31fdaf, 0xfe31fd7b,
0xfde4fe16, 0xff220048, 0xffce0007, 0xffe1fe57,
0xfdb9fde4, 0xfe42fde9, 0xfedd0019, 0x0011ff07,
0xfdf6fe0a, 0xfe02fdd2, 0xfee20016, 0xffe7000c,
0x0011ff3b, 0xfdcafe14, 0xfcd5fdc7, 0xfdd7ff06,
0x00310009, 0x00c0ffb8, 0xffd6fe11, 0xfdc2fcfa,
0xfce9fda2, 0xfe16ff91, 0x0006fff0, 0x00030001,
0xfe7cfe0d, 0xfe43fdcd, 0xfddefed5, 0x0050ffc1,
0x0012ffee, 0xfe1bfdc3, 0xfdf7fe2f, 0xfdecfefc,
0x0029ffe3, 0xfe30fde3, 0xfe01fde4, 0xfe0dfe2f,
0xffc0ffe4, 0xffe6000c, 0xffa6fdfd, 0xfdb1fd39,
0xfcbcfde0, 0xfe4d0008, 0xffdb000d, 0xffe10009,
0xfefbfda7, 0xfde4fcc1, 0xfe01fdd2, 0xff780013,
0x001a000d, 0xffefff7a, 0xfdb8fe4b, 0xfdacfe29,
0xfdc8ff24, 0xfffa0006, 0xff7afe0a, 0xfe29fdc7,
0xfddafee1, 0x0018ffd7, 0x003afee9, 0xfdc5fe3a,
0xfdc9fe25, 0xfd91fead, 0xfff4fffd, 0xffedffd0,
0xff52fde6, 0xfdbafd16, 0xfe41fe11, 0xff04000d,
0xffb4ffd3, 0xffcaffc5, 0xfdf5fe06, 0xfd2bfdc2,
0xfe21fdda, 0xffa40027, 0xffe60048, 0xffb3fe37,
0xfe0ffdd2, 0xfddefe09, 0xfe76000d, 0xff6dfe1f,
0xfdf5fe2c, 0xfdfbfe1e, 0xffcfffe4, 0x0017fff0,
0x0019fee9, 0xfe02fe33, 0xfdf2fe0a, 0xfe64002a,
0x0014fffc, 0xffce0025, 0xfea9fdd7, 0xfe2ffe16,
0xfe05fdea, 0xfff6ffe3, 0xffd7fff1, 0x002cff00,
0xfdecfe68, 0xfe2dfe03, 0xfdd6feb3, 0xffc7fff3,
0x003a0014, 0xfe7efdc2, 0xfdcdfdf7, 0xfdc9fede,
0x0005ff44, 0xfd9bfdf5, 0xfe0dfddc, 0xfdeafe50,
0xffc9fffa, 0x0003000d, 0xff54fddd, 0xfe20fde4,
0xfe08fdcc, 0xff620021, 0xffeb0024, 0xfff7ff80,
0xfe1dfe08, 0xfdb4fe5b, 0xfd9afef7, 0xffc3ffef,
0x0008ffe8, 0xff6afd97, 0xfe53fdc6, 0xfe17fdac,
0xfe66ffef, 0xffea002b, 0xfff0fe79, 0xfda8fe6d,
0xfd54fe36, 0xfe520069, 0xff1cfe76, 0xfd94ff63,
0x0376ff8a, 0x000dffd4, 0x0020001e, 0xffebfff9,
0xffdf0037, 0xffecfff4, 0x000bfff7, 0xffbdffe6,
0x00010031, 0xffcf000b, 0xffb9ffe2, 0xfff8ffd3,
0x00270001, 0xfff00014, 0x0011ffea, 0xffd7ffd9,
0xfff70072, 0x00350009, 0x001a005d, 0x000dffda,
0xffebfff1, 0x00390015, 0xffe5ffd6, 0xfff8fff0,
0xfff2fff4, 0xffd7ffd2, 0x00170017, 0xffdb0010,
0xfffefffa, 0xffeb0012, 0x0005ffcb, 0x0008fff2,
0xfff5fff9, 0x001c0013, 0xfff9ffd6, 0x00180037,
0x00220000, 0x00000026, 0xfff40009, 0x0019ffed,
0x000d000f, 0xffffffd0, 0xffd80012, 0x0005fffd,
0xffedfff9, 0xfff5fff9, 0xfff20021, 0xfffefff7,
0xfffb0005, 0x0004fff1, 0x0009fffe, 0xfff8fffd,
0x0003fffe, 0x0001fff5, 0x00000001, 0x00080005,
0xfffffffb, 0xffff0004, 0x00070000, 0xffffffff,
0x00000003, 0xfffe0000, 0x00010001, 0xffff0001,
0xffff0001, 0xfffd0000, 0xffff0001, 0x00010000,
0xfffeffff, 0x00000001, 0x0001ffff, 0x0001ffff,
0x00000000, 0x00000000, 0x00000000, 0x0001ffff,
0x00000000, 0x0000ffff, 0x00000000, 0x00000000,
0x00000000, 0x0001ffff,
0
};
 
 
#define NSAMPLE_WORDS 12748
#define NSAMPLES 12748
#define NSAMPLE_WORDS 6375
 
 
#endif
/sw/dev/asmstartup.h
52,16 → 52,8
"\t.global\t_start\n"
"\t.type\t_start,@function\n"
"_start:\n"
"\tNDUMP\n"
"\tMOV\tkernel_exit(PC),uPC\n"
"\tLDI\t255,R0\n"
"\tSW\tR0,0x414\n"
"\tLDI\t_top_of_stack,SP\n"
"\tJSR\tentry\n"
"NEXIT\tR0\n"
"kernel_exit:\n"
"\tHALT\n"
"\tBRA\tkernel_exit\n"
"LDI\t_top_of_stack,SP\n"
"\tBRA\tentry\n"
"\t.section\t.text");
 
#endif
/sw/dev/helloworld.c
22,7 → 22,7
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
// Copyright (C) 2015-2016, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
52,32 → 52,30
const char msg[] = "Hello, world!\r\n";
 
void entry(void) {
volatile IOSPACE *const sys = (IOSPACE *)IOADDR;
register IOSPACE *sys = (IOSPACE *)IOADDR;
int ledset = 0;
 
sys->io_spio = 0x0f0;
 
/// Turn off timer B
sys->io_watchdog = 0;
sys->io_timb = 0;
 
while(1) {
const char *ptr;
sys->io_timer = TM_ONE_SECOND; // Ticks per second, 80M
sys->io_tima = TM_ONE_SECOND; // Ticks per second, 80M
sys->io_pic = 0x07fffffff; // Acknowledge and turn off all ints
 
ptr = msg;
while(*ptr) {
unsigned iv = *(unsigned char *)ptr++;
 
// Wait while our transmitter is busy
while((sys->io_pic & INT_UARTTX)==0)
;
sys->io_uart = iv; // Transmit our character
sys->io_uart = *ptr++; // Transmit our character
sys->io_pic = INT_UARTTX; // Clear the int flag
}
 
// Now, wait for the top of the second
while((sys->io_pic & INT_TIMER)==0)
while((sys->io_pic & INT_TIMA)==0)
;
 
ledset <<= 1;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.