Index: apps/codecs.c =================================================================== --- apps/codecs.c (revision 29826) +++ apps/codecs.c (working copy) @@ -70,7 +70,7 @@ extern void* plugin_get_audio_buffer(size_t *buffer_size); -#if (CONFIG_PLATFORM & PLATFORM_NATIVE) && defined(HAVE_RECORDING) +#if (CONFIG_PLATFORM & PLATFORM_NATIVE) #undef open static int open(const char* pathname, int flags, ...) { @@ -150,6 +150,7 @@ enc_finish_chunk, enc_get_pcm_data, enc_unget_pcm_data, +#endif /* HAVE_RECORDING */ /* file */ (open_func)PREFIX(open), @@ -159,10 +160,10 @@ (write_func)PREFIX(write), round_value_to_list32, -#endif /* HAVE_RECORDING */ - /* new stuff at the end, sort into place next time the API gets incompatible */ + strchr, + strncmp, }; void codec_get_full_path(char *path, const char *codec_root_fn) Index: apps/codecs.h =================================================================== --- apps/codecs.h (revision 29826) +++ apps/codecs.h (working copy) @@ -29,6 +29,7 @@ #include #include +#include #include "strlcpy.h" #include "config.h" #include "system.h" @@ -210,6 +211,7 @@ void (*enc_finish_chunk)(void); unsigned char * (*enc_get_pcm_data)(size_t size); size_t (*enc_unget_pcm_data)(size_t size); +#endif /* file */ int (*open)(const char* pathname, int flags, ...); @@ -221,10 +223,11 @@ const unsigned long list[], int count, bool signd); -#endif /* new stuff at the end, sort into place next time the API gets incompatible */ + char *(*strchr)(const char *s, int c); + int (*strncmp)(const char *, const char *, size_t); }; /* codec header */ Index: apps/metadata/sc68.c =================================================================== --- apps/metadata/sc68.c (revision 0) +++ apps/metadata/sc68.c (revision 0) @@ -0,0 +1,276 @@ +#include +#include +#include +#include +#include + +#include "system.h" +#include "metadata.h" +#include "metadata_common.h" +#include "metadata_parsers.h" +#include "rbunicode.h" + +/* Ripped from Benjamin Gerardīs sc68 library. + http://sc68.atari.org */ + +#define sndh_cc FOURCC('S','N','D','H') + +/* Peek Little Endian Unaligned 32 bit value */ +static int LPeek(const void *a) +{ + return get_long_le( (void*) a ); +} + +static int LPeekBE(const void *a) +{ + return get_long_be( (void*) a ); +} + +static int myatoi(const char *s, int i, int max, int * pv) +{ + int v = 0; + for (; i='0' && c<='9') { + v = v * 10 + c - '0'; + } else { + break; + } + } + if (pv) *pv = v; + return i; +} + +static int sndh_is_magic(const char *buffer, int max) +{ + const int start = 6; + int i=0, v = 0; + if (max >= start) { + for (i=start, v = LPeekBE(buffer); i < max && v != sndh_cc; + v = ((v<<8)| (buffer[i++]&255)) & 0xFFFFFFFF) + ; + } + i = (v == sndh_cc) ? i-4: 0; + return i; +} + +static int sc68_info(struct mp3entry* id3, const char* data, int len) +{ + char* b; + int chk_size; + for (b = (char *) data; len >= 8; b += chk_size, len -= chk_size) { + char chk[8]; + + if (b[0] != 'S' || b[1] != 'C') { + break; + } + + chk[0] = b[2]; + chk[1] = b[3]; + chk[2] = 0; + chk_size = LPeek(b + 4); + b += 8; + len -= 8; + + /* Base chunk, ignore it */ + if (!strcmp(chk, "68")) { + chk_size = 0; + } else if (!strcmp(chk, "FN")) { + id3->title = b; + } + /* Music name */ + else if (!strcmp(chk, "MN")) { + id3->title = b; + } + /* Author name */ + else if (!strcmp(chk, "AN")) { + id3->artist = b; + } + /* Composer name */ + else if (!strcmp(chk, "CN")) { + id3->album = b; + } + /* Playing time */ + else if (!strcmp(chk, "TI")) { + id3->length = LPeek(b) * 1000u; + } + /* EOF */ + else if (!strcmp(chk, "EF")) { + len = 0; + break; + } + } + + return 0; +} + +static int sndh_info(struct mp3entry* id3, const char* data, int len) +{ + int frq = 0, time = 0 , musicmon = 0; + int i; + int unknowns = 0; + const int unknowns_max = 8; + int fail = 0; + char * b = (char *) data; + char empty_tag[4] = { 0, 0, 0, 0 }; + + i = sndh_is_magic(data, len); + if (!i) { + /* should not happen since we already have tested it. */ + return -1; + } + + i += 4; /* Skip sndh_cc */ + len -= 4; + + /* $$$ Hacky: + Some music have 0 after values. I don't know what are + sndh rules. May be 0 must be skipped or may be tag must be word + aligned. + Anyway the current parser allows a given number of successive + unknown tags. May be this number should be increase in order to prevent + some "large" unknown tag to break the parser. + */ + + while (i < len) { + char * s; + int unknown; + + s = 0; + unknown = 0; + if (!memcmp(b+i,"COMM",4)) { + /* Composer */ + s = id3->artist = b+i+4; + } else if (!memcmp(b+i,"TITL",4)) { /* title */ + /* Title */ + s = id3->title = b+i+4; + } else if (!memcmp(b+i,"RIPP",4)) { + /* Ripper */ + s = b+i+4; + } else if (!memcmp(b+i,"CONV",4)) { + /* Converter */ + s = b+i+4; + } else if (!memcmp(b+i,"MuMo",4)) { + /* Music Mon ??? */ + musicmon = 1; + i += 4; + } else if (!memcmp(b+i,"TIME",4)) { + /* Time in second */ + time = (((unsigned char)*(b + i + 4)) << 8) | + ((unsigned char)*(b + i + 5)); + i += 6; + } else if (!memcmp(b+i,"##",2)) { + /* +'xx' number of track */ + i = myatoi(b, i+2, len, 0); + while( i < len && *(b + i) == 0 ) { + i++; + } + } else if (!memcmp(b+i,"!V",2)) { + /* +string VBL frq */ + if (!frq) { + i = myatoi(b, i+2, len, &frq); + } + } else if (!memcmp(b+i,"**",2)) { + /* FX +string 2 char ??? */ + i += 4; + } + else if (!memcmp(b+i, "YEAR", 4)) { + /* year */ + s = id3->year_string = b+i+4; + } + else if( *(b+i) == 'T' && (*(b+i+1) == 'A' || + *(b+i+1) == 'B' || + *(b+i+1) == 'C' || + *(b+i+1) == 'D') ) { + i = myatoi(b, i+2, len, &frq); + while( i < len && *(b + i) == 0 ) { + i++; + } + } + else if( memcmp( b + i, empty_tag, 4 ) == 0 || + memcmp( b + i, "HDNS", 4 ) == 0 ) { + i = len; + } else { + /* skip until next 0 byte, as long as it's inside the tag area */ + + i += 4; + while( *(b + i) != 0 && i < len ) { + i++; + } + + unknown = 1; + } + + if (unknown) { + ++ unknowns; + /* Unkwown tag, finish here. */ + ++i; + if (fail || unknowns >= unknowns_max) { + i = len; + } + unknown = 0; + } else { + unknowns = 0; /* Reset successive unkwown. */ + if (s) { + int j,k,c; + for (j=k=0; c=(s[j]&255), c; ++j) { + if (c <= 32) s[j] = 32; + else k=j+1; + } + s[k] = 0; /* Strip triling space */ + i += j + 5; + + /* skip the trailing null chars */ + while( i < len && *(b + i) == 0 ) { + i++; + } + } + } + } + + id3->length = (time > 0 ? time : 180) * 1000; + return 0; +} + +bool get_sc68_metadata(int fd, struct mp3entry* id3) +{ + /* Use the trackname part of the id3 structure as a temporary buffer */ + unsigned char* buf = (unsigned char *)id3->path; + int read_bytes; + + memset(buf, 0, MAX_PATH); + if ((lseek(fd, 0, SEEK_SET) < 0) + || ((read_bytes = read(fd, buf, MAX_PATH - 1)) < 32)) + return false; + + id3->vbr = false; + id3->filesize = filesize(fd); + /* we only render 16 bits, 44.1KHz, Stereo */ + id3->bitrate = 706; + id3->frequency = 44100; + + /* default song length */ + id3->length = 180*1000; + + /* If file is iced skip next step */ + if (!memcmp(buf,"ICE!",4)) /* ICE! packed song */ + return true; + + /* Check for sndh magic */ + else if (sndh_is_magic(buf, 32)) { + sndh_info(id3, buf, MAX_PATH); + return true; + } + /* Check for sc68 */ + else if (!memcmp(buf, "SC68 Music-file / (c) (BeN)jamin Gerard / SasHipA-Dev ", 56)) { + sc68_info(id3, buf + 56, MAX_PATH - 56); + return true; + } + else if (!memcmp(buf, "SC68-V2", 8)) { + sc68_info(id3, buf + 8, MAX_PATH - 8); + return true; + } + + /* No support for (g)zipped files */ + return false; +} Index: apps/metadata/metadata_parsers.h =================================================================== --- apps/metadata/metadata_parsers.h (revision 29826) +++ apps/metadata/metadata_parsers.h (working copy) @@ -47,3 +47,4 @@ bool get_vox_metadata(int fd, struct mp3entry* id3); bool get_wave64_metadata(int fd, struct mp3entry* id3); bool get_tta_metadata(int fd, struct mp3entry* id3); +bool get_sc68_metadata(int fd, struct mp3entry* id3); Index: apps/metadata.c =================================================================== --- apps/metadata.c (revision 29826) +++ apps/metadata.c (working copy) @@ -210,6 +210,9 @@ /* Advanced Audio Coding High Efficiency in M4A container */ [AFMT_MP4_AAC_HE] = AFMT_ENTRY("AAC-HE","aac", NULL, get_mp4_metadata, "mp4\0"), + /* Atari SC68 & SNDH music formats */ + [AFMT_SC68] = + AFMT_ENTRY("SC68", "sc68", NULL, get_sc68_metadata, "sc68\0sndh\0"), #endif }; @@ -293,6 +296,7 @@ case AFMT_SID: case AFMT_MOD: case AFMT_SAP: + case AFMT_SC68: /* Type must be allocated and loaded in its entirety onto the buffer */ return TYPE_ATOMIC_AUDIO; Index: apps/metadata.h =================================================================== --- apps/metadata.h (revision 29826) +++ apps/metadata.h (working copy) @@ -87,6 +87,7 @@ AFMT_WMAVOICE, /* WMA Voice in ASF */ AFMT_MPC_SV8, /* Musepack SV8 */ AFMT_MP4_AAC_HE, /* Advanced Audio Coding (AAC-HE) in M4A container */ + AFMT_SC68, /* Atari SC68 & SNDH music formats */ #endif /* add new formats at any index above this line to have a sensible order - Index: apps/SOURCES =================================================================== --- apps/SOURCES (revision 29826) +++ apps/SOURCES (working copy) @@ -224,6 +224,7 @@ metadata/au.c metadata/vox.c metadata/tta.c +metadata/sc68.c #endif #ifdef HAVE_TAGCACHE tagcache.c Index: apps/filetypes.c =================================================================== --- apps/filetypes.c (revision 29826) +++ apps/filetypes.c (working copy) @@ -112,6 +112,8 @@ { "vox", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA }, { "w64", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA }, { "tta", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA }, + { "sc68", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA }, + { "sndh", FILE_ATTR_AUDIO, Icon_Audio, VOICE_EXT_MPA }, #endif { "m3u", FILE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST }, { "m3u8",FILE_ATTR_M3U, Icon_Playlist, LANG_PLAYLIST }, Index: apps/codecs/sc68.c =================================================================== --- apps/codecs/sc68.c (revision 0) +++ apps/codecs/sc68.c (revision 0) @@ -0,0 +1,163 @@ + +/* Ripped from Benjamin Gerardīs sc68 library. + http://sc68.atari.org */ + +#include "codeclib.h" +#include "libsc68/sc68.h" + +CODEC_HEADER + +/* Maximum number of bytes to process in one iteration */ +#define CHUNK_SIZE (1024*2) + +static int16_t samples[CHUNK_SIZE] IBSS_ATTR; +static sc68_t* sc68 IDATA_ATTR CACHEALIGN_ATTR; +uint8_t *sc68file IDATA_ATTR CACHEALIGN_ATTR; + +/****************** rockbox interface ******************/ + +static void set_codec_track(int t, int multitrack) { + sc68_stop(sc68); + if (sc68_play(sc68, t, 1)) { + /* An error happened */ + return; + } + + if (multitrack) ci->set_elapsed(t*1000); /* t is track no to display */ + else ci->set_elapsed(0); +} + +/* this is the codec entry point */ +enum codec_status codec_main(enum codec_entry_call_reason reason) +{ + if (reason == CODEC_LOAD) { + /* we only render 16 bits, interleaved stereo */ + ci->configure(DSP_SET_SAMPLE_DEPTH, 16); + ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED); + + sc68_init(0); + } + + return CODEC_OK; +} + +/* this is called for each file to process */ +enum codec_status codec_run(void) +{ + int err, track, is_multitrack, is_seeking; + size_t filesize; + intptr_t param; + uint32_t elapsed_time = 0; + + /* Track info container */ + sc68_music_info_t info; + + DEBUGF("SC68: next_track\n"); + if (codec_init()) { + return CODEC_ERROR; + } + + codec_set_replaygain(ci->id3); + + /* Create sc68 instance */ + if (sc68 = sc68_create(0), !sc68) { + DEBUGF("SC68: sc68_create error\n"); + return CODEC_ERROR; + } + + /* Set disk root as user path */ + sc68_set_user(sc68, "/"); + + /* We want 44 Khz (?) */ + ci->configure(DSP_SET_FREQUENCY, sc68_sampling_rate(sc68, 44100)); + + /* Reset track and time counters */ + track = is_multitrack = is_seeking = 0; + elapsed_time = 0; + + /* Read the entire file */ + DEBUGF("SC68: request file\n"); + ci->seek_buffer(0); + sc68file = ci->request_buffer(&filesize, ci->filesize); + if (!sc68file || filesize < (size_t)ci->filesize) { + DEBUGF("SC68: file load failed\n"); + sc68_destroy(sc68); + return CODEC_ERROR; + } + + if ((err = sc68_load_mem(sc68, sc68file, filesize))) { + DEBUGF("SC68: sc68_load_mem failed (%d)\n", err); + sc68_destroy(sc68); + return CODEC_ERROR; + } + + memset(&info, 0, sizeof(sc68_music_info_t)); + sc68_music_info(sc68, &info, track, 0); + + /* Check if file has multiple tracks */ + is_multitrack = (info.tracks > 1); + +next_track: + set_codec_track(track, is_multitrack); + + /* for REPEAT_ONE we disable track limits */ + if (ci->global_settings->repeat_mode != REPEAT_ONE) { + sc68_set_fade(sc68, info.time_ms > 0 ? info.time_ms - 4000 : 176 * 1000, 4000); + } + + /* The main decoder loop */ + while (1) { + enum codec_command_action action = ci->get_command(¶m); + + if (action == CODEC_ACTION_HALT) + break; + + if (action == CODEC_ACTION_SEEK_TIME) { + if (is_multitrack) { + track = param/1000; + ci->seek_complete(); + if (track >= info.tracks) break; + goto next_track; + } + + ci->set_elapsed(param); + elapsed_time = param; + sc68_seek(sc68, param, &is_seeking); + + /* Flush audio output */ + while( is_seeking ) { + sc68_seek(sc68, -1, &is_seeking); + err = sc68_process(sc68, samples, CHUNK_SIZE >> 1) & SC68_END; + if (err) { + DEBUGF("SC68: seek error\n"); + is_seeking = 0; + break; + } + } + + ci->seek_complete(); + } + + /* Generate audio buffer */ + err = sc68_process(sc68, samples, CHUNK_SIZE >> 1) & SC68_END; + if (err) { + DEBUGF("SC68: requesting next track\n"); + track++; + if (track >= info.tracks) break; + goto next_track; + } + + ci->pcmbuf_insert(samples, NULL, CHUNK_SIZE >> 1); + + /* Set elapsed time for one track files */ + if (is_multitrack == 0) { + elapsed_time += (CHUNK_SIZE / 2) / 44.1; + ci->set_elapsed(elapsed_time); + } + } + + /* Destroy current track */ + sc68_destroy(sc68); + + return CODEC_OK; +} Index: apps/codecs/libsc68/unice68/unice68.c =================================================================== --- apps/codecs/libsc68/unice68/unice68.c (revision 0) +++ apps/codecs/libsc68/unice68/unice68.c (revision 0) @@ -0,0 +1,288 @@ +/* + * sc68 - ICE! depacker + * Copyright (C) 1998-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#ifndef PACKAGE_NAME +# define PACKAGE_NAME "unice68" +#endif +#ifndef PACKAGE_VERSION +# define PACKAGE_VERSION __DATE__ +#endif + +/* #define ICEVERSION 240 */ +#include "unice68.h" + +#include +#include +#include +#include +#include + +static int verbose = 0; + +/* Message levels */ +enum { + D = 2, /* Message level Debug */ + V = 1, /* Message level verbose */ + N = 0, /* Message level normal */ + Q = -1 /* Message level quiet */ +}; + +static void message(const int level, const char *format, ...) +{ + va_list list; + if (verbose >= level) { + int save_errno = errno; + va_start(list, format); + vfprintf(stderr,format,list); + fflush(stderr); + va_end(list); + errno = save_errno; + } +} + +static int print_usage(void) +{ + int ice_version = unice68_ice_version(); + printf + ( + "Usage: " PACKAGE_NAME " [OPTION] [--] [[] ]\n" + "\n" + "ICE! depacker %d.%02d\n" + "\n" + " `-' as input/output uses respectively stdin/stdout.\n" + "\n" + "Options:\n" + "\n" + " -v --verbose Be more verbose (multiple use possible)\n" + " -q --quiet Be less verbose (multiple use possible)\n" + " -h --help Print this message and exit\n" + " -V --version Print version and copyright and exit\n" + "\n" + "Copyright (C) 2003-2009 Benjamin Gerard\n" + "\n" + "Visit <" PACKAGE_URL ">\n" + "Report bugs to <" PACKAGE_BUGREPORT ">\n", + ice_version/100, ice_version%100 + ); + return 1; +} + +static int print_version(void) +{ + puts(unice68_versionstr()); + puts + ( + "\n" + "Copyright (C) 2001-2009 Benjamin Gerard.\n" + "License GPLv3+ or later \n" + "This is free software: you are free to change and redistribute it.\n" + "There is NO WARRANTY, to the extent permitted by law.\n" + "\n" + "Written by Benjamin Gerard" + ); + return 0; +} + +int main(int argc, char *argv[]) +{ + int csize, dsize, i, n; + void * buffer = 0, * depack = 0; + int err = 255; + FILE * in = 0, * out = 0; + const char * fin=0, *fout=0; + char header[12]; + + argv[0] = "unice68"; + for (i=n=1; i 1) { + fin = argv[1]; + } + if (argc > 2) { + fout = argv[2]; + } + if (argc > 3) { + fprintf(stderr,"unice68: Unexcepted argument `%s'\n", argv[3]); + return 255; + } + + if (!fin || !strcmp(fin,"-")) { + fin = ""; + in = stdin; + } else { + in = fopen(fin,"rb"); + } + message(V,"input file `%s'\n",fin); + if (!in) { + perror(argv[0]); + goto error; + } + + err = (int)fread (header, 1, sizeof(header), in); + if (err == -1) { + perror(argv[0]); + goto error; + } + + if (err < sizeof(header)) { + fprintf(stderr, "unice68: Not enought byte to be a valid ice file.\n"); + goto error; + } + csize = 0; + dsize = unice68_depacked_size(header, &csize); + if (dsize == -1) { + fprintf(stderr, "unice68: Not a valid ice file : missing magic.\n"); + goto error; + } + if (csize < 0 || dsize < 0) { + fprintf(stderr, "weird sizes: %d/%d.\n", csize,dsize); + goto error; + } + + message(N,"ICE! compressed:%d uncompressed:%d ratio:%d%%\n", + csize,dsize,(csize+50)*100/dsize); + + buffer = malloc(csize+sizeof(header)); + if (!buffer) { + perror(argv[0]); + goto error; + } + + memcpy(buffer, header, sizeof(header)); + message(D,"reading %d bytes from `%s' ... ", csize, fin); + err = (int) fread((char *)buffer + sizeof(header) , 1, csize, in); + message(D,"%s\n", err != csize ? "failed :(" : "success :)"); + + if (err != csize) { + if (err == -1) { + perror(argv[0]); + goto error; + } else { + fprintf(stderr, "unice68: Read error get %d bytes on %d requested\n", + err, csize); + err = 2; + goto error; + } + } + + depack = malloc(dsize); + if (!depack) { + perror(argv[0]); + err = 255; + goto error; + } + message(D,"%d bytes output buffer allocated, running depacker ... ", dsize); + err = unice68_depacker(depack, buffer); + message(D,"%s\n",err ? "failed :(" : "success :)"); + + if (!err) { + if (!fout || !strcmp(fout,"-")) { + fout = ""; + out = stdout; + } else { + out = fopen(fout,"wb"); + } + message(V,"output file is `%s'\n",fout); + + if (!out) { + perror(argv[0]); + goto error; + } + message(D,"writing %d bytes into output file `%s' ... ", dsize, fout); + err = (int) fwrite(depack, 1, dsize, out); + message(D,"%s\n", err != dsize ? "failed :(" : "success :)"); + if (err != dsize) { + err = -1; + perror(argv[0]); + goto error; + } + err = 0; + } + + error: + if (in && in != stdin) { + fclose(in); + } + if (out) { + fflush(out); + if (out != stdout) fclose(out); + } + free(buffer); + free(depack); + + err &= 255; + message(D,"exit with code %d\n", err); + + return err & 255; +} Index: apps/codecs/libsc68/unice68/AUTHORS =================================================================== --- apps/codecs/libsc68/unice68/AUTHORS (revision 0) +++ apps/codecs/libsc68/unice68/AUTHORS (revision 0) @@ -0,0 +1,18 @@ + unice68 - ice depacker + + unice68 is part of the sc68 project + + (C) Copyright 1998-2009 Benjamin Gerard + + +*Atari ST original version* + [fill-me] + +*Author and maintainer* + Benjamin Gerard + +*Homepage* + http://sc68.atari.org/ + +*Project* + http://sourceforge.net/projects/sc68/ Index: apps/codecs/libsc68/unice68/unice68.h =================================================================== --- apps/codecs/libsc68/unice68/unice68.h (revision 0) +++ apps/codecs/libsc68/unice68/unice68.h (revision 0) @@ -0,0 +1,146 @@ +/** + * @ingroup unice68_lib + * @file unice68.h + * @author Benjamin Gerard + * @date 2003/08/06 + * @brief ICE! depacker header + * + */ + +/* $Id$ */ + +#ifndef _UNICE68_H_ +#define _UNICE68_H_ + +#ifndef UNICE68_EXTERN +# ifdef __cplusplus +# define UNICE68_EXTERN extern "C" +# else +# define UNICE68_EXTERN extern +# endif +#endif + +#ifndef UNICE68_API +/* Building */ +# ifdef UNICE68_EXPORT +# if defined(DLL_EXPORT) && defined(HAVE_DECLSPEC) +# define UNICE68_API __declspec(dllexport) +# elif defined(HAVE_VISIBILITY) +# define UNICE68_API UNICE68_EXTERN __attribute__ ((visibility("default"))) +# else +# define UNICE68_API UNICE68_EXTERN +# endif +/* Using */ +# else +# if defined(UNICE68_DLL) +# define UNICE68_API __declspec(dllimport) +# else +# define UNICE68_API UNICE68_EXTERN +# endif +# endif +#endif + +/** @defgroup unice68_lib unice68 library + * @ingroup api68 + * @brief ICE! 2.4 depacker. + * + * unice68 library provides functions to depack ICE! packed buffer. + * The depacker used is a rought conversion of the original ICE 2.4 + * routine written in 68000 assembler. ICE packer was (and may be + * is) widely used on the Atari ST the Atari ST. + * + * @note unice68 library is re-entrant (thread-safe). + * + * @note It is pretty much impossible to implement a progressive + * version of the depacker. At least the entire packed file must be + * loaded before depacking it because data order is reversed. + * + * @{ + */ + +#ifndef UNICE68_API +/** unice68 symbols specification. + * + * Define special atributs for importing/exporting unice68 symbols. + */ +#define UNICE68_API UNICE68_EXTERN +#error "UNICE68_API should be defined" +#endif + +UNICE68_API +/** Get unice68 version. + * + * @return version number + */ +int unice68_version(void); + +UNICE68_API +/** Get unice68 version. + * + * @return version string + */ +const char * unice68_versionstr(void); + +UNICE68_API +/** Get ICE depacker version. + * + * @return version number (MAJOR*100+MINOR) + */ +int unice68_ice_version(void); + +UNICE68_API +/** Test ICE and get compressed and uncompresed size. + * + * The unice68_depacked_size() function returns the uncompressed + * size of a ICE compressed buffer. If p_size is not 0 it is fill with + * the size of the compressed data found in header (useful for stream + * operation). + * If the value pointed by p_csize is not 0 the function assumes that it is + * an expected compressed size and compares it to header one. If it differs + * the function returns the bitwise NOT value of uncompressed data. This + * should be a minus value but not -1. + * + * @param buffer buffer with at least 12 bytes of data (ice header). + * @param p_csize Optionnal pointer to store compressed size. + * May be use to verify an expected compressed size. + * See function documentation for more details. + * + * @return uncompressed size + * @retval >0 Uncompressed size + * @retval -1 Error; not a valid ICE packed buffer + * @retval <0 Bitwise NOT of uncompressed size but verify failed. + * + */ +int unice68_depacked_size(const void * buffer, int * p_csize); + +UNICE68_API +/** Test ICE and get compressed and uncompresed size. + * @deprecated in favor of unice68_depacked_size() + */ +int unice68_get_depacked_size(const void * buffer, int * p_csize); + +UNICE68_API +/** Depack an ICE buffer to another. + * + * The unice68_depacker() function depacks src input ICE compressed + * buffer into dst output buffer. The dst buffer is assumed to be + * already allocated and large enough. + * + * @param dst output (destination) buffer (uncompressed data). + * @param src input (source) buffer (compressed data). + * + * @return error code + * @retval 0 succcess + * @retval -1 failure + * + * @warning The original ICE depacker may allow to use the same buffer for + * compressed and uncompressed data. Anyway this has not been tested + * and you are encouraged to add guard bands. + */ +int unice68_depacker(void * dst, const void * src); + +/** + * @} + */ + +#endif /* #ifndef _UNICE68_H_ */ Index: apps/codecs/libsc68/unice68/COPYING =================================================================== --- apps/codecs/libsc68/unice68/COPYING (revision 0) +++ apps/codecs/libsc68/unice68/COPYING (revision 0) @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: 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 + MERCHANTABILITY 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. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. Index: apps/codecs/libsc68/unice68/unice68_native.c =================================================================== --- apps/codecs/libsc68/unice68/unice68_native.c (revision 0) +++ apps/codecs/libsc68/unice68/unice68_native.c (revision 0) @@ -0,0 +1,585 @@ +/* + * unice68 - ice depacker library (native version) + * + * Copyright (C) 2003-2009 Benjamin Gerard + * + * + * This program is free software; 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 2 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 + * MERCHANTABILITY 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; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + * 02111-1307 USA + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifndef PACKAGE_NAME +# define PACKAGE_NAME "unice68" +#endif +#ifndef PACKAGE_VERSION +# define PACKAGE_VERSION __DATE__ +#endif +#ifndef PACKAGE_VERNUM +# define PACKAGE_VERNUM 0 +#endif + +#include "unice68.h" + +#ifdef TYPE_U8 +typedef TYPE_U8 u8 +#else +typedef unsigned char u8; +#endif + +#ifdef TYPE_S8 +typedef TYPE_S8 s8 +#else +typedef signed char s8; +#endif + +#ifdef TYPE_S16 +typedef TYPE_S16 s16 +#else +typedef signed short s16; +#endif + +typedef u8 * areg_t; +typedef int dreg_t; + +typedef struct { + areg_t a0,a1,a2,a3,a4,a5,a6,a7; + dreg_t d0,d1,d2,d3,d4,d5,d6,d7; + areg_t ctop,cbot,dtop,dbot; + int overflow; +} all_regs_t; + +#define ICE_MAGIC 0x49434521 /* 'ICE!' */ + +#define B_CC(CC, LABEL) if (CC) {goto LABEL;} +#define DB_CC(CC, REG, LABEL) if (!(CC) && --REG >= 0) {goto LABEL;} +#define DBF(REG,LABEL) DB_CC(0, REG, LABEL) +#define GET_1_BIT_BCC(LABEL) B_CC(!get_1_bit(R), LABEL) +#define DBF_COUNT(REG) ( ( (REG) & 0xFFFF ) + 1 ) + +static const int direkt_tab[] = { + 0x7fff000e,0x00ff0007,0x00070002,0x00030001,0x00030001, + 270-1, 15-1, 8-1, 5-1, 2-1 +}; + +static const u8 length_tab[] = { + 9,1,0,-1,-1, + 8,4,2,1,0 +}; + +static const s8 more_offset[] = { + 11, 4, 7, 0, + 0x01,0x1f, -1,-1, 0x00,0x1F +}; + +static const int more_offset_word[] = { + 0x0b04,0x0700,0x011f,-1,0x001f +}; + +#if 0 +static void dump_regs(const char * label) +{ + if (label) { + fprintf(stderr, "%s:\n", label); + } +#define DUMP(N) fprintf(stderr,"d%d=%08X a%d=%p\n",N,d##N,N,a##N) + DUMP(0); + DUMP(1); + DUMP(2); + DUMP(3); + DUMP(4); + DUMP(5); + DUMP(6); + DUMP(7); +} +#endif + + +static void strings(all_regs_t *); +static void normal_bytes(all_regs_t *); +static int get_d0_bits(all_regs_t *, int d0); + +static inline int check_drange(all_regs_t *R, const areg_t a, const areg_t b) +{ + if (a < R->dtop || b >= R->dbot) { + R->overflow |= 1; + } + return R->overflow; +} + +static inline int check_crange(all_regs_t *R, const areg_t a, const areg_t b) +{ + if (a < R->ctop || b >= R->cbot) { + R->overflow |= 2; + } + return R->overflow; +} + + +/* getinfo: moveq #3,d1 */ +/* getbytes: lsl.l #8,d0 */ +/* move.b (a0)+,d0 */ +/* dbf d1,getbytes */ +/* rts */ +static inline int getinfo(all_regs_t *R) +{ + const areg_t a0 = R->a0; + const int r0 = (0[a0]<<24) + (1[a0]<<16) + (2[a0]<<8) + 3[a0]; + R->a0 = a0+4; + return r0; +} + +/* get_1_bit: */ +/* add.b d7,d7 */ +/* bne.s bitfound */ +/* move.b -(a5),d7 */ +/* addx.b d7,d7 */ +/* bitfound: */ +/* rts */ + +static inline int get_1_bit(all_regs_t *R) +{ + int r; + + r = (R->d7 & 255) << 1; + B_CC(r & 255, bitfound); + + check_crange(R,R->a5-1,R->a5-1); + + r = (r>>8) + (*(--R->a5) << 1); + bitfound: + R->d7 = (R->d7 & ~0xFF) | (r & 0xFF); + return r >> 8; +} + + +/* ice_decrunch: + * a0 = Pointer to packed data + * a1 = Address to which the data is unpacked + * + * During depacking: + * + * a5 : current packed data pointer (read from bottom to top) + * a6 : current depacked data pointer (written from bottom to top) + * a4 : depack buffer top, used to detect end of depacking. + */ + +static int ice_decrunch(all_regs_t *R) +{ + int id; + int csize; + int dsize; + +/* movem.l d0-a6,-(a7) */ +/* bsr.s getinfo */ +/* cmpi.l #'ICE!',d0 */ +/* bne not_packed */ +/* bsr.s getinfo */ +/* lea.l -8(a0,d0.l),a5 */ +/* bsr.s getinfo */ +/* move.l d0,(a7) */ +/* move.l a1,a4 */ +/* move.l a1,a6 */ +/* adda.l d0,a6 */ +/* move.l a6,a3 */ +/* move.b -(a5),d7 */ +/* bsr normal_bytes */ + + R->ctop = R->a0; + R->dtop = R->a1; + + id = getinfo(R); + if (id != ICE_MAGIC) { + return -1; + } + csize = getinfo(R); + R->cbot = R->a5 = R->a0 - 8 + csize; + R->d0 = dsize = getinfo(R); + R->a6 = R->a4 = R->a1; + R->a6 += R->d0; + R->dbot = R->a3 = R->a6; + + R->d7 = *(--R->a5); + normal_bytes(R); + +/* move.l a3,a6 */ +/* bsr get_1_bit */ +/* bcc.s not_packed */ +/* move.w #$0f9f,d7 */ +/* bsr get_1_bit */ +/* bcc.s ice_00 */ +/* moveq #15,d0 */ +/* bsr get_d0_bits */ +/* move.w d1,d7 */ + + R->a6 = R->a3; + GET_1_BIT_BCC(not_packed); + R->d7 = 0x0f9f; + GET_1_BIT_BCC(ice_00); + R->d7 = R->d1 = get_d0_bits(R, 15); + +/* ice_00: moveq #3,d6 */ +/* ice_01: move.w -(a3),d4 */ +/* moveq #3,d5 */ +/* ice_02: add.w d4,d4 */ +/* addx.w d0,d0 */ +/* add.w d4,d4 */ +/* addx.w d1,d1 */ +/* add.w d4,d4 */ +/* addx.w d2,d2 */ +/* add.w d4,d4 */ +/* addx.w d3,d3 */ +/* dbra d5,ice_02 */ +/* dbra d6,ice_01 */ +/* movem.w d0-d3,(a3) */ +/* dbra d7,ice_00 */ + + ice_00: + R->d6 = 3; + ice_01: + R->a3 -= 2; + R->d4 = (R->a3[0]<<8) | R->a3[1]; + R->d5 = 3; + ice_02: + R->d4 += R->d4; + R->d0 += R->d0 + (R->d4>>16); + R->d4 &= 0xFFFF; + + R->d4 += R->d4; + R->d1 += R->d1 + (R->d4>>16); + R->d4 &= 0xFFFF; + + R->d4 += R->d4; + R->d2 += R->d2 + (R->d4>>16); + R->d4 &= 0xFFFF; + + R->d4 += R->d4; + R->d3 += R->d3 + (R->d4>>16); + R->d4 &= 0xFFFF; + + DBF(R->d5,ice_02); + DBF(R->d6,ice_01); + + if (check_crange(R, R->a3, R->a3+7)) { + goto not_packed; + } + + 0[R->a3] = R->d0 >> 8; + 1[R->a3] = R->d0; + + 2[R->a3] = R->d1 >> 8; + 3[R->a3] = R->d1; + + 4[R->a3] = R->d2 >> 8; + 5[R->a3] = R->d2; + + 6[R->a3] = R->d3 >> 8; + 7[R->a3] = R->d3; + + DBF(R->d7,ice_00); + + not_packed: + return -!!R->overflow; +} + +static void normal_bytes(all_regs_t *R) +{ +/* normal_bytes: */ +/* bsr.s get_1_bit */ +/* bcc.s test_if_end */ +/* moveq.l #0,d1 */ +/* bsr.s get_1_bit */ +/* bcc.s copy_direkt */ +/* lea.l direkt_tab+20(pc),a1 */ +/* moveq.l #4,d3 */ +/* nextgb: move.l -(a1),d0 */ +/* bsr.s get_d0bits */ +/* swap.w d0 */ +/* cmp.w d0,d1 */ +/* dbne d3,nextgb */ +/* no_more: add.l 20(a1),d1 */ +/* copy_direkt: */ +/* move.b -(a5),-(a6) */ +/* dbf d1,copy_direkt */ +/* test_if_end: */ +/* cmpa.l a4,a6 */ +/* bgt.s strings */ +/* rts */ + + + while (1) { + const int * tab; + + GET_1_BIT_BCC(test_if_end); + R->d1 = 0; + GET_1_BIT_BCC(copy_direkt); + + tab = direkt_tab + (20>>2); + R->d3 = 4; + nextgb: + R->d0 = * (--tab); + R->d1 = get_d0_bits(R, R->d0); + R->d0 = (R->d0 >> 16) | ~0xFFFF; + DB_CC((R->d0^R->d1)&0xFFFF, R->d3, nextgb); +/* no_more: */ + R->d1 += tab[(20>>2)]; + + copy_direkt: + { + const int cnt = DBF_COUNT(R->d1); + if (check_drange(R, R->a6-cnt, R->a6-1) | + check_crange(R, R->a5-cnt, R->a5-1)) { + break; + } + } + lp_copy: + *(--R->a6) = *(--R->a5); + DBF(R->d1,lp_copy); + + test_if_end: + if (R->a6 <= R->a4) { + if (R->a6 < R->a4) { + check_drange(R, R->a6, R->a6); + } + break; + } + strings(R); + } +} + + + +/* get_d0_bits: */ +/* moveq.l #0,d1 */ +/* hole_bit_loop: */ +/* add.b d7,d7 */ +/* bne.s on_d0 */ +/* move.b -(a5),d7 */ +/* addx.b d7,d7 */ +/* on_d0: addx.w d1,d1 */ +/* dbf d0,hole_bit_loop */ +/* rts */ + +static int get_d0_bits(all_regs_t *R, int r0) +{ + int r7 = R->d7; + int r1 = 0; + + r0 &= 0xFFFF; + if (r0 > 15) { + R->overflow |= 4; + return 0; + } + + hole_bit_loop: + r7 = (r7 & 255) << 1; + B_CC(r7 & 255, on_d0); + + check_crange(R,R->a5-1,R->a5-1); + + r7 = (*(--R->a5) << 1) + (r7>>8); + on_d0: + r1 += r1 + (r7>>8); + DBF(r0,hole_bit_loop); + R->d7 = (R->d7 &~0xFF) | (r7 & 0xFF); + R->d0 |= 0xFFFF; + return r1; +} + +static void strings(all_regs_t *R) +{ +/* strings: */ +/* lea.l length_tab(pc),a1 */ +/* moveq.l #3,d2 */ +/* get_length_bit: */ +/* bsr.s get_1_bit */ +/* dbcc d2,get_length_bit */ +/* no_length_bit: */ +/* moveq.l #0,d4 */ +/* moveq.l #0,d1 */ +/* move.b 1(a1,d2.w),d0 */ +/* ext.w d0 */ +/* bmi.s no_Ober */ +/* get_Ober: bsr.s get_d0_bits */ +/* no_Ober: move.b 6(a1,d2.w),d4 */ +/* add.w d1,d4 */ +/* beq.s get_offset_2 */ + + R->a1 = (areg_t)length_tab; + R->d2 = 3; + get_length_bit: + DB_CC(get_1_bit(R)==0, R->d2, get_length_bit); +/* no_length_bit: */ + R->d4 = R->d1 = 0; /* $$$ d4 is not needed here. */ + R->d0 = (R->d0 & ~0xFFFF) | (0xFFFF & (s8)R->a1[ 1 + (s16)R->d2 ]); + B_CC(R->d0&0x8000, no_Ober); +/* get_Ober: */ + R->d1 = get_d0_bits(R, R->d0); + R->d0 |= 0xFFFF; + no_Ober: + R->d4 = R->a1 [ 6 + (s16)R->d2 ]; + R->d4 += R->d1; + B_CC(R->d4==0,get_offset_2); + +/* lea.l more_offset(pc),a1 */ +/* moveq.l #1,d2 */ +/* getoffs: bsr.s get_1_bit */ +/* dbcc d2,getoffs */ +/* moveq.l #0,d1 */ +/* move.b 1(a1,d2.w),d0 */ +/* ext.w d0 */ +/* bsr.s get_d0_bits */ +/* add.w d2,d2 */ +/* add.w 6(a1,d2.w),d1 */ +/* bpl.s depack_bytes */ +/* sub.w d4,d1 */ +/* bra.s depack_bytes */ + + R->a1 = (areg_t)more_offset; + R->d2 = 1; + getoffs: + DB_CC(get_1_bit(R)==0,R->d2,getoffs); + + R->d1 = get_d0_bits(R,(int)(s8)more_offset[1+(s16)R->d2]); + R->d0 |= 0xFFFF; + R->d1 += more_offset_word[3+(s16)R->d2]; + if (R->d1 < 0) { + R->d1 -= R->d4; + } + goto depack_bytes; + + + /* get_offset_2: */ + /* moveq.l #0,d1 */ + /* moveq.l #5,d0 */ + /* moveq.l #-1,d2 */ + /* bsr.s get_1_bit */ + /* bcc.s less_40 */ + /* moveq.l #8,d0 */ + /* moveq.l #$3f,d2 */ + /* less_40: bsr.s get_d0_bits */ + /* add.w d2,d1 */ + + get_offset_2: + R->d1 = 0; + R->d0 = 5; + R->d2 = -1; + GET_1_BIT_BCC(less_40); + R->d0 = 8; + R->d2 = 0x3f; + less_40: + R->d1 = get_d0_bits(R, R->d0); + R->d0 |= 0xFFFF; + R->d1 += R->d2; + + /* depack_bytes: */ + /* lea.l 2(a6,d4.w),a1 */ + /* adda.w d1,a1 */ + /* move.b -(a1),-(a6) */ + /* dep_b: move.b -(a1),-(a6) */ + /* dbf d4,dep_b */ + /* bra normal_bytes */ + + depack_bytes: + R->a1 = R->a6 + 2 + (s16)R->d4 + (s16)R->d1; + check_drange(R, R->a6 - DBF_COUNT(R->d4) - 1, R->a6-1); + if (R->a6>R->a4) *(--R->a6) = *(--R->a1); + dep_b: + if (R->a6>R->a4) *(--R->a6) = *(--R->a1); + DBF(R->d4,dep_b); +} + +int unice68_get_depacked_size(const void * buffer, int * p_csize) +{ + return unice68_depacked_size(buffer,p_csize); +} + +int unice68_depacked_size(const void * buffer, int * p_csize) +{ + int id, csize, dsize; + int csize_verif = p_csize ? *p_csize : 0; + all_regs_t allregs; + + if (csize_verif && csize_verif<12) { + return -1; + } + + allregs.a0 = (areg_t)buffer; + id = getinfo(&allregs); + if (id != ICE_MAGIC) { + return -1; + } + csize = getinfo(&allregs); + if (csize < 12) { + return -2; + } + csize -= 12; + dsize = getinfo(&allregs); + if (p_csize) { + *p_csize = csize; + } + if (csize_verif && (csize != csize_verif)) { + dsize = ~dsize; + } + return dsize; +} + +int unice68_depacker(void * dest, const void * src) +{ + all_regs_t allregs; + + allregs.d0 = + allregs.d1 = + allregs.d2 = + allregs.d3 = + allregs.d4 = + allregs.d5 = + allregs.d6 = + allregs.d7 = 0; + + allregs.a2 = + allregs.a3 = + allregs.a4 = + allregs.a5 = + allregs.a6 = + allregs.a7 = 0; + + allregs.a0 = (areg_t)src; + allregs.a1 = dest; + allregs.overflow = 0; + + return ice_decrunch(&allregs); +} + +int unice68_ice_version(void) +{ + return 240; +} + +const char * unice68_versionstr(void) +{ + return PACKAGE_NAME " " PACKAGE_VERSION " ICE! 2.40" ; +} + +int unice68_version(void) +{ + return PACKAGE_VERNUM; +} Index: apps/codecs/libsc68/unice68/unice68_doc.h =================================================================== --- apps/codecs/libsc68/unice68/unice68_doc.h (revision 0) +++ apps/codecs/libsc68/unice68/unice68_doc.h (revision 0) @@ -0,0 +1,56 @@ +/* This file exists for documentation purpose only. */ +/** +@defgroup unice68_prg unice68 program +@ingroup usertools68 + +Ice depacker based on 68000 ICE 2.40 original. + + +@section unice68_author AUTHOR + + Written by Benjamin Gerard + + +@section unice68_licence LICENCE + + Copyright (C) 2001-2009 Benjamin Gerard + + This program is free software: 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 + MERCHANTABILITY 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. + + If not, see . + + +@section unice68_synopsis SYNOPSIS + + unice68 [OPTION] [--] [ [\] \ ] + + +@section unice68_options OPTIONS + + @arg @b -h --help Print help message and exit. + @arg @b -V --version Print version and copyright and exit. + @arg @b -v --verbose Be verbose (cumulative). + @arg @b -q --quiet Keep quiet (cumulative). + + +@section unice68_bugs BUGS + + Report bugs to + + +@section unice68_seealso SEE ALSO + + @see info68_prg, sc68_prg + +*/ Index: apps/codecs/libsc68/mixer68.c =================================================================== --- apps/codecs/libsc68/mixer68.c (revision 0) +++ apps/codecs/libsc68/mixer68.c (revision 0) @@ -0,0 +1,327 @@ +/* + * sc68 - audio mixer + * Copyright (C) 2001-2009 Ben(jamin) Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include "mixer68.h" + +/* ARM compliant version */ +/* #define SWAP_16BITWORD(V) ((V^=V<<16), (V^=V>>16), (V^=V<<16)) */ + +#define SWAP_16BITWORD(V) (((u32)(V)>>16)+(V<<16)) + +/* Mix 16-bit-stereo PCM into 16-bit-stereo with sign change. + * + * PCM' = PCM ^ sign + * + * sign=0 : Keep input sign, + * sign=0x00008000 : Change left channel sign + * sign=0x80000000 : Change right channel sign + * sign=0x80008000 : Change both channel + */ +void mixer68_stereo_16_LR(u32 * dst, u32 * src, int nb, const u32 sign) +{ + u32 *end; + + /* Optimize trivial case : same buffer, no sign change */ + if (!sign && dst == src) { + return; + } + + end = dst+nb; + if (nb&1) { + *dst++ = (*src++) ^ sign; + } + if (nb&2) { + *dst++ = (*src++) ^ sign; + *dst++ = (*src++) ^ sign; + } + if (dst>16); + } while (dst < end); + } +} + +/* Duplicate left channel into right channel and change sign. + * PCM' = ( PCM-L | (PCM-L<<16) ) ^ sign + */ +void mixer68_dup_L_to_R(u32 *dst, u32 *src, int nb, + const u32 sign) +{ + u32 * const end = dst+nb; + if (nb&1) { + u32 v; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + } + if (nb&2) { + u32 v; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + } + if (dst < end) { + do { + u32 v; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + v = (u16)*src++; *dst++ = ((v<<16)|v) ^ sign; + } while (dst < end); + } + +} + +/* Duplicate right channel into left channel and change sign. + * PCM = ( PCM-R | (PCM-R>>16) ) ^ sign + */ +void mixer68_dup_R_to_L(u32 *dst, u32 *src, int nb, const u32 sign) +{ + u32 * const end = dst+nb; + + if (nb&1) { + u32 v; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + } + if (nb&2) { + u32 v; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + } + if (dst < end) { + do { + u32 v; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + v = *src++&0xFFFF0000; *dst++ = ((v>>16)|v) ^ sign; + } while (dst < end); + } + +} + +/* Blend Left and right voice : + * factor [0..65536], 0:blend nothing, 65536:swap L/R + */ +void mixer68_blend_LR(u32 * dst, u32 * src, int nb, + int factor, + const u32 sign_r, const u32 sign_w) +{ + u32 *end; + int oof; + + if (factor < 0) { + factor = 0; + } else if (factor > 65536) { + factor = 65536; + } + +#undef MIX_ONE +#define MIX_ONE \ + r = (int)(s32)(*src++ ^ sign_r); \ + l = r >> 16; \ + r = (int)(s16)r; \ + *dst++ = ( \ + ((l*oof+r*factor)&0xFFFF0000) \ + | \ + ((u32)(r*oof+l*factor) >> 16) \ + ) ^ sign_w + + oof = 65536-factor; + end = dst+nb; + if (nb&1) { + int l,r; + MIX_ONE; + } + if (nb&2) { + int l,r; + MIX_ONE; + MIX_ONE; + } + if (dst < end) { + do { + int l,r; + + MIX_ONE; + MIX_ONE; + MIX_ONE; + MIX_ONE; + } while (dst < end); + } + +} + +/* Multiply left/right (signed) channel by ml/mr factor [-65536..65536] + */ +void mixer68_mult_LR(u32 *dst, u32 *src, int nb, + const int ml, const int mr, + const u32 sign_r, const u32 sign_w) +{ + u32 * end; + + /* Optimize some trivial case. */ + + if (ml == 65536 && mr == 65536) { + mixer68_stereo_16_LR(dst, src, nb, sign_r ^ sign_w); + return; + } + + if (ml==0 && mr==0) { + mixer68_fill(dst, nb, sign_w); + return; + } + +#undef MIX_ONE +#define MIX_ONE \ + r = (int)(s32)(*src++ ^ sign_r); \ + l = (int)(s16)r; \ + r = r >> 16; \ + *dst++ = ((((u32)(l*ml))>>16) | ((r*mr)&0xFFFF0000)) ^ sign_w + + end = dst+nb; + + if (nb&1) { + int l,r; + MIX_ONE; + } + + if (nb&2) { + int l,r; + MIX_ONE; + MIX_ONE; + } + + if (dst < end) { + do { + int l,r; + MIX_ONE; + MIX_ONE; + MIX_ONE; + MIX_ONE; + } while (dst < end); + } + +} + +/* Fill buffer sign with value (RRRRLLLL) + */ +void mixer68_fill(u32 * dst, int nb, const u32 sign) +{ + u32 * const end = dst+nb;; + + if (nb&1) { + *dst++ = sign; + } + if (nb&2) { + *dst++ = sign; + *dst++ = sign; + } + if (dst < end) { + do { + *dst++ = sign; + *dst++ = sign; + *dst++ = sign; + *dst++ = sign; + } while (dst < end); + } +} + +void mixer68_copy(u32 * dst, u32 * src, int nb) +{ + + /* Optimize trivial case : same buffer */ + if (dst == src || nb<=0) { + return; + } else { + u32 * const end = dst+nb; + if (nb&1) { + *dst++ = *src++; + } + if (nb&2) { + *dst++ = *src++; + *dst++ = *src++; + } + if (dst + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef HAVE_IO68_CONFIG_OPTION68_H +# include "io68/config_option68.h" +#else +# include "io68/default_option68.h" +#endif + +#include "conf68.h" + +/* file68 headers */ +#include "file68/error68.h" +#include "file68/file68.h" +#include "file68/url68.h" +#include "file68/string68.h" +#include "file68/msg68.h" +#include "file68/alloc68.h" +#include "file68/option68.h" + +/* standard headers */ +#include +#include +#include + +#ifndef DEBUG_CONFIG68_O +# define DEBUG_CONFIG68_O 0 +#endif +static int config68_cat = msg68_DEFAULT; + +typedef union { + int i; /**< Used with CONFIG68_INT fields. */ + const char * s; /**< Used with CONFIG68_STR fields. */ +} config68_value_t; + +typedef struct _config68_field_s config68_field_t; + +typedef struct +{ + int exported; /**< exported as cli option. */ + const char *name; /**< name of the entry. */ + config68_type_t type; /**< Type of this config entry. */ + const char *comment; /**< Comment. */ + config68_value_t min; /**< Minimum value allowed. */ + config68_value_t max; /**< Maximum value allowed. */ + config68_value_t def; /**< Default value the entry. */ + config68_value_t val; /**< Value for the entry. */ +} config68_entry_t; + +struct _config68_s { + int saved; /**< True if config has been saved. */ + int size; /**< Number of entries allocated. */ + int n; /**< Number of entries in used. */ + + /** Config entry table. + * @warning Must be at the end of the struct. + */ + config68_entry_t entries[1]; +}; + + +/* Defines for the config default values. */ +#define AMIGA_BLEND 0x5000 /* Amiga default blending factor. */ +#define DEFAULT_TIME (3*60) /* Track default time in second. */ +#define FORCE_TRACK 1 /* 0:no forced track */ +#define SKIP_TIME 4 /* Skip music time in sec. */ +#define MAX_TIME (24*60*60) /* 1 day should be enought. */ +#define DEFAULT_SEEKSPD 0x0F00 /* << 8 */ +#define MAX_SEEKSPD 0x1F00 + +static const config68_entry_t conftab[] = { + { 0, + "version", CONFIG68_INT, + "major*100+minor", + {0}, {10000}, {PACKAGE_VERNUM}, {PACKAGE_VERNUM} + }, + { 0, /* controled by application */ + "sampling-rate", CONFIG68_INT, + "sampling rate in Hz", + {SAMPLING_RATE_MIN},{SAMPLING_RATE_MAX},{SAMPLING_RATE_DEF},{SAMPLING_RATE_DEF} + }, + { 1, + "amiga-blend", CONFIG68_INT, + "Amiga left/right voices blending factor {32768:center}", + {0}, {65535}, {AMIGA_BLEND}, {AMIGA_BLEND} + }, + + { 0, /* could be export but is it useful */ + "force-track", CONFIG68_INT, + "override default track {0:off}", + {0}, {99}, {FORCE_TRACK}, {FORCE_TRACK} + }, + { 0, /* could be export but is it useful */ + "force-loop", CONFIG68_INT, + "override default loop {-1:off 0:inf}", + {-1}, {100}, {-1}, {-1} + }, + { 1, + "skip-time", CONFIG68_INT, + "prevent short track from being played (in sec) {0:off}", + {0}, {MAX_TIME}, {SKIP_TIME}, {SKIP_TIME} + }, + { 1, + "default-time", CONFIG68_INT, + "default track time (in second)", + {0}, {MAX_TIME}, {DEFAULT_TIME}, {DEFAULT_TIME} + }, + { 0, /* could be export but is it useful */ + "seek-speed", CONFIG68_INT, + "seek speed factor {0:OFF 256:1 512:2 ...}", + {0}, {MAX_SEEKSPD}, {DEFAULT_SEEKSPD}, {DEFAULT_SEEKSPD} + }, + { 0, + "total-time", CONFIG68_INT, + "total playing time since first launch", + {0}, {0}, {0}, {0} + }, + { 0, + "total-ms", CONFIG68_INT, + "total-time adjustment", + {0}, {999}, {0}, {0} + }, + { 0, /* already exported by file68 */ + "music-path", CONFIG68_STR, + "local sc68 music path", + {0}, {0}, {0}, {0} + }, + { 0, /* currently unsupported */ + "allow-remote", CONFIG68_INT, + "enable remote access (using curl) (disable is not upported)", + {0}, {1}, {1}, {1} + }, + { 0, /* already exported by file68 */ + "remote-music-path", CONFIG68_STR, + "remote sc68 music path", + {0}, {0}, {0}, {0} + } +}; + +static const int nconfig = sizeof(conftab) / sizeof(conftab[0]); + +static const char config_header[] = + "# -*- conf-mode -*-\n" + "#\n" + "# sc68 config file generated by " PACKAGE_STRING "\n" + "#\n" + "# " PACKAGE_URL "\n" + "#\n" + "# You can edit this file. If you remove it, sc68 will generate\n" + "# a new one at start-up with default values, but you will lost your\n" + "# total playing time. To avoid it, you should either save its value\n" + "# or delete all lines you want to be resetted.\n" + "# - *int* : integer values; \"C\" number format (e.g.0xFE0120).\n" + "# - *str* : String values; quoted with (\"); must not contain (\").\n" + "#\n"; + +static int is_symbol_char(int c) +{ + return + (c>='0' && c<='9') + || (c>='a' && c<='z') + || (c>='A' && c<='Z') + || c=='_' + || c=='.'; +} + +static int digit(int c, unsigned int base) +{ + int n = -1; + if (c <= '9') { + n = c - '0'; + } else if (c <= 'Z') { + n = c - 'A' + 10; + } else if (c <= 'z'){ + n = c - 'a' + 10; + } + if ((unsigned int)n < base) { + return n; + } + return -1; +} + +#ifdef HAVE_STRTOL +# define mystrtoul strtol +#else + +/** $$$ Need this function for dcplaya version. */ +long mystrtoul(const char * s, + char * * end, + unsigned int base) +{ + const char * start = s; + unsigned long v = 0; + int neg = 0, c; + + /* Skip starting spaces. */ + for (c = *s; (c == ' ' || c == 9 || c == 10 || c == 13); c = *++s) + ; + + /* Get optionnal sign. */ + /* $$$ ben : Does not make sens with unsigned value ! */ + if (c == '-' || c == '+') { + neg = (c == '-'); + c = *++s; + } + + /* Get the base. */ + if (!base) { + /* Assume default base is 10 */ + base = 10; + + /* Could be either octal(8) or hexidecimal(16) */ + if (c == '0') { + base = 8; + c = *++s; + if (c == 'x' || c == 'X') { + base = 16; + c = *++s; + } + } + } else if (base == 16 && c == '0') { + /* Hexa mode must skip "0x" sequence */ + c = *++s; + if (c == 'x' || c == 'X') { + c = *++s; + } + } + + c = digit(c,base); + if (c < 0) { + s = start; + } else { + do { + v = v * base + c; + c = digit(*++s,base); + } while (c >= 0); + } + + if (end) { + *end = (char *)s; + } + + return neg ? -(signed long)v : (signed long)v; +} + +#endif + +static int config_set_int(config68_t * conf, config68_entry_t *e, int v) +{ + int m,M; + + if (e->type != CONFIG68_INT) { + TRACE68(config68_cat, + "conf: set int name='%s' bad type (%d)\n", e->name, e->type); + return -1; + } + m = e->min.i; + M = e->max.i; + + /* TRACE68(config68_cat, */ + /* "conf: set int name='%s' [%d..%d] cur:%d req:%d \n", */ + /* e->name, m, M, e->val.i, v); */ + + if (m != M) { + if (m==0 && M == 1) { + v = !!v; + } else if (v < m) { + v = m; + } else if (v > M) { + v = M; + } + } + + if (v != e->val.i) { + conf->saved = 0; + e->val.i = v; + TRACE68(config68_cat, + "conf: set int name='%s' [%d..%d] new:%d\n", + e->name, m, M, e->val.i); + } + return 0; +} + +static int config_set_str(config68_t * conf, config68_entry_t *e, + const char * s) +{ + int err = 0; + int m,M; + + if (e->type != CONFIG68_STR) { + return -1; + } + + m = e->min.i; + M = e->max.i; + if (m != M) { + int v = s ? strlen(s) : 0; + if (v < m || v > M) { + s = 0; + err = -1; + } + } + + if (!s) { + if (e->val.s) { + free68((void*)e->val.s); + e->val.s = 0; + conf->saved = 0; + } + } else if (!e->val.s || strcmp(s,e->val.s)) { + free68((void*)e->val.s); + e->val.s = strdup68(s); + err = -!e->val.s; + conf->saved = 0; + } + + return err; +} + + +/* Check config values and correct invalid ones + */ +int config68_valid(config68_t * conf) +{ + int err = 0; + int i; + + if (!conf) { + return -1; + } + + for (i=0; i < conf->n; i++) { + config68_entry_t *e = conf->entries+i; + switch (e->type) { + case CONFIG68_INT: + err |= config_set_int(conf, e, e->val.i); + break; + case CONFIG68_STR: + err |= config_set_str(conf, e, e->val.s); + break; + default: + err = -1; + } + } + + return -!!err; +} + +static int keycmp(const char * k1, const char * k2) +{ + int c1,c2; + + if (k1 == k2) return 0; + if (!k1) return -1; + if (!k2) return 1; + do { + c1 = *k1++; if (c1 == '_') c1 = '-'; + c2 = *k2++; if (c2 == '_') c2 = '-'; + } while (c1 == c2 && c1); + return c1 - c2; +} + + +int config68_get_idx(const config68_t * conf, const char * name) +{ + if (!conf) { + return -1; + } + if (name) { + int i; + for (i=0; in; i++) { + if (!keycmp(name, conf->entries[i].name)) { + return i; + } + } + } + return -1; +} + +config68_type_t config68_range(const config68_t * conf, int idx, + int * min, int * max, int * def) +{ + config68_type_t type = CONFIG68_ERR; + int vmin = 0 , vmax = 0, vdef = 0; + + if (conf && idx >= 0 && idx < conf->n) { + type = conf->entries[idx].type; + vmin = conf->entries[idx].min.i; + vmax = conf->entries[idx].max.i; + vdef = conf->entries[idx].def.i; + } + if (min) *min = vmin; + if (max) *max = vmax; + if (def) *def = vdef; + return type; +} + +config68_type_t config68_get(const config68_t * conf, + int * v, + const char ** name) +{ + int idx; + config68_type_t type = CONFIG68_ERR; + + if (conf) { + idx = v ? *v : -1; + if (idx == -1 && name) { + idx = config68_get_idx(conf, *name); + } + if (idx >= 0 && idx < conf->n) { + switch (type = conf->entries[idx].type) { + case CONFIG68_INT: + if (v) *v = conf->entries[idx].val.i; + break; + + case CONFIG68_STR: + if (name) *name = conf->entries[idx].val.s + ? conf->entries[idx].val.s + : conf->entries[idx].def.s; + break; + + default: + type = CONFIG68_ERR; + break; + } + } + } + return type; +} + +config68_type_t config68_set(config68_t * conf, int idx, const char * name, + int v, const char * s) +{ + config68_type_t type = CONFIG68_ERR; + if (conf) { + if (name) { + idx = config68_get_idx(conf, name); + } + if (idx >= 0 && idx < conf->n) { + switch (type = conf->entries[idx].type) { + case CONFIG68_INT: + config_set_int(conf, conf->entries+idx, v); + break; + + case CONFIG68_STR: + if (!config_set_str(conf, conf->entries+idx, s)) { + break; + } + default: + type = CONFIG68_ERR; + break; + } + } + } + return type; +} + +static int save_config_entry(istream68_t * os, const config68_entry_t * e) +{ + int i,err = 0; + char tmp[64]; + +#ifndef _FILE68_NO_SAVE_FUNCTION_ + err |= istream68_puts(os, "\n# ") < 0; + err |= istream68_puts(os, e->comment) < 0; + + switch (e->type) { + case CONFIG68_INT: + snprintf(tmp, 64, "; *int* [%d..%d]", e->min.i, e->max.i); + err |= istream68_puts(os, tmp) < 0; + snprintf(tmp, 64, " (%d)\n", e->def.i); + err |= istream68_puts(os, tmp) < 0; + break; + + case CONFIG68_STR: + err |= istream68_puts(os, "; *str* (\"") < 0; + err |= istream68_puts(os, e->def.s) < 0; + err |= istream68_puts(os, "\")\n") < 0; + break; + + default: + istream68_puts(os, e->name); + istream68_puts(os, ": invalid type\n"); + return -1; + } + + /* transform name */ + for (i=0; e->name[i]; ++i) { + int c = e->name[i]; + tmp[i] = (c == '-') ? '_' : c; + } + tmp[i] = 0; + + switch (e->type) { + case CONFIG68_INT: + err |= istream68_puts(os, tmp) < 0; + err |= istream68_putc(os, '=') < 0; + snprintf(tmp, 64, "%d", e->val.i); + err |= istream68_puts(os, tmp) < 0; + TRACE68(config68_cat,"conf: save name='%s'=%d\n",e->name,e->val.i); + break; + + case CONFIG68_STR: { + const char * s = e->val.s ? e->val.s : e->def.s; + if (!s) { + err |= istream68_putc(os, '#') < 0; + } + err |= istream68_puts(os, tmp) < 0; + err |= istream68_putc(os, '=') < 0; + err |= istream68_putc(os, '"') < 0; + err |= istream68_puts(os, s) < 0; + err |= istream68_putc(os, '"') < 0; + TRACE68(config68_cat,"conf: save name='%s'=\"%s\"\n",e->name,s); + } break; + + default: + break; + } + err |= istream68_putc(os, '\n') < 0; +#endif + return err; +} + +int config68_save(config68_t * conf) +{ +#if defined(ROCKBOX) + return 0; +#endif + int i,err; + istream68_t * os=0; + const int sizeof_config_hd = sizeof(config_header)-1; /* Remove '\0' */ + + TRACE68(config68_cat,"conf: saving ...\n", conf); + + if (!conf) { + err = error68(0,"conf: null pointer"); + goto error; + } + os = url68_stream_create("RSC68://config", 2); + err = istream68_open(os); + if (!err) { + TRACE68(config68_cat,"conf: save into \"%s\"\n", + istream68_filename(os)); + err = + - (istream68_write(os, config_header, sizeof_config_hd) + != sizeof_config_hd); + } + for (i=0; !err && i < conf->n; ++i) { + err = save_config_entry(os, conf->entries+i); + } + + error: + istream68_close(os); + istream68_destroy(os); + + TRACE68(config68_cat, "config68_save => [%s]\n",strok68(err)); + return err; +} + + +/* Load config from file + */ +int config68_load(config68_t * conf) +{ + istream68_t * is = 0; + char s[1024], * word; + int err; + config68_type_t type; + + TRACE68(config68_cat, "conf: loading ...\n",conf); + + err = config68_default(conf); + if (err) { + goto error; + } + + is = url68_stream_create("RSC68://config", 1); + err = istream68_open(is); + if (err) { + goto error; + } + TRACE68(config68_cat, "conf: filename='%s'\n", + istream68_filename(is)); + + for(;;) { + char * name; + int i, len, c = 0, idx; + + len = istream68_gets(is, s, sizeof(s)); + if (len == -1) { + err = -1; + break; + } + if (len == 0) { + break; + } + + i = 0; + + /* Skip space */ + while (i < len && (c=s[i++], (c == ' ' || c == 9))) + ; + + if (!is_symbol_char(c)) { + continue; + } + + /* Get symbol name. */ + name = s+i-1; + while (i < len && is_symbol_char(c = s[i++])) + if (c == '_') s[i-1] = c = '-'; + s[i-1] = 0; + + /* TRACE68(config68_cat,"conf: load get key name='%s\n", name); */ + + /* Skip space */ + while (i < len && (c == ' ' || c == 9)) { + c=s[i++]; + } + + /* Must have '=' */ + if (c != '=') { + continue; + } + c=s[i++]; + /* Skip space */ + while (i < len && (c == ' ' || c == 9)) { + c=s[i++]; + } + + if (c == '"') { + type = CONFIG68_STR; + word = s + i; + /* TRACE68(config68_cat, */ + /* "conf: load name='%s' looks like a string(%d)\n", */ + /* name, type); */ + } else if (c == '-' || digit(c, 10) != -1) { + type = CONFIG68_INT; + word = s + i - 1; + /* TRACE68(config68_cat, */ + /* "conf: load name='%s' looks like an int(%d)\n", name, type); */ + } else { + TRACE68(config68_cat, + "conf: load name='%s' looks like nothing valid\n", name); + continue; + } + /* TRACE68(config68_cat, */ + /* "conf: load name='%s' not parsed value='%s'\n", name, word); */ + + idx = config68_get_idx(conf, name); + if (idx < 0) { + /* Create this config entry */ + TRACE68(config68_cat, "conf: load name='%s' unknown\n", name); + continue; + } + if (conf->entries[idx].type != type) { + TRACE68(config68_cat, "conf: load name='%s' types differ\n", name); + continue; + } + + switch (type) { + case CONFIG68_INT: + config_set_int(conf, conf->entries+idx, mystrtoul(word, 0, 0)); + TRACE68(config68_cat, "conf: load name='%s'=%d\n", + conf->entries[idx].name, conf->entries[idx].val.i); + break; + case CONFIG68_STR: + while (i < len && (c=s[i++], c && c != '"')) + ; + s[i-1] = 0; + config_set_str(conf, conf->entries+idx, word); + TRACE68(config68_cat, "conf: load name='%s'=\"%s\"\n", + conf->entries[idx].name, conf->entries[idx].val.s); + default: + break; + } + } + if (!err) { + err = config68_valid(conf); + } + + error: + istream68_destroy(is); + TRACE68(config68_cat, "conf: loaded => [%s]\n",strok68(err)); + return err; +} + +/* Fill config struct with default values. + */ +int config68_default(config68_t * conf) +{ + int i; + + if(!conf) { + return -1; + } + for (i=0; i < conf->n; i++) { + config68_entry_t * e = conf->entries+i; + switch (e->type) { + case CONFIG68_INT: + e->val.i = e->def.i; + break; + case CONFIG68_STR: + free68((void*)e->val.s); + e->val.s = 0; + default: + break; + } + } + conf->saved = 0; + return config68_valid(conf); +} + +config68_t * config68_create(int size) +{ + config68_t * c; + int i,j; + + TRACE68(config68_cat, "config68: create size=%d\n",size); + + if (size < nconfig) { + size = nconfig; + } + c = (config68_t*) alloc68(sizeof(*c)-sizeof(c->entries)+sizeof(*c->entries)*size); + if (c) { + c->size = size; + c->saved = 0; + for (j=i=0; ientries[j] = conftab[i]; + switch(c->entries[j].type) { + case CONFIG68_INT: + config_set_int(c, c->entries+j, c->entries[j].def.i); + ++j; + break; + + case CONFIG68_STR: + c->entries[j].val.s = 0; + c->entries[j].def.s = 0; + config_set_str(c, c->entries+j, 0); + ++j; + break; + + default: + break; + } + } + c->n = j; + } + TRACE68(config68_cat, "config68: create => [%s]\n",strok68(!c)); + + return c; +} + +void config68_destroy(config68_t * c) +{ + TRACE68(config68_cat, "config68: destroy [%p]\n",c); + if (c) { + int i; + + for (i=0; in; ++i) { + if (c->entries[i].type == CONFIG68_STR) { + free68((void*)c->entries[i].val.s); + } + } + free68(c); + } +} + +option68_t * config68_options; +int config68_option_count; + +int config68_init(void) +{ + if (config68_cat == msg68_DEFAULT) { + int f = msg68_cat("conf","config file", DEBUG_CONFIG68_O); + if (f > 0) config68_cat = f; + } + + if (!config68_options) { + int i,n; + option68_t * options = 0; + + /* count exported config key. */ + for (i=n=0; i 0) { + options = (option68_t*) alloc68(n*sizeof(*options)); + if (!options) { + msg68_error("conf: alloc error\n"); + } else { + int j; + for (i=j=0; i> s + */ +int68_t lsr68(emu68_t * const emu68, uint68_t d, int s, const int l); + +EMU68_EXTERN +/** Arithmetic Shift Left. + * + * The asl68() function performs arithmetic (signed) shift left and + * updates SR flags accordingly + * + * @param emu68 68k emulator instance + * @param d normalized destination operand + * @param s source operand (shift count) + * @param l word length in bit minus one (7, 15 or 31) + * @return normalized result + * @retval d << s + * + */ +int68_t asl68(emu68_t * const emu68, int68_t d, int s, const int l); + +EMU68_EXTERN +/** Arithmetic Shift Right. + * + * The asr68() function performs arithmetic (signed) shift right and + * updates SR flags accordingly + * + * @param emu68 68k emulator instance + * @param d normalized destination operand + * @param s source operand (shift count) + * @param l word length in bit minus one (7, 15 or 31) + * @return normalized result + * @retval d >> s + */ +int68_t asr68(emu68_t * const emu68, int68_t d, int s, const int l); + +EMU68_EXTERN +/** ROtation Left. + * + * The rol68() function performs bit rotation to the left and updates + * SR flags accordingly + * + * @param emu68 68k emulator instance + * @param d normalized destination operand + * @param s source operand (shift count) + * @param l word length in bit minus one (7, 15 or 31) + * @return normalized result + */ +int68_t rol68(emu68_t * const emu68, uint68_t d, int s, const int l); + +EMU68_EXTERN +/** ROtation Right. + * + * The ror68() function performs bit rotation to the right and + * updates SR flags accordingly + * + * @param emu68 68k emulator instance + * @param d normalized destination operand + * @param s source operand (shift count) + * @param l word length in bit minus one (7, 15 or 31) + * @return normalized result + */ +int68_t ror68(emu68_t * const emu68, uint68_t d, int s, const int l); + +EMU68_EXTERN +/** ROtation eXtended Left. + * + * The roxl68() function performs extended bit rotation to the left + * and updates SR flags accordingly + * + * @param emu68 68k emulator instance + * @param d normalized destination operand + * @param s source operand (shift count) + * @param l word length in bit minus one (7, 15 or 31) + * @return normalized result + */ +int68_t roxl68(emu68_t * const emu68, uint68_t d, int s, const int l); + +EMU68_EXTERN +/** ROtation eXtended Right. + * + * The roxr68() function performs extended bit rotation to the right + * and updates SR flags accordingly + * + * @param emu68 68k emulator instance + * @param d normalized destination operand + * @param s source operand (shift count) + * @param l word length in bit minus one (7, 15 or 31) + * @return normalized result + */ +int68_t roxr68(emu68_t * const emu68, uint68_t d, int s, const int l); + +/** @} */ + + +/** @name Binary Coded Decimal (BCD) instructions + * + * Three instructions support operations on binary-coded decimal + * (BCD) numbers. The arithmetic operations on packed BCD numbers are + * ABCD, SBCD, and NBCD. + * + * @{ + */ + +EMU68_EXTERN +/** Negate Binary Coded Decimal with extend. + * + * The nbcd68() function performs BCD negating with extend and + * updates SR flags accordingly + * + * @param emu68 68k emulator instance. + * @param d destination operand + * @return result + * @retval 0 - d,10 - X + */ +int68_t nbcd68(emu68_t * const emu68, int68_t d); + +EMU68_EXTERN +/** Addition Binary Coded Decimal with extend. + * + * The abcd68() function performs BCD addition with extend and + * updates SR flags accordingly + * + * @param emu68 68k emulator instance. + * @param d destination operand + * @return result + * @retval s,10 + d,10 + X + */ +int68_t abcd68(emu68_t * const emu68, int68_t s, int68_t d); + +EMU68_EXTERN +/** Substract Binary Coded Decimal with extend. + * + * The sbcd68() function performs BCD substraction with extend and + * updates SR flags accordingly + * + * @param emu68 68k emulator instance. + * @param d destination operand + * @return result + * @retval d,10 - s,10 - X + */ +int68_t sbcd68(emu68_t * const emu68, int68_t s, int68_t d); + +/** @} */ + + +/** @name Exception functions + * @{ + */ + +EMU68_EXTERN +void buserror68(emu68_t * const emu68, const int addr, const int mode); + +EMU68_EXTERN +void exception68(emu68_t * const emu68, const int vector, const int level); + +EMU68_EXTERN +void linea68(emu68_t * const emu68); + +EMU68_EXTERN +void linef68(emu68_t * const emu68); + +/** @} */ + + +/** @name System Control Instructions + * + * Privileged and trapping instructions as well as instructions that + * use or modify the CCR provide system control operations. FSAVE and + * FRESTORE save and restore the nonuser visible portion of the FPU + * during context switches in a virtual memory or multitasking + * system. The conditional trap instructions, which use the same + * conditional tests as their corresponding program control + * instructions, allow an optional 16- or 32-bit immediate operand to + * be included as part of the instruction for passing parameters to + * the operating system. These instructions cause the processor to + * flush the instruction pipe. Table 3-10 summarizes these + * instructions. See 3.2 Integer Unit Condition Code Computation for + * more details on condition codes. + * + * @{ + */ + +EMU68_EXTERN +void chk68(emu68_t * const emu68, const int68_t a, const int68_t b); + +EMU68_EXTERN +void illegal68(emu68_t * const emu68); + +EMU68_EXTERN +void linea68(emu68_t * const emu68); + +EMU68_EXTERN +void linef68(emu68_t * const emu68); + +EMU68_EXTERN +void trap68(emu68_t * const emu68, const int n); + +EMU68_EXTERN +void trapv68(emu68_t * const emu68); + +EMU68_EXTERN +void andtosr68(emu68_t * const emu68, int68_t v); + +EMU68_EXTERN +void orrtosr68(emu68_t * const emu68, int68_t v); + +EMU68_EXTERN +void eortosr68(emu68_t * const emu68, int68_t v); + +EMU68_EXTERN +void reset68(emu68_t * const emu68); + +EMU68_EXTERN +void stop68(emu68_t * const emu68); + +/** @} */ + + +/** + * @} + */ + +#endif /* #ifndef _EMU68_INST68_H_ */ Index: apps/codecs/libsc68/emu68/getea68.c =================================================================== --- apps/codecs/libsc68/emu68/getea68.c (revision 0) +++ apps/codecs/libsc68/emu68/getea68.c (revision 0) @@ -0,0 +1,221 @@ +/* + * emu68 - get 68000 addressing mode effective address + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "error68_.h" +#include "assert68.h" +#include "mem68.h" + +static addr68_t ea_error(emu68_t * const emu68, const int reg) +{ + assert(EMU68_BREAK); + return 0; +} + +/* (AN) */ +static addr68_t ea_inAN(emu68_t * const emu68, const int reg) +{ + return (s32) REG68.a[reg]; +} + +/* (AN)+ */ +static addr68_t ea_inANpb(emu68_t * const emu68, const int reg) +{ + addr68_t addr = (s32) REG68.a[reg]; + REG68.a[reg] = (u32) ( REG68.a[reg] + 1 + (reg==7) ); + return addr; +} + +static addr68_t ea_inANpw(emu68_t * const emu68, const int reg) +{ + addr68_t addr = (s32) REG68.a[reg]; + REG68.a[reg] = (u32) ( REG68.a[reg] + 2 ); + return addr; +} + +static addr68_t ea_inANpl(emu68_t * const emu68, const int reg) +{ + addr68_t addr = (s32) REG68.a[reg]; + REG68.a[reg] = (u32) ( REG68.a[reg] + 4 ); + return addr; +} + +/* -(AN) */ +static addr68_t ea_inmANb(emu68_t * const emu68, const int reg) +{ + return (s32) ( REG68.a[reg] = (u32) ( REG68.a[reg] - 1 - (reg==7) ) ); +} + +static addr68_t ea_inmANw(emu68_t * const emu68, const int reg) +{ + return (s32) ( REG68.a[reg] = (u32) ( REG68.a[reg] - 2 ) ); +} + +static addr68_t ea_inmANl(emu68_t * const emu68, const int reg) +{ + return (s32) ( REG68.a[reg] = (u32) ( REG68.a[reg] - 4 ) ); +} + +/* d(AN) */ +static addr68_t ea_indAN(emu68_t * const emu68, const int reg) +{ + return (s32) ( REG68.a[reg] + get_nextw() ); +} + +/* d(AN,Xi) */ +static addr68_t ea_inANXI(emu68_t * const emu68, const int reg) +{ + int68_t w = get_nextw(); + int68_t reg2; + reg2 = ( w >> 12 ) & 15; + reg2 = ( w & 04000 ) + ? (int68_t) (s32) REG68.d[reg2] + : (int68_t) (s16) REG68.d[reg2] + ; + return (s32) ( REG68.a[reg] + (s8) w + reg2 ); +} + +/* ABS.W */ +static addr68_t ea_inABSW(emu68_t * const emu68, const int reg) +{ + return get_nextw(); +} + +/* ABS.L */ +static addr68_t ea_inABSL(emu68_t * const emu68, const int reg) +{ + return get_nextl(); +} + +/* d(PC) */ +static addr68_t ea_inrelPC(emu68_t * const emu68, const int reg) +{ + addr68_t pc = (s32) REG68.pc; + return (s32) ( pc + get_nextw() ); +} + +/* d(PC,Xi) */ +static addr68_t ea_inPCXI(emu68_t * const emu68, const int reg) +{ + addr68_t pc = (s32) REG68.pc; + int68_t w = get_nextw(); + int68_t reg2 = ( w >> 12 ) & 15; + pc += ( w & 04000 ) + ? (int68_t) (s32) REG68.d[reg2] + : (int68_t) (s16) REG68.d[reg2] + ; + pc += (s8) w; + return (s32) pc; +} + +/* # */ +static addr68_t ea_inIMMb(emu68_t * const emu68, const int reg) +{ + addr68_t pc = (s32) REG68.pc; + REG68.pc = (u32) ( pc + 2 ); + return (s32) ( pc + 1 ); +} + +static addr68_t ea_inIMMw(emu68_t * const emu68, const int reg) +{ + s32 pc = REG68.pc; + REG68.pc = (u32) (pc + 2); + return pc; +} + +static addr68_t ea_inIMMl(emu68_t * const emu68, const int reg) +{ + s32 pc = REG68.pc; + REG68.pc = (u32) ( pc + 4 ); + return pc; +} + +/*************************** + * * + * Opmode tables for Get EA * + * * + ***************************/ + +/* Mode 7 tables */ + +static addr68_t (* const ea_b7[8])(emu68_t * const, const int) = +{ + ea_inABSW, ea_inABSL, ea_inrelPC, ea_inPCXI, + ea_inIMMb, ea_error, ea_error, ea_error +}; + +static addr68_t (* const ea_w7[8])(emu68_t * const, const int) = +{ + ea_inABSW, ea_inABSL, ea_inrelPC, ea_inPCXI, + ea_inIMMw, ea_error, ea_error, ea_error +}; + +static addr68_t (* const ea_l7[8])(emu68_t * const, const int) = +{ + ea_inABSW, ea_inABSL, ea_inrelPC, ea_inPCXI, + ea_inIMMl, ea_error, ea_error, ea_error +}; + +/* Mode 7 redirect functions */ + +static addr68_t ea_mode7b(emu68_t * const emu68, const int reg) +{ + return (ea_b7[reg])(emu68, reg); +} + +static addr68_t ea_mode7w(emu68_t * const emu68, const int reg) +{ + return (ea_w7[reg])(emu68, reg); +} + +static addr68_t ea_mode7l(emu68_t * const emu68, const int reg) +{ + return (ea_l7[reg])(emu68, reg); +} + +/* Get EA tables */ + +addr68_t (* const get_eab68[8])(emu68_t * const, const int) = +{ + ea_error, ea_error, ea_inAN, ea_inANpb, + ea_inmANb,ea_indAN,ea_inANXI, + ea_mode7b, +}; + +addr68_t (* const get_eaw68[8])(emu68_t * const, const int) = +{ + ea_error, ea_error, ea_inAN, ea_inANpw, + ea_inmANw,ea_indAN,ea_inANXI, + ea_mode7w, +}; + +addr68_t (* const get_eal68[8])(emu68_t * const, const int) = +{ + ea_error, ea_error, ea_inAN, ea_inANpl, + ea_inmANl,ea_indAN,ea_inANXI, + ea_mode7l, +}; + Index: apps/codecs/libsc68/emu68/type68.h =================================================================== --- apps/codecs/libsc68/emu68/type68.h (revision 0) +++ apps/codecs/libsc68/emu68/type68.h (revision 0) @@ -0,0 +1,126 @@ +/** + * @ingroup emu68_lib + * @file emu68/type68.h + * @brief Type definitions header. + * @date 1999/03/13 + * @author Benjamin Gerard + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_TYPE68_H_ +#define _EMU68_TYPE68_H_ + +#if defined (ROCKBOX) +#include +#else + #ifdef HAVE_STDINT_H + #include + #endif + + #ifdef HAVE_SYS_TYPES_H + # include + #endif +#endif + +/** @defgroup emu68_lib_types Type definitions + * @ingroup emu68_lib + * + * Definition of types used by EMU68 and SC68 related projects. + * Some of them are probably not neccessary and should be remove to + * improve execution time on 64 or more bit platforms. + * Setting wrong types may probably produce annoying effects on EMU68. + * It is a limitation to EMU68 portability. + * + * @{ + */ + +/** @name Fixed size integer types. + * @{ + */ + +typedef uint8_t u8; /**< Must be an unsigned 8 bit integer. */ +typedef int8_t s8; /**< Must be a signed 8 bit integer. */ + +typedef uint16_t u16; /**< Must be an unsigned 16 bit integer. */ +typedef int16_t s16; /**< Must be a signed 16 bit integer. */ + +typedef uint32_t u32; /**< Must be an unsigned 32 bit integer. */ +typedef int32_t s32; /**< Must be a signed 32 bit integer. */ + +typedef uint64_t u64; /**< Must be an unsigned 64 bit integer. */ +typedef int64_t s64; /**< Must be a signed 64 bit integer. */ + +/** @} */ + +#ifndef INT68_BITS + +/* Commonly used int (should be fastest at least 32 bit type). */ +typedef int_fast32_t int68_t; /**< fast signed integer type. */ +typedef int68_t sint68_t; /**< fast signed integer type. */ +typedef uint_fast32_t uint68_t; /**< fast unsigned integer type. */ + +#elif INT68_BITS == 32 + +typedef s32 int68_t; /**< 32bit signed integer type. */ +typedef s32 sint68_t; /**< 32bit signed integer type. */ +typedef u32 uint68_t; /**< 32bit unsigned integer type. */ + +#elif INT68_BITS == 64 + +typedef s64 int68_t; /**< 64bit signed integer type. */ +typedef s64 sint68_t; /**< 64bit signed integer type. */ +typedef u64 uint68_t; /**< 64bit unsigned integer type. */ + +#else +# error "invalid define INT68_BITS" +#endif + +/* $$$ Switch back to int_fast as soon as it is safe to have int68_t + * width > 32bit. Most problems about it probably are in the macro68.h + * file. + * + * $$$ Thing should be fixed now. Still need more testing to validate + * the new 68K emulator engine. + * + * */ + +typedef unsigned int uint_t; /**< natural unsigned int. */ +typedef uint68_t cycle68_t; /**< Type for cycle counters. */ +typedef int68_t addr68_t; /**< Type for 68k memory addressing. */ +typedef struct io68_s io68_t; /**< IO chip instance type. */ +typedef struct emu68_s emu68_t; /**< 68k emulator instance type. */ + +/** 68k memory access function. */ +typedef void (*memfunc68_t)(emu68_t * const); + +/** + * @} + */ + +#define BASE_FIX (sizeof(int68_t)<<3) /* number of bit of int68_t type. */ +#define BYTE_FIX (BASE_FIX-8) /* shift to normalize byte operands. */ +#define WORD_FIX (BASE_FIX-16) /* shift to normalize word operands. */ +#define LONG_FIX (BASE_FIX-32) /* shift to normalize long operands. */ +#define SIGN_FIX (BASE_FIX-1) /* sign bit raw. */ +#define SIGN_BIT SIGN_FIX /* sign bit raw. */ +#define SIGN_MSK ( (int68_t) ( (int68_t) 1 << SIGN_FIX ) ) /* sign mask. */ + +#define BYTE_MSK ( (int68_t) 0xFFFFFF00 ) +#define WORD_MSK ( (int68_t) 0xFFFF0000 ) +#define LONG_MSK ( (int68_t) 0x00000000 ) + +#define NRM_BYTE_MSK ( (int68_t) ( (int68_t) 0x000000FF << BYTE_FIX ) ) +#define NRM_WORD_MSK ( (int68_t) ( (int68_t) 0x0000FFFF << WORD_FIX ) ) +#define NRM_LONG_MSK ( (int68_t) ( (int68_t) 0xFFFFFFFF << LONG_FIX ) ) +/* L={7,15,31} */ +#define NRM_MSK(L) ( (int68_t) ( (int68_t) ((int68_t) 1 << SIGN_BIT) >> (L))) + +#define NRM_BYTE_ONE ( (int68_t) ( (int68_t) 0x00000001 << BYTE_FIX ) ) +#define NRM_WORD_ONE ( (int68_t) ( (int68_t) 0x00000001 << WORD_FIX ) ) +#define NRM_LONG_ONE ( (int68_t) ( (int68_t) 0x00000001 << LONG_FIX ) ) + +#endif /* #ifndef _EMU68_TYPE68_H_ */ Index: apps/codecs/libsc68/emu68/getea68.h =================================================================== --- apps/codecs/libsc68/emu68/getea68.h (revision 0) +++ apps/codecs/libsc68/emu68/getea68.h (revision 0) @@ -0,0 +1,61 @@ +#error "don't use anymore" + +/* + * @ingroup emu68_core_devel + * @file emu68/getea68.h + * @author Benjamin Gerard + * @date 1999/03/13 + * @brief 68k effective address calculation function table. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_GETEA68_H_ +#define _EMU68_GETEA68_H_ + +#include "emu68_api.h" +#include "type68.h" + + +/** @addtogroup emu68_core_devel + * + * @{ + */ + +/** @name Effective address calculation tables. + * + * The get_ab[bwl] tables are used by EMU68 to calculate operand + * effective address. Each of them is indexed by operand addressing + * mode. Each entry is a pointer to a function which do everything + * neccessary to update processor state (e.g. address register + * increment or decrement). reg parameter is register number coded + * in the three first bit (0 to 2) of 68k opcode. When the mode is + * 7, register parameter is used as an index in a second level + * function table for extended addressing mode. + * + * @{ + */ + +EMU68_EXTERN +/** Byte operand effective address calculation function table. */ +addr68_t (*const get_eab68[8])(emu68_t * const,int reg); + +EMU68_EXTERN +/** Word operand effective address calculation function table. */ +addr68_t (*const get_eaw68[8])(emu68_t * const,int reg); + +EMU68_EXTERN +/** Long operand effective address calculation function table. */ +addr68_t (*const get_eal68[8])(emu68_t * const,int reg); + + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _EMU68_GETEA68_H_ */ Index: apps/codecs/libsc68/emu68/crc32.c =================================================================== --- apps/codecs/libsc68/emu68/crc32.c (revision 0) +++ apps/codecs/libsc68/emu68/crc32.c (revision 0) @@ -0,0 +1,74 @@ +/* + * emu68 - crc32 + * + * Original implemantation by Gary S. Brown + */ + +/* $Id: emu68.c 116 2009-06-18 14:09:54Z benjihan $ */ + +static u32 crc32_tab[] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL + }; + +static uint68_t crc32(uint68_t crc32val, const u8 * s, int68_t len) +{ + const u8 * e = s + len; + + while ( s < e ) { + crc32val = + crc32_tab[(crc32val ^ *s++) & 0xff] ^ + (crc32val >> 8); + } + return crc32val; +} Index: apps/codecs/libsc68/emu68/ioplug68.c =================================================================== --- apps/codecs/libsc68/emu68/ioplug68.c (revision 0) +++ apps/codecs/libsc68/emu68/ioplug68.c (revision 0) @@ -0,0 +1,110 @@ +/* + * emu68 - 68000 IO manager + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "ioplug68.h" +#include "mem68.h" + +static void do_io_unplug(emu68_t * const emu68, io68_t * const io) +{ + /* Remove memory acces handler */ + emu68_mem_reset_area(emu68, (io->addr_lo>>8)&255); +} + +/* Unplug all IO */ +static void _ioplug_unplug_all(emu68_t * const emu68, const int destroy) +{ + io68_t *next = emu68->iohead; + while (next) { + io68_t *io = next; + next = io->next; + do_io_unplug(emu68, io); + if (destroy && io->destroy) { + io->destroy(io); + } + } + emu68->iohead = 0; + emu68->nio = 0; +} + + +/* Unplug all IO */ +void emu68_ioplug_unplug_all(emu68_t * const emu68) +{ + _ioplug_unplug_all(emu68, 0); +} + +/* Unplug and destroy all IO */ +void emu68_ioplug_destroy_all(emu68_t * const emu68) +{ + _ioplug_unplug_all(emu68, 1); +} + +/* Unplug an IO : + * - remove from IO-list + * - remove memory access handler + * + * return 0 if IO successfully unplugged + */ +int emu68_ioplug_unplug(emu68_t * const emu68, io68_t *this_io) +{ + io68_t *io,**pio; + + if(!this_io) { + return 0; + } + + for (io = emu68->iohead, pio = &emu68->iohead; + io; + pio=&io->next, io=io->next) { + /* Find it ??? */ + if (io==this_io) { + *pio = io->next; + --emu68->nio; + do_io_unplug(emu68, io); + return 0; + } + } + return -1; +} + +/* Plug new IO : + * - add to io list + * - add new memory access handler + */ +void emu68_ioplug(emu68_t * const emu68, io68_t * const io) +{ + if (emu68 && io) { + int i; + io->next = emu68->iohead; + emu68->iohead = io; + io->emu68 = emu68; + ++emu68->nio; + for (i=(u8)(io->addr_lo>>8); i<=(u8)(io->addr_hi>>8); ++i) { + emu68->mapped_io[i] = io; + } + } +} Index: apps/codecs/libsc68/emu68/inl68_bcd.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_bcd.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_bcd.h (revision 0) @@ -0,0 +1,71 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_bcd.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k binary coded decimal arithmetic inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_BCD_H_ +#define _INL68_BCD_H_ + +static inline +int inl_abcd68(emu68_t * const emu68, int a, int b) +{ + int x = ( emu68->reg.sr >> SR_X_BIT ) & 1; + a += b + x; /* unadjusted result */ + b = a; /* store unadjusted result */ + x = REG68.sr & (SR_Z); /* use x as ccr */ + if ( (a&15) > 9 ) + a += 6; + if ( a > 0x90 ) { + a += 0x60; + x |= SR_C|SR_X; + } + a = (u8)a; + if (a) x &= ~SR_Z; + x |= (a&0x80) >> (7-SR_N_BIT); + x |= ((~b)&a&0x80) >> (7-SR_V_BIT); + SET_CCR(REG68.sr,x); + + return a; +} + +static inline +int inl_sbcd68(emu68_t * const emu68, int a, int b) +{ + int x = ( emu68->reg.sr >> SR_X_BIT ) & 1; + int r = a - b - x; + if ( (b&0xF) + x > (a&15) ) + r -= 6; + + b = a; /* store unadjusted result */ + x = REG68.sr & (SR_Z); /* use x as ccr */ + + if ( r & 0x80 ) { + r -= 0x60; + x |= SR_C|SR_X; + } + + a = (u8)r; + if (a) x &= ~SR_Z; + x |= (a&0x80) >> (7-SR_N_BIT); + x |= (b&(~a)&0x80) >> (7-SR_V_BIT); + + SET_CCR(REG68.sr,x); + + return a; +} + +static inline +int inl_nbcd68(emu68_t * const emu68, int a) +{ + return inl_sbcd68(emu68,0,a); +} + +#endif /* #ifndef _INL68_BCD_H_ */ Index: apps/codecs/libsc68/emu68/ioplug68.h =================================================================== --- apps/codecs/libsc68/emu68/ioplug68.h (revision 0) +++ apps/codecs/libsc68/emu68/ioplug68.h (revision 0) @@ -0,0 +1,77 @@ +/** + * @ingroup emu68_lib + * @file emu68/ioplug68.h + * @date 1999/03/13 + * @brief 68k IO plugger header. + * @author Benjamin Gerard + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_IOPLUG68_H_ +#define _EMU68_IOPLUG68_H_ + +#include "emu68_api.h" +#include "struct68.h" + +/** + * @defgroup emu68_lib_ioplug 68k IO plugger + * @ingroup emu68_lib_api + * @brief IO plugging and mapping facilities. + * + * Provide functions for warm plugging/unplugging of IO + * chipset. Limitations are explained in @ref emu68_mem68_devel "68k + * memory and IO manager" detailed description. + * + * @{ + */ + +EMU68_API +/** Unplug all IO. + * + * Process emu68_ioplug_unplug() function for all pluged IO. + * + */ +void emu68_ioplug_unplug_all(emu68_t * const emu68); + +EMU68_API +/** Unplug and destroy all IO. + * + * Process emu68_ioplug_unplug() function for all pluged IO and + * destroy each io by calling its io68_t::destroy function. + * + */ +void emu68_ioplug_destroy_all(emu68_t * const emu68); + +EMU68_API +/** Unplug an IO. + * + * The emu68_ioplug_unplug() function removes an IO from pluged IO + * list and reset memory access handler for its area. + * + * @param io Address of IO structure to unplug. + * + * @return error-code + * @retval 0 Success + * @retval <0 Error (probably no matching IO) + */ +int emu68_ioplug_unplug(emu68_t * const emu68, io68_t * const io); + +EMU68_API +/** Plug an IO. + * + * The emu68_ioplug() function add an IO to pluged IO list and add + * suitable memory access handlers. + * + * @param io Address of IO structure to plug. + */ +void emu68_ioplug(emu68_t * const emu68, io68_t * const io); + +/** + * @} + */ + +#endif /* #ifndef _EMU68_IOPLUG68_H_ */ Index: apps/codecs/libsc68/emu68/inl68_logic.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_logic.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_logic.h (revision 0) @@ -0,0 +1,51 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_logic.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k logical instruction inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_LOGIC_H_ +#define _INL68_LOGIC_H_ + +#include "inl68_progctrl.h" /* for inl_tst68() */ + +static inline +int68_t inl_and68(emu68_t * const emu68, const int68_t s, int68_t d) +{ + d &= s; + inl_tst68(emu68, d); + return d; +} + +static inline +int68_t inl_orr68(emu68_t * const emu68, const int68_t s, int68_t d) +{ + d |= s; + inl_tst68(emu68, d); + return d; +} + +static inline +int68_t inl_eor68(emu68_t * const emu68, const int68_t s, int68_t d) +{ + d ^= s; + inl_tst68(emu68, d); + return d; +} + +static inline +int68_t inl_not68(emu68_t * const emu68, int68_t d) +{ + d = ~d; + inl_tst68(emu68, d); + return d; +} + +#endif /* #ifndef _INL68_LOGIC_H_ */ Index: apps/codecs/libsc68/emu68/inl68_exception.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_exception.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_exception.h (revision 0) @@ -0,0 +1,42 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_exception.h + * @brief 68k exception header. + * @date 2009/05/08 + * @author Benjamin Gerard + * + */ + +/* $Id$ */ + +#ifndef _EMU68_INL_EXCEPTION68_H_ +#define _EMU68_INL_EXCEPTION68_H_ + +EMU68_EXTERN +void exception68(emu68_t * const emu68, const int vector, const int level); + +static inline +void inl_exception68(emu68_t * const emu68, const int vector, const int level) +{ + exception68(emu68, vector, level); +} + +static inline +void inl_buserror68(emu68_t * const emu68, int addr, int mode) +{ + inl_exception68(emu68, BUSERR_VECTOR, -1); +} + +static inline +void inl_linea68(emu68_t * const emu68) +{ + inl_exception68(emu68, LINEA_VECTOR, -1); +} + +static inline +void inl_linef68(emu68_t * const emu68) +{ + inl_exception68(emu68, LINEF_VECTOR, -1); +} + +#endif /* #ifndef _EMU68_INL_EXCEPTION68_H_ */ Index: apps/codecs/libsc68/emu68/assert68.h =================================================================== --- apps/codecs/libsc68/emu68/assert68.h (revision 0) +++ apps/codecs/libsc68/emu68/assert68.h (revision 0) @@ -0,0 +1,36 @@ +/** + * @ingroup emu68_lib + * @file emu68/assert68.h + * @brief assert feature header. + * @date 2009/06/12 + * @author Benjamin Gerard + * + */ + +/* $Id$ */ + +#ifndef _EMU68_ASSERT68_H_ +#define _EMU68_ASSERT68_H_ + +#ifdef HAVE_LIMITS_H +# include +#endif +#if defined(HAVE_ASSERT_H) || defined(ROCKBOX) +# include +#endif +#ifndef assert +# error "assert macro must be defined" +#endif +#if defined(NDEBUG_LIBSC68) && !defined(NDEBUG) +# error "Compile libsc68 in release mode with assert enable" +#endif + +#ifndef EMU68_BREAK +# ifndef DEBUG +# define EMU68_BREAK 1 /* NOT debug mode */ +# else +# define EMU68_BREAK 0 /* debug mode */ +# endif +#endif + +#endif /* #ifndef _EMU68_ASSERT68_H_ */ Index: apps/codecs/libsc68/emu68/lines68.c =================================================================== --- apps/codecs/libsc68/emu68/lines68.c (revision 0) +++ apps/codecs/libsc68/emu68/lines68.c (revision 0) @@ -0,0 +1,40 @@ +/** + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#if !defined(EMU68_MONOLITIC) && !defined(ROCKBOX) +# error "EMU68_MONOLITIC should be defined when compiling this file." +#else +# include "emu68_api.h" + +/* Monolitic build: remove all forced inlines */ +# undef inline +# define inline + +# include "lines68.h" +# include "lines/line0.c" +# include "lines/line1.c" +# include "lines/line2.c" +# include "lines/line3.c" +# include "lines/line4.c" +# include "lines/line5.c" +# include "lines/line6.c" +# include "lines/line7.c" +# include "lines/line8.c" +# include "lines/line9.c" +# include "lines/lineA.c" +# include "lines/lineB.c" +# include "lines/lineC.c" +# include "lines/lineD.c" +# include "lines/lineE.c" +# include "lines/lineF.c" + +# include "struct68.h" +# include "lines/table.c" +#endif Index: apps/codecs/libsc68/emu68/inl68_bitmanip.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_bitmanip.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_bitmanip.h (revision 0) @@ -0,0 +1,45 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_bitmanip.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k bit manipalution instruction inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_BITMANIP_H_ +#define _INL68_BITMANIP_H_ + +static inline +void inl_btst68(emu68_t * const emu68, const int68_t v, const int bit) +{ + REG68.sr = ( REG68.sr & ~SR_Z ) + | ( ( (~v >> bit) & 1 ) << SR_Z_BIT ); +} + +static inline +int68_t inl_bset68(emu68_t * const emu68, const int68_t v, const int bit) +{ + inl_btst68(emu68, v, bit); + return v | ( 1 << bit ); +} + +static inline +int68_t inl_bclr68(emu68_t * const emu68, const int68_t v, const int bit) +{ + inl_btst68(emu68, v, bit); + return v & ~( 1 << bit ); +} + +static inline +int68_t inl_bchg68(emu68_t * const emu68, const int68_t v, const int bit) +{ + inl_btst68(emu68, v, bit); + return v ^ ( 1 << bit ); +} + +#endif /* #ifndef _INL68_BITMANIP_H_ */ Index: apps/codecs/libsc68/emu68/lines/line0.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line0.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line0.c (revision 0) @@ -0,0 +1,2085 @@ +/* line0.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 0: Bit Manipulation/MOVEP/Immediate */ + +static inline +void BTST_reg(emu68_t * const emu68, const int bit, int reg0) +{ + /* BTST.L #b,Dn */ + int68_t a = REG68.d[reg0]; + BTSTL(a,a,bit); + ADDCYCLE(2); +} + +static inline +void BTST_mem(emu68_t * const emu68, const int bit, int mode, int reg0) +{ + /* BTST.B #b, */ + addr68_t addr = get_eab68[mode](emu68,reg0); + int68_t a = read_B(addr); + BTSTB(a,a,bit); + ADDCYCLE(0); +} + +static inline +void BCHG_reg(emu68_t * const emu68, const int bit, int reg0) +{ + /* BCHG.L #b,Dn */ + int68_t a = REG68.d[reg0]; + BCHGL(a,a,bit); + REG68.d[reg0] = (u32) a; + ADDCYCLE(4); +} + +static inline +void BCHG_mem(emu68_t * const emu68, const int bit, int mode, int reg0) +{ + /* BCHG.B #b, */ + addr68_t addr = get_eab68[mode](emu68,reg0); + int68_t a = read_B(addr); + BCHGB(a,a,bit); + write_B(addr,a); + ADDCYCLE(4); +} + +static inline +void BCLR_reg(emu68_t * const emu68, const int bit, int reg0) +{ + /* BCLR.L #b,Dn */ + int68_t a = REG68.d[reg0]; + BCLRL(a,a,bit); + REG68.d[reg0] = (u32) a; + ADDCYCLE(6); +} + +static inline +void BCLR_mem(emu68_t * const emu68, const int bit, int mode, int reg0) +{ + /* BCLR.B #b, */ + addr68_t addr = get_eab68[mode](emu68,reg0); + int68_t a = read_B(addr); + BCLRB(a,a,bit); + write_B(addr,a); + ADDCYCLE(4); +} + +static inline +void BSET_reg(emu68_t * const emu68, const int bit, int reg0) +{ + /* BSET.L #b,Dn */ + int68_t a = REG68.d[reg0]; + BSETL(a,a,bit); + REG68.d[reg0] = (u32) a; + ADDCYCLE(4); +} + +static inline +void BSET_mem(emu68_t * const emu68, const int bit, int mode, int reg0) +{ + /* BSET.B #b, */ + addr68_t addr = get_eab68[mode](emu68,reg0); + int68_t a = read_B(addr); + BSETB(a,a,bit); + write_B(addr,a); + ADDCYCLE(4); +} + +static void l0_ill(emu68_t * const emu68, int reg0) +{ + reg0 = reg0; + ILLEGAL; +} + +static void l0_ORRb0(emu68_t * const emu68, int reg0) +{ + /* ORRI.B #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +static void l0_ANDb0(emu68_t * const emu68, int reg0) +{ + /* ANDI.B #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +static void l0_EORb0(emu68_t * const emu68, int reg0) +{ + /* EORI.B #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + EORB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +static void l0_ADDb0(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +static void l0_SUBb0(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +static void l0_CMPb0(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw0(emu68_t * const emu68, int reg0) +{ + /* ORRI.W #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +static void l0_ANDw0(emu68_t * const emu68, int reg0) +{ + /* ANDI.W #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +static void l0_EORw0(emu68_t * const emu68, int reg0) +{ + /* EORI.W #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + EORW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +static void l0_ADDw0(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +static void l0_SUBw0(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +static void l0_CMPw0(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I,Dn */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl0(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I,Dn */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +static void l0_ANDl0(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I,Dn */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +static void l0_EORl0(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I,Dn */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + EORL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +static void l0_ADDl0(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I,Dn */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +static void l0_SUBl0(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I,Dn */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +static void l0_CMPl0(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I,Dn */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + CMPL(s,d); +} + +static void l0_ORRb2(emu68_t * const emu68, int reg0) +{ + /* ORRI.B #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ANDb2(emu68_t * const emu68, int reg0) +{ + /* ANDI.B #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_EORb2(emu68_t * const emu68, int reg0) +{ + /* EORI.B #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ADDb2(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_SUBb2(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_CMPb2(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw2(emu68_t * const emu68, int reg0) +{ + /* ORRI.W #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ANDw2(emu68_t * const emu68, int reg0) +{ + /* ANDI.W #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_EORw2(emu68_t * const emu68, int reg0) +{ + /* EORI.W #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ADDw2(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_SUBw2(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_CMPw2(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I,(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl2(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I,(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ANDl2(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I,(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_EORl2(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I,(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ADDl2(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I,(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_SUBl2(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I,(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_CMPl2(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I,(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + CMPL(s,d); +} + +static void l0_ORRb3(emu68_t * const emu68, int reg0) +{ + /* ORRI.B #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ANDb3(emu68_t * const emu68, int reg0) +{ + /* ANDI.B #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_EORb3(emu68_t * const emu68, int reg0) +{ + /* EORI.B #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ADDb3(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_SUBb3(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_CMPb3(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw3(emu68_t * const emu68, int reg0) +{ + /* ORRI.W #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ANDw3(emu68_t * const emu68, int reg0) +{ + /* ANDI.W #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_EORw3(emu68_t * const emu68, int reg0) +{ + /* EORI.W #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ADDw3(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_SUBw3(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_CMPw3(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl3(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ANDl3(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_EORl3(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ADDl3(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_SUBl3(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_CMPl3(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I,(An)+ */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + CMPL(s,d); +} + +static void l0_ORRb4(emu68_t * const emu68, int reg0) +{ + /* ORRI.B #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ANDb4(emu68_t * const emu68, int reg0) +{ + /* ANDI.B #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_EORb4(emu68_t * const emu68, int reg0) +{ + /* EORI.B #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ADDb4(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_SUBb4(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_CMPb4(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw4(emu68_t * const emu68, int reg0) +{ + /* ORRI.W #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ANDw4(emu68_t * const emu68, int reg0) +{ + /* ANDI.W #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_EORw4(emu68_t * const emu68, int reg0) +{ + /* EORI.W #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ADDw4(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_SUBw4(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_CMPw4(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl4(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ANDl4(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_EORl4(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ADDl4(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_SUBl4(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_CMPl4(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I,-(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + CMPL(s,d); +} + +static void l0_ORRb5(emu68_t * const emu68, int reg0) +{ + /* ORRI.B #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ANDb5(emu68_t * const emu68, int reg0) +{ + /* ANDI.B #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_EORb5(emu68_t * const emu68, int reg0) +{ + /* EORI.B #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ADDb5(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_SUBb5(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_CMPb5(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw5(emu68_t * const emu68, int reg0) +{ + /* ORRI.W #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ANDw5(emu68_t * const emu68, int reg0) +{ + /* ANDI.W #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_EORw5(emu68_t * const emu68, int reg0) +{ + /* EORI.W #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ADDw5(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_SUBw5(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_CMPw5(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl5(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ANDl5(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_EORl5(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ADDl5(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_SUBl5(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_CMPl5(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I,d(An) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + CMPL(s,d); +} + +static void l0_ORRb6(emu68_t * const emu68, int reg0) +{ + /* ORRI.B #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ANDb6(emu68_t * const emu68, int reg0) +{ + /* ANDI.B #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_EORb6(emu68_t * const emu68, int reg0) +{ + /* EORI.B #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_ADDb6(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_SUBb6(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_CMPb6(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw6(emu68_t * const emu68, int reg0) +{ + /* ORRI.W #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ANDw6(emu68_t * const emu68, int reg0) +{ + /* ANDI.W #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_EORw6(emu68_t * const emu68, int reg0) +{ + /* EORI.W #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_ADDw6(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_SUBw6(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_CMPw6(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl6(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ANDl6(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_EORl6(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ADDl6(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_SUBl6(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_CMPl6(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I,d(An,Xi) */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + CMPL(s,d); +} + +static void l0_ORRb7(emu68_t * const emu68, int reg0) +{ + if (reg0==4) { /* ORR TO CCR */ + uint68_t a; + a = get_nextw()&255; + REG68.sr |= a; + } else { + /* ORRI.B #I, */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); + } +} + +static void l0_ANDb7(emu68_t * const emu68, int reg0) +{ + if (reg0==4) { /* AND TO CCR */ + uint68_t a; + a = get_nextw()|0xFF00; + REG68.sr &= a; + } else { + /* ANDI.B #I, */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); + } +} + +static void l0_EORb7(emu68_t * const emu68, int reg0) +{ + if (reg0==4) { /* EOR TO CCR */ + uint68_t a; + a = get_nextw()&255; + REG68.sr ^= a; + } else { + /* EORI.B #I, */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); + } +} + +static void l0_ADDb7(emu68_t * const emu68, int reg0) +{ + /* ADDI.B #I, */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_SUBb7(emu68_t * const emu68, int reg0) +{ + /* SUBI.B #I, */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +static void l0_CMPb7(emu68_t * const emu68, int reg0) +{ + /* CMPI.B #I, */ + const uint68_t s = ( (int68_t) get_nextw() << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + CMPB(s,d); +} + +static void l0_ORRw7(emu68_t * const emu68, int reg0) +{ + if (reg0==4) { /* ORR TO SR */ + uint68_t a; + a = get_nextw(); + REG68.sr |= a; + } else { + /* ORRI.W #I, */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); + } +} + +static void l0_ANDw7(emu68_t * const emu68, int reg0) +{ + if (reg0==4) { /* AND TO SR */ + uint68_t a; + a = get_nextw(); + REG68.sr &= a; + } else { + /* ANDI.W #I, */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); + } +} + +static void l0_EORw7(emu68_t * const emu68, int reg0) +{ + if (reg0==4) { /* EOR TO SR */ + uint68_t a; + a = get_nextw(); + REG68.sr ^= a; + } else { + /* EORI.W #I, */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); + } +} + +static void l0_ADDw7(emu68_t * const emu68, int reg0) +{ + /* ADDI.W #I, */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_SUBw7(emu68_t * const emu68, int reg0) +{ + /* SUBI.W #I, */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +static void l0_CMPw7(emu68_t * const emu68, int reg0) +{ + /* CMPI.W #I, */ + const uint68_t s = ( (int68_t) get_nextw() << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + CMPW(s,d); +} + +static void l0_ORRl7(emu68_t * const emu68, int reg0) +{ + /* ORRI.L #I, */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ANDl7(emu68_t * const emu68, int reg0) +{ + /* ANDI.L #I, */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_EORl7(emu68_t * const emu68, int reg0) +{ + /* EORI.L #I, */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_ADDl7(emu68_t * const emu68, int reg0) +{ + /* ADDI.L #I, */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_SUBl7(emu68_t * const emu68, int reg0) +{ + /* SUBI.L #I, */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +static void l0_CMPl7(emu68_t * const emu68, int reg0) +{ + /* CMPI.L #I, */ + const uint68_t s = ( (int68_t) get_nextl() << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + CMPL(s,d); +} + +static void (*const line0_imm[8][32])(emu68_t * const emu68, int) = +{ +/* ORR */ + { + l0_ORRb0,l0_ill,l0_ORRb2,l0_ORRb3,l0_ORRb4,l0_ORRb5,l0_ORRb6,l0_ORRb7, + l0_ORRw0,l0_ill,l0_ORRw2,l0_ORRw3,l0_ORRw4,l0_ORRw5,l0_ORRw6,l0_ORRw7, + l0_ORRl0,l0_ill,l0_ORRl2,l0_ORRl3,l0_ORRl4,l0_ORRl5,l0_ORRl6,l0_ORRl7, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* AND */ + { + l0_ANDb0,l0_ill,l0_ANDb2,l0_ANDb3,l0_ANDb4,l0_ANDb5,l0_ANDb6,l0_ANDb7, + l0_ANDw0,l0_ill,l0_ANDw2,l0_ANDw3,l0_ANDw4,l0_ANDw5,l0_ANDw6,l0_ANDw7, + l0_ANDl0,l0_ill,l0_ANDl2,l0_ANDl3,l0_ANDl4,l0_ANDl5,l0_ANDl6,l0_ANDl7, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* SUB */ + { + l0_SUBb0,l0_ill,l0_SUBb2,l0_SUBb3,l0_SUBb4,l0_SUBb5,l0_SUBb6,l0_SUBb7, + l0_SUBw0,l0_ill,l0_SUBw2,l0_SUBw3,l0_SUBw4,l0_SUBw5,l0_SUBw6,l0_SUBw7, + l0_SUBl0,l0_ill,l0_SUBl2,l0_SUBl3,l0_SUBl4,l0_SUBl5,l0_SUBl6,l0_SUBl7, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* ADD */ + { + l0_ADDb0,l0_ill,l0_ADDb2,l0_ADDb3,l0_ADDb4,l0_ADDb5,l0_ADDb6,l0_ADDb7, + l0_ADDw0,l0_ill,l0_ADDw2,l0_ADDw3,l0_ADDw4,l0_ADDw5,l0_ADDw6,l0_ADDw7, + l0_ADDl0,l0_ill,l0_ADDl2,l0_ADDl3,l0_ADDl4,l0_ADDl5,l0_ADDl6,l0_ADDl7, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* ??? */ + { + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* EOR */ + { + l0_EORb0,l0_ill,l0_EORb2,l0_EORb3,l0_EORb4,l0_EORb5,l0_EORb6,l0_EORb7, + l0_EORw0,l0_ill,l0_EORw2,l0_EORw3,l0_EORw4,l0_EORw5,l0_EORw6,l0_EORw7, + l0_EORl0,l0_ill,l0_EORl2,l0_EORl3,l0_EORl4,l0_EORl5,l0_EORl6,l0_EORl7, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* CMP */ + { + l0_CMPb0,l0_ill,l0_CMPb2,l0_CMPb3,l0_CMPb4,l0_CMPb5,l0_CMPb6,l0_CMPb7, + l0_CMPw0,l0_ill,l0_CMPw2,l0_CMPw3,l0_CMPw4,l0_CMPw5,l0_CMPw6,l0_CMPw7, + l0_CMPl0,l0_ill,l0_CMPl2,l0_CMPl3,l0_CMPl4,l0_CMPl5,l0_CMPl6,l0_CMPl7, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +/* ??? */ + { + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill,l0_ill, + + }, +}; + +DECL_LINE68(line000) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_reg(emu68, bit, reg0); + } else { + line0_imm[reg9][0](emu68,reg0); + } +} + +DECL_LINE68(line001) +{ + if (reg9 == 4) { + ILLEGAL; /* BTST #xx,An (op:00000000000000000000000000000001) */ + assert(EMU68_BREAK); + } else { + line0_imm[reg9][1](emu68,reg0); + } +} + +DECL_LINE68(line002) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_mem(emu68, bit, 2, reg0); + } else { + line0_imm[reg9][2](emu68,reg0); + } +} + +DECL_LINE68(line003) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_mem(emu68, bit, 3, reg0); + } else { + line0_imm[reg9][3](emu68,reg0); + } +} + +DECL_LINE68(line004) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_mem(emu68, bit, 4, reg0); + } else { + line0_imm[reg9][4](emu68,reg0); + } +} + +DECL_LINE68(line005) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_mem(emu68, bit, 5, reg0); + } else { + line0_imm[reg9][5](emu68,reg0); + } +} + +DECL_LINE68(line006) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_mem(emu68, bit, 6, reg0); + } else { + line0_imm[reg9][6](emu68,reg0); + } +} + +DECL_LINE68(line007) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BTST_mem(emu68, bit, 7, reg0); + } else { + line0_imm[reg9][7](emu68,reg0); + } +} + +DECL_LINE68(line008) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_reg(emu68, bit, reg0); + } else { + line0_imm[reg9][8](emu68,reg0); + } +} + +DECL_LINE68(line009) +{ + if (reg9 == 4) { + ILLEGAL; /* BCHG #xx,An (op:00000000000000000000000000000011) */ + assert(EMU68_BREAK); + } else { + line0_imm[reg9][9](emu68,reg0); + } +} + +DECL_LINE68(line00A) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_mem(emu68, bit, 2, reg0); + } else { + line0_imm[reg9][10](emu68,reg0); + } +} + +DECL_LINE68(line00B) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_mem(emu68, bit, 3, reg0); + } else { + line0_imm[reg9][11](emu68,reg0); + } +} + +DECL_LINE68(line00C) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_mem(emu68, bit, 4, reg0); + } else { + line0_imm[reg9][12](emu68,reg0); + } +} + +DECL_LINE68(line00D) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_mem(emu68, bit, 5, reg0); + } else { + line0_imm[reg9][13](emu68,reg0); + } +} + +DECL_LINE68(line00E) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_mem(emu68, bit, 6, reg0); + } else { + line0_imm[reg9][14](emu68,reg0); + } +} + +DECL_LINE68(line00F) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCHG_mem(emu68, bit, 7, reg0); + } else { + line0_imm[reg9][15](emu68,reg0); + } +} + +DECL_LINE68(line010) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_reg(emu68, bit, reg0); + } else { + line0_imm[reg9][16](emu68,reg0); + } +} + +DECL_LINE68(line011) +{ + if (reg9 == 4) { + ILLEGAL; /* BCLR #xx,An (op:00000000000000000000000000000021) */ + assert(EMU68_BREAK); + } else { + line0_imm[reg9][17](emu68,reg0); + } +} + +DECL_LINE68(line012) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_mem(emu68, bit, 2, reg0); + } else { + line0_imm[reg9][18](emu68,reg0); + } +} + +DECL_LINE68(line013) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_mem(emu68, bit, 3, reg0); + } else { + line0_imm[reg9][19](emu68,reg0); + } +} + +DECL_LINE68(line014) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_mem(emu68, bit, 4, reg0); + } else { + line0_imm[reg9][20](emu68,reg0); + } +} + +DECL_LINE68(line015) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_mem(emu68, bit, 5, reg0); + } else { + line0_imm[reg9][21](emu68,reg0); + } +} + +DECL_LINE68(line016) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_mem(emu68, bit, 6, reg0); + } else { + line0_imm[reg9][22](emu68,reg0); + } +} + +DECL_LINE68(line017) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BCLR_mem(emu68, bit, 7, reg0); + } else { + line0_imm[reg9][23](emu68,reg0); + } +} + +DECL_LINE68(line018) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_reg(emu68, bit, reg0); + } else { + line0_imm[reg9][24](emu68,reg0); + } +} + +DECL_LINE68(line019) +{ + if (reg9 == 4) { + ILLEGAL; /* BSET #xx,An (op:00000000000000000000000000000031) */ + assert(EMU68_BREAK); + } else { + line0_imm[reg9][25](emu68,reg0); + } +} + +DECL_LINE68(line01A) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_mem(emu68, bit, 2, reg0); + } else { + line0_imm[reg9][26](emu68,reg0); + } +} + +DECL_LINE68(line01B) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_mem(emu68, bit, 3, reg0); + } else { + line0_imm[reg9][27](emu68,reg0); + } +} + +DECL_LINE68(line01C) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_mem(emu68, bit, 4, reg0); + } else { + line0_imm[reg9][28](emu68,reg0); + } +} + +DECL_LINE68(line01D) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_mem(emu68, bit, 5, reg0); + } else { + line0_imm[reg9][29](emu68,reg0); + } +} + +DECL_LINE68(line01E) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_mem(emu68, bit, 6, reg0); + } else { + line0_imm[reg9][30](emu68,reg0); + } +} + +DECL_LINE68(line01F) +{ + if (reg9 == 4) { + const int bit = get_nextw(); + BSET_mem(emu68, bit, 7, reg0); + } else { + line0_imm[reg9][31](emu68,reg0); + } +} + +DECL_LINE68(line020) +{ + /* BTST.L Dx,Dy */ + int68_t y = REG68.d[reg0]; + const int x = REG68.d[reg9]; + BTSTL(y,y,x); + ADDCYCLE(2); +} + +DECL_LINE68(line021) +{ + /* MOVEP.W d(An),Dn */ + const addr68_t l = REG68.a[reg0] + get_nextw(); + uint68_t a; + a = read_B( l + 0 ) << 8; + a += read_B( l + 2 ) << 0; + REG68.d[reg9] = ( REG68.d[reg9] & ~0xFFFF ) + a; + ADDCYCLE(8); +} + +DECL_LINE68(line022) +{ + /* BTST.B Dn,(An) */ + const addr68_t l = get_EAB(2,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BTSTB(y,y,x); + ADDCYCLE(0); +} + +DECL_LINE68(line023) +{ + /* BTST.B Dn,(An)+ */ + const addr68_t l = get_EAB(3,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BTSTB(y,y,x); + ADDCYCLE(0); +} + +DECL_LINE68(line024) +{ + /* BTST.B Dn,-(An) */ + const addr68_t l = get_EAB(4,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BTSTB(y,y,x); + ADDCYCLE(0); +} + +DECL_LINE68(line025) +{ + /* BTST.B Dn,d(An) */ + const addr68_t l = get_EAB(5,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BTSTB(y,y,x); + ADDCYCLE(0); +} + +DECL_LINE68(line026) +{ + /* BTST.B Dn,d(An,Xi) */ + const addr68_t l = get_EAB(6,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BTSTB(y,y,x); + ADDCYCLE(0); +} + +DECL_LINE68(line027) +{ + /* BTST.B Dn, */ + const addr68_t l = get_EAB(7,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BTSTB(y,y,x); + ADDCYCLE(0); +} + +DECL_LINE68(line028) +{ + /* BCHG.L Dx,Dy */ + int68_t y = REG68.d[reg0]; + const int x = REG68.d[reg9]; + BCHGL(y,y,x); + REG68.d[reg0] = (u32) y; + ADDCYCLE(4); +} + +DECL_LINE68(line029) +{ + /* MOVEP.L d(An),Dn */ + const addr68_t l = REG68.a[reg0] + get_nextw(); + uint68_t a; + a = read_B( l + 0 ) << 24; + a += read_B( l + 2 ) << 16; + a += read_B( l + 4 ) << 8; + a += read_B( l + 6 ) << 0; + REG68.d[reg9] = a; + ADDCYCLE(16); +} + +DECL_LINE68(line02A) +{ + /* BCHG.B Dn,(An) */ + const addr68_t l = get_EAB(2,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCHGB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line02B) +{ + /* BCHG.B Dn,(An)+ */ + const addr68_t l = get_EAB(3,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCHGB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line02C) +{ + /* BCHG.B Dn,-(An) */ + const addr68_t l = get_EAB(4,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCHGB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line02D) +{ + /* BCHG.B Dn,d(An) */ + const addr68_t l = get_EAB(5,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCHGB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line02E) +{ + /* BCHG.B Dn,d(An,Xi) */ + const addr68_t l = get_EAB(6,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCHGB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line02F) +{ + /* BCHG.B Dn, */ + const addr68_t l = get_EAB(7,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCHGB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line030) +{ + /* BCLR.L Dx,Dy */ + int68_t y = REG68.d[reg0]; + const int x = REG68.d[reg9]; + BCLRL(y,y,x); + REG68.d[reg0] = (u32) y; + ADDCYCLE(6); +} + +DECL_LINE68(line031) +{ + /* MOVEP.W Dn,d(An) */ + const addr68_t l = REG68.a[reg0] + get_nextw(); + const uint68_t a = REG68.d[reg9]; + write_B( l + 0, a >> 8); + write_B( l + 2, a >> 0); + ADDCYCLE(8); +} + +DECL_LINE68(line032) +{ + /* BCLR.B Dn,(An) */ + const addr68_t l = get_EAB(2,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCLRB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line033) +{ + /* BCLR.B Dn,(An)+ */ + const addr68_t l = get_EAB(3,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCLRB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line034) +{ + /* BCLR.B Dn,-(An) */ + const addr68_t l = get_EAB(4,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCLRB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line035) +{ + /* BCLR.B Dn,d(An) */ + const addr68_t l = get_EAB(5,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCLRB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line036) +{ + /* BCLR.B Dn,d(An,Xi) */ + const addr68_t l = get_EAB(6,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCLRB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line037) +{ + /* BCLR.B Dn, */ + const addr68_t l = get_EAB(7,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BCLRB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line038) +{ + /* BSET.L Dx,Dy */ + int68_t y = REG68.d[reg0]; + const int x = REG68.d[reg9]; + BSETL(y,y,x); + REG68.d[reg0] = (u32) y; + ADDCYCLE(4); +} + +DECL_LINE68(line039) +{ + /* MOVEP.L Dn,d(An) */ + const addr68_t l = REG68.a[reg0] + get_nextw(); + const uint68_t a = REG68.d[reg9]; + write_B( l + 0, a >> 24); + write_B( l + 2, a >> 16); + write_B( l + 4, a >> 8); + write_B( l + 6, a >> 0); + ADDCYCLE(16); +} + +DECL_LINE68(line03A) +{ + /* BSET.B Dn,(An) */ + const addr68_t l = get_EAB(2,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BSETB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line03B) +{ + /* BSET.B Dn,(An)+ */ + const addr68_t l = get_EAB(3,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BSETB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line03C) +{ + /* BSET.B Dn,-(An) */ + const addr68_t l = get_EAB(4,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BSETB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line03D) +{ + /* BSET.B Dn,d(An) */ + const addr68_t l = get_EAB(5,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BSETB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line03E) +{ + /* BSET.B Dn,d(An,Xi) */ + const addr68_t l = get_EAB(6,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BSETB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + +DECL_LINE68(line03F) +{ + /* BSET.B Dn, */ + const addr68_t l = get_EAB(7,reg0); + int68_t y = read_B(l); + const int x = REG68.d[reg9]; + BSETB(y,y,x); + write_B(l,y); + ADDCYCLE(4); +} + Index: apps/codecs/libsc68/emu68/lines/line1.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line1.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line1.c (revision 0) @@ -0,0 +1,505 @@ +/* line1.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 1: Move Byte */ + +DECL_LINE68(line100) +{ + /* MOVE.B Dx,Dy */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line101) +{ + /* MOVE.B Ax,Dy */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line102) +{ + /* MOVE.B (Ax),Dy */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line103) +{ + /* MOVE.B (Ax)+,Dy */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line104) +{ + /* MOVE.B -(Ax),Dy */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line105) +{ + /* MOVE.B d(Ax),Dy */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line106) +{ + /* MOVE.B d(Ax,Xi),Dy */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line107) +{ + /* MOVE.B ,Dy */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( (uint68_t) a >> BYTE_FIX ); +} + +DECL_LINE68(line108) +{ + ILLEGAL; /* MOVEA.B Dx,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line109) +{ + ILLEGAL; /* MOVEA.B Ax,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line10A) +{ + ILLEGAL; /* MOVEA.B (Ax),An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line10B) +{ + ILLEGAL; /* MOVEA.B (Ax)+,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line10C) +{ + ILLEGAL; /* MOVEA.B -(Ax),An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line10D) +{ + ILLEGAL; /* MOVEA.B d(Ax),An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line10E) +{ + ILLEGAL; /* MOVEA.B d(Ax,Xi),An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line10F) +{ + ILLEGAL; /* MOVEA.B ,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line110) +{ + /* MOVE.B Dx,(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line111) +{ + /* MOVE.B Ax,(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line112) +{ + /* MOVE.B (Ax),(Ay) */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line113) +{ + /* MOVE.B (Ax)+,(Ay) */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line114) +{ + /* MOVE.B -(Ax),(Ay) */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line115) +{ + /* MOVE.B d(Ax),(Ay) */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line116) +{ + /* MOVE.B d(Ax,Xi),(Ay) */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line117) +{ + /* MOVE.B ,(Ay) */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(2, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line118) +{ + /* MOVE.B Dx,(Ay)+ */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line119) +{ + /* MOVE.B Ax,(Ay)+ */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line11A) +{ + /* MOVE.B (Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line11B) +{ + /* MOVE.B (Ax)+,(Ay)+ */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line11C) +{ + /* MOVE.B -(Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line11D) +{ + /* MOVE.B d(Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line11E) +{ + /* MOVE.B d(Ax,Xi),(Ay)+ */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line11F) +{ + /* MOVE.B ,(Ay)+ */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(3, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line120) +{ + /* MOVE.B Dx,-(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line121) +{ + /* MOVE.B Ax,-(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line122) +{ + /* MOVE.B (Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line123) +{ + /* MOVE.B (Ax)+,-(Ay) */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line124) +{ + /* MOVE.B -(Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line125) +{ + /* MOVE.B d(Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line126) +{ + /* MOVE.B d(Ax,Xi),-(Ay) */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line127) +{ + /* MOVE.B ,-(Ay) */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(4, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line128) +{ + /* MOVE.B Dx,d(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line129) +{ + /* MOVE.B Ax,d(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line12A) +{ + /* MOVE.B (Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line12B) +{ + /* MOVE.B (Ax)+,d(Ay) */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line12C) +{ + /* MOVE.B -(Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line12D) +{ + /* MOVE.B d(Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line12E) +{ + /* MOVE.B d(Ax,Xi),d(Ay) */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line12F) +{ + /* MOVE.B ,d(Ay) */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(5, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line130) +{ + /* MOVE.B Dx,d(Ay,Xi) */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line131) +{ + /* MOVE.B Ax,d(Ay,Xi) */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line132) +{ + /* MOVE.B (Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line133) +{ + /* MOVE.B (Ax)+,d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line134) +{ + /* MOVE.B -(Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line135) +{ + /* MOVE.B d(Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line136) +{ + /* MOVE.B d(Ax,Xi),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line137) +{ + /* MOVE.B ,d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(6, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line138) +{ + /* MOVE.B Dx, */ + const int68_t a = (int68_t) REG68.d[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line139) +{ + /* MOVE.B Ax, */ + const int68_t a = (int68_t) REG68.a[reg0] << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line13A) +{ + /* MOVE.B (Ax), */ + const int68_t a = (int68_t) read_EAB(2,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line13B) +{ + /* MOVE.B (Ax)+, */ + const int68_t a = (int68_t) read_EAB(3,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line13C) +{ + /* MOVE.B -(Ax), */ + const int68_t a = (int68_t) read_EAB(4,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line13D) +{ + /* MOVE.B d(Ax), */ + const int68_t a = (int68_t) read_EAB(5,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line13E) +{ + /* MOVE.B d(Ax,Xi), */ + const int68_t a = (int68_t) read_EAB(6,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + +DECL_LINE68(line13F) +{ + /* MOVE.B , */ + const int68_t a = (int68_t) read_EAB(7,reg0) << BYTE_FIX; + MOVEB(a); + write_EAB(7, reg9, a >> BYTE_FIX); +} + Index: apps/codecs/libsc68/emu68/lines/line2.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line2.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line2.c (revision 0) @@ -0,0 +1,505 @@ +/* line2.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 2: Move Long */ + +DECL_LINE68(line200) +{ + /* MOVE.L Dx,Dy */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line201) +{ + /* MOVE.L Ax,Dy */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line202) +{ + /* MOVE.L (Ax),Dy */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line203) +{ + /* MOVE.L (Ax)+,Dy */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line204) +{ + /* MOVE.L -(Ax),Dy */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line205) +{ + /* MOVE.L d(Ax),Dy */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line206) +{ + /* MOVE.L d(Ax,Xi),Dy */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line207) +{ + /* MOVE.L ,Dy */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + REG68.d[reg9] = ( (uint68_t) a >> LONG_FIX ); +} + +DECL_LINE68(line208) +{ + /* MOVEA.L Dx,An */ + REG68.a[reg9] = REG68.d[reg0]; +} + +DECL_LINE68(line209) +{ + /* MOVEA.L Ax,An */ + REG68.a[reg9] = REG68.a[reg0]; +} + +DECL_LINE68(line20A) +{ + /* MOVEA.L (Ax),An */ + REG68.a[reg9] = read_EAL(2,reg0); +} + +DECL_LINE68(line20B) +{ + /* MOVEA.L (Ax)+,An */ + REG68.a[reg9] = read_EAL(3,reg0); +} + +DECL_LINE68(line20C) +{ + /* MOVEA.L -(Ax),An */ + REG68.a[reg9] = read_EAL(4,reg0); +} + +DECL_LINE68(line20D) +{ + /* MOVEA.L d(Ax),An */ + REG68.a[reg9] = read_EAL(5,reg0); +} + +DECL_LINE68(line20E) +{ + /* MOVEA.L d(Ax,Xi),An */ + REG68.a[reg9] = read_EAL(6,reg0); +} + +DECL_LINE68(line20F) +{ + /* MOVEA.L ,An */ + REG68.a[reg9] = read_EAL(7,reg0); +} + +DECL_LINE68(line210) +{ + /* MOVE.L Dx,(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line211) +{ + /* MOVE.L Ax,(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line212) +{ + /* MOVE.L (Ax),(Ay) */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line213) +{ + /* MOVE.L (Ax)+,(Ay) */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line214) +{ + /* MOVE.L -(Ax),(Ay) */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line215) +{ + /* MOVE.L d(Ax),(Ay) */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line216) +{ + /* MOVE.L d(Ax,Xi),(Ay) */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line217) +{ + /* MOVE.L ,(Ay) */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(2, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line218) +{ + /* MOVE.L Dx,(Ay)+ */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line219) +{ + /* MOVE.L Ax,(Ay)+ */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line21A) +{ + /* MOVE.L (Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line21B) +{ + /* MOVE.L (Ax)+,(Ay)+ */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line21C) +{ + /* MOVE.L -(Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line21D) +{ + /* MOVE.L d(Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line21E) +{ + /* MOVE.L d(Ax,Xi),(Ay)+ */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line21F) +{ + /* MOVE.L ,(Ay)+ */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(3, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line220) +{ + /* MOVE.L Dx,-(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line221) +{ + /* MOVE.L Ax,-(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line222) +{ + /* MOVE.L (Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line223) +{ + /* MOVE.L (Ax)+,-(Ay) */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line224) +{ + /* MOVE.L -(Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line225) +{ + /* MOVE.L d(Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line226) +{ + /* MOVE.L d(Ax,Xi),-(Ay) */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line227) +{ + /* MOVE.L ,-(Ay) */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(4, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line228) +{ + /* MOVE.L Dx,d(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line229) +{ + /* MOVE.L Ax,d(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line22A) +{ + /* MOVE.L (Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line22B) +{ + /* MOVE.L (Ax)+,d(Ay) */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line22C) +{ + /* MOVE.L -(Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line22D) +{ + /* MOVE.L d(Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line22E) +{ + /* MOVE.L d(Ax,Xi),d(Ay) */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line22F) +{ + /* MOVE.L ,d(Ay) */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(5, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line230) +{ + /* MOVE.L Dx,d(Ay,Xi) */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line231) +{ + /* MOVE.L Ax,d(Ay,Xi) */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line232) +{ + /* MOVE.L (Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line233) +{ + /* MOVE.L (Ax)+,d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line234) +{ + /* MOVE.L -(Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line235) +{ + /* MOVE.L d(Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line236) +{ + /* MOVE.L d(Ax,Xi),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line237) +{ + /* MOVE.L ,d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(6, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line238) +{ + /* MOVE.L Dx, */ + const int68_t a = (int68_t) REG68.d[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line239) +{ + /* MOVE.L Ax, */ + const int68_t a = (int68_t) REG68.a[reg0] << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line23A) +{ + /* MOVE.L (Ax), */ + const int68_t a = (int68_t) read_EAL(2,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line23B) +{ + /* MOVE.L (Ax)+, */ + const int68_t a = (int68_t) read_EAL(3,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line23C) +{ + /* MOVE.L -(Ax), */ + const int68_t a = (int68_t) read_EAL(4,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line23D) +{ + /* MOVE.L d(Ax), */ + const int68_t a = (int68_t) read_EAL(5,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line23E) +{ + /* MOVE.L d(Ax,Xi), */ + const int68_t a = (int68_t) read_EAL(6,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + +DECL_LINE68(line23F) +{ + /* MOVE.L , */ + const int68_t a = (int68_t) read_EAL(7,reg0) << LONG_FIX; + MOVEL(a); + write_EAL(7, reg9, a >> LONG_FIX); +} + Index: apps/codecs/libsc68/emu68/lines/line3.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line3.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line3.c (revision 0) @@ -0,0 +1,505 @@ +/* line3.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 3: Move Word */ + +DECL_LINE68(line300) +{ + /* MOVE.W Dx,Dy */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line301) +{ + /* MOVE.W Ax,Dy */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line302) +{ + /* MOVE.W (Ax),Dy */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line303) +{ + /* MOVE.W (Ax)+,Dy */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line304) +{ + /* MOVE.W -(Ax),Dy */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line305) +{ + /* MOVE.W d(Ax),Dy */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line306) +{ + /* MOVE.W d(Ax,Xi),Dy */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line307) +{ + /* MOVE.W ,Dy */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( (uint68_t) a >> WORD_FIX ); +} + +DECL_LINE68(line308) +{ + /* MOVEA.W Dx,An */ + REG68.a[reg9] = (u32)(s16) REG68.d[reg0]; +} + +DECL_LINE68(line309) +{ + /* MOVEA.W Ax,An */ + REG68.a[reg9] = (u32)(s16) REG68.a[reg0]; +} + +DECL_LINE68(line30A) +{ + /* MOVEA.W (Ax),An */ + REG68.a[reg9] = (u32)(s16) read_EAW(2,reg0); +} + +DECL_LINE68(line30B) +{ + /* MOVEA.W (Ax)+,An */ + REG68.a[reg9] = (u32)(s16) read_EAW(3,reg0); +} + +DECL_LINE68(line30C) +{ + /* MOVEA.W -(Ax),An */ + REG68.a[reg9] = (u32)(s16) read_EAW(4,reg0); +} + +DECL_LINE68(line30D) +{ + /* MOVEA.W d(Ax),An */ + REG68.a[reg9] = (u32)(s16) read_EAW(5,reg0); +} + +DECL_LINE68(line30E) +{ + /* MOVEA.W d(Ax,Xi),An */ + REG68.a[reg9] = (u32)(s16) read_EAW(6,reg0); +} + +DECL_LINE68(line30F) +{ + /* MOVEA.W ,An */ + REG68.a[reg9] = (u32)(s16) read_EAW(7,reg0); +} + +DECL_LINE68(line310) +{ + /* MOVE.W Dx,(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line311) +{ + /* MOVE.W Ax,(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line312) +{ + /* MOVE.W (Ax),(Ay) */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line313) +{ + /* MOVE.W (Ax)+,(Ay) */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line314) +{ + /* MOVE.W -(Ax),(Ay) */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line315) +{ + /* MOVE.W d(Ax),(Ay) */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line316) +{ + /* MOVE.W d(Ax,Xi),(Ay) */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line317) +{ + /* MOVE.W ,(Ay) */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(2, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line318) +{ + /* MOVE.W Dx,(Ay)+ */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line319) +{ + /* MOVE.W Ax,(Ay)+ */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line31A) +{ + /* MOVE.W (Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line31B) +{ + /* MOVE.W (Ax)+,(Ay)+ */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line31C) +{ + /* MOVE.W -(Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line31D) +{ + /* MOVE.W d(Ax),(Ay)+ */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line31E) +{ + /* MOVE.W d(Ax,Xi),(Ay)+ */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line31F) +{ + /* MOVE.W ,(Ay)+ */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(3, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line320) +{ + /* MOVE.W Dx,-(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line321) +{ + /* MOVE.W Ax,-(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line322) +{ + /* MOVE.W (Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line323) +{ + /* MOVE.W (Ax)+,-(Ay) */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line324) +{ + /* MOVE.W -(Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line325) +{ + /* MOVE.W d(Ax),-(Ay) */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line326) +{ + /* MOVE.W d(Ax,Xi),-(Ay) */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line327) +{ + /* MOVE.W ,-(Ay) */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(4, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line328) +{ + /* MOVE.W Dx,d(Ay) */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line329) +{ + /* MOVE.W Ax,d(Ay) */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line32A) +{ + /* MOVE.W (Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line32B) +{ + /* MOVE.W (Ax)+,d(Ay) */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line32C) +{ + /* MOVE.W -(Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line32D) +{ + /* MOVE.W d(Ax),d(Ay) */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line32E) +{ + /* MOVE.W d(Ax,Xi),d(Ay) */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line32F) +{ + /* MOVE.W ,d(Ay) */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(5, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line330) +{ + /* MOVE.W Dx,d(Ay,Xi) */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line331) +{ + /* MOVE.W Ax,d(Ay,Xi) */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line332) +{ + /* MOVE.W (Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line333) +{ + /* MOVE.W (Ax)+,d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line334) +{ + /* MOVE.W -(Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line335) +{ + /* MOVE.W d(Ax),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line336) +{ + /* MOVE.W d(Ax,Xi),d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line337) +{ + /* MOVE.W ,d(Ay,Xi) */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(6, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line338) +{ + /* MOVE.W Dx, */ + const int68_t a = (int68_t) REG68.d[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line339) +{ + /* MOVE.W Ax, */ + const int68_t a = (int68_t) REG68.a[reg0] << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line33A) +{ + /* MOVE.W (Ax), */ + const int68_t a = (int68_t) read_EAW(2,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line33B) +{ + /* MOVE.W (Ax)+, */ + const int68_t a = (int68_t) read_EAW(3,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line33C) +{ + /* MOVE.W -(Ax), */ + const int68_t a = (int68_t) read_EAW(4,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line33D) +{ + /* MOVE.W d(Ax), */ + const int68_t a = (int68_t) read_EAW(5,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line33E) +{ + /* MOVE.W d(Ax,Xi), */ + const int68_t a = (int68_t) read_EAW(6,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + +DECL_LINE68(line33F) +{ + /* MOVE.W , */ + const int68_t a = (int68_t) read_EAW(7,reg0) << WORD_FIX; + MOVEW(a); + write_EAW(7, reg9, a >> WORD_FIX); +} + Index: apps/codecs/libsc68/emu68/lines/line4.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line4.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line4.c (revision 0) @@ -0,0 +1,1022 @@ +/* line4.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 4: Miscellaneous */ + +static void funky4_m6_0(emu68_t * const emu68) +{ + RESET; +} + +static void funky4_m6_1(emu68_t * const emu68) +{ + NOP; +} + +static void funky4_m6_2(emu68_t * const emu68) +{ + STOP; +} + +static void funky4_m6_3(emu68_t * const emu68) +{ + RTE; +} + +static void funky4_m6_4(emu68_t * const emu68) +{ + ILLEGAL; +} + +static void funky4_m6_5(emu68_t * const emu68) +{ + RTS; +} + +static void funky4_m6_6(emu68_t * const emu68) +{ + TRAPV; +} + +static void funky4_m6_7(emu68_t * const emu68) +{ + RTR; +} + + +static void (*const funky4_m6_func[8])(emu68_t * const) = { + funky4_m6_0,funky4_m6_1,funky4_m6_2,funky4_m6_3, + funky4_m6_4,funky4_m6_5,funky4_m6_6,funky4_m6_7, +}; + +static void funky4_m0(emu68_t * const emu68, int reg0) +{ + const int a = ( 0 << 3 ) + reg0; + TRAP(a); +} + +static void funky4_m1(emu68_t * const emu68, int reg0) +{ + const int a = ( 1 << 3 ) + reg0; + TRAP(a); +} + +static void funky4_m2(emu68_t * const emu68, int reg0) +{ + LINK(reg0); +} + +static void funky4_m3(emu68_t * const emu68, int reg0) +{ + UNLK(reg0); +} + +static void funky4_m4(emu68_t * const emu68, int reg0) +{ + REG68.usp = REG68.a[reg0]; +} + +static void funky4_m5(emu68_t * const emu68, int reg0) +{ + REG68.a[reg0] = REG68.usp; +} + +static void funky4_m6(emu68_t * const emu68, int reg0) +{ + funky4_m6_func[reg0](emu68); +} + +static void funky4_m7(emu68_t * const emu68, int reg0) +{ + ILLEGAL; +} + +static void (* const funky4_func[8])(emu68_t * const, int) = { + funky4_m0,funky4_m1,funky4_m2,funky4_m3, + funky4_m4,funky4_m5,funky4_m6,funky4_m7, +}; + +static void movemregw(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t m = (u16) get_nextw(), addr; + s32 * r = REG68.d; + addr = get_eaw68[mode](emu68,reg0); + for(; m; r++, m>>=1) + if ( m & 1 ){ *r = read_W(addr); addr += 2; } + if ( mode == 3 ) REG68.a[reg0] = addr; +} + +static void movemregl(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t m = (u16) get_nextw(), addr; + s32 * r = REG68.d; + addr = get_eal68[mode](emu68,reg0); + for(; m; r++, m>>=1) + if ( m & 1 ){ *r = read_L(addr); addr += 4; } + if ( mode == 3 ) REG68.a[reg0] = addr; +} + +static void movemmemw(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t m = (u16)get_nextw(), addr; + if (mode==4) { + s32 * r = REG68.a+7; + addr = get_eaw68[3](emu68,reg0); + for(; m; r--, m>>=1) + if (m&1) write_W(addr-=2,*r); + REG68.a[reg0] = addr; + } else { + s32 * r = REG68.d; + addr = get_eaw68[mode](emu68,reg0); + for(; m; r++, m>>=1) + if (m&1) { write_W(addr,*r); addr+=2; } + } +} + +static void movemmeml(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t m = (u16)get_nextw(), addr; + if (mode==4) { + s32 * r = REG68.a+7; + addr = get_eal68[3](emu68,reg0); + for(; m; r--, m>>=1) + if (m&1) write_L(addr-=4,*r); + REG68.a[reg0] = addr; + } else { + s32 * r = REG68.d; + addr = get_eal68[mode](emu68,reg0); + for(; m; r++, m>>=1) + if (m&1) { write_L(addr,*r); addr+=4; } + } +} + +static void line4_r0_s0(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NEGX.B Dn */ + b = (uint68_t) REG68.d[reg0] << BYTE_FIX; + NEGXB(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( b >> BYTE_FIX ); + } else { + assert(mode != 1); + /* NEGX.B */ + const addr68_t addr = get_eab68[mode](emu68,reg0); + b = read_B(addr) << BYTE_FIX; + NEGXB(b,b); + write_B(addr, b >> BYTE_FIX); + } +} + +static void line4_r0_s1(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NEGX.W Dn */ + b = (uint68_t) REG68.d[reg0] << WORD_FIX; + NEGXW(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( b >> WORD_FIX ); + } else { + assert(mode != 1); + /* NEGX.W */ + const addr68_t addr = get_eaw68[mode](emu68,reg0); + b = read_W(addr) << WORD_FIX; + NEGXW(b,b); + write_W(addr, b >> WORD_FIX); + } +} + +static void line4_r0_s2(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NEGX.L Dn */ + b = (uint68_t) REG68.d[reg0] << LONG_FIX; + NEGXL(b,b); + REG68.d[reg0] = ( b >> LONG_FIX ); + } else { + assert(mode != 1); + /* NEGX.L */ + const addr68_t addr = get_eal68[mode](emu68,reg0); + b = read_L(addr) << LONG_FIX; + NEGXL(b,b); + write_L(addr, b >> LONG_FIX); + } +} + +static void line4_r0_s3(emu68_t * const emu68, int mode, int reg0) +{ + /* MOVE FROM SR */ + if (mode) + write_W(get_eaw68[mode](emu68,reg0),REG68.sr); + else + REG68.d[reg0] = (REG68.d[reg0]&0xFFFF0000) + (u16)REG68.sr; +} + +static void line4_r1_s0(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* CLR.B Dn */ + CLRB(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( b >> BYTE_FIX ); + } else { + assert(mode != 1); + /* CLR.B */ + const addr68_t addr = get_eab68[mode](emu68,reg0); + CLRB(b,b); + write_B(addr, b >> BYTE_FIX); + } +} + +static void line4_r1_s1(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* CLR.W Dn */ + CLRW(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( b >> WORD_FIX ); + } else { + assert(mode != 1); + /* CLR.W */ + const addr68_t addr = get_eaw68[mode](emu68,reg0); + CLRW(b,b); + write_W(addr, b >> WORD_FIX); + } +} + +static void line4_r1_s2(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* CLR.L Dn */ + CLRL(b,b); + REG68.d[reg0] = ( b >> LONG_FIX ); + } else { + assert(mode != 1); + /* CLR.L */ + const addr68_t addr = get_eal68[mode](emu68,reg0); + CLRL(b,b); + write_L(addr, b >> LONG_FIX); + } +} + +static void line4_r1_s3(emu68_t * const emu68, int mode, int reg0) +{ + ILLEGAL; +} + +static void line4_r2_s0(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NEG.B Dn */ + b = (uint68_t) REG68.d[reg0] << BYTE_FIX; + NEGB(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( b >> BYTE_FIX ); + } else { + assert(mode != 1); + /* NEG.B */ + const addr68_t addr = get_eab68[mode](emu68,reg0); + b = read_B(addr) << BYTE_FIX; + NEGB(b,b); + write_B(addr, b >> BYTE_FIX); + } +} + +static void line4_r2_s1(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NEG.W Dn */ + b = (uint68_t) REG68.d[reg0] << WORD_FIX; + NEGW(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( b >> WORD_FIX ); + } else { + assert(mode != 1); + /* NEG.W */ + const addr68_t addr = get_eaw68[mode](emu68,reg0); + b = read_W(addr) << WORD_FIX; + NEGW(b,b); + write_W(addr, b >> WORD_FIX); + } +} + +static void line4_r2_s2(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NEG.L Dn */ + b = (uint68_t) REG68.d[reg0] << LONG_FIX; + NEGL(b,b); + REG68.d[reg0] = ( b >> LONG_FIX ); + } else { + assert(mode != 1); + /* NEG.L */ + const addr68_t addr = get_eal68[mode](emu68,reg0); + b = read_L(addr) << LONG_FIX; + NEGL(b,b); + write_L(addr, b >> LONG_FIX); + } +} + +static void line4_r2_s3(emu68_t * const emu68, int mode, int reg0) +{ + /* MOVE TO CCR */ + if (mode) + SET_CCR(REG68.sr,read_W(get_eaw68[mode](emu68,reg0))); + else + SET_CCR(REG68.sr,REG68.d[reg0]); +} + +static void line4_r3_s0(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NOT.B Dn */ + b = (uint68_t) REG68.d[reg0] << BYTE_FIX; + NOTB(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( b >> BYTE_FIX ); + } else { + assert(mode != 1); + /* NOT.B */ + const addr68_t addr = get_eab68[mode](emu68,reg0); + b = read_B(addr) << BYTE_FIX; + NOTB(b,b); + write_B(addr, b >> BYTE_FIX); + } +} + +static void line4_r3_s1(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NOT.W Dn */ + b = (uint68_t) REG68.d[reg0] << WORD_FIX; + NOTW(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( b >> WORD_FIX ); + } else { + assert(mode != 1); + /* NOT.W */ + const addr68_t addr = get_eaw68[mode](emu68,reg0); + b = read_W(addr) << WORD_FIX; + NOTW(b,b); + write_W(addr, b >> WORD_FIX); + } +} + +static void line4_r3_s2(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NOT.L Dn */ + b = (uint68_t) REG68.d[reg0] << LONG_FIX; + NOTL(b,b); + REG68.d[reg0] = ( b >> LONG_FIX ); + } else { + assert(mode != 1); + /* NOT.L */ + const addr68_t addr = get_eal68[mode](emu68,reg0); + b = read_L(addr) << LONG_FIX; + NOTL(b,b); + write_L(addr, b >> LONG_FIX); + } +} + +static void line4_r3_s3(emu68_t * const emu68, int mode, int reg0) +{ + /* MOVE TO SR */ + if (mode) + REG68.sr = read_W(get_eaw68[mode](emu68,reg0)); + else + REG68.sr = (u16)REG68.d[reg0]; +} + +static void line4_r4_s0(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* NBCD.B Dn */ + b = (uint68_t) REG68.d[reg0] << BYTE_FIX; + NBCDB(b,b); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( b >> BYTE_FIX ); + } else { + assert(mode != 1); + /* NBCD.B */ + const addr68_t addr = get_eab68[mode](emu68,reg0); + b = read_B(addr) << BYTE_FIX; + NBCDB(b,b); + write_B(addr, b >> BYTE_FIX); + } +} + +static void line4_r4_s1(emu68_t * const emu68, int mode, int reg0) +{ + if (!mode) { + /* SWAP */ + SWAP(reg0); + } else { + /* PEA */ + pushl(get_eal68[mode](emu68,reg0)); + } +} + +static void line4_r4_s2(emu68_t * const emu68, int mode, int reg0) +{ + if (!mode) { + /* EXT.W Dn */ + const int68_t d = (int68_t) (s8) REG68.d[reg0] << WORD_FIX; + EXTW(d); + REG68.d[reg0] &= 0xFFFF0000; + REG68.d[reg0] |= (uint68_t) d >> WORD_FIX; + } else { + /* MOVEM.W REGS, */ + movemmemw(emu68, mode, reg0); + } +} + +static void line4_r4_s3(emu68_t * const emu68, int mode, int reg0) +{ + if (!mode) { + /* EXT.L Dn */ + const int68_t d = (int68_t) (s16) REG68.d[reg0] << LONG_FIX; + EXTL(d); + REG68.d[reg0] = d>>LONG_FIX; + } else { + /* MOVEM.L REGS, */ + movemmeml(emu68, mode, reg0); + } +} + +static void line4_r5_s0(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* TST.B Dn */ + b = (uint68_t) REG68.d[reg0] << BYTE_FIX; + TSTB(b,b); + } else { + assert(mode != 1); + /* TST.B */ + const addr68_t addr = get_eab68[mode](emu68,reg0); + b = read_B(addr) << BYTE_FIX; + TSTB(b,b); + } +} + +static void line4_r5_s1(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* TST.W Dn */ + b = (uint68_t) REG68.d[reg0] << WORD_FIX; + TSTW(b,b); + } else { + assert(mode != 1); + /* TST.W */ + const addr68_t addr = get_eaw68[mode](emu68,reg0); + b = read_W(addr) << WORD_FIX; + TSTW(b,b); + } +} + +static void line4_r5_s2(emu68_t * const emu68, int mode, int reg0) +{ + uint68_t b; + + if ( !mode ) { + /* TST.L Dn */ + b = (uint68_t) REG68.d[reg0] << LONG_FIX; + TSTL(b,b); + } else { + assert(mode != 1); + /* TST.L */ + const addr68_t addr = get_eal68[mode](emu68,reg0); + b = read_L(addr) << LONG_FIX; + TSTL(b,b); + } +} + +static void line4_r5_s3(emu68_t * const emu68, int mode, int reg0) +{ + if (mode<2) { + /* TAS.B Dn */ + int68_t a = (int68_t) REG68.d[reg0]; + TASB(a,a); + REG68.d[reg0] = a; + } else { + if ( mode == 7 && reg0 > 1 ) { + ILLEGAL; + } else { + /* TAS.B */ + const addr68_t l = get_eab68[mode](emu68,reg0); + int68_t a = read_B(l); + TASB(a,a); + write_B(l,a); + } + } +} + +static void line4_r6_s0(emu68_t * const emu68, int mode, int reg0) +{ + ILLEGAL; +} + +static void line4_r6_s1(emu68_t * const emu68, int mode, int reg0) +{ + ILLEGAL; +} + +static void line4_r6_s2(emu68_t * const emu68, int mode, int reg0) +{ + /* MOVEM.W ,REGS */ + movemregw(emu68,mode,reg0); +} + +static void line4_r6_s3(emu68_t * const emu68, int mode, int reg0) +{ + /* MOVEM.L ,REGS */ + movemregl(emu68,mode,reg0); +} + +static void line4_r7_s0(emu68_t * const emu68, int mode, int reg0) +{ + ILLEGAL; +} + +static void line4_r7_s1(emu68_t * const emu68, int mode, int reg0) +{ + funky4_func[mode](emu68,reg0); +} + +static void line4_r7_s2(emu68_t * const emu68, int mode, int reg0) +{ + /* JSR */ + const addr68_t pc = get_eal68[mode](emu68,reg0); + JSR(pc); +} + +static void line4_r7_s3(emu68_t * const emu68, int mode, int reg0) +{ + /* JMP */ + const addr68_t pc = get_eal68[mode](emu68,reg0); + JMP(pc); +} + +DECL_STATIC_LINE68((* const line4_0_func[8])) = { + line4_r0_s0,line4_r1_s0,line4_r2_s0,line4_r3_s0, + line4_r4_s0,line4_r5_s0,line4_r6_s0,line4_r7_s0, +}; + +DECL_STATIC_LINE68((* const line4_1_func[8])) = { + line4_r0_s1,line4_r1_s1,line4_r2_s1,line4_r3_s1, + line4_r4_s1,line4_r5_s1,line4_r6_s1,line4_r7_s1, +}; + +DECL_STATIC_LINE68((* const line4_2_func[8])) = { + line4_r0_s2,line4_r1_s2,line4_r2_s2,line4_r3_s2, + line4_r4_s2,line4_r5_s2,line4_r6_s2,line4_r7_s2, +}; + +DECL_STATIC_LINE68((* const line4_3_func[8])) = { + line4_r0_s3,line4_r1_s3,line4_r2_s3,line4_r3_s3, + line4_r4_s3,line4_r5_s3,line4_r6_s3,line4_r7_s3, +}; + +DECL_LINE68(line400) +{ + line4_0_func[reg9](emu68,0,reg0); +} + +DECL_LINE68(line401) +{ + line4_0_func[reg9](emu68,1,reg0); +} + +DECL_LINE68(line402) +{ + line4_0_func[reg9](emu68,2,reg0); +} + +DECL_LINE68(line403) +{ + line4_0_func[reg9](emu68,3,reg0); +} + +DECL_LINE68(line404) +{ + line4_0_func[reg9](emu68,4,reg0); +} + +DECL_LINE68(line405) +{ + line4_0_func[reg9](emu68,5,reg0); +} + +DECL_LINE68(line406) +{ + line4_0_func[reg9](emu68,6,reg0); +} + +DECL_LINE68(line407) +{ + line4_0_func[reg9](emu68,7,reg0); +} + +DECL_LINE68(line408) +{ + line4_1_func[reg9](emu68,0,reg0); +} + +DECL_LINE68(line409) +{ + line4_1_func[reg9](emu68,1,reg0); +} + +DECL_LINE68(line40A) +{ + line4_1_func[reg9](emu68,2,reg0); +} + +DECL_LINE68(line40B) +{ + line4_1_func[reg9](emu68,3,reg0); +} + +DECL_LINE68(line40C) +{ + line4_1_func[reg9](emu68,4,reg0); +} + +DECL_LINE68(line40D) +{ + line4_1_func[reg9](emu68,5,reg0); +} + +DECL_LINE68(line40E) +{ + line4_1_func[reg9](emu68,6,reg0); +} + +DECL_LINE68(line40F) +{ + line4_1_func[reg9](emu68,7,reg0); +} + +DECL_LINE68(line410) +{ + line4_2_func[reg9](emu68,0,reg0); +} + +DECL_LINE68(line411) +{ + line4_2_func[reg9](emu68,1,reg0); +} + +DECL_LINE68(line412) +{ + line4_2_func[reg9](emu68,2,reg0); +} + +DECL_LINE68(line413) +{ + line4_2_func[reg9](emu68,3,reg0); +} + +DECL_LINE68(line414) +{ + line4_2_func[reg9](emu68,4,reg0); +} + +DECL_LINE68(line415) +{ + line4_2_func[reg9](emu68,5,reg0); +} + +DECL_LINE68(line416) +{ + line4_2_func[reg9](emu68,6,reg0); +} + +DECL_LINE68(line417) +{ + line4_2_func[reg9](emu68,7,reg0); +} + +DECL_LINE68(line418) +{ + line4_3_func[reg9](emu68,0,reg0); +} + +DECL_LINE68(line419) +{ + line4_3_func[reg9](emu68,1,reg0); +} + +DECL_LINE68(line41A) +{ + line4_3_func[reg9](emu68,2,reg0); +} + +DECL_LINE68(line41B) +{ + line4_3_func[reg9](emu68,3,reg0); +} + +DECL_LINE68(line41C) +{ + line4_3_func[reg9](emu68,4,reg0); +} + +DECL_LINE68(line41D) +{ + line4_3_func[reg9](emu68,5,reg0); +} + +DECL_LINE68(line41E) +{ + line4_3_func[reg9](emu68,6,reg0); +} + +DECL_LINE68(line41F) +{ + line4_3_func[reg9](emu68,7,reg0); +} + +DECL_LINE68(line420) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:040 */ +#else + /* CHK.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line421) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:041 */ +#else + /* CHK.L An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +#endif +} + +DECL_LINE68(line422) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:042 */ +#else + /* CHK.L (An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line423) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:043 */ +#else + /* CHK.L (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line424) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:044 */ +#else + /* CHK.L -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line425) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:045 */ +#else + /* CHK.L d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line426) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:046 */ +#else + /* CHK.L d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line427) +{ +#ifndef EMU68_68020 + ILLEGAL; /* CHK.L op:047 */ +#else + /* CHK.L ,Dn */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CHKL(s,d); +#endif +} + +DECL_LINE68(line428) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line429) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line42A) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line42B) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line42C) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line42D) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line42E) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line42F) +{ + ILLEGAL; /* line:4 op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line430) +{ + /* CHK.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line431) +{ + /* CHK.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line432) +{ + /* CHK.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line433) +{ + /* CHK.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line434) +{ + /* CHK.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line435) +{ + /* CHK.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line436) +{ + /* CHK.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line437) +{ + /* CHK.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CHKW(s,d); +} + +DECL_LINE68(line438) +{ + /* LEA Dn,An */ + ILLEGAL; /* LEA Dn,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line439) +{ + /* LEA An,An */ + ILLEGAL; /* LEA An,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line43A) +{ + /* LEA (An),An */ + REG68.a[reg9] = (u32) REG68.a[reg0]; +} + +DECL_LINE68(line43B) +{ + /* LEA (An)+,An */ + ILLEGAL; /* LEA (An)+,An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line43C) +{ + /* LEA -(An),An */ + ILLEGAL; /* LEA -(An),An */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line43D) +{ + /* LEA d(An),An */ + REG68.a[reg9] = (u32) ( REG68.a[reg0] + get_nextw() ); +} + +DECL_LINE68(line43E) +{ + /* LEA d(An,Xi),An */ + REG68.a[reg9] = (u32) get_eal68[6](emu68,reg0); +} + +DECL_LINE68(line43F) +{ + /* LEA ,An */ + REG68.a[reg9] = (u32) get_eal68[7](emu68,reg0); +} + Index: apps/codecs/libsc68/emu68/lines/line5.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line5.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line5.c (revision 0) @@ -0,0 +1,583 @@ +/* line5.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 5: ADDQ/SUBQ/Scc/DBcc/TRAPcc */ + +DECL_LINE68(line500) +{ + /* ADDQ.B #Q,Dn */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line501) +{ + /* ADDQ.B #Q,An */ + ILLEGAL; /* .B not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line502) +{ + /* ADDQ.B #Q,(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line503) +{ + /* ADDQ.B #Q,(An)+ */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line504) +{ + /* ADDQ.B #Q,-(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line505) +{ + /* ADDQ.B #Q,d(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line506) +{ + /* ADDQ.B #Q,d(An,Xi) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line507) +{ + /* ADDQ.B #Q, */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line508) +{ + /* ADDQ.W #Q,Dn */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line509) +{ + /* ADDQ.W #Q,An */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg0] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line50A) +{ + /* ADDQ.W #Q,(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line50B) +{ + /* ADDQ.W #Q,(An)+ */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line50C) +{ + /* ADDQ.W #Q,-(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line50D) +{ + /* ADDQ.W #Q,d(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line50E) +{ + /* ADDQ.W #Q,d(An,Xi) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line50F) +{ + /* ADDQ.W #Q, */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line510) +{ + /* ADDQ.L #Q,Dn */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line511) +{ + /* ADDQ.L #Q,An */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg0] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line512) +{ + /* ADDQ.L #Q,(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line513) +{ + /* ADDQ.L #Q,(An)+ */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line514) +{ + /* ADDQ.L #Q,-(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line515) +{ + /* ADDQ.L #Q,d(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line516) +{ + /* ADDQ.L #Q,d(An,Xi) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line517) +{ + /* ADDQ.L #Q, */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line518) +{ + /* Scc Dn */ + const int r = SCC((reg9<<1)+0); + REG68.d[reg0] = (REG68.d[reg0]&0xFFFFFF00)+r; +} + +DECL_LINE68(line519) +{ + /* DBcc Dn, */ + DBCC(reg0,(reg9<<1)+0); +} + +DECL_LINE68(line51A) +{ + /* Scc (An) */ + const int r = SCC((reg9<<1)+0); + write_EAB(2,reg0,r); +} + +DECL_LINE68(line51B) +{ + /* Scc (An)+ */ + const int r = SCC((reg9<<1)+0); + write_EAB(3,reg0,r); +} + +DECL_LINE68(line51C) +{ + /* Scc -(An) */ + const int r = SCC((reg9<<1)+0); + write_EAB(4,reg0,r); +} + +DECL_LINE68(line51D) +{ + /* Scc d(An) */ + const int r = SCC((reg9<<1)+0); + write_EAB(5,reg0,r); +} + +DECL_LINE68(line51E) +{ + /* Scc d(An,Xi) */ + const int r = SCC((reg9<<1)+0); + write_EAB(6,reg0,r); +} + +DECL_LINE68(line51F) +{ + /* Scc */ + const int r = SCC((reg9<<1)+0); + write_EAB(7,reg0,r); +} + +DECL_LINE68(line520) +{ + /* SUBQ.B #Q,Dn */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line521) +{ + /* SUBQ.B #Q,An */ + ILLEGAL; /* .B not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line522) +{ + /* SUBQ.B #Q,(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line523) +{ + /* SUBQ.B #Q,(An)+ */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line524) +{ + /* SUBQ.B #Q,-(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line525) +{ + /* SUBQ.B #Q,d(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line526) +{ + /* SUBQ.B #Q,d(An,Xi) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line527) +{ + /* SUBQ.B #Q, */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line528) +{ + /* SUBQ.W #Q,Dn */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line529) +{ + /* SUBQ.W #Q,An */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg0] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line52A) +{ + /* SUBQ.W #Q,(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line52B) +{ + /* SUBQ.W #Q,(An)+ */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line52C) +{ + /* SUBQ.W #Q,-(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line52D) +{ + /* SUBQ.W #Q,d(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line52E) +{ + /* SUBQ.W #Q,d(An,Xi) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line52F) +{ + /* SUBQ.W #Q, */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line530) +{ + /* SUBQ.L #Q,Dn */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line531) +{ + /* SUBQ.L #Q,An */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg0] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line532) +{ + /* SUBQ.L #Q,(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line533) +{ + /* SUBQ.L #Q,(An)+ */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line534) +{ + /* SUBQ.L #Q,-(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line535) +{ + /* SUBQ.L #Q,d(An) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line536) +{ + /* SUBQ.L #Q,d(An,Xi) */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line537) +{ + /* SUBQ.L #Q, */ + const uint68_t s = ( (int68_t) ( ( ( reg9 - 1 ) & 7 ) + 1 ) << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line538) +{ + /* Scc Dn */ + const int r = SCC((reg9<<1)+1); + REG68.d[reg0] = (REG68.d[reg0]&0xFFFFFF00)+r; +} + +DECL_LINE68(line539) +{ + /* DBcc Dn, */ + DBCC(reg0,(reg9<<1)+1); +} + +DECL_LINE68(line53A) +{ + /* Scc (An) */ + const int r = SCC((reg9<<1)+1); + write_EAB(2,reg0,r); +} + +DECL_LINE68(line53B) +{ + /* Scc (An)+ */ + const int r = SCC((reg9<<1)+1); + write_EAB(3,reg0,r); +} + +DECL_LINE68(line53C) +{ + /* Scc -(An) */ + const int r = SCC((reg9<<1)+1); + write_EAB(4,reg0,r); +} + +DECL_LINE68(line53D) +{ + /* Scc d(An) */ + const int r = SCC((reg9<<1)+1); + write_EAB(5,reg0,r); +} + +DECL_LINE68(line53E) +{ + /* Scc d(An,Xi) */ + const int r = SCC((reg9<<1)+1); + write_EAB(6,reg0,r); +} + +DECL_LINE68(line53F) +{ + /* Scc */ + const int r = SCC((reg9<<1)+1); + write_EAB(7,reg0,r); +} + Index: apps/codecs/libsc68/emu68/lines/line6.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line6.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line6.c (revision 0) @@ -0,0 +1,527 @@ +/* line6.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 6: Bcc/BSR/BRA */ + +DECL_LINE68(line600) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + if (!reg0) + pc += get_nextw(); /* .W */ + else + pc += reg0; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line601) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +8; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line602) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +16; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line603) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +24; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line604) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +32; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line605) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +40; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line606) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +48; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line607) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +56; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line608) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +64; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line609) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +72; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line60A) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +80; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line60B) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +88; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line60C) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +96; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line60D) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0+104; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line60E) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0+112; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line60F) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0+120; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line610) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-128; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line611) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-120; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line612) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-112; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line613) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-104; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line614) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -96; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line615) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -88; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line616) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -80; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line617) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -72; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line618) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -64; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line619) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -56; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line61A) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -48; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line61B) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -40; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line61C) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -32; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line61D) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -24; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line61E) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -16; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line61F) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -8; /* .B */ + BCC(pc,(reg9<<1)+0); +} + +DECL_LINE68(line620) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + if (!reg0) + pc += get_nextw(); /* .W */ + else + pc += reg0; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line621) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +8; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line622) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +16; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line623) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +24; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line624) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +32; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line625) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +40; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line626) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +48; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line627) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +56; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line628) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +64; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line629) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +72; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line62A) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +80; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line62B) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +88; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line62C) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 +96; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line62D) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0+104; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line62E) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0+112; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line62F) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0+120; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line630) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-128; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line631) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-120; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line632) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-112; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line633) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0-104; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line634) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -96; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line635) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -88; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line636) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -80; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line637) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -72; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line638) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -64; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line639) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -56; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line63A) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -48; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line63B) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -40; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line63C) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -32; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line63D) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -24; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line63E) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -16; /* .B */ + BCC(pc,(reg9<<1)+1); +} + +DECL_LINE68(line63F) +{ + /* Bcc or BSR */ + uint68_t pc = REG68.pc; + pc += reg0 -8; /* .B */ + BCC(pc,(reg9<<1)+1); +} + Index: apps/codecs/libsc68/emu68/lines/line7.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line7.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line7.c (revision 0) @@ -0,0 +1,457 @@ +/* line7.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 7: MOVEQ */ + +DECL_LINE68(line700) +{ + /* MOVEQ #N,Dn [0..7] */ + int68_t a = reg0 +0; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line701) +{ + /* MOVEQ #N,Dn [8..15] */ + int68_t a = reg0 +8; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line702) +{ + /* MOVEQ #N,Dn [16..23] */ + int68_t a = reg0 +16; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line703) +{ + /* MOVEQ #N,Dn [24..31] */ + int68_t a = reg0 +24; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line704) +{ + /* MOVEQ #N,Dn [32..39] */ + int68_t a = reg0 +32; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line705) +{ + /* MOVEQ #N,Dn [40..47] */ + int68_t a = reg0 +40; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line706) +{ + /* MOVEQ #N,Dn [48..55] */ + int68_t a = reg0 +48; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line707) +{ + /* MOVEQ #N,Dn [56..63] */ + int68_t a = reg0 +56; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line708) +{ + /* MOVEQ #N,Dn [64..71] */ + int68_t a = reg0 +64; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line709) +{ + /* MOVEQ #N,Dn [72..79] */ + int68_t a = reg0 +72; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line70A) +{ + /* MOVEQ #N,Dn [80..87] */ + int68_t a = reg0 +80; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line70B) +{ + /* MOVEQ #N,Dn [88..95] */ + int68_t a = reg0 +88; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line70C) +{ + /* MOVEQ #N,Dn [96..103] */ + int68_t a = reg0 +96; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line70D) +{ + /* MOVEQ #N,Dn [104..111] */ + int68_t a = reg0 +104; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line70E) +{ + /* MOVEQ #N,Dn [112..119] */ + int68_t a = reg0 +112; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line70F) +{ + /* MOVEQ #N,Dn [120..127] */ + int68_t a = reg0 +120; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line710) +{ + /* MOVEQ #N,Dn [-128..-121] */ + int68_t a = reg0 -128; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line711) +{ + /* MOVEQ #N,Dn [-120..-113] */ + int68_t a = reg0 -120; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line712) +{ + /* MOVEQ #N,Dn [-112..-105] */ + int68_t a = reg0 -112; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line713) +{ + /* MOVEQ #N,Dn [-104..-97] */ + int68_t a = reg0 -104; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line714) +{ + /* MOVEQ #N,Dn [-96..-89] */ + int68_t a = reg0 -96; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line715) +{ + /* MOVEQ #N,Dn [-88..-81] */ + int68_t a = reg0 -88; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line716) +{ + /* MOVEQ #N,Dn [-80..-73] */ + int68_t a = reg0 -80; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line717) +{ + /* MOVEQ #N,Dn [-72..-65] */ + int68_t a = reg0 -72; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line718) +{ + /* MOVEQ #N,Dn [-64..-57] */ + int68_t a = reg0 -64; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line719) +{ + /* MOVEQ #N,Dn [-56..-49] */ + int68_t a = reg0 -56; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line71A) +{ + /* MOVEQ #N,Dn [-48..-41] */ + int68_t a = reg0 -48; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line71B) +{ + /* MOVEQ #N,Dn [-40..-33] */ + int68_t a = reg0 -40; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line71C) +{ + /* MOVEQ #N,Dn [-32..-25] */ + int68_t a = reg0 -32; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line71D) +{ + /* MOVEQ #N,Dn [-24..-17] */ + int68_t a = reg0 -24; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line71E) +{ + /* MOVEQ #N,Dn [-16..-9] */ + int68_t a = reg0 -16; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line71F) +{ + /* MOVEQ #N,Dn [-8..-1] */ + int68_t a = reg0 -8; + REG68.d[reg9] = (u32)a; + MOVEL(a); +} + +DECL_LINE68(line720) +{ + ILLEGAL; /* op:040 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line721) +{ + ILLEGAL; /* op:041 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line722) +{ + ILLEGAL; /* op:042 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line723) +{ + ILLEGAL; /* op:043 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line724) +{ + ILLEGAL; /* op:044 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line725) +{ + ILLEGAL; /* op:045 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line726) +{ + ILLEGAL; /* op:046 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line727) +{ + ILLEGAL; /* op:047 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line728) +{ + ILLEGAL; /* op:050 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line729) +{ + ILLEGAL; /* op:051 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line72A) +{ + ILLEGAL; /* op:052 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line72B) +{ + ILLEGAL; /* op:053 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line72C) +{ + ILLEGAL; /* op:054 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line72D) +{ + ILLEGAL; /* op:055 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line72E) +{ + ILLEGAL; /* op:056 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line72F) +{ + ILLEGAL; /* op:057 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line730) +{ + ILLEGAL; /* op:060 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line731) +{ + ILLEGAL; /* op:061 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line732) +{ + ILLEGAL; /* op:062 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line733) +{ + ILLEGAL; /* op:063 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line734) +{ + ILLEGAL; /* op:064 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line735) +{ + ILLEGAL; /* op:065 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line736) +{ + ILLEGAL; /* op:066 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line737) +{ + ILLEGAL; /* op:067 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line738) +{ + ILLEGAL; /* op:070 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line739) +{ + ILLEGAL; /* op:071 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line73A) +{ + ILLEGAL; /* op:072 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line73B) +{ + ILLEGAL; /* op:073 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line73C) +{ + ILLEGAL; /* op:074 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line73D) +{ + ILLEGAL; /* op:075 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line73E) +{ + ILLEGAL; /* op:076 */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line73F) +{ + ILLEGAL; /* op:077 */ + assert(EMU68_BREAK); +} + Index: apps/codecs/libsc68/emu68/lines/line8.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line8.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line8.c (revision 0) @@ -0,0 +1,583 @@ +/* line8.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 8: OR/DIV/SBCD */ + +DECL_LINE68(line800) +{ + /* ORR.B Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line801) +{ + /* ORR.B An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line802) +{ + /* ORR.B (An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(2,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line803) +{ + /* ORR.B (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAB(3,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line804) +{ + /* ORR.B -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(4,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line805) +{ + /* ORR.B d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(5,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line806) +{ + /* ORR.B d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAB(6,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line807) +{ + /* ORR.B ,Dn */ + const uint68_t s = ( (int68_t) read_EAB(7,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ORRB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line808) +{ + /* ORR.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line809) +{ + /* ORR.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line80A) +{ + /* ORR.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line80B) +{ + /* ORR.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line80C) +{ + /* ORR.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line80D) +{ + /* ORR.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line80E) +{ + /* ORR.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line80F) +{ + /* ORR.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ORRW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line810) +{ + /* ORR.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line811) +{ + /* ORR.L An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line812) +{ + /* ORR.L (An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line813) +{ + /* ORR.L (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line814) +{ + /* ORR.L -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line815) +{ + /* ORR.L d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line816) +{ + /* ORR.L d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line817) +{ + /* ORR.L ,Dn */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line818) +{ + /* DIVU.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line819) +{ + /* DIVU.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line81A) +{ + /* DIVU.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line81B) +{ + /* DIVU.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line81C) +{ + /* DIVU.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line81D) +{ + /* DIVU.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line81E) +{ + /* DIVU.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line81F) +{ + /* DIVU.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line820) +{ + /* SBCD Dy,Dx */ + int s = (u8) REG68.d[reg0]; + int d = (u8) REG68.d[reg9]; + SBCDB(d,s,d); + REG68.d[reg9] = (REG68.d[reg9] & 0xFFFFFF00) | d; +} + +DECL_LINE68(line821) +{ + /* SBCD -(Ay),-(Ax) */ + const addr68_t l0 = REG68.a[reg0] = (u32) ( REG68.a[reg0] - 1 ); + const addr68_t l9 = REG68.a[reg9] = (u32) ( REG68.a[reg9] - 1 ); + int s = read_B(l0); + int d = read_B(l9); + SBCDB(d,s,d); + write_B(l9,d); +} + +DECL_LINE68(line822) +{ + /* ORR.B Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line823) +{ + /* ORR.B Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line824) +{ + /* ORR.B Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line825) +{ + /* ORR.B Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line826) +{ + /* ORR.B Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line827) +{ + /* ORR.B Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ORRB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line828) +{ + ILLEGAL; /* EXG on other line (op:050) */ +} + +DECL_LINE68(line829) +{ + ILLEGAL; /* EXG on other line (op:051) */ +} + +DECL_LINE68(line82A) +{ + /* ORR.W Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line82B) +{ + /* ORR.W Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line82C) +{ + /* ORR.W Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line82D) +{ + /* ORR.W Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line82E) +{ + /* ORR.W Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line82F) +{ + /* ORR.W Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ORRW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line830) +{ + /* ORR.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + ORRL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line831) +{ + ILLEGAL; /* EXG on other line (op:061) */ +} + +DECL_LINE68(line832) +{ + /* ORR.L Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line833) +{ + /* ORR.L Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line834) +{ + /* ORR.L Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line835) +{ + /* ORR.L Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line836) +{ + /* ORR.L Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line837) +{ + /* ORR.L Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ORRL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line838) +{ + /* DIVS.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line839) +{ + /* DIVS.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(line83A) +{ + /* DIVS.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line83B) +{ + /* DIVS.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line83C) +{ + /* DIVS.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line83D) +{ + /* DIVS.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line83E) +{ + /* DIVS.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line83F) +{ + /* DIVS.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + DIVSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + Index: apps/codecs/libsc68/emu68/lines/line9.c =================================================================== --- apps/codecs/libsc68/emu68/lines/line9.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/line9.c (revision 0) @@ -0,0 +1,603 @@ +/* line9.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 9: SUB/SUBX */ + +DECL_LINE68(line900) +{ + /* SUB.B Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line901) +{ + /* SUB.B An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line902) +{ + /* SUB.B (An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(2,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line903) +{ + /* SUB.B (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAB(3,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line904) +{ + /* SUB.B -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(4,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line905) +{ + /* SUB.B d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(5,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line906) +{ + /* SUB.B d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAB(6,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line907) +{ + /* SUB.B ,Dn */ + const uint68_t s = ( (int68_t) read_EAB(7,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + SUBB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(line908) +{ + /* SUB.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line909) +{ + /* SUB.W An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line90A) +{ + /* SUB.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line90B) +{ + /* SUB.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line90C) +{ + /* SUB.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line90D) +{ + /* SUB.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line90E) +{ + /* SUB.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line90F) +{ + /* SUB.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + SUBW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(line910) +{ + /* SUB.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line911) +{ + /* SUB.L An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line912) +{ + /* SUB.L (An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line913) +{ + /* SUB.L (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line914) +{ + /* SUB.L -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line915) +{ + /* SUB.L d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line916) +{ + /* SUB.L d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line917) +{ + /* SUB.L ,Dn */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + SUBL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line918) +{ + /* SUBA.W Dn,An */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line919) +{ + /* SUBA.W An,An */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line91A) +{ + /* SUBA.W (An),An */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line91B) +{ + /* SUBA.W (An)+,An */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line91C) +{ + /* SUBA.W -(An),An */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line91D) +{ + /* SUBA.W d(An),An */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line91E) +{ + /* SUBA.W d(An,Xi),An */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line91F) +{ + /* SUBA.W ,An */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line920) +{ + int68_t a,b,s; + a = (int68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(line921) +{ + int68_t a,b,s; + a = read_B(REG68.a[reg0]-=1)<>BYTE_FIX); +} + +DECL_LINE68(line922) +{ + /* SUB.B Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line923) +{ + /* SUB.B Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line924) +{ + /* SUB.B Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line925) +{ + /* SUB.B Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line926) +{ + /* SUB.B Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line927) +{ + /* SUB.B Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + SUBB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(line928) +{ + int68_t a,b,s; + a = (int68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(line929) +{ + int68_t a,b,s; + a = read_W(REG68.a[reg0]-=2)<>WORD_FIX); +} + +DECL_LINE68(line92A) +{ + /* SUB.W Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line92B) +{ + /* SUB.W Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line92C) +{ + /* SUB.W Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line92D) +{ + /* SUB.W Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line92E) +{ + /* SUB.W Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line92F) +{ + /* SUB.W Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + SUBW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(line930) +{ + int68_t a,b,s; + a = (int68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(line931) +{ + int68_t a,b,s; + a = read_L(REG68.a[reg0]-=4)<>LONG_FIX); +} + +DECL_LINE68(line932) +{ + /* SUB.L Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line933) +{ + /* SUB.L Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line934) +{ + /* SUB.L Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line935) +{ + /* SUB.L Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line936) +{ + /* SUB.L Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line937) +{ + /* SUB.L Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + SUBL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(line938) +{ + /* SUBA.L Dn,An */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line939) +{ + /* SUBA.L An,An */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line93A) +{ + /* SUBA.L (An),An */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line93B) +{ + /* SUBA.L (An)+,An */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line93C) +{ + /* SUBA.L -(An),An */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line93D) +{ + /* SUBA.L d(An),An */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line93E) +{ + /* SUBA.L d(An,Xi),An */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(line93F) +{ + /* SUBA.L ,An */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + SUBAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + Index: apps/codecs/libsc68/emu68/lines/table.c =================================================================== --- apps/codecs/libsc68/emu68/lines/table.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/table.c (revision 0) @@ -0,0 +1,274 @@ +/* table.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line 10: d[reg0] */ + +#ifndef EMU68_MONOLITIC +EMU68_EXTERN linefunc68_t + line000,line001,line002,line003,line004,line005,line006,line007, + line008,line009,line00A,line00B,line00C,line00D,line00E,line00F, + line010,line011,line012,line013,line014,line015,line016,line017, + line018,line019,line01A,line01B,line01C,line01D,line01E,line01F, + line020,line021,line022,line023,line024,line025,line026,line027, + line028,line029,line02A,line02B,line02C,line02D,line02E,line02F, + line030,line031,line032,line033,line034,line035,line036,line037, + line038,line039,line03A,line03B,line03C,line03D,line03E,line03F, + line100,line101,line102,line103,line104,line105,line106,line107, + line108,line109,line10A,line10B,line10C,line10D,line10E,line10F, + line110,line111,line112,line113,line114,line115,line116,line117, + line118,line119,line11A,line11B,line11C,line11D,line11E,line11F, + line120,line121,line122,line123,line124,line125,line126,line127, + line128,line129,line12A,line12B,line12C,line12D,line12E,line12F, + line130,line131,line132,line133,line134,line135,line136,line137, + line138,line139,line13A,line13B,line13C,line13D,line13E,line13F, + line200,line201,line202,line203,line204,line205,line206,line207, + line208,line209,line20A,line20B,line20C,line20D,line20E,line20F, + line210,line211,line212,line213,line214,line215,line216,line217, + line218,line219,line21A,line21B,line21C,line21D,line21E,line21F, + line220,line221,line222,line223,line224,line225,line226,line227, + line228,line229,line22A,line22B,line22C,line22D,line22E,line22F, + line230,line231,line232,line233,line234,line235,line236,line237, + line238,line239,line23A,line23B,line23C,line23D,line23E,line23F, + line300,line301,line302,line303,line304,line305,line306,line307, + line308,line309,line30A,line30B,line30C,line30D,line30E,line30F, + line310,line311,line312,line313,line314,line315,line316,line317, + line318,line319,line31A,line31B,line31C,line31D,line31E,line31F, + line320,line321,line322,line323,line324,line325,line326,line327, + line328,line329,line32A,line32B,line32C,line32D,line32E,line32F, + line330,line331,line332,line333,line334,line335,line336,line337, + line338,line339,line33A,line33B,line33C,line33D,line33E,line33F, + line400,line401,line402,line403,line404,line405,line406,line407, + line408,line409,line40A,line40B,line40C,line40D,line40E,line40F, + line410,line411,line412,line413,line414,line415,line416,line417, + line418,line419,line41A,line41B,line41C,line41D,line41E,line41F, + line420,line421,line422,line423,line424,line425,line426,line427, + line428,line429,line42A,line42B,line42C,line42D,line42E,line42F, + line430,line431,line432,line433,line434,line435,line436,line437, + line438,line439,line43A,line43B,line43C,line43D,line43E,line43F, + line500,line501,line502,line503,line504,line505,line506,line507, + line508,line509,line50A,line50B,line50C,line50D,line50E,line50F, + line510,line511,line512,line513,line514,line515,line516,line517, + line518,line519,line51A,line51B,line51C,line51D,line51E,line51F, + line520,line521,line522,line523,line524,line525,line526,line527, + line528,line529,line52A,line52B,line52C,line52D,line52E,line52F, + line530,line531,line532,line533,line534,line535,line536,line537, + line538,line539,line53A,line53B,line53C,line53D,line53E,line53F, + line600,line601,line602,line603,line604,line605,line606,line607, + line608,line609,line60A,line60B,line60C,line60D,line60E,line60F, + line610,line611,line612,line613,line614,line615,line616,line617, + line618,line619,line61A,line61B,line61C,line61D,line61E,line61F, + line620,line621,line622,line623,line624,line625,line626,line627, + line628,line629,line62A,line62B,line62C,line62D,line62E,line62F, + line630,line631,line632,line633,line634,line635,line636,line637, + line638,line639,line63A,line63B,line63C,line63D,line63E,line63F, + line700,line701,line702,line703,line704,line705,line706,line707, + line708,line709,line70A,line70B,line70C,line70D,line70E,line70F, + line710,line711,line712,line713,line714,line715,line716,line717, + line718,line719,line71A,line71B,line71C,line71D,line71E,line71F, + line720,line721,line722,line723,line724,line725,line726,line727, + line728,line729,line72A,line72B,line72C,line72D,line72E,line72F, + line730,line731,line732,line733,line734,line735,line736,line737, + line738,line739,line73A,line73B,line73C,line73D,line73E,line73F, + line800,line801,line802,line803,line804,line805,line806,line807, + line808,line809,line80A,line80B,line80C,line80D,line80E,line80F, + line810,line811,line812,line813,line814,line815,line816,line817, + line818,line819,line81A,line81B,line81C,line81D,line81E,line81F, + line820,line821,line822,line823,line824,line825,line826,line827, + line828,line829,line82A,line82B,line82C,line82D,line82E,line82F, + line830,line831,line832,line833,line834,line835,line836,line837, + line838,line839,line83A,line83B,line83C,line83D,line83E,line83F, + line900,line901,line902,line903,line904,line905,line906,line907, + line908,line909,line90A,line90B,line90C,line90D,line90E,line90F, + line910,line911,line912,line913,line914,line915,line916,line917, + line918,line919,line91A,line91B,line91C,line91D,line91E,line91F, + line920,line921,line922,line923,line924,line925,line926,line927, + line928,line929,line92A,line92B,line92C,line92D,line92E,line92F, + line930,line931,line932,line933,line934,line935,line936,line937, + line938,line939,line93A,line93B,line93C,line93D,line93E,line93F, + lineA00,lineA01,lineA02,lineA03,lineA04,lineA05,lineA06,lineA07, + lineA08,lineA09,lineA0A,lineA0B,lineA0C,lineA0D,lineA0E,lineA0F, + lineA10,lineA11,lineA12,lineA13,lineA14,lineA15,lineA16,lineA17, + lineA18,lineA19,lineA1A,lineA1B,lineA1C,lineA1D,lineA1E,lineA1F, + lineA20,lineA21,lineA22,lineA23,lineA24,lineA25,lineA26,lineA27, + lineA28,lineA29,lineA2A,lineA2B,lineA2C,lineA2D,lineA2E,lineA2F, + lineA30,lineA31,lineA32,lineA33,lineA34,lineA35,lineA36,lineA37, + lineA38,lineA39,lineA3A,lineA3B,lineA3C,lineA3D,lineA3E,lineA3F, + lineB00,lineB01,lineB02,lineB03,lineB04,lineB05,lineB06,lineB07, + lineB08,lineB09,lineB0A,lineB0B,lineB0C,lineB0D,lineB0E,lineB0F, + lineB10,lineB11,lineB12,lineB13,lineB14,lineB15,lineB16,lineB17, + lineB18,lineB19,lineB1A,lineB1B,lineB1C,lineB1D,lineB1E,lineB1F, + lineB20,lineB21,lineB22,lineB23,lineB24,lineB25,lineB26,lineB27, + lineB28,lineB29,lineB2A,lineB2B,lineB2C,lineB2D,lineB2E,lineB2F, + lineB30,lineB31,lineB32,lineB33,lineB34,lineB35,lineB36,lineB37, + lineB38,lineB39,lineB3A,lineB3B,lineB3C,lineB3D,lineB3E,lineB3F, + lineC00,lineC01,lineC02,lineC03,lineC04,lineC05,lineC06,lineC07, + lineC08,lineC09,lineC0A,lineC0B,lineC0C,lineC0D,lineC0E,lineC0F, + lineC10,lineC11,lineC12,lineC13,lineC14,lineC15,lineC16,lineC17, + lineC18,lineC19,lineC1A,lineC1B,lineC1C,lineC1D,lineC1E,lineC1F, + lineC20,lineC21,lineC22,lineC23,lineC24,lineC25,lineC26,lineC27, + lineC28,lineC29,lineC2A,lineC2B,lineC2C,lineC2D,lineC2E,lineC2F, + lineC30,lineC31,lineC32,lineC33,lineC34,lineC35,lineC36,lineC37, + lineC38,lineC39,lineC3A,lineC3B,lineC3C,lineC3D,lineC3E,lineC3F, + lineD00,lineD01,lineD02,lineD03,lineD04,lineD05,lineD06,lineD07, + lineD08,lineD09,lineD0A,lineD0B,lineD0C,lineD0D,lineD0E,lineD0F, + lineD10,lineD11,lineD12,lineD13,lineD14,lineD15,lineD16,lineD17, + lineD18,lineD19,lineD1A,lineD1B,lineD1C,lineD1D,lineD1E,lineD1F, + lineD20,lineD21,lineD22,lineD23,lineD24,lineD25,lineD26,lineD27, + lineD28,lineD29,lineD2A,lineD2B,lineD2C,lineD2D,lineD2E,lineD2F, + lineD30,lineD31,lineD32,lineD33,lineD34,lineD35,lineD36,lineD37, + lineD38,lineD39,lineD3A,lineD3B,lineD3C,lineD3D,lineD3E,lineD3F, + lineE00,lineE01,lineE02,lineE03,lineE04,lineE05,lineE06,lineE07, + lineE08,lineE09,lineE0A,lineE0B,lineE0C,lineE0D,lineE0E,lineE0F, + lineE10,lineE11,lineE12,lineE13,lineE14,lineE15,lineE16,lineE17, + lineE18,lineE19,lineE1A,lineE1B,lineE1C,lineE1D,lineE1E,lineE1F, + lineE20,lineE21,lineE22,lineE23,lineE24,lineE25,lineE26,lineE27, + lineE28,lineE29,lineE2A,lineE2B,lineE2C,lineE2D,lineE2E,lineE2F, + lineE30,lineE31,lineE32,lineE33,lineE34,lineE35,lineE36,lineE37, + lineE38,lineE39,lineE3A,lineE3B,lineE3C,lineE3D,lineE3E,lineE3F, + lineF00,lineF01,lineF02,lineF03,lineF04,lineF05,lineF06,lineF07, + lineF08,lineF09,lineF0A,lineF0B,lineF0C,lineF0D,lineF0E,lineF0F, + lineF10,lineF11,lineF12,lineF13,lineF14,lineF15,lineF16,lineF17, + lineF18,lineF19,lineF1A,lineF1B,lineF1C,lineF1D,lineF1E,lineF1F, + lineF20,lineF21,lineF22,lineF23,lineF24,lineF25,lineF26,lineF27, + lineF28,lineF29,lineF2A,lineF2B,lineF2C,lineF2D,lineF2E,lineF2F, + lineF30,lineF31,lineF32,lineF33,lineF34,lineF35,lineF36,lineF37, + lineF38,lineF39,lineF3A,lineF3B,lineF3C,lineF3D,lineF3E,lineF3F; +#endif + + +linefunc68_t *line_func[1024] = +{ + line000,line001,line002,line003,line004,line005,line006,line007, + line008,line009,line00A,line00B,line00C,line00D,line00E,line00F, + line010,line011,line012,line013,line014,line015,line016,line017, + line018,line019,line01A,line01B,line01C,line01D,line01E,line01F, + line020,line021,line022,line023,line024,line025,line026,line027, + line028,line029,line02A,line02B,line02C,line02D,line02E,line02F, + line030,line031,line032,line033,line034,line035,line036,line037, + line038,line039,line03A,line03B,line03C,line03D,line03E,line03F, + line100,line101,line102,line103,line104,line105,line106,line107, + line108,line109,line10A,line10B,line10C,line10D,line10E,line10F, + line110,line111,line112,line113,line114,line115,line116,line117, + line118,line119,line11A,line11B,line11C,line11D,line11E,line11F, + line120,line121,line122,line123,line124,line125,line126,line127, + line128,line129,line12A,line12B,line12C,line12D,line12E,line12F, + line130,line131,line132,line133,line134,line135,line136,line137, + line138,line139,line13A,line13B,line13C,line13D,line13E,line13F, + line200,line201,line202,line203,line204,line205,line206,line207, + line208,line209,line20A,line20B,line20C,line20D,line20E,line20F, + line210,line211,line212,line213,line214,line215,line216,line217, + line218,line219,line21A,line21B,line21C,line21D,line21E,line21F, + line220,line221,line222,line223,line224,line225,line226,line227, + line228,line229,line22A,line22B,line22C,line22D,line22E,line22F, + line230,line231,line232,line233,line234,line235,line236,line237, + line238,line239,line23A,line23B,line23C,line23D,line23E,line23F, + line300,line301,line302,line303,line304,line305,line306,line307, + line308,line309,line30A,line30B,line30C,line30D,line30E,line30F, + line310,line311,line312,line313,line314,line315,line316,line317, + line318,line319,line31A,line31B,line31C,line31D,line31E,line31F, + line320,line321,line322,line323,line324,line325,line326,line327, + line328,line329,line32A,line32B,line32C,line32D,line32E,line32F, + line330,line331,line332,line333,line334,line335,line336,line337, + line338,line339,line33A,line33B,line33C,line33D,line33E,line33F, + line400,line401,line402,line403,line404,line405,line406,line407, + line408,line409,line40A,line40B,line40C,line40D,line40E,line40F, + line410,line411,line412,line413,line414,line415,line416,line417, + line418,line419,line41A,line41B,line41C,line41D,line41E,line41F, + line420,line421,line422,line423,line424,line425,line426,line427, + line428,line429,line42A,line42B,line42C,line42D,line42E,line42F, + line430,line431,line432,line433,line434,line435,line436,line437, + line438,line439,line43A,line43B,line43C,line43D,line43E,line43F, + line500,line501,line502,line503,line504,line505,line506,line507, + line508,line509,line50A,line50B,line50C,line50D,line50E,line50F, + line510,line511,line512,line513,line514,line515,line516,line517, + line518,line519,line51A,line51B,line51C,line51D,line51E,line51F, + line520,line521,line522,line523,line524,line525,line526,line527, + line528,line529,line52A,line52B,line52C,line52D,line52E,line52F, + line530,line531,line532,line533,line534,line535,line536,line537, + line538,line539,line53A,line53B,line53C,line53D,line53E,line53F, + line600,line601,line602,line603,line604,line605,line606,line607, + line608,line609,line60A,line60B,line60C,line60D,line60E,line60F, + line610,line611,line612,line613,line614,line615,line616,line617, + line618,line619,line61A,line61B,line61C,line61D,line61E,line61F, + line620,line621,line622,line623,line624,line625,line626,line627, + line628,line629,line62A,line62B,line62C,line62D,line62E,line62F, + line630,line631,line632,line633,line634,line635,line636,line637, + line638,line639,line63A,line63B,line63C,line63D,line63E,line63F, + line700,line701,line702,line703,line704,line705,line706,line707, + line708,line709,line70A,line70B,line70C,line70D,line70E,line70F, + line710,line711,line712,line713,line714,line715,line716,line717, + line718,line719,line71A,line71B,line71C,line71D,line71E,line71F, + line720,line721,line722,line723,line724,line725,line726,line727, + line728,line729,line72A,line72B,line72C,line72D,line72E,line72F, + line730,line731,line732,line733,line734,line735,line736,line737, + line738,line739,line73A,line73B,line73C,line73D,line73E,line73F, + line800,line801,line802,line803,line804,line805,line806,line807, + line808,line809,line80A,line80B,line80C,line80D,line80E,line80F, + line810,line811,line812,line813,line814,line815,line816,line817, + line818,line819,line81A,line81B,line81C,line81D,line81E,line81F, + line820,line821,line822,line823,line824,line825,line826,line827, + line828,line829,line82A,line82B,line82C,line82D,line82E,line82F, + line830,line831,line832,line833,line834,line835,line836,line837, + line838,line839,line83A,line83B,line83C,line83D,line83E,line83F, + line900,line901,line902,line903,line904,line905,line906,line907, + line908,line909,line90A,line90B,line90C,line90D,line90E,line90F, + line910,line911,line912,line913,line914,line915,line916,line917, + line918,line919,line91A,line91B,line91C,line91D,line91E,line91F, + line920,line921,line922,line923,line924,line925,line926,line927, + line928,line929,line92A,line92B,line92C,line92D,line92E,line92F, + line930,line931,line932,line933,line934,line935,line936,line937, + line938,line939,line93A,line93B,line93C,line93D,line93E,line93F, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00,lineA00, + lineB00,lineB01,lineB02,lineB03,lineB04,lineB05,lineB06,lineB07, + lineB08,lineB09,lineB0A,lineB0B,lineB0C,lineB0D,lineB0E,lineB0F, + lineB10,lineB11,lineB12,lineB13,lineB14,lineB15,lineB16,lineB17, + lineB18,lineB19,lineB1A,lineB1B,lineB1C,lineB1D,lineB1E,lineB1F, + lineB20,lineB21,lineB22,lineB23,lineB24,lineB25,lineB26,lineB27, + lineB28,lineB29,lineB2A,lineB2B,lineB2C,lineB2D,lineB2E,lineB2F, + lineB30,lineB31,lineB32,lineB33,lineB34,lineB35,lineB36,lineB37, + lineB38,lineB39,lineB3A,lineB3B,lineB3C,lineB3D,lineB3E,lineB3F, + lineC00,lineC01,lineC02,lineC03,lineC04,lineC05,lineC06,lineC07, + lineC08,lineC09,lineC0A,lineC0B,lineC0C,lineC0D,lineC0E,lineC0F, + lineC10,lineC11,lineC12,lineC13,lineC14,lineC15,lineC16,lineC17, + lineC18,lineC19,lineC1A,lineC1B,lineC1C,lineC1D,lineC1E,lineC1F, + lineC20,lineC21,lineC22,lineC23,lineC24,lineC25,lineC26,lineC27, + lineC28,lineC29,lineC2A,lineC2B,lineC2C,lineC2D,lineC2E,lineC2F, + lineC30,lineC31,lineC32,lineC33,lineC34,lineC35,lineC36,lineC37, + lineC38,lineC39,lineC3A,lineC3B,lineC3C,lineC3D,lineC3E,lineC3F, + lineD00,lineD01,lineD02,lineD03,lineD04,lineD05,lineD06,lineD07, + lineD08,lineD09,lineD0A,lineD0B,lineD0C,lineD0D,lineD0E,lineD0F, + lineD10,lineD11,lineD12,lineD13,lineD14,lineD15,lineD16,lineD17, + lineD18,lineD19,lineD1A,lineD1B,lineD1C,lineD1D,lineD1E,lineD1F, + lineD20,lineD21,lineD22,lineD23,lineD24,lineD25,lineD26,lineD27, + lineD28,lineD29,lineD2A,lineD2B,lineD2C,lineD2D,lineD2E,lineD2F, + lineD30,lineD31,lineD32,lineD33,lineD34,lineD35,lineD36,lineD37, + lineD38,lineD39,lineD3A,lineD3B,lineD3C,lineD3D,lineD3E,lineD3F, + lineE00,lineE01,lineE02,lineE03,lineE04,lineE05,lineE06,lineE07, + lineE08,lineE09,lineE0A,lineE0B,lineE0C,lineE0D,lineE0E,lineE0F, + lineE10,lineE11,lineE12,lineE13,lineE14,lineE15,lineE16,lineE17, + lineE18,lineE19,lineE1A,lineE1B,lineE1C,lineE1D,lineE1E,lineE1F, + lineE20,lineE21,lineE22,lineE23,lineE24,lineE25,lineE26,lineE27, + lineE28,lineE29,lineE2A,lineE2B,lineE2C,lineE2D,lineE2E,lineE2F, + lineE30,lineE31,lineE32,lineE33,lineE34,lineE35,lineE36,lineE37, + lineE38,lineE39,lineE3A,lineE3B,lineE3C,lineE3D,lineE3E,lineE3F, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, + lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00,lineF00, +}; + Index: apps/codecs/libsc68/emu68/lines/lineA.c =================================================================== --- apps/codecs/libsc68/emu68/lines/lineA.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/lineA.c (revision 0) @@ -0,0 +1,14 @@ +/* lineA.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line A: (Unassigned, Reserved) */ + +DECL_LINE68(lineA00) +{ + LINEA; +} + Index: apps/codecs/libsc68/emu68/lines/lineB.c =================================================================== --- apps/codecs/libsc68/emu68/lines/lineB.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/lineB.c (revision 0) @@ -0,0 +1,575 @@ +/* lineB.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line B: CMP/EOR */ + +DECL_LINE68(lineB00) +{ + /* CMP.B Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB01) +{ + /* CMP.B An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB02) +{ + /* CMP.B (An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(2,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB03) +{ + /* CMP.B (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAB(3,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB04) +{ + /* CMP.B -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(4,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB05) +{ + /* CMP.B d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(5,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB06) +{ + /* CMP.B d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAB(6,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB07) +{ + /* CMP.B ,Dn */ + const uint68_t s = ( (int68_t) read_EAB(7,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + CMPB(s,d); +} + +DECL_LINE68(lineB08) +{ + /* CMP.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB09) +{ + /* CMP.W An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB0A) +{ + /* CMP.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB0B) +{ + /* CMP.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB0C) +{ + /* CMP.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB0D) +{ + /* CMP.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB0E) +{ + /* CMP.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB0F) +{ + /* CMP.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + CMPW(s,d); +} + +DECL_LINE68(lineB10) +{ + /* CMP.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB11) +{ + /* CMP.L An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB12) +{ + /* CMP.L (An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB13) +{ + /* CMP.L (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB14) +{ + /* CMP.L -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB15) +{ + /* CMP.L d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB16) +{ + /* CMP.L d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB17) +{ + /* CMP.L ,Dn */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + CMPL(s,d); +} + +DECL_LINE68(lineB18) +{ + /* CMPA.W Dn,An */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB19) +{ + /* CMPA.W An,An */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB1A) +{ + /* CMPA.W (An),An */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB1B) +{ + /* CMPA.W (An)+,An */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB1C) +{ + /* CMPA.W -(An),An */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB1D) +{ + /* CMPA.W d(An),An */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB1E) +{ + /* CMPA.W d(An,Xi),An */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB1F) +{ + /* CMPA.W ,An */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAW(s,d); +} + +DECL_LINE68(lineB20) +{ + /* EOR.B Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << BYTE_FIX; + EORB(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineB21) +{ + /* CMPM.B (Ay)+,(Ax)+ */ + int68_t y0, x9; addr68_t l; + l = (s32) REG68.a[reg0]; + REG68.a[reg0] = (u32) ( REG68.a[reg0] + 1 ); + y0 = read_B(l) << BYTE_FIX; + l = (s32) REG68.a[reg9]; + REG68.a[reg9] = (u32) ( REG68.a[reg9] + 1 ); + x9 = read_B(l) << BYTE_FIX; + CMPB(y0,x9); +} + +DECL_LINE68(lineB22) +{ + /* EOR.B Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineB23) +{ + /* EOR.B Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineB24) +{ + /* EOR.B Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineB25) +{ + /* EOR.B Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineB26) +{ + /* EOR.B Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineB27) +{ + /* EOR.B Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + EORB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineB28) +{ + /* EOR.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << WORD_FIX; + EORW(d,s,d); + REG68.d[reg0] = ( REG68.d[reg0] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineB29) +{ + /* CMPM.W (Ay)+,(Ax)+ */ + int68_t y0, x9; addr68_t l; + l = (s32) REG68.a[reg0]; + REG68.a[reg0] = (u32) ( REG68.a[reg0] + 2 ); + y0 = read_W(l) << WORD_FIX; + l = (s32) REG68.a[reg9]; + REG68.a[reg9] = (u32) ( REG68.a[reg9] + 2 ); + x9 = read_W(l) << WORD_FIX; + CMPW(y0,x9); +} + +DECL_LINE68(lineB2A) +{ + /* EOR.W Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineB2B) +{ + /* EOR.W Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineB2C) +{ + /* EOR.W Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineB2D) +{ + /* EOR.W Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineB2E) +{ + /* EOR.W Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineB2F) +{ + /* EOR.W Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + EORW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineB30) +{ + /* EOR.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + EORL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineB31) +{ + /* CMPM.L (Ay)+,(Ax)+ */ + int68_t y0, x9; addr68_t l; + l = (s32) REG68.a[reg0]; + REG68.a[reg0] = (u32) ( REG68.a[reg0] + 4 ); + y0 = read_L(l) << LONG_FIX; + l = (s32) REG68.a[reg9]; + REG68.a[reg9] = (u32) ( REG68.a[reg9] + 4 ); + x9 = read_L(l) << LONG_FIX; + CMPL(y0,x9); +} + +DECL_LINE68(lineB32) +{ + /* EOR.L Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineB33) +{ + /* EOR.L Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineB34) +{ + /* EOR.L Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineB35) +{ + /* EOR.L Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineB36) +{ + /* EOR.L Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineB37) +{ + /* EOR.L Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + EORL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineB38) +{ + /* CMPA.L Dn,An */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB39) +{ + /* CMPA.L An,An */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB3A) +{ + /* CMPA.L (An),An */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB3B) +{ + /* CMPA.L (An)+,An */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB3C) +{ + /* CMPA.L -(An),An */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB3D) +{ + /* CMPA.L d(An),An */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB3E) +{ + /* CMPA.L d(An,Xi),An */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + +DECL_LINE68(lineB3F) +{ + /* CMPA.L ,An */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + CMPAL(s,d); +} + Index: apps/codecs/libsc68/emu68/lines/lineC.c =================================================================== --- apps/codecs/libsc68/emu68/lines/lineC.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/lineC.c (revision 0) @@ -0,0 +1,586 @@ +/* lineC.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line C: AND/MUL/ABCD/EXG */ + +DECL_LINE68(lineC00) +{ + /* AND.B Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC01) +{ + /* AND.B An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(lineC02) +{ + /* AND.B (An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(2,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC03) +{ + /* AND.B (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAB(3,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC04) +{ + /* AND.B -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(4,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC05) +{ + /* AND.B d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(5,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC06) +{ + /* AND.B d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAB(6,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC07) +{ + /* AND.B ,Dn */ + const uint68_t s = ( (int68_t) read_EAB(7,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ANDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineC08) +{ + /* AND.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC09) +{ + /* AND.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(lineC0A) +{ + /* AND.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC0B) +{ + /* AND.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC0C) +{ + /* AND.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC0D) +{ + /* AND.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC0E) +{ + /* AND.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC0F) +{ + /* AND.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ANDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineC10) +{ + /* AND.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC11) +{ + /* AND.L An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(lineC12) +{ + /* AND.L (An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC13) +{ + /* AND.L (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC14) +{ + /* AND.L -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC15) +{ + /* AND.L d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC16) +{ + /* AND.L d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC17) +{ + /* AND.L ,Dn */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC18) +{ + /* MULU.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC19) +{ + /* MULU.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(lineC1A) +{ + /* MULU.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC1B) +{ + /* MULU.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC1C) +{ + /* MULU.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC1D) +{ + /* MULU.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC1E) +{ + /* MULU.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC1F) +{ + /* MULU.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULUW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC20) +{ + /* ABCD Dy,Dx */ + int s = (u8) REG68.d[reg0]; + int d = (u8) REG68.d[reg9]; + ABCDB(d,s,d); + REG68.d[reg9] = (REG68.d[reg9] & 0xFFFFFF00) | d; +} + +DECL_LINE68(lineC21) +{ + /* ABCD -(Ay),-(Ax) */ + const addr68_t l0 = REG68.a[reg0] = (u32) ( REG68.a[reg0] - 1 ); + const addr68_t l9 = REG68.a[reg9] = (u32) ( REG68.a[reg9] - 1 ); + int s = read_B(l0); + int d = read_B(l9); + ABCDB(d,s,d); + write_B(l9,d); +} + +DECL_LINE68(lineC22) +{ + /* AND.B Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineC23) +{ + /* AND.B Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineC24) +{ + /* AND.B Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineC25) +{ + /* AND.B Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineC26) +{ + /* AND.B Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineC27) +{ + /* AND.B Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ANDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineC28) +{ + /* EXG Dx,Dy */ + EXG(reg9,reg0); +} + +DECL_LINE68(lineC29) +{ + /* EXG Ax,Ay */ + EXG(reg9+8,reg0+8); +} + +DECL_LINE68(lineC2A) +{ + /* AND.W Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineC2B) +{ + /* AND.W Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineC2C) +{ + /* AND.W Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineC2D) +{ + /* AND.W Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineC2E) +{ + /* AND.W Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineC2F) +{ + /* AND.W Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ANDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineC30) +{ + /* AND.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg0] << LONG_FIX; + ANDL(d,s,d); + REG68.d[reg0] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC31) +{ + /* EXG Dx,Ay */ + EXG(reg9,reg0+8); +} + +DECL_LINE68(lineC32) +{ + /* AND.L Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineC33) +{ + /* AND.L Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineC34) +{ + /* AND.L Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineC35) +{ + /* AND.L Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineC36) +{ + /* AND.L Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineC37) +{ + /* AND.L Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ANDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineC38) +{ + /* MULS.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC39) +{ + /* MULS.W An,Dn */ + ILLEGAL; /* source An not allowed */ + assert(EMU68_BREAK); +} + +DECL_LINE68(lineC3A) +{ + /* MULS.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC3B) +{ + /* MULS.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC3C) +{ + /* MULS.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC3D) +{ + /* MULS.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC3E) +{ + /* MULS.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineC3F) +{ + /* MULS.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + MULSW(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + Index: apps/codecs/libsc68/emu68/lines/lineD.c =================================================================== --- apps/codecs/libsc68/emu68/lines/lineD.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/lineD.c (revision 0) @@ -0,0 +1,603 @@ +/* lineD.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line D: ADD/ADDX */ + +DECL_LINE68(lineD00) +{ + /* ADD.B Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD01) +{ + /* ADD.B An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD02) +{ + /* ADD.B (An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(2,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD03) +{ + /* ADD.B (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAB(3,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD04) +{ + /* ADD.B -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(4,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD05) +{ + /* ADD.B d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAB(5,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD06) +{ + /* ADD.B d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAB(6,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD07) +{ + /* ADD.B ,Dn */ + const uint68_t s = ( (int68_t) read_EAB(7,reg0) << BYTE_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << BYTE_FIX; + ADDB(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & BYTE_MSK ) + ( d >> BYTE_FIX ); +} + +DECL_LINE68(lineD08) +{ + /* ADD.W Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD09) +{ + /* ADD.W An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD0A) +{ + /* ADD.W (An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD0B) +{ + /* ADD.W (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD0C) +{ + /* ADD.W -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD0D) +{ + /* ADD.W d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD0E) +{ + /* ADD.W d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD0F) +{ + /* ADD.W ,Dn */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << WORD_FIX; + ADDW(d,s,d); + REG68.d[reg9] = ( REG68.d[reg9] & WORD_MSK ) + ( d >> WORD_FIX ); +} + +DECL_LINE68(lineD10) +{ + /* ADD.L Dn,Dn */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD11) +{ + /* ADD.L An,Dn */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD12) +{ + /* ADD.L (An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD13) +{ + /* ADD.L (An)+,Dn */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD14) +{ + /* ADD.L -(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD15) +{ + /* ADD.L d(An),Dn */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD16) +{ + /* ADD.L d(An,Xi),Dn */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD17) +{ + /* ADD.L ,Dn */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.d[reg9] << LONG_FIX; + ADDL(d,s,d); + REG68.d[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD18) +{ + /* ADDA.W Dn,An */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD19) +{ + /* ADDA.W An,An */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD1A) +{ + /* ADDA.W (An),An */ + const uint68_t s = ( (int68_t) read_EAW(2,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD1B) +{ + /* ADDA.W (An)+,An */ + const uint68_t s = ( (int68_t) read_EAW(3,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD1C) +{ + /* ADDA.W -(An),An */ + const uint68_t s = ( (int68_t) read_EAW(4,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD1D) +{ + /* ADDA.W d(An),An */ + const uint68_t s = ( (int68_t) read_EAW(5,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD1E) +{ + /* ADDA.W d(An,Xi),An */ + const uint68_t s = ( (int68_t) read_EAW(6,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD1F) +{ + /* ADDA.W ,An */ + const uint68_t s = ( (int68_t) read_EAW(7,reg0) << WORD_FIX ) >> 16; + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAW(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD20) +{ + int68_t a,b,s; + a = (int68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineD21) +{ + int68_t a,b,s; + a = read_B(REG68.a[reg0]-=1)<>BYTE_FIX); +} + +DECL_LINE68(lineD22) +{ + /* ADD.B Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(2,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineD23) +{ + /* ADD.B Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(3,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineD24) +{ + /* ADD.B Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(4,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineD25) +{ + /* ADD.B Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(5,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineD26) +{ + /* ADD.B Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(6,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineD27) +{ + /* ADD.B Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << BYTE_FIX ); + const addr68_t l = get_EAB(7,reg0); + uint68_t d = read_B(l) << BYTE_FIX; + ADDB(d,s,d); + write_B(l, d >> BYTE_FIX); +} + +DECL_LINE68(lineD28) +{ + int68_t a,b,s; + a = (int68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineD29) +{ + int68_t a,b,s; + a = read_W(REG68.a[reg0]-=2)<>WORD_FIX); +} + +DECL_LINE68(lineD2A) +{ + /* ADD.W Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(2,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineD2B) +{ + /* ADD.W Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(3,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineD2C) +{ + /* ADD.W Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(4,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineD2D) +{ + /* ADD.W Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(5,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineD2E) +{ + /* ADD.W Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(6,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineD2F) +{ + /* ADD.W Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << WORD_FIX ); + const addr68_t l = get_EAW(7,reg0); + uint68_t d = read_W(l) << WORD_FIX; + ADDW(d,s,d); + write_W(l, d >> WORD_FIX); +} + +DECL_LINE68(lineD30) +{ + int68_t a,b,s; + a = (int68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineD31) +{ + int68_t a,b,s; + a = read_L(REG68.a[reg0]-=4)<>LONG_FIX); +} + +DECL_LINE68(lineD32) +{ + /* ADD.L Dn,(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(2,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineD33) +{ + /* ADD.L Dn,(An)+ */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(3,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineD34) +{ + /* ADD.L Dn,-(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(4,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineD35) +{ + /* ADD.L Dn,d(An) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(5,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineD36) +{ + /* ADD.L Dn,d(An,Xi) */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(6,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineD37) +{ + /* ADD.L Dn, */ + const uint68_t s = ( (int68_t) REG68.d[reg9] << LONG_FIX ); + const addr68_t l = get_EAL(7,reg0); + uint68_t d = read_L(l) << LONG_FIX; + ADDL(d,s,d); + write_L(l, d >> LONG_FIX); +} + +DECL_LINE68(lineD38) +{ + /* ADDA.L Dn,An */ + const uint68_t s = ( (int68_t) REG68.d[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD39) +{ + /* ADDA.L An,An */ + const uint68_t s = ( (int68_t) REG68.a[reg0] << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD3A) +{ + /* ADDA.L (An),An */ + const uint68_t s = ( (int68_t) read_EAL(2,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD3B) +{ + /* ADDA.L (An)+,An */ + const uint68_t s = ( (int68_t) read_EAL(3,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD3C) +{ + /* ADDA.L -(An),An */ + const uint68_t s = ( (int68_t) read_EAL(4,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD3D) +{ + /* ADDA.L d(An),An */ + const uint68_t s = ( (int68_t) read_EAL(5,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD3E) +{ + /* ADDA.L d(An,Xi),An */ + const uint68_t s = ( (int68_t) read_EAL(6,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + +DECL_LINE68(lineD3F) +{ + /* ADDA.L ,An */ + const uint68_t s = ( (int68_t) read_EAL(7,reg0) << LONG_FIX ); + uint68_t d = (int68_t) REG68.a[reg9] << LONG_FIX; + ADDAL(d,s,d); + REG68.a[reg9] = ( d >> LONG_FIX ); +} + Index: apps/codecs/libsc68/emu68/lines/lineE.c =================================================================== --- apps/codecs/libsc68/emu68/lines/lineE.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/lineE.c (revision 0) @@ -0,0 +1,603 @@ +/* lineE.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line E: Shift/Rotate/Bit Field */ + +static void ASR_mem(emu68_t * const emu68, int reg, int mode) +{ + /* ASR.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void LSR_mem(emu68_t * const emu68, int reg, int mode) +{ + /* LSR.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void ROXR_mem(emu68_t * const emu68, int reg, int mode) +{ + /* ROXR.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void ROR_mem(emu68_t * const emu68, int reg, int mode) +{ + /* ROR.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void ASL_mem(emu68_t * const emu68, int reg, int mode) +{ + /* ASL.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void LSL_mem(emu68_t * const emu68, int reg, int mode) +{ + /* LSL.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void ROXL_mem(emu68_t * const emu68, int reg, int mode) +{ + /* ROXL.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void ROL_mem(emu68_t * const emu68, int reg, int mode) +{ + /* ROL.W */ + const addr68_t l = get_EAW(mode,reg); + int68_t a = read_W(l)<>WORD_FIX); +} + +static void (*const lslmemR_fc[4])(emu68_t *const,int,int)= +{ + ASR_mem, LSR_mem, ROXR_mem, ROR_mem, +}; + +static void (*const lslmemL_fc[4])(emu68_t *const,int,int)= +{ + ASL_mem, LSL_mem, ROXL_mem, ROL_mem, +}; + +DECL_LINE68(lineE00) +{ + /* ASR.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE01) +{ + /* LSR.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE02) +{ + /* ROXR.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE03) +{ + /* ROR.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE04) +{ + /* ASR.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE05) +{ + /* LSR.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE06) +{ + /* ROXR.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE07) +{ + /* ROR.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE08) +{ + /* ASR.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE09) +{ + /* LSR.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE0A) +{ + /* ROXR.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE0B) +{ + /* ROR.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE0C) +{ + /* ASR.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE0D) +{ + /* LSR.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE0E) +{ + /* ROXR.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE0F) +{ + /* ROR.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE10) +{ + /* ASR.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE11) +{ + /* LSR.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE12) +{ + /* ROXR.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE13) +{ + /* ROR.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE14) +{ + /* ASR.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE15) +{ + /* LSR.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE16) +{ + /* ROXR.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE17) +{ + /* ROR.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE18) +{ + lslmemR_fc[reg9&3](emu68,reg0,0); +} + +DECL_LINE68(lineE19) +{ + lslmemR_fc[reg9&3](emu68,reg0,1); +} + +DECL_LINE68(lineE1A) +{ + lslmemR_fc[reg9&3](emu68,reg0,2); +} + +DECL_LINE68(lineE1B) +{ + lslmemR_fc[reg9&3](emu68,reg0,3); +} + +DECL_LINE68(lineE1C) +{ + lslmemR_fc[reg9&3](emu68,reg0,4); +} + +DECL_LINE68(lineE1D) +{ + lslmemR_fc[reg9&3](emu68,reg0,5); +} + +DECL_LINE68(lineE1E) +{ + lslmemR_fc[reg9&3](emu68,reg0,6); +} + +DECL_LINE68(lineE1F) +{ + lslmemR_fc[reg9&3](emu68,reg0,7); +} + +DECL_LINE68(lineE20) +{ + /* ASL.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE21) +{ + /* LSL.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE22) +{ + /* ROXL.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE23) +{ + /* ROL.B #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE24) +{ + /* ASL.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE25) +{ + /* LSL.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE26) +{ + /* ROXL.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE27) +{ + /* ROL.B Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>BYTE_FIX); +} + +DECL_LINE68(lineE28) +{ + /* ASL.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE29) +{ + /* LSL.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE2A) +{ + /* ROXL.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE2B) +{ + /* ROL.W #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE2C) +{ + /* ASL.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE2D) +{ + /* LSL.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE2E) +{ + /* ROXL.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE2F) +{ + /* ROL.W Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>WORD_FIX); +} + +DECL_LINE68(lineE30) +{ + /* ASL.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE31) +{ + /* LSL.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE32) +{ + /* ROXL.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE33) +{ + /* ROL.L #d,Dn */ + const int d = ((reg9-1)&7)+1; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE34) +{ + /* ASL.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE35) +{ + /* LSL.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE36) +{ + /* ROXL.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE37) +{ + /* ROL.L Dn,Dn */ + const int d = REG68.d[reg9]; + uint68_t a = (uint68_t)REG68.d[reg0]<>LONG_FIX); +} + +DECL_LINE68(lineE38) +{ + lslmemL_fc[reg9&3](emu68,reg0,0); +} + +DECL_LINE68(lineE39) +{ + lslmemL_fc[reg9&3](emu68,reg0,1); +} + +DECL_LINE68(lineE3A) +{ + lslmemL_fc[reg9&3](emu68,reg0,2); +} + +DECL_LINE68(lineE3B) +{ + lslmemL_fc[reg9&3](emu68,reg0,3); +} + +DECL_LINE68(lineE3C) +{ + lslmemL_fc[reg9&3](emu68,reg0,4); +} + +DECL_LINE68(lineE3D) +{ + lslmemL_fc[reg9&3](emu68,reg0,5); +} + +DECL_LINE68(lineE3E) +{ + lslmemL_fc[reg9&3](emu68,reg0,6); +} + +DECL_LINE68(lineE3F) +{ + lslmemL_fc[reg9&3](emu68,reg0,7); +} + Index: apps/codecs/libsc68/emu68/lines/lineF.c =================================================================== --- apps/codecs/libsc68/emu68/lines/lineF.c (revision 0) +++ apps/codecs/libsc68/emu68/lines/lineF.c (revision 0) @@ -0,0 +1,14 @@ +/* lineF.c - EMU68 generated code by + * gen68 2009-06-12 07:20:25 + * Copyright (C) 1998-2009 Benjamin Gerard + * + * $Id$ + */ + +/* Line F: Coprocessor Interface/MC68040 and CPU32 Extensions */ + +DECL_LINE68(lineF00) +{ + LINEF; +} + Index: apps/codecs/libsc68/emu68/mem68.c =================================================================== --- apps/codecs/libsc68/emu68/mem68.c (revision 0) +++ apps/codecs/libsc68/emu68/mem68.c (revision 0) @@ -0,0 +1,312 @@ +/* + * emu68 - 68000 memory and IO access + * Copyright (C) 1998-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "mem68.h" + +/** Test for direct memory access or IO quick table access */ +#define ISIO68(ADDR) ((ADDR)&0x800000) + +/* Set memory access check flags. */ +static void chkframe(emu68_t * const emu68, addr68_t addr, const int flags) +{ + int oldchk = emu68->chk[addr]; + if ((oldchk&flags) != flags) { + emu68->framechk |= flags; + emu68->chk[addr] = oldchk|flags; + } +} + +static void chkframe_b(emu68_t * const emu68, const int flags) +{ + chkframe(emu68, emu68->bus_addr&MEMMSK68, flags); +} + +static void chkframe_w(emu68_t * const emu68, const int flags) +{ + chkframe(emu68, (emu68->bus_addr+0)&MEMMSK68, flags); + chkframe(emu68, (emu68->bus_addr+1)&MEMMSK68, flags); +} + +static void chkframe_l(emu68_t * const emu68, const int flags) +{ + chkframe(emu68, (emu68->bus_addr+0)&MEMMSK68, flags); + chkframe(emu68, (emu68->bus_addr+1)&MEMMSK68, flags); + chkframe(emu68, (emu68->bus_addr+3)&MEMMSK68, flags); + chkframe(emu68, (emu68->bus_addr+4)&MEMMSK68, flags); +} + + +/* ,--------------------------------------------------------. + * | | + * | 68000 memory access functions | + * | | + * | These functions don't check address/bus access nor | + * | and privilege access violation. | + * | | + * `--------------------------------------------------------' + */ + + +/* ,--------------------------------------------------------. + * | Dummy IO | + * `--------------------------------------------------------' + */ + +static void dummy_read (io68_t * const io) {} +static void dummy_write (io68_t * const io) {} +static interrupt68_t* dummy_interrupt(io68_t * const io, const cycle68_t cycle) { return 0; } +static cycle68_t dummy_next_interrupt(io68_t * const io, const cycle68_t cycle) { return 0; } +static void dummy_adjust_cycle(io68_t * const io, const cycle68_t cycle) {} +static int dummy_reset(io68_t * const io) { return 0; } +static void dummy_destroy(io68_t * const io) {} + +static io68_t dummy_io = { + 0,"Onboard-Memory",0,0, + dummy_read,dummy_read,dummy_read, + dummy_write,dummy_write,dummy_write, + dummy_interrupt,dummy_next_interrupt, + dummy_adjust_cycle,dummy_reset,dummy_destroy,0 +}; + + +/* ,--------------------------------------------------------. + * | Read functions | + * `--------------------------------------------------------' + */ + +void mem68_read_b(emu68_t * const emu68) +{ + const addr68_t addr = emu68->bus_addr; + if (ISIO68(addr)) { + io68_t * const io = emu68->mapped_io[(u8)((addr)>>8)]; + io->r_byte(io); + } else { + emu68->bus_data = emu68->mem[addr&MEMMSK68]; + if (emu68->chk) { + chkframe_b(emu68, EMU68_R); + } + } +} + +void mem68_read_w(emu68_t * const emu68) +{ + const addr68_t addr = emu68->bus_addr; + if (ISIO68(addr)) { + io68_t * const io = emu68->mapped_io[(u8)((addr)>>8)]; + io->r_word(io); + } else { + const u8 * const mem = emu68->mem+(addr&MEMMSK68); + emu68->bus_data = (mem[0]<<8) + mem[1]; + if (emu68->chk) { + chkframe_w(emu68, EMU68_R); + } + } +} + +void mem68_read_l(emu68_t * const emu68) +{ + const addr68_t addr = emu68->bus_addr; + if (ISIO68(addr)) { + io68_t * const io = emu68->mapped_io[(u8)((addr)>>8)]; + io->r_long(io); + } else { + const u8 * const mem = emu68->mem+(addr&MEMMSK68); + emu68->bus_data = (mem[0]<<24) + (mem[1]<<16) + (mem[2]<<8) + mem[3]; + if (emu68->chk) { + chkframe_l(emu68, EMU68_R); + } + } +} + + +/* ,--------------------------------------------------------. + * | Write functions | + * `--------------------------------------------------------' + */ + +void mem68_write_b(emu68_t * emu68) +{ + const addr68_t addr = emu68->bus_addr; + if (ISIO68(addr)) { + io68_t * const io = emu68->mapped_io[(u8)((addr)>>8)]; + io->w_byte(io); + } else { + emu68->mem[addr&MEMMSK68] = emu68->bus_data; + if (emu68->chk) { + chkframe_b(emu68, EMU68_W); + } + } +} + +void mem68_write_w(emu68_t * emu68) +{ + const addr68_t addr = emu68->bus_addr; + if (ISIO68(addr)) { + io68_t * const io = emu68->mapped_io[(u8)((addr)>>8)]; + io->w_word(io); + } else { + u8 * mem = emu68->mem + (addr&MEMMSK68); + int68_t v = emu68->bus_data; + mem[1] = v; v>>=8; mem[0] = v; + if (emu68->chk) { + chkframe_w(emu68, EMU68_W); + } + } +} + +void mem68_write_l(emu68_t * emu68) +{ + const addr68_t addr = emu68->bus_addr; + if (ISIO68(addr)) { + io68_t * const io = emu68->mapped_io[(u8)((addr)>>8)]; + io->w_long(io); + } else { + u8 * mem = emu68->mem + (addr&MEMMSK68); + int68_t v = emu68->bus_data; + mem[3] = v; v>>=8; mem[2] = v; v>>=8; mem[1] = v; v>>=8; mem[0] = v; + if (emu68->chk) { + chkframe_l(emu68, EMU68_W); + } + } +} + + +/* Read 68000 (PC)+ word + * - This version assume PC is in 68000 memory + * as long I don't try to make 68000 execute + * @ IO address, I assume it is not possible ! + */ + +int68_t mem68_nextw(emu68_t * const emu68) +{ + int68_t v; + u8 *mem = emu68->mem+(REG68.pc&MEMMSK68); + v = (int68_t)(s8)mem[0]<<8; + v |= mem[1]; + if (emu68->chk) { + chkframe_w(emu68, EMU68_R+EMU68_X); + } + REG68.pc += 2; + return v; +} + +int68_t mem68_nextl(emu68_t * const emu68) +{ + int68_t v; + u8 *mem = emu68->mem+(REG68.pc&MEMMSK68); + v = (int68_t)(s8)mem[0]<<24; + v |= mem[1]<<16; + v |= mem[2]<< 8; + v |= mem[3]; + if (emu68->chk) { + chkframe_l(emu68, EMU68_R+EMU68_X); + } + REG68.pc += 4; + return v; +} + +void mem68_pushw(emu68_t * emu68, int68_t v) +{ + REG68.a[7] -= 2; + write_W(REG68.a[7],v); +} + +void mem68_pushl(emu68_t * emu68, int68_t v) +{ + REG68.a[7] -= 4; + write_L(REG68.a[7],v); +} + +int68_t mem68_popl(emu68_t * emu68) +{ + int68_t v = (s32)read_L(REG68.a[7]); + REG68.a[7] += 4; + return v; +} + +int68_t mem68_popw(emu68_t * emu68) +{ + s32 v = read_W(REG68.a[7]); + REG68.a[7] += 2; + return v; +} + + +void emu68_pushl(emu68_t * const emu68, int68_t val) +{ + if (emu68) + mem68_pushl(emu68, val); +} + +void emu68_pushw(emu68_t * const emu68, int68_t val) +{ + if (emu68) + mem68_pushw(emu68, val); +} + + +int68_t emu68_popl(emu68_t * emu68) +{ + return emu68 + ? mem68_popl(emu68) + : -1 + ; +} + +int68_t emu68_popw(emu68_t * emu68) +{ + return emu68 + ? mem68_popw(emu68) + : -1 + ; +} + +/* Init memory quick acces table for SC68 + */ +void emu68_mem_init(emu68_t * emu68) +{ + emu68_mem_reset(emu68); +} + +/* Reset memory quick acces table for SC68 + */ +void emu68_mem_reset(emu68_t * emu68) +{ + if (emu68) { + int i; + for(i=0; i<256; i++) { + emu68_mem_reset_area(emu68, (u8)i); + } + } +} + +/* Reset memory acces control area to normal state : + */ +void emu68_mem_reset_area(emu68_t * emu68, u8 area) +{ + emu68->mapped_io[area] = &dummy_io; +} Index: apps/codecs/libsc68/emu68/lines68.h =================================================================== --- apps/codecs/libsc68/emu68/lines68.h (revision 0) +++ apps/codecs/libsc68/emu68/lines68.h (revision 0) @@ -0,0 +1,38 @@ +/** + * @ingroup emu68_lib + * @file emu68/lines68.h + * @brief 68k instructions header. + * @date 2009/05/08 + * @author Benjamin Gerard + * + * The lines68.h header file should include all files required for + * compiling instruction emulator files. + * + */ + +/* $Id$ */ + +#ifndef _EMU68_LINES68_H_ +#define _EMU68_LINES68_H_ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "assert68.h" +#include "excep68.h" +#include "emu68.h" +#include "inst68.h" +#include "macro68.h" + +#include "inl68_exception.h" +#include "inl68_arithmetic.h" +#include "inl68_bcd.h" +#include "inl68_bitmanip.h" +#include "inl68_datamove.h" +#include "inl68_logic.h" +#include "inl68_progctrl.h" +#include "inl68_shifting.h" +#include "inl68_systctrl.h" + +#endif /* #ifndef _EMU68_LINES68_H_ */ Index: apps/codecs/libsc68/emu68/inl68_shifting.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_shifting.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_shifting.h (revision 0) @@ -0,0 +1,223 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_shifting.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k bit shifting inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_SHIFTING_H_ +#define _INL68_SHIFTING_H_ + +static inline +void inl_swap68(emu68_t * const emu68, int dn) +{ + uint68_t v = (u32) REG68.d[dn]; + REG68.d[dn] = v = ( v >> 16 ) + ( (int68_t)(u16)v << 16 ); + REG68.sr = ( REG68.sr & ( 0xFF00 | SR_X ) ) + | ( !v << SR_Z_BIT ) + | ( ( v >> (31 - SR_N_BIT) ) & SR_N ) + ; +} + +static inline +int68_t inl_lsl68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + int ccr; + + s &= 63; + inl_addcycle68(emu68, 2*s); + if (--s < 0) { + ccr = REG68.sr & SR_X; /* X unaffected on no shift */ + } else if ((unsigned)s > SIGN_BIT) { + d = 0; + ccr = 0; + } else { + d <<= s; + ccr = ( d >> SIGN_BIT ) & ( SR_X | SR_C ); /* X & C */ + d <<= 1; + } + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = (REG68.sr & 0xFF00) | ccr; + return d; +} + +static inline +int68_t inl_lsr68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + int ccr; + + s &= 63; + inl_addcycle68(emu68, 2*s); + if (--s < 0) { + ccr = REG68.sr & SR_X; /* X unaffected on no shift */ + } else if ((unsigned)s > SIGN_BIT) { + d = 0; /* shift > word width; X is 0 */ + ccr = 0; + } else { + const uint68_t m = NRM_MSK(l); + d >>= s; + ccr = -( ( d >> ( SIGN_BIT - l ) ) & 1 ) & ( SR_X | SR_C ); /* X & C */ + d = ( d >> 1 ) & m; + } + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = (REG68.sr & 0xFF00) | ccr; + return d; +} + +static inline +int68_t inl_asl68(emu68_t * const emu68, int68_t d, int s, const int l) +{ + int ccr; + + s &= 63; + inl_addcycle68(emu68, 2*s); + if (--s < 0) { + ccr = REG68.sr & SR_X; /* X unaffected on no shift */ + } else if (s > l) { + ccr = -!!d & SR_V; /* V */ + d = 0; + } else { + int68_t r = d; + d <<= s; + ccr = ( d >> SIGN_BIT ) & ( SR_X | SR_C ); /* X & C */ + d <<= 1; + ccr |= -( r != ( (d >> s) >> 1 ) ) & SR_V; /* V on shift can't be revert */ + } + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = ( REG68.sr & 0xFF00 ) | ccr; + return d; +} + +static inline +int68_t inl_asr68(emu68_t * const emu68, int68_t d, int s, const int l) +{ + int ccr; + + s &= 63; + inl_addcycle68(emu68, 2*s); + if (--s < 0) { + ccr = REG68.sr & SR_X; /* X unaffected on no shift */ + } else if (s > l) { + d >>= SIGN_BIT; /* shift > word width; X is MSB */ + ccr = (int) d & ( SR_C | SR_X ); /* X & C is MSB */ + } else { + const uint68_t m = NRM_MSK(l); + d >>= s; + ccr = -( ( d >> ( SIGN_BIT - l ) ) & 1 ) & ( SR_X | SR_C ); /* X & C */ + d = ( d >> 1 ) & m; + } + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = (REG68.sr & 0xFF00) | ccr; + return d; +} + +static inline +int68_t inl_rol68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + int ccr = REG68.sr & (0xFF00 | SR_X); /* X unaffected */ + + if (s &= 63) { + const uint68_t m = NRM_MSK(l); + inl_addcycle68(emu68, 2*s); + d = ( ( d << ( s & l ) ) | ( d >> ( -s & l ) ) ) & m; + ccr |= -( ( d >> (SIGN_FIX - l) ) & 1 ) & SR_C; /* C is LSB */ + } + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = ccr; + return d; +} + +static inline +int68_t inl_ror68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + int ccr = REG68.sr & (0xFF00 | SR_X); /* X unaffected */ + + if (s &= 63) { + const uint68_t m = NRM_MSK(l); + inl_addcycle68(emu68, 2*s); + d = ( ( d >> ( s & l ) ) | ( d << ( -s & l ) ) ) & m; + ccr |= ( d >> ( SIGN_BIT - SR_C_BIT ) ) & SR_C; /* C is MSB */ + } + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = ccr; + return d; +} + +static inline +int68_t inl_roxl68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + int ccr = REG68.sr & ( 0xFF00 | SR_X ); /* X is unaffected on no shift */ + + if (s &= 63) { + const uint68_t m = NRM_MSK(l); + inl_addcycle68(emu68, 2*s); + s %= (l+2); /* s := [0 .. l+1] */ + if (--s >= 0) { /* s := [0 .. l] */ + uint68_t x, c, r = d; + + r <<= s; + c = (ccr >> SR_X_BIT) & 1; /* old X */ + x = r >> SIGN_BIT; /* new X */ + ccr = -(int)x & SR_X; + r <<= 1; + r |= c << ( SIGN_BIT - l + s ); + d >>= 1; + d >>= l - s; + d |= r; + d &= m; + } + } + + ccr |= (ccr & SR_X) >> (SR_X_BIT - SR_C_BIT); /* C is X whatever shift */ + ccr |= -!d & SR_Z; + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; + REG68.sr = ccr; + return d; +} + +static inline +int68_t inl_roxr68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + int ccr = REG68.sr & ( 0xFF00 | SR_X ); /* X unaffected on no shift */ + + s &= 63; + inl_addcycle68(emu68, 2*s); + if (s) { + const uint68_t m = NRM_MSK(l); + s %= l + 2; /* s := [0 .. l+1] */ + if (--s >= 0) { /* s := [0 .. l] */ + uint68_t r = d; + uint68_t x, c; + + d >>= s; + c = (ccr >> SR_X_BIT) & 1; /* old X */ + x = (d >> (SIGN_BIT-l)) & 1; /* new X */ + ccr = -(int)x & SR_X; + d >>= 1; + d |= c << (SIGN_BIT-s); + r <<= 1; + r <<= l-s; + d |= r; + d &= m; + } + } + ccr |= (ccr & SR_X) >> (SR_X_BIT - SR_C_BIT); /* C is X */ + ccr |= -!d & SR_Z; /* Z */ + ccr |= ( d >> ( SIGN_BIT - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = ccr; + return d; +} + +#endif /* #ifndef _INL68_SHIFTING_H_ */ Index: apps/codecs/libsc68/emu68/mem68.h =================================================================== --- apps/codecs/libsc68/emu68/mem68.h (revision 0) +++ apps/codecs/libsc68/emu68/mem68.h (revision 0) @@ -0,0 +1,356 @@ +/** + * @ingroup emu68_lib + * @file emu68/mem68.h + * @author Benjamin Gerard + * @date 1999/03/13 + * @brief 68k memory and IO manager header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_MEM68_H_ +#define _EMU68_MEM68_H_ + +#include "emu68_api.h" +#include "struct68.h" + +/** @defgroup emu68_lib_mem68 68k memory and IO manager + * @ingroup emu68_lib + * @brief Handling memory and I/O access. + * + * EMU68 memory manager assumes that all addresses in the lowest + * half part of address space are memory access. A simple bit test + * over most signifiant bit (23) of address allow to choose beetween + * memory or eventual IO access. In case of memory access, address + * is masked to fit available 68K onboard memory. Overflow does NOT + * generate address error. IO access are performed towards quick + * access tables. There are 6 acccess tables: for each read and + * write access in 3 sizes (byte, word and long). Each of this 6 + * tables has 256 entries filled with a pointer to suitable + * function. At init time, the entries of all tables are initialized + * to access 68K onboard memory. When an IO is plugged by user, it + * is mapped somewhere in 68K address space. EMU68 memory manager + * get bit 8 to 15 of address to make an index to be used in the + * suitable table (R/W for B/W/L). + * + * Featuring : + * - Onboard memory byte, word and long read/write access. + * - Optimized IO warm mapping/unmapping. + * - Optionnal (compile time) enhanced memory control with RWX access + * tag and hardware breakpoints. + * + * Limitations : + * - For optimization purposes IO must be mapped in high half memory + * (bit 23 of address setted). + * - Two IO can not shared the same memory location for bit 8 to 15. + * Conflicts could be resolved by creating an intermediate IO which + * dispatches to others. This mechanism has not been implemented yet, + * so users must do it themself if needed. + * + * Atari-ST & Amiga IO areas : + * - @p FF8800-FF88FF : YM2149 (ST) + * - @p FF8900-FF89FF : Micro-Wire (STE) + * - @p FF8200-FF82FF : Shifter (ST) + * - @p FFFA00-FFFAFF : MFP (ST) + * - @p DFF000-DFF0DF : Paula (AMIGA) + * + * @{ + */ + +/** Memory access flags for emu68_t::chk (debug mode only). */ +enum { + EMU68_R = 0x01, /**< Memory location has been read */ + EMU68_W = 0x02, /**< Memory location has been written */ + EMU68_X = 0x04, /**< Memory location has been executed */ + EMU68_B = 0x08, /**< Memory location has emulator-breakpoint */ + EMU68_M = 0xF0 /**< Breakpoint number */ +}; + +/** @name Memory/IO quick access tables. + * @{ + */ + + +/** @} */ + +/** @name Effective address calculation tables. + * + * The get_ab[bwl] tables are used by EMU68 to calculate operand + * effective address. Each of them is indexed by operand addressing + * mode. Each entry is a pointer to a function which do everything + * neccessary to update processor state (e.g. address register + * increment or decrement). reg parameter is register number coded + * in the three first bit (0 to 2) of 68k opcode. When the mode is + * 7, register parameter is used as an index in a second level + * function table for extended addressing mode. + * + * @{ + */ + +EMU68_EXTERN +/** Byte operand effective address calculation function table. */ +addr68_t (*const get_eab68[8])(emu68_t * const,int reg); + +EMU68_EXTERN +/** Word operand effective address calculation function table. */ +addr68_t (*const get_eaw68[8])(emu68_t * const,int reg); + +EMU68_EXTERN +/** Long operand effective address calculation function table. */ +addr68_t (*const get_eal68[8])(emu68_t * const,int reg); + + +#define get_EAB(MODE,REG) get_eab68[MODE](emu68,REG) +#define get_EAW(MODE,REG) get_eaw68[MODE](emu68,REG) +#define get_EAL(MODE,REG) get_eal68[MODE](emu68,REG) + + +/** @name 68K onboard memory access. + * @{ + */ + +EMU68_EXTERN +/** Read memory byte */ +void mem68_read_b(emu68_t * const emu68); + +EMU68_EXTERN +/** Read memory word */ +void mem68_read_w(emu68_t * const emu68); + +EMU68_EXTERN +/** Read memory long */ +void mem68_read_l(emu68_t * const emu68); + +EMU68_EXTERN +/** Write memory byte */ +void mem68_write_b(emu68_t * const emu68); + +EMU68_EXTERN +/** Write memory word */ +void mem68_write_w(emu68_t * const emu68); + +EMU68_EXTERN +/** Write memory long */ +void mem68_write_l(emu68_t * const emu68); + +static inline uint68_t _read_B(emu68_t * const emu68, + const addr68_t addr) +{ + emu68->bus_addr = addr; + mem68_read_b(emu68); + return (u8) emu68->bus_data; +} + +static inline uint68_t _read_EAB(emu68_t * const emu68, + const int mode, const int reg) +{ + emu68->bus_addr = get_eab68[mode](emu68,reg); + mem68_read_b(emu68); + return (u8) emu68->bus_data; +} + + +static inline uint68_t _read_W(emu68_t * const emu68, + const addr68_t addr) +{ + emu68->bus_addr = addr; + mem68_read_w(emu68); + return (u16) emu68->bus_data; +} + +static inline uint68_t _read_EAW(emu68_t * const emu68, + const int mode, const int reg) +{ + emu68->bus_addr = get_eaw68[mode](emu68,reg); + mem68_read_w(emu68); + return (u16) emu68->bus_data; +} + + +static inline uint68_t _read_L(emu68_t * const emu68, + const addr68_t addr) +{ + emu68->bus_addr = addr; + mem68_read_l(emu68); + return (u32) emu68->bus_data; +} + +static inline uint68_t _read_EAL(emu68_t * const emu68, + const int mode, const int reg) +{ + emu68->bus_addr = get_eal68[mode](emu68,reg); + mem68_read_l(emu68); + return (u32) emu68->bus_data; +} + +/** Read memory byte. */ +#define read_B(ADDR) _read_B(emu68,(ADDR)) + +/** Read memory word. */ +#define read_W(ADDR) _read_W(emu68,(ADDR)) + +/** Read memory long. */ +#define read_L(ADDR) _read_L(emu68,(ADDR)) + +/** Read memory byte from AE mode. */ +#define read_EAB(MODE,PARM) _read_EAB(emu68,(MODE),(PARM)) + +/** Read memory word from AE mode. */ +#define read_EAW(MODE,PARM) _read_EAW(emu68,(MODE),(PARM)) + +/** Read memory long from AE mode. */ +#define read_EAL(MODE,PARM) _read_EAL(emu68,(MODE),(PARM)) + +static inline void _write_B(emu68_t * const emu68, + const addr68_t addr, const int68_t v) +{ + emu68->bus_addr = addr; + emu68->bus_data = v; + mem68_write_b(emu68); +} + +static inline void _write_EAB(emu68_t * const emu68, + const int mode, const int reg, const int68_t v) +{ + emu68->bus_addr = get_eab68[mode](emu68,reg); + emu68->bus_data = v; + mem68_write_b(emu68); +} + + +static inline void _write_W(emu68_t * const emu68, addr68_t addr, int68_t v) +{ + emu68->bus_addr = addr; + emu68->bus_data = v; + mem68_write_w(emu68); +} + +static inline void _write_EAW(emu68_t * const emu68, + const int mode, const int reg, const int68_t v) +{ + emu68->bus_addr = get_eaw68[mode](emu68,reg); + emu68->bus_data = v; + mem68_write_w(emu68); +} + + +static inline void _write_L(emu68_t * const emu68, addr68_t addr, int68_t v) +{ + emu68->bus_addr = addr; + emu68->bus_data = v; + mem68_write_l(emu68); +} + +static inline void _write_EAL(emu68_t * const emu68, + const int mode, const int reg, const int68_t v) +{ + emu68->bus_addr = get_eal68[mode](emu68,reg); + emu68->bus_data = v; + mem68_write_l(emu68); +} + + +/** Write memory byte */ +#define write_B(ADDR,V) _write_B(emu68,(ADDR),(V)) + +/** Write memory word */ +#define write_W(ADDR,V) _write_W(emu68,(ADDR),(V)) + +/** Write memory long */ +#define write_L(ADDR,V) _write_L(emu68,(ADDR),(V)) + +/** Write memory byte at EA mode */ +#define write_EAB(MODE,PARM,V) _write_EAB(emu68,(MODE),(PARM),(V)) + +/** Write memory word at EA mode */ +#define write_EAW(MODE,PARM,V) _write_EAW(emu68,(MODE),(PARM),(V)) + +/** Write memory long at EA mode */ +#define write_EAL(MODE,PARM,V) _write_EAL(emu68,(MODE),(PARM),(V)) + +/** @} */ + + +/** @name Instruction read. + * @{ + */ +EMU68_EXTERN +int68_t mem68_nextw(emu68_t * emu68); /**< Decode word and update PC */ +EMU68_EXTERN +int68_t mem68_nextl(emu68_t * emu68); /**< Decode long and update PC */ + +/** mem68_nextw() convenience macro */ +#define get_nextw() mem68_nextw(emu68) +/** mem68_nextl() convenience macro */ +#define get_nextl() mem68_nextl(emu68) + +/** @} */ + + +/** @name Stack access. + * @{ + */ +EMU68_EXTERN void mem68_pushl(emu68_t * emu68, int68_t v); /**< Push long */ +EMU68_EXTERN void mem68_pushw(emu68_t * emu68, int68_t v); /**< Push word */ +EMU68_EXTERN int68_t mem68_popl(emu68_t * emu68); /**< Pop long */ +EMU68_EXTERN int68_t mem68_popw(emu68_t * emu68); /**< Pop word */ + +/** mem68_pushl() convenience macro */ +#define pushl(V) mem68_pushl(emu68,(V)); +/** mem68_pushw() convenience macro */ +#define pushw(V) mem68_pushw(emu68,(V)); +/** mem68_popl() convenience macro */ +#define popl() mem68_popl(emu68); +/** mem68_popw() convenience macro */ +#define popw() mem68_popw(emu68); + +/** @} */ + +EMU68_EXTERN +/** Init memory quick access table. + * + * The emu68_mem_init() function must be call at init time. + * Currently this function only call the emu68_mem_reset() + * function. + * + * @see emu68_mem_reset() + */ +void emu68_mem_init(emu68_t * const emu68); + +EMU68_EXTERN +/** Reset memory quick access table. + * + * The emu68_mem_reset() function restores all memory access to + * default. All mapped IO will be discard and replace by onboard + * memory access. + */ +void emu68_mem_reset(emu68_t * const emu68); + +EMU68_EXTERN +/** Add a new memory access control area (for new IO). + * + * @param area Which area (bit 16 to 23 of address) to change. + * @param read_bwl Read function table (byte, word and long in this order) + * @param write_bwl idem read_bwl for write access. + * + * @see emu68_mem_reset_area() + */ +void emu68_mem_new_area(emu68_t * const emu68, u8 area, + memfunc68_t *read_bwl, + memfunc68_t *write_bwl); + +EMU68_EXTERN +/** Reset memory access control area to default state. + * + * @see emu68_mem_new_area() + */ +void emu68_mem_reset_area(emu68_t * const emu68, u8 area); + +/** + * @} + */ + +#endif /* #ifndef _EMU68_MEM68_H_ */ Index: apps/codecs/libsc68/emu68/emu68_api.h =================================================================== --- apps/codecs/libsc68/emu68/emu68_api.h (revision 0) +++ apps/codecs/libsc68/emu68/emu68_api.h (revision 0) @@ -0,0 +1,33 @@ +/** + * @ingroup emu68_lib + * @file emu68/emu68_api.h + * @author Benjamin Gerard + * @date 2009/02/10 + * @brief emu68 library export header. + * + */ + +/* $Id: emu68.h 91 2009-02-09 17:25:51Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_EMU68_API_H_ +#define _EMU68_EMU68_API_H_ + +#ifndef EMU68_API +# ifdef EMU68_EXPORT +# if !defined(ROCKBOX) +# include "sc68/sc68.h" +# endif +# define EMU68_EXTERN SC68_EXTERN +# define EMU68_API SC68_API +# elif defined (__cplusplus) +# define EMU68_EXTERN extern "C" +# define EMU68_API EMU68_EXTERN +# else +# define EMU68_EXTERN extern +# define EMU68_API EMU68_EXTERN +# endif +#endif + +#endif /* #ifndef _EMU68_EMU68_API_H_ */ Index: apps/codecs/libsc68/emu68/cc68.c =================================================================== --- apps/codecs/libsc68/emu68/cc68.c (revision 0) +++ apps/codecs/libsc68/emu68/cc68.c (revision 0) @@ -0,0 +1,58 @@ +/* + * emu68 - Code condition function table + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#error "deprecated: should not be compiled" + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "struct68.h" +#include "srdef68.h" +#include "cc68.h" + +/* ,--------------------------. + * | Condition code functions | + * `--------------------------' */ + +static int is_cc0(const int sr) { return inl_is_cc0(sr); } /* 0000 TR */ +static int is_cc1(const int sr) { return inl_is_cc1(sr); } /* 0001 FA */ +static int is_cc2(const int sr) { return inl_is_cc2(sr); } /* 0010 HI */ +static int is_cc3(const int sr) { return inl_is_cc3(sr); } /* 0011 LS */ +static int is_cc4(const int sr) { return inl_is_cc4(sr); } /* 0100 CC */ +static int is_cc5(const int sr) { return inl_is_cc5(sr); } /* 0101 CS */ +static int is_cc6(const int sr) { return inl_is_cc6(sr); } /* 0110 NE */ +static int is_cc7(const int sr) { return inl_is_cc7(sr); } /* 0111 EQ */ +static int is_cc8(const int sr) { return inl_is_cc8(sr); } /* 1000 VC */ +static int is_cc9(const int sr) { return inl_is_cc9(sr); } /* 1001 VS */ +static int is_ccA(const int sr) { return inl_is_ccA(sr); } /* 1010 PL */ +static int is_ccB(const int sr) { return inl_is_ccB(sr); } /* 1011 MI */ +static int is_ccC(const int sr) { return inl_is_ccC(sr); } /* 1100 GE */ +static int is_ccD(const int sr) { return inl_is_ccD(sr); } /* 1101 LT */ +static int is_ccE(const int sr) { return inl_is_ccE(sr); } /* 1110 GT */ +static int is_ccF(const int sr) { return inl_is_ccF(sr); } /* 1111 LE */ + +int (* const is_cc68[16])(const int) = { + is_cc0, is_cc1, is_cc2, is_cc3, is_cc4, is_cc5, is_cc6, is_cc7, + is_cc8, is_cc9, is_ccA, is_ccB, is_ccC, is_ccD, is_ccE, is_ccF +}; Index: apps/codecs/libsc68/emu68/emu68.c =================================================================== --- apps/codecs/libsc68/emu68/emu68.c (revision 0) +++ apps/codecs/libsc68/emu68/emu68.c (revision 0) @@ -0,0 +1,914 @@ +/* + * emu68 - api + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "struct68.h" +#include "srdef68.h" +#include "excep68.h" +#include "assert68.h" + +#include "emu68.h" +#include "ioplug68.h" + +#include "macro68.h" + +#include "inl68_exception.h" +#include + +EMU68_EXTERN linefunc68_t *line_func[1024]; + +/* ,-----------------------------------------------------------------. + * | Internal struct access | + * `-----------------------------------------------------------------' + */ + +/* Set new interrupt IO + * return previous pointer + */ +io68_t * emu68_set_interrupt_io(emu68_t * emu68, io68_t * io) +{ + io68_t * oldio = 0; + if (emu68) { + oldio = emu68->interrupt_io; + emu68->interrupt_io = io; + } + return oldio; +} + +void emu68_set_registers(emu68_t * emu68, const reg68_t * r, int mask) +{ + if (emu68 && r) { + int i; + if ( mask & ( 1 << REG68_US_IDX ) ) REG68.usp = r->usp; + if ( mask & ( 1 << REG68_PC_IDX ) ) REG68.pc = r->pc; + if ( mask & (1 << REG68_SR_IDX ) ) REG68.sr = r->sr; + for ( i=0; i<8; i++ ) + if ( mask & ( 1 << ( REG68_D0_IDX + i ) ) ) REG68.d[i] = r->d[i]; + for ( i=0; i<8; i++) + if ( mask & ( 1 << ( REG68_A0_IDX + i ) ) ) REG68.a[i] = r->a[i]; + } +} + +void emu68_get_registers(const emu68_t * const emu68, reg68_t * r, int mask) +{ + if (emu68 && r) { + int i; + if ( mask & ( 1 << REG68_US_IDX ) ) r->usp = REG68.usp; + if ( mask & ( 1 << REG68_PC_IDX ) ) r->pc = REG68.pc; + if ( mask & ( 1 << REG68_SR_IDX ) ) r->sr = REG68.sr; + for ( i=0; i<8; i++ ) + if ( mask & ( 1 << ( REG68_D0_IDX + i ) ) ) r->d[i] = REG68.d[i]; + for ( i=0; i<8; i++ ) + if ( mask & ( 1 << ( REG68_A0_IDX + i ) ) ) r->a[i] = REG68.a[i]; + } +} + +void emu68_set_cycle(emu68_t * const emu68, cycle68_t cycle) +{ + emu68->cycle = cycle; +} + +cycle68_t emu68_get_cycle(emu68_t * const emu68) +{ + return emu68->cycle; +} + +void * emu68_set_cookie(emu68_t * const emu68, void * cookie) +{ + void * old = 0; + if (emu68) { + old = emu68->cookie; + emu68->cookie = cookie; + } + return old; +} + +void * emu68_get_cookie(emu68_t * const emu68) +{ + return emu68 + ? emu68->cookie + : 0 + ; +} + +emu68_handler_t emu68_set_handler(emu68_t * const emu68, emu68_handler_t hdl) +{ + emu68_handler_t old = 0; + if (emu68) { + old = emu68->handler; + emu68->handler = hdl; + } + return old; +} + +emu68_handler_t emu68_get_handler(emu68_t * const emu68) +{ + return emu68 + ? emu68->handler + : 0 + ; +} + + +/* ,-----------------------------------------------------------------. + * | Onboard memory access | + * `-----------------------------------------------------------------' + */ + +u8 * emu68_memptr(emu68_t * const emu68, addr68_t dst, uint68_t sz) +{ + u8 * ptr = 0; + if (emu68) { + addr68_t end = (dst+sz)&MEMMSK68; + if (sz > (unsigned)MEMMSK68+1) { + emu68_error_add(emu68, + "Not enough 68K memory ($%X>=$%X)",sz,emu68->memmsk); + } else if (end < dst) { + emu68_error_add(emu68, + "68K memory overflow :($%X-%X,$%X)",dst,dst+sz,sz); + } else { + ptr = emu68->mem + dst; + } + } + return ptr; +} + +u8 * emu68_chkptr(emu68_t * const emu68, addr68_t dst, uint68_t sz) +{ + u8 * ptr = emu68_memptr(emu68,dst,sz); + if (ptr && emu68->chk) { + ptr = emu68->chk + (ptr - emu68->mem); + } + return ptr; +} + +/* Peek & Poke */ +int emu68_peek(emu68_t * const emu68, addr68_t addr) +{ + return emu68 + ? emu68->mem[addr&MEMMSK68] + : -1 + ; +} + +int emu68_chkpeek(emu68_t * const emu68, addr68_t addr) +{ + return (emu68 && emu68->chk) + ? emu68->chk[addr&MEMMSK68] + : -1 + ; +} + +int emu68_poke(emu68_t * const emu68, addr68_t addr, int68_t v) +{ + return emu68 + ? (emu68->mem[addr & MEMMSK68] = v) + : -1 + ; +} + +int emu68_chkpoke(emu68_t * const emu68, addr68_t addr, int68_t v) +{ + return (emu68 && emu68->chk) + ? (emu68->chk[addr & MEMMSK68] = v) + : -1 + ; +} + +/* Write memory block to 68K on board memory + */ +int emu68_memput(emu68_t * const emu68, addr68_t dst, u8 *src, uint68_t sz) +{ + u8 * ptr = emu68_memptr(emu68,dst,sz); + if (ptr) { + memcpy(ptr,src,sz); + return 0; + } + return -1; +} + +/* Read memory block from 68K on board memory + */ +int emu68_memget(emu68_t * const emu68, u8 *dst, addr68_t src, uint68_t sz) +{ + u8 * ptr = emu68_memptr(emu68,src,sz); + if (ptr) { + memcpy(dst,ptr,sz); + } + return -!ptr; +} + +int emu68_memset(emu68_t * const emu68, addr68_t dst, u8 val, uint68_t sz) +{ + u8 * ptr; + + if (!emu68) { + ptr = 0; + } else { + if (!sz) { + sz = emu68->memmsk + 1 - dst; + } + ptr = emu68_memptr(emu68, dst, sz); + if (ptr) { + while (sz--) *ptr++ = val; + } + } + return -!ptr; +} + +int emu68_chkset(emu68_t * const emu68, addr68_t dst, u8 val, uint68_t sz) +{ + u8 * ptr; + + if (!emu68) { + ptr = 0; + } else { + if (!sz) { + sz = emu68->memmsk+1-dst; + } + ptr = emu68_chkptr(emu68, dst, sz); + if (ptr) { + while (sz--) *ptr++ = val; + } + } + return -!ptr; +} + +#include "crc32.c" + +uint68_t emu68_crc32(emu68_t * const emu68) +{ + uint68_t crc = 0; + if ( emu68 ) { + int i; + u8 tmp [ 18 * 4 + 2 ]; /* serialize registers */ + s32 * reg32 = emu68->reg.d; + for ( i = 0; i < 18*4; i += 4 ) { + unsigned int v = reg32[i>>2]; + tmp[i+0] = v >> 24; + tmp[i+1] = v >> 16; + tmp[i+2] = v >> 8; + tmp[i+3] = v; + } + tmp[i++] = emu68->reg.sr >> 8; + tmp[i++] = emu68->reg.sr; + assert ( i == sizeof(tmp) ); + + crc = crc32(crc, tmp, i); + crc = crc32(crc, emu68->mem, emu68->memmsk+1); + } + return crc; +} + +/* Process a single instruction emulation. */ +static inline void step68(emu68_t * const emu68) +{ + int line,opw,reg9; + u8 * mem; + + assert( emu68->status == EMU68_NRM ); + + /* TODO: check address valid */ + mem = emu68->mem + (REG68.pc & (MEMMSK68 & ~1)); + REG68.pc += 2; + opw = (mem[0]<<8) | mem[1]; + + /* 68000 OP-WORD format : + * 1111 0000 0000 0000 ( LINE ) + * 0000 0001 1111 1000 ( OP ) + * 0000 0000 0000 0111 ( REG 0 ) + * 0000 1110 0000 0000 ( REG 9 ) + */ + + /* LINE RG9 OPCODE RG0 */ + /* -------------------- */ + line = opw & 0170000; /* 1111 000 000-000 000 */ + opw -= line; /* 0000 111 111-111 111 */ + reg9 = opw & 07000; /* 0000 111 000-000 000 */ + opw -= reg9; /* 0000 000 111-111 111 */ + reg9 >>= 9; /* reg9 */ + line |= opw<<3; + line >>= 6; + opw &= 7; /* 0000 000 000-000 111 */ + (line_func[line])(emu68, reg9, opw); +} + +/* Run a single step emulation with all pogramm controls. */ +static inline int controlled_step68(emu68_t * const emu68) +{ + assert( emu68->status == EMU68_NRM ); + + /* Running in debug mode. */ + if (emu68->chk) { + /* HardWare TRACE exception */ + exception68(emu68, HWTRACE_VECTOR, -1); + if (emu68->status != EMU68_NRM) + return emu68->status; + /* HardWare BREAKPOINT exception */ + if (emu68->chk[ REG68.pc & MEMMSK68 ] & EMU68_B) { + exception68(emu68, HWBREAK_VECTOR, -1); + if (emu68->status != EMU68_NRM) + return emu68->status; + } + } + + /* Execute 68K instruction. */ + step68(emu68); + + /* Instruction countdown */ + if ( emu68->instructions && !--emu68->instructions ) + emu68->status = EMU68_BRK; + + return emu68->status; +} + +static void loop68(emu68_t * const emu68) +{ + assert( ! (emu68->finish_sp & 1 ) ); + while ( controlled_step68(emu68) == EMU68_NRM && + emu68->finish_sp >= (addr68_t) REG68.a[7] ) + ; +} + +/* Execute one instruction. */ +int emu68_step(emu68_t * const emu68) +{ + int rc = EMU68_ERR; + + if (emu68) { + switch (emu68->status) { + + case EMU68_NRM: + emu68->framechk = 0; + case EMU68_BRK: + emu68->status = EMU68_NRM; + loop68(emu68); + case EMU68_STP: + rc = emu68->status; + break; + + default: + assert(!"unexpected value for emu68_t::status"); + break; + } + } + return rc; +} + +/* Continue after a break. */ +int emu68_continue(emu68_t * const emu68) +{ + int rc = EMU68_ERR; + + if (emu68) { + switch (emu68->status) { + + case EMU68_NRM: + /* Nothing to continue: error */ + break; + + case EMU68_BRK: + emu68->status = EMU68_NRM; + controlled_step68(emu68); + case EMU68_STP: + rc = emu68->status; + break; + + default: + assert(!"unexpected value for emu68_t::status"); + break; + } + } + return rc; +} + +int emu68_finish(emu68_t * const emu68, uint68_t instructions) +{ + io68_t *io; + + if (!emu68) { + return EMU68_ERR; + } + + emu68->finish_sp = REG68.a[7]; + emu68->framechk = 0; + emu68->instructions = instructions; + + for (io=emu68->iohead; io; io=io->next) { + io->adjust_cycle(io,emu68->cycle); + } + emu68->cycle = 0; + + loop68(emu68); + + return emu68->status; +} + +/* Execute one instruction. */ +int emu68_interrupt(emu68_t * const emu68, cycle68_t cycleperpass) +{ + + if (!emu68) { + return EMU68_ERR; + } + + assert ( emu68->status == EMU68_NRM || emu68->status == EMU68_STP ); + + /* Get interrupt IO (MFP) if any */ + if (emu68->interrupt_io) { + for ( ;; ) { + const int ipl = ( REG68.sr >> SR_I_BIT ) & 7; + interrupt68_t * t = + emu68->interrupt_io->interrupt(emu68->interrupt_io, cycleperpass); + if (!t) + break; + emu68->cycle = t->cycle; + if (t->level > ipl) { + inl_exception68(emu68, t->vector, t->level); + emu68->finish_sp = (addr68_t) REG68.a[7]; + loop68(emu68); + } + } + } + emu68->cycle = cycleperpass; + + return emu68->status; +} + +#if 0 +/* Run until RTS level0 occurs + * and play Interruption for 1 pass. + * ( Specific SC68 !!! ) + */ +void emu68_level_and_interrupt(emu68_t * const emu68, + cycle68_t cycleperpass) +{ + addr68_t stack, pc; + cycle68_t cycle; + io68_t *io; + + if (!emu68) { + return; + } + stack = REG68.a[7]; + pc = REG68.pc; + REG68.a[7] = stack - 4; + + /* Clear ORed memory access flags ... */ + emu68->framechk = 0; + + /* Adjust internal IO cycle counter */ + for (io=emu68->iohead; io; io=io->next) { + (io->adjust_cycle)(io,emu68->cycle); + } + emu68->cycle = 0; + + /* Do until RTS */ + do { + step68(emu68); + } while (stack>(addr68_t)REG68.a[7]); + + cycle=0; + + /* Get interrupt IO (MFP) if any */ + if (emu68->interrupt_io) { + interrupt68_t * t; + int ipl = (REG68.sr & (7<> SR_I_BIT; +#ifdef _DEBUG + int ipl_lost = 0; + int irq_pass = 0; +#endif + /* $$$ HACK: mfp interupt at level 5 */ + /* $$$ TEMP: FOR DEBUGIN A MUSIC !! */ + if ( /*1 ||*/ 6 > ipl ) { + do { + + /* Spool interrupt */ + /* Execute mfp interrupt emulation */ + t = emu68->interrupt_io->interrupt(emu68->interrupt_io, cycleperpass); + if (t) { +#ifdef DEBUG + if (t->cycle >= cycleperpass) { + *(int *)0 = 0xDEADBEEF; + } +#endif + + + emu68->cycle=t->cycle; + REG68.a[7] = stack; /* $$$ Safety net */ + REG68.pc = 0x12345678; + inl_exception68(emu68,t->vector,t->level); + poll_rte(emu68, stack); +#ifdef _DEBUG + if (REG68.pc != 0x12345678) { + BREAKPOINT68; + } + if (REG68.a[7] != stack) { + BREAKPOINT68; + } + if (!(REG68.sr & 0x2000)) { + BREAKPOINT68; + } +#endif + } else { + // BREAKPOINT68; + break; //$$$ ??? + } + } while (t); + } else { + // ipl masks irq +#ifdef _DEBUG + // This happens sometime + //BREAKPOINT68; + ipl_lost++; +#endif + } + } + + /* Restore A7, PC, and new cycle counter */ + REG68.a[7] = stack; + REG68.pc = pc; + emu68->cycle = cycleperpass; +} + +/* Run like a JSR at pc, exec interrupt if cycleperpass > 0. + */ +void emu68_run_rts(emu68_t * const emu68, + addr68_t pc, cycle68_t cycleperpass) +{ + addr68_t stack; + + if (!emu68) { + return; + } + + /* Push current pc .*/ + stack = REG68.a[7]; + pushl(REG68.pc); + REG68.pc = pc; + + /* Clear ORed memory access flags ... */ + emu68->framechk = 0; + + /* Adjust internal IO cycle counter & find MFP */ + if (emu68->cycle) { + io68_t *io; + for (io=emu68->iohead; io; io=io->next) { + (io->adjust_cycle)(io, emu68->cycle); + } + emu68->cycle = 0; + } + + /* Do until RTS */ + do { + step68(emu68); + } while (stack > (addr68_t)REG68.a[7]); + + /* Get interrupt IO (MFP) if any */ + if (cycleperpass && emu68->interrupt_io) { + interrupt68_t *t; + int ipl = (REG68.sr & (7<> SR_I_BIT; + cycle68_t cycle = 0; + + if (6 > ipl ) { + cycle68_t fd; + + /* Spool interrupt */ + while (fd = + emu68->interrupt_io->next_interrupt(emu68->interrupt_io,cycle), + fd != IO68_NO_INT) { + /* ... This must not happen ... */ + if( (int)fd < 0 ) { + fd = 0; + } + + /* ... */ + + /* TIME travel to next interruption */ + cycle += fd; + + if(cycle >= cycleperpass) { + /* interrupt after this pass */ + break; + } + + /* Execute mfp interrupt emulation */ + t = emu68->interrupt_io->interrupt(emu68->interrupt_io,cycle); + if (t) { + emu68->cycle=cycle; + REG68.a[7] = stack; /* $$$ Safety net */ + inl_exception68(emu68,t->vector,t->level); + poll_rte(emu68,stack); + } + } + } + } + emu68->cycle = cycleperpass; +} + + +/* Run emulation for given number of cycle + */ +void emu68_cycle(emu68_t * const emu68, cycle68_t cycleperpass) +{ + cycle68_t cycle; + io68_t *io; + + /* Clear ORed memory access flags ... */ +#ifdef EMU68DEBUG + REG68.framechk = 0; +#endif + + /* Adjust internal IO cycle counter */ + for (io=emu68->iohead; io; io=io->next) { + (io->adjust_cycle)(io, emu68->cycle); + } + + /* Do until RTS */ + cycle = emu68->cycle = 0; + do + { + /* If not stopped, execute an instruction */ + if (1/* !REG68.status */) { + step68(emu68); + cycle += 4; + } + emu68->cycle = cycle; + + if (emu68->interrupt_io) { + interrupt68_t *t; + int ipl; + + ipl = (REG68.sr & (7<> SR_I_BIT; + + /* $$$ HACK : mfp interupt at level 5 */ + if (6 > ipl) { + t = emu68->interrupt_io->interrupt(emu68->interrupt_io,cycle); + if (t) { + inl_exception68(emu68,t->vector,t->level); + /* $$$ extra cycle should be added here for exception handle */ + } + } + } + } while(cycle < cycleperpass); + + // $$$ This is hack : should be "cycle" and handle later + cycle = cycleperpass; + emu68->cycle = cycle; +} + +#endif + +/* Get debug mode. */ +int emu68_debugmode(emu68_t * const emu68) +{ + return emu68 + ? !!emu68->chk + : -1 + ; +} + +/* ,-----------------------------------------------------------------. + * | Breakpoints | + * `-----------------------------------------------------------------' + */ + +static void bp_reset(emu68_t * const emu68) +{ + int id; + for ( id=0; id<16; ++id ) { + emu68->breakpoints[id].addr = 0; + emu68->breakpoints[id].count = 0; + emu68->breakpoints[id].reset = 0; + } +} + +void emu68_bp_delall(emu68_t * const emu68) +{ + int id; + for ( id=0; id<16; ++id ) { + emu68_bp_del(emu68, id); + } +} + +void emu68_bp_del(emu68_t * const emu68, int id) +{ + if (emu68 && (unsigned int)id<16u && emu68->breakpoints[id].count) { + if (emu68->chk) { + const addr68_t addr = emu68->breakpoints[id].addr & MEMMSK68; + emu68->chk[addr] &= ~(EMU68_B|EMU68_M); + } + emu68->breakpoints[id].addr = 0; + emu68->breakpoints[id].count = 0; + emu68->breakpoints[id].reset = 0; + } +} + +int emu68_bp_set(emu68_t * const emu68, int id, + addr68_t addr, uint68_t count, uint68_t reset) +{ + if (!emu68) { + id = -1; + } else { + if ( id == -1 ) + for ( id=0; id<16 && emu68->breakpoints[id].count; ++id) + ; + if ( (unsigned int) id < 16u) { + emu68->breakpoints[id].addr = addr; + emu68->breakpoints[id].count = count; + emu68->breakpoints[id].reset = reset; + } else { + id = -1; + } + } + return id; +} + +int emu68_bp_find(emu68_t * const emu68, addr68_t addr) +{ + int id = -1; + if (emu68) { + int i; + for ( i=0; i<16; ++i ) { + if (emu68->breakpoints[i].count && + !( (emu68->breakpoints[i].addr ^ addr) & MEMMSK68 ) ) { + id = i; + break; + } + } + } + return id; +} + + +/* ,-----------------------------------------------------------------. + * | Emulator init functions | + * `-----------------------------------------------------------------' + */ + +static emu68_parms_t def_parms; + +emu68_t * emu68_create(emu68_parms_t * const parms) +{ + emu68_t * emu68 = 0; + int memsize, membyte; + emu68_parms_t * const p = parms ? parms : &def_parms; + + if (!p->log2mem) { + p->log2mem = def_parms.log2mem; + } + if (p->log2mem<16||p->log2mem>24) { + goto error; + } + + if (!p->clock) { + p->clock = def_parms.clock; + } + if ((unsigned)p->clock<500000u || (unsigned)p->clock>60000000u) { + goto error; + } + + memsize = 1<log2mem; + membyte = sizeof(emu68_t) + (memsize<debug); + emu68 = emu68_alloc(membyte); + if (!emu68) { + goto error; + } + memset(emu68,0,sizeof(membyte)); + strncpy(emu68->name,p->name?p->name:"emu68",sizeof(emu68->name)-1); + emu68->clock = p->clock; + + emu68->log2mem = p->log2mem; + emu68->memmsk = memsize-1; + if (p->debug) { + emu68->chk = emu68->mem + memsize+4; + } + + emu68_mem_init(emu68); + emu68_reset(emu68); + + error: + return emu68; +} + +emu68_t * emu68_duplicate(emu68_t * emu68src, const char * dupname) +{ + emu68_parms_t parms; + emu68_t * emu68 = 0; + + if (!emu68src) + goto error; + + /* Create an instance with the same parameters */ + parms.name = dupname; + parms.log2mem = emu68->log2mem; + parms.clock = emu68->clock; + parms.debug = !!emu68->chk; + emu68 = emu68_create(&parms); + if (!emu68) + goto error; + + /* Copy registers and status */ + emu68->reg = emu68src->reg; + emu68->cycle = emu68src->cycle; + emu68->framechk = emu68src->framechk; + emu68->instructions = emu68src->instructions; + emu68->finish_sp = emu68src->finish_sp; + emu68->status = emu68src->status; + + /* Copy memory */ + memcpy(emu68->mem, emu68src->mem, 1<log2mem); + if (emu68->chk) + memcpy(emu68->chk, emu68src->chk, 1<log2mem); + + /* Copy breakpoints */ + memcpy(emu68->breakpoints, emu68src->breakpoints, sizeof(emu68->breakpoints)); + +error: + return emu68; +} + +/* Destroy emulator instance. */ +void emu68_destroy(emu68_t * const emu68) +{ + if (emu68) { + emu68_ioplug_destroy_all(emu68); + emu68_free(emu68); + } +} + +/* 68000 Hardware Reset + * - PC = 0 + * - SR = 2700 + * - A7 = end of mem - 4 + * - All registers cleared + * - All IO reseted + */ +void emu68_reset(emu68_t * const emu68) +{ + if (emu68) { + io68_t * io; + for (io=emu68->iohead; io; io=io->next) { + (io->reset)(io); + } + bp_reset(emu68); + + memset(REG68.d,0,sizeof(REG68.d)*2); + REG68.pc = 0; + REG68.sr = 0x2700; + REG68.a[7] = MEMMSK68+1-4; + REG68.usp = REG68.a[7]; + + emu68->cycle = 0; + emu68->framechk = 0; + emu68->instructions = 0; + emu68->finish_sp = -1; + emu68->status = EMU68_NRM; + } +} + +/* ,-----------------------------------------------------------------. + * | Library init functions | + * `-----------------------------------------------------------------' + */ + +/* Library initialize. */ +int emu68_init(int * argc, char ** argv) +{ + def_parms.name = 0; + def_parms.log2mem = 19; /* log2mem: 2^19 => 512 kB */ + def_parms.clock = EMU68_ATARIST_CLOCK; + def_parms.debug = 0; + + /* $$$ TODO: parse argument */ + return 0; +} + +/* Library shutdown. */ +void emu68_shutdown(void) +{ +} + Index: apps/codecs/libsc68/emu68/table68.c =================================================================== --- apps/codecs/libsc68/emu68/table68.c (revision 0) +++ apps/codecs/libsc68/emu68/table68.c (revision 0) @@ -0,0 +1,8 @@ +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "emu68_api.h" +#include "lines/table.c" Index: apps/codecs/libsc68/emu68/error68_.c =================================================================== --- apps/codecs/libsc68/emu68/error68_.c (revision 0) +++ apps/codecs/libsc68/emu68/error68_.c (revision 0) @@ -0,0 +1,78 @@ +/* + * emu68 - error message handler + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include +#include +#include + +#include "error68_.h" + +#ifdef MAXERROR +#undef MAXERROR +#endif +#ifdef MAXERRORSTR +#undef MAXERRORSTR +#endif + +#define MAXERROR (sizeof(emu68->err)/sizeof(emu68->err[0])) +#define MAXERRORSTR sizeof(emu68->err[0]) + +/* Push error message + */ +int emu68_error_add(emu68_t * const emu68, const char * format, ...) +{ + if (emu68 && format) { + va_list list; + int n = emu68->nerr; + + if ((unsigned)n >= MAXERROR) { + memmove(emu68->err[0],emu68->err[1],MAXERRORSTR*(MAXERROR-1)); + n = MAXERROR-1; + } + +#ifdef HAVE_SNPRINTF + va_start(list,format); + vsnprintf(emu68->err[n],MAXERRORSTR,format,list); + va_end(list); +#endif + emu68->err[n][MAXERRORSTR-1] = 0; + emu68->nerr = ++n; + } + return -1; +} + +/* Pop error message + */ +const char * emu68_error_get(emu68_t * const emu68) +{ + const char * res = 0; + if (emu68 && emu68->nerr > 0) { + res = emu68->err[--emu68->nerr]; + } + return res; +} Index: apps/codecs/libsc68/emu68/struct68.h =================================================================== --- apps/codecs/libsc68/emu68/struct68.h (revision 0) +++ apps/codecs/libsc68/emu68/struct68.h (revision 0) @@ -0,0 +1,237 @@ +/** + * @ingroup emu68_lib + * @file emu68/struct68.h + * @author Benjamin Gerard + * @date 13/03/1999 + * @brief Struture definitions header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_STRUCT68_H_ +#define _EMU68_STRUCT68_H_ + +#include "type68.h" + +/** @addtogroup emu68_lib_types + * @{ + */ + +/** IO no pending interruption return value. + * + * The next_int function of IO plugin must return IO68_NO_INT when no + * interruption has been triggered. + */ +#define IO68_NO_INT (0x80000000) + +/** Convenience macro to access reg68 in the current emu68 instance. */ +#define REG68 (emu68->reg) + +/** Mask for memory overflow. */ +#define MEMMSK68 (emu68->memmsk) + + +/** @name Memory access caller type + * @{ + */ + +/** Write memory function. */ +typedef void (*memwfunc68_t)(emu68_t * const); +/** Write IO chip function. */ +typedef void (*iomemfunc68_t)(io68_t * const); + +/** @} */ + +/** First level (16 lines) decoder function. */ +typedef void (linefunc68_t)(emu68_t * const, int, int); + +#ifndef EMU68_MONOLITIC +# define DECL_LINE68(N) \ + void N(emu68_t * const emu68, int reg9, int reg0) +# define DECL_STATIC_LINE68(N) static DECL_LINE68(N) +#else +# define DECL_LINE68(N) \ + static void N(emu68_t * const emu68, int reg9, int reg0) +# define DECL_STATIC_LINE68(N) DECL_LINE68(N) +#endif + + +/** 68K interruption exception structure. + */ +typedef struct +{ + int vector; /**< Interrupt vector number */ + int level; /**< Interrupt level [0..7]. */ + cycle68_t cycle; /**< Cycle the interruption falls. */ +} interrupt68_t; + + +/** IO emulator plugin structure. + * + * All 68K IO must have a filled io68_t structure to be warm plug + * or unplug with ioplug interface. + * + */ +struct io68_s +{ + struct io68_s * next; /**< IO list; pointer to next. */ + char name[32]; /**< IO identifier name. */ + addr68_t addr_lo; /**< IO mapping area start address. */ + addr68_t addr_hi; /**< IO mapping area end address. */ + + iomemfunc68_t r_byte; /**< IO read byte function. */ + iomemfunc68_t r_word; /**< IO read word function. */ + iomemfunc68_t r_long; /**< IO read long function. */ + + iomemfunc68_t w_byte; /**< IO write byte function. */ + iomemfunc68_t w_word; /**< IO write word function. */ + iomemfunc68_t w_long; /**< IO write long function. */ + + /** IO interruption function claim. */ + interrupt68_t* (*interrupt)(io68_t * const, const cycle68_t); + /** IO get next interruption cycle. */ + cycle68_t (*next_interrupt)(io68_t * const, const cycle68_t); + /** IO adjust cycle function. */ + void (*adjust_cycle)(io68_t * const, const cycle68_t); + /** IO reset function. */ + int (*reset)(io68_t * const); + /** Destructor. */ + void (*destroy)(io68_t * const); + + /** Emulator this IO is attached to. */ + emu68_t * emu68; +}; + + +/** 68K internal registers. + */ +typedef struct +{ + s32 d[8]; /**< 68K data registers. */ + s32 a[8]; /**< 68K address registers. */ + s32 usp; /**< 68K User Stack Pointers. */ + s32 pc; /**< 68K Program Counter. */ + int sr; /**< 68K Status Register. */ +} reg68_t; + +#define REG68_D0_IDX 000 +#define REG68_D1_IDX 001 +#define REG68_D2_IDX 002 +#define REG68_D3_IDX 003 +#define REG68_D4_IDX 004 +#define REG68_D5_IDX 005 +#define REG68_D6_IDX 006 +#define REG68_D7_IDX 007 +#define REG68_DN_IDX(N) (N&7) + +#define REG68_A0_IDX 010 +#define REG68_A1_IDX 011 +#define REG68_A2_IDX 012 +#define REG68_A3_IDX 013 +#define REG68_A4_IDX 014 +#define REG68_A5_IDX 015 +#define REG68_A6_IDX 016 +#define REG68_A7_IDX 017 +#define REG68_AN_IDX(N) (8+(N&7)) + +#define REG68_US_IDX 020 +#define REG68_PC_IDX 021 +#define REG68_SR_IDX 022 + +/** Exception trapping handler. + * + * The emu68_handler_t handler is called by EMU68 when an exception + * occurs. This does not include interruption triggered by IO chip + * but only software exception like TRACE, ILLEGAL, ZERO DIVIDE, + * CHK, TRAP, RESET ... + * + * @param emu68 emulator instance + * @param vector exception vector number + * @param cookie user-data pointer +*/ +typedef int (*emu68_handler_t)(emu68_t* const emu68, int vector, void * cookie); + +/** Init parameters. */ +/* typedef struct { */ +/* int * argc; /\**< Argument count. *\/ */ +/* char ** argv; /\**< Arguments. *\/ */ +/* } emu68_init_t; */ + +/** Breakpoint definition. */ +typedef struct { + addr68_t addr; /**< Breakpoint address. */ + uint68_t count; /**< Break countdown; 0:disable */ + uint68_t reset; /**< Reset countdown after break. */ +} emu68_bp_t; + +/** 68K Emulator struct. */ +struct emu68_s { + char name[32]; /**< Identifier. */ + + /* Error. */ + char err[128][4]; /**< Error message stack. */ + int nerr; /**< Error counter. */ + + reg68_t reg; /**< 68000 internal registers. */ + cycle68_t cycle; /**< Internal cycle counter. */ + uint68_t clock; /**< Master clock frequency. */ + + /* Exception trapping. */ + emu68_handler_t handler; /**< Exception trap handler. */ + void * cookie; /**< User data. */ + + int status; /**< Execution status. */ + uint68_t instructions; /**< Instruction countdown. */ + addr68_t finish_sp; /**< Finish Stack Pointer. */ + + /* IO chips. */ + int nio; /**< # IO plug in IO-list. */ + io68_t * iohead; /**< Head of IO-list. */ + io68_t * interrupt_io; /**< Current interuptible IO. */ + io68_t * mapped_io[256]; + + /* Memory access. */ + addr68_t bus_addr; /**< bus address for memory access. */ + int68_t bus_data; /**< bus data for memory access. */ + int framechk; /**< ORed chk change for current frame. */ + u8 * chk; /**< Access-Control-Memory buffer. */ + + emu68_bp_t breakpoints[16]; /**< Hardware breakpoints. */ + + /* Onboard memory. */ + addr68_t memmsk; /**< Onboard memory mask (2^log2mem-1). */ + int log2mem; /**< Onboard memory buffer size (2^log2mem). */ + u8 mem[16]; /**< Onboard memory buffer. + @notice Must be last in struct. */ +}; + +static inline +void inl_setcycle68(emu68_t * const emu68, const cycle68_t n) +{ +#ifdef EMU68CYCLE + emu68->cycle = n; +#endif +} + +static inline +void inl_addcycle68(emu68_t * const emu68, const cycle68_t n) +{ +#ifdef EMU68CYCLE + emu68->cycle += n; +#endif +} + +#ifndef CUSTOM_ALLOC +# include +# define emu68_alloc(size) malloc(size) +# define emu68_free(size) free(size) +#endif + +/** + * @} + */ + +#endif /* #ifndef _EMU68_STRUCT68_H_ */ Index: apps/codecs/libsc68/emu68/cc68.h =================================================================== --- apps/codecs/libsc68/emu68/cc68.h (revision 0) +++ apps/codecs/libsc68/emu68/cc68.h (revision 0) @@ -0,0 +1,231 @@ +/** + * @ingroup emu68_lib + * @file emu68/cc68.h + * @author Benjamin Gerard + * @date 1999/03/13 + * @brief Condition code header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_CC68_H_ +#define _EMU68_CC68_H_ + +#include "emu68_api.h" +#include "srdef68.h" + +/** @addtogroup emu68_lib_core + * @{ + */ + +/** Code Conditions. */ +enum { + CC68_TR = 0x0, CC68_FA = 0x1, CC68_HI = 0x2, CC68_LS = 0x3, + CC68_CC = 0x4, CC68_CS = 0x5, CC68_NE = 0x6, CC68_EQ = 0x7, + CC68_VC = 0x8, CC68_VS = 0x9, CC68_PL = 0xA, CC68_MI = 0xB, + CC68_GE = 0xC, CC68_LT = 0xD, CC68_GT = 0xE, CC68_LE = 0xF +}; + +/** @name Condition tests. + * + * Theses macros perform conditionnal tests depending on CCR value. + * + * @return 1 condition true + * @return 0 condition false + * @{ + */ + +/** 0000 True. + * @param sr current SR value + * @retval always true + */ +static inline int inl_is_cc0(const int sr) +{ + return 1; +} + +/** 0001 False. + * @param sr current SR value + * @return always false + */ +static inline int inl_is_cc1(const int sr) +{ + return 0; +} + +/** 0010 High. + * @param sr current SR value + * @retval ÂŽ(C|Z) <-> ÂŽC&ÂŽZ + */ +static inline int inl_is_cc2(const int sr) +{ + return ~ + ( ( sr >> SR_C_BIT ) + | + ( sr >> SR_Z_BIT ) + ) & 1; +} +/* #define IS_HI(SR) inl_is_cc2(SR) */ + +/** 0011 Low or Same. + * @param sr current SR value + * @return (C|Z) + */ +static inline int inl_is_cc3(const int sr) +{ + return + ( ( sr >> SR_C_BIT ) + | + ( sr >> SR_Z_BIT ) + ) & 1; +} +/* #define IS_LS(SR) inl_is_cc3(SR) */ + +/** 0100 Carry Clear. + * @param sr current SR value + * @return ÂŽC + */ +static inline int inl_is_cc4(const int sr) +{ + return ~ + ( sr >> SR_C_BIT ) & 1; +} + +/** 0101 Carry Set. + * @param sr current SR value + * @return C + */ +static inline int inl_is_cc5(const int sr) +{ + return + ( sr >> SR_C_BIT ) & 1; +} + +/** 0110 Not Equal (not zero). + * @param sr current SR value + * @return ÂŽZ + */ +static inline int inl_is_cc6(const int sr) +{ + return ~ + ( sr >> SR_Z_BIT ) & 1; +} +/* #define IS_NE(SR) IS_EQ(~SR) */ + +/** 0111 Equal (zero). + * @param sr current SR value + * @return Z + */ +static inline int inl_is_cc7(const int sr) +{ + return + ( sr >> SR_Z_BIT ) & 1; +} +/* #define IS_EQ(SR) ( */ + +/** 1000 Overflow Clear. + * @param sr current SR value + * @return ÂŽV + */ +static inline int inl_is_cc8(const int sr) +{ + return ~ + ( sr >> SR_V_BIT ) & 1; +} + +/** 1001 Overflow Set. + * @param sr current SR value + * @return V + */ +static inline int inl_is_cc9(const int sr) +{ + return + ( sr >> SR_V_BIT ) & 1; +} + +/** 1010 Plus. + * @param sr current SR value + * @return ÂŽN + */ +static inline int inl_is_ccA(const int sr) +{ + return ~ + ( sr >> SR_N_BIT ) & 1; +} + +/** 1011 Minus. + * @param sr current SR value + * @return N + */ +static inline int inl_is_ccB(const int sr) +{ + return + ( sr >> SR_N_BIT ) & 1; +} + +/** 1100 Greater or Equal. + * @param sr current SR value + * @return ÂŽ(N^V) + */ +static inline int inl_is_ccC(const int sr) +{ + return ~ + ( ( sr >> SR_N_BIT ) + ^ + ( sr >> SR_V_BIT ) + ) & 1; +} + +/** 1101 Less Than. + * @param sr current SR value + * @return N^V + */ +static inline int inl_is_ccD(const int sr) +{ + return + ( ( sr >> SR_N_BIT ) + ^ + ( sr >> SR_V_BIT ) + ) & 1; +} + +/** 1110 Greater Than. + * @param sr current SR value + * @return ÂŽ(Z|(N^V)) + */ +static inline int inl_is_ccE(const int sr) +{ + return ~ + ( ( sr >> SR_Z_BIT ) + | + ( ( sr >> SR_N_BIT ) + ^ + ( sr >> SR_V_BIT ) ) + ) & 1; +} + +/** 1111 Less or Equal. + * @param sr current SR value + * @return (Z|(N^V)) + */ +static inline int inl_is_ccF(const int sr) +{ + return + ( ( sr >> SR_Z_BIT ) + | + ( ( sr >> SR_N_BIT ) + ^ + ( sr >> SR_V_BIT ) ) + ) & 1; +} + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _EMU68_CC68_H_ */ Index: apps/codecs/libsc68/emu68/emu68.h =================================================================== --- apps/codecs/libsc68/emu68/emu68.h (revision 0) +++ apps/codecs/libsc68/emu68/emu68.h (revision 0) @@ -0,0 +1,495 @@ +/** + * @ingroup emu68_lib + * @file emu68/emu68.h + * @author Benjamin Gerard + * @date 1999/03/13 + * @brief 68K emulator header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_EMU68_H_ +#define _EMU68_EMU68_H_ + +#include "emu68_api.h" + +#include "struct68.h" +#include "error68_.h" +#include "cc68.h" +#include "srdef68.h" +#include "mem68.h" + +/** @defgroup emu68_lib 68k emulator library + * @ingroup sc68_lib + * @brief The 68k emulator library. + */ + +/** @defgroup emu68_lib_core 68k emulator core + * @ingroup emu68_lib + * @brief The core of the 68k emulator. + */ + +/** @addtogroup emu68_lib + * @{ + */ + +/** @name Library init functions + * @{ + */ + +EMU68_API +/** + * Init EMU68 library. + * + * The emu68_init() function initializes the EMU68 library. It + * should be call once before any other emu68 call. The function + * will perform internal setup. EMU68 behaviour can be adjust by + * passing arguments in the argv[] array. Parsed arguments are + * removed and the remaining number of argument is returned. + * + * @retval -1 on error + * @retval 0 on success + * + * @see emu68_shutdown() + */ +int emu68_init(int * argc, char ** argv); + +EMU68_API +/** + * Shutdown 68K emulator. + * + * The emu68_shutdown() function shutdown the EM68 library. It + * must be call at the end and further more calls are forbidden + * except for emu68_init(). All emulator instances created should + * have been killed before. + * + * @see emu68_init() + */ +void emu68_shutdown(void); + +/** @} */ + + +/** @name EMU68 instance functions + * @{ + */ + +/** Atari ST clock (as written on cristal clock chip). */ +#define EMU68_ATARIST_CLOCK (8010613u&~3u) + +/** + * 68k emulator instance creation parameters. This structure have to + * be filled before calling the emu68_create() function to customize + * the instance. Members set to zero are replaced by default values. + */ +typedef struct { + const char * name; /**< Identifier name. */ + int log2mem; /**< Memory amount (value of the power of 2). */ + int clock; /**< CPU clock frequency (in hz). */ + int debug; /**< Run in debug mode (0:off). */ +} emu68_parms_t; + +EMU68_API +/** + * Create a 68k emulator instance. + * + * The emu68_create() function creates an instance of the 68k + * emulator. The logmem parameter is the size of the 68K memory + * expressed in power of 2. Valid values are in the range 17 to 24 + * (inclusive) respectively 128 Kb to 16 Mb. Members set to zero + * will be replaced by the default value; alternatively if null + * pointer is passed the whole default parameters is applied (512KB + * at 8Mhz). + * + * @param parms Creation parameters or null pointer. + * @return emu68 instance + * @retval 0 on error + */ +emu68_t * emu68_create(emu68_parms_t * const parms); + +EMU68_API +/** + * Duplicate a 68k emulator instance. + * + * The emu68_dup() function creates an new instance of the 68k + * emulator which is a duplicate of the given emu68 instance. + * + * @param emu68 emulator instance to duplicate + * @param name duplicate emulator name [0:auto] + * + * @return duplicated emu68 instance + * @retval 0 on error + * + * @todo Duplicate attached IO is currently not supported since IO + * modules do not have a dup() function. + */ +emu68_t * emu68_duplicate(emu68_t * emu68, const char * name); + +EMU68_API +/** + * Destroy a 68k emulator instance. + * @param emu68 emulator instance + */ +void emu68_destroy(emu68_t * const emu68); + +EMU68_API +/** + * Hardware Reset. + * + * Perform following operations: + * - PC = 0 + * - SR = 2700 + * - A7 = end of mem - 4 + * - All registers cleared + * - All IO reseted + * + * @param emu68 emulator instance + */ +void emu68_reset(emu68_t * const emu68); + +/** @} */ + + +/* /\ ============================================================ /\ */ +/* < > ============================================================ < > */ +/* \/ ============================================================ \/ */ + + +/** @name Exception and Interruption control functions. + * + * EMU68 has a very limited interrupt handler. In fact only one + * source of interruption is used which is enought for sc68 + * needs. The emu68_set_interrupt_io() function selects the given + * IO chip as the candidate to interruption. + * + * Exception can be trapped and notified by calling specified + * handler function. + * + * @{ + */ + +EMU68_API +/** Set new interrupt IO. + * + * @param emu68 emulator instance + * @param io pointer to the only io that could possibly interrupt + * @return pointer to previous interrupt IO + */ +io68_t * emu68_set_interrupt_io(emu68_t * const emu68, io68_t * io); + +EMU68_API +/** Set user-data pointer. + * + * @param emu68 emulator instance + * @param cookie user-data pointer + * @return previous user-data pointer + */ +void * emu68_set_cookie(emu68_t * const emu68, void * cookie); + +EMU68_API +/** Get user-data pointer. + * + * @param emu68 emulator instance + * @return current user-data pointer + */ +void * emu68_get_cookie(emu68_t * const emu68); + +EMU68_API +/** Set user handler. + * + * @param emu68 emulator instance + * @param hdl user handler (0:do not update) + * @return previous handler + */ +emu68_handler_t emu68_set_handler(emu68_t * const emu68, emu68_handler_t hdl); + +/** @} */ + + +/** @name Cycle counter access functions. + * @{ + */ + +EMU68_API +/** Set internal cycle counter. + * + * @param emu68 emulator instance + */ +void emu68_set_cycle(emu68_t * const emu68, cycle68_t cycle); + +EMU68_API +/** Get internal cycle counter. + * + * @param emu68 emulator instance + */ +cycle68_t emu68_get_cycle(emu68_t * const emu68); + +/** @} */ + + +/* /\ ============================================================ /\ */ +/* < > ============================================================ < > */ +/* \/ ============================================================ \/ */ + + +/** @name EMU68 on-board memory access + * @{ + */ + +EMU68_API +/** Check if a memory block is in 68K on-board memory range. + * + * @param emu68 emulator instance + * + * @return Pointer to onboard memory block + * @retval 0 Failure + */ +u8 * emu68_memptr(emu68_t * const emu68, addr68_t dest, uint68_t sz); + +EMU68_API +/** Check for a memory access status block. + * + * @param emu68 emulator instance + * + * @return Pointer to onboard memory block + * @retval 0 Failure + */ +u8 * emu68_chkptr(emu68_t * const emu68, addr68_t dst, uint68_t sz); + + +EMU68_API +/** Get byte in 68K onboard memory. + * + * @param emu68 emulator instance + * @param emu68 emulator instance + * + * @see emu68_poke() + */ +int emu68_peek(emu68_t * const emu68, addr68_t addr); + +EMU68_API +/** Get byte in 68K access control memory. + * + * @param emu68 emulator instance + * @param emu68 emulator instance + * + * @see emu68_poke() + */ +int emu68_chkpeek(emu68_t * const emu68, addr68_t addr); + + +EMU68_API +/** Put a byte in 68K onboard memory. + * + * @param emu68 emulator instance + * + * @see emu68_peek() + */ +int emu68_poke(emu68_t * const emu68, addr68_t addr, int68_t v); + +EMU68_API +/** Put a byte in 68K access control memory. + * + * @param emu68 emulator instance + * + * @see emu68_peek() + */ +int emu68_chkpoke(emu68_t * const emu68, addr68_t addr, int68_t v); + +EMU68_API +/** Put a memory block to 68K on-board memory. + * + * The function copy a memory block in 68K on-board memory after verifying + * that the operation access valid 68K memory. + * + * @param emu68 emulator instance + * + * @see emu68_memget() + * @see emu68_memvalid() + */ +int emu68_memput(emu68_t * const emu68, + addr68_t dst, u8 * src, uint68_t sz); + +EMU68_API +/** Get 68K on-board memory into a memory block. + * + * The function copy a 68K on-board memory to a memory location after + * verifying that the operation access valid 68K memory. + * + * @param emu68 emulator instance + * + * @see emu68_memput() + * @see emu68_memvalid() + */ +int emu68_memget(emu68_t * const emu68, + u8 * dst, addr68_t src, uint68_t sz); + +EMU68_API +/** Fill a 68k on board memory block with a value. + * + * @param emu68 emulator instance + */ +int emu68_memset(emu68_t * const emu68, addr68_t dst, u8 val, uint68_t sz); + +EMU68_API +/** Fill a 68k access control memory block with a value. + * + * @param emu68 emulator instance + */ +int emu68_chkset(emu68_t * const emu68, addr68_t dst, u8 val, uint68_t sz); + +EMU68_API +/** Push 32-bit long word. + * @param emu68 emulator instance + * @param val value to push. + */ +void emu68_pushl(emu68_t * const emu68, int68_t val); + +EMU68_API +/** Push 16-bit word. + * @param emu68 emulator instance + * @param val value to push. + */ +void emu68_pushw(emu68_t * const emu68, int68_t val); + +EMU68_API +/** Pop 32-bit long word. + * @param emu68 emulator instance + * @return poped 32-bit value + */ +int68_t emu68_popl(emu68_t * emu68); + +EMU68_API +/** Pop 16-bit word. + * @param emu68 emulator instance + * @return poped 16-bit value + */ +int68_t emu68_popw(emu68_t * emu68); + +EMU68_API +/** Compute CRC32 of emu68 object (registers + memory). + * @param emu68 emulator instance + * @return crc32 + */ +uint68_t emu68_crc32(emu68_t * const emu68); + +/** @} */ + + +/** @name Execution functions + * @{ + * + * @todo Describe execution loop here ... + * + */ + +/** Execution status code. + * + * The emu68_status_e:: values + */ +enum emu68_status_e { + EMU68_ERR = -1, /**< Execution failed. */ + EMU68_NRM = 0, /**< Execution finished. */ + EMU68_STP = 1, /**< Execution stopped. */ + EMU68_BRK = 2, /**< Execution breaked. */ + EMU68_XCT = 3 /**< Execution in exception. */ +}; + +EMU68_API +/** Execute one instruction. + * + * @param emu68 emulator instance + * @return @ref emu68_status_e "execution status" + */ +int emu68_step(emu68_t * const emu68); + +EMU68_API +/** Execute until RTS (Return To Subroutine). + * + * @param emu68 emulator instance + * @return @ref emu68_status_e "execution status" + */ +int emu68_finish(emu68_t * const emu68, cycle68_t cycles); + +EMU68_API +/** Continue a breaked execution. + * + * @param emu68 emulator instance + * @return @ref emu68_status_e "execution status" + */ +int emu68_continue(emu68_t * const emu68); + + +EMU68_API +/** Execute interruptions with given cycle interval. + * + * @param emu68 emulator instance + * @param cycles interval within to excute interruptions + * @return @ref emu68_rc_e "execution return code" + */ +int emu68_interrupt(emu68_t * const emu68, cycle68_t cycles); + +/** @} */ + +/** @name Breakpoint functions. + * @{ + */ + +/** Kill all existing breakpoints. + */ +void emu68_bp_delall(emu68_t * const emu68); + +/** Delete a existing breakpoint. + * @param emu68 emulator instance + * @param id breakpoint identifier + */ +void emu68_bp_del(emu68_t * const emu68, int id); + +/** Set/Create a breakpoint. + * @param emu68 emulator instance + * @param id breakpoint identifier (-1:find free breakpooint) + * @param addr breakpoint address + * @param count breakpoint countdown + * @param reset breakpoint countdown reset (0:remove after break) + * @return breakpoint identifier + * @retval -1 on error + */ +int emu68_bp_set(emu68_t * const emu68, int id, + addr68_t addr, uint68_t count, uint68_t reset); + +/** Find breakpoint. + * @param emu68 emulator instance + * @param addr breakpoint address + * @return breakpoint identifier + * @retval -1 on error + */ +int emu68_bp_find(emu68_t * const emu68, addr68_t addr); + +/** @} */ + +/** @name Version checking functions + * @{ + */ + +EMU68_API +/** Get debug mode. + * + * @param emu68 emulator instance + * + * @retval 0 normal mode + * @retval 1 debug mode + * @retval -1 error + */ +int emu68_debugmode(emu68_t * const emu68); + +/** @} */ + + +/** + * @} + */ + +#endif /* #ifndef _EMU68_EMU68_H_ */ Index: apps/codecs/libsc68/emu68/error68_.h =================================================================== --- apps/codecs/libsc68/emu68/error68_.h (revision 0) +++ apps/codecs/libsc68/emu68/error68_.h (revision 0) @@ -0,0 +1,60 @@ +/** + * @ingroup emu68_lib + * @file emu68/error68_.h + * @author Benjamin Gerard + * @date 1999/03/13 + * @brief Error message stack header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_ERROR68_H_ +#define _EMU68_ERROR68_H_ + +#include "emu68_api.h" +#include "struct68.h" + +/** @defgroup emu68_lib_error Error message stack + * @ingroup emu68_lib_api + * + * EMU68 error handling consists on a fixed size stack of + * messages. When an EMU68 function fails, it stores a description + * message for the error and returns -1. If error stack is full, + * the oldest stacked message is removed. + * + * @{ + */ + +EMU68_API +/** Push formatted error message. + * + * The emu68_error_add() function formats error message and pushes + * it in error stack. On overflow the older message is lost. + * + * @param emu68 emulator instance. + * @param format printf() like format string. + * + * @return error-code + */ +int emu68_error_add(emu68_t * const emu68, const char * format, ...); + +EMU68_API +/** Pop last error message. + * + * Retrieve and remove last error message from error stack. + * + * @param emu68 emulator instance. + * + * @return Last pushed error message. + * @retval 0 Empty message stack, no more message. + */ +const char * emu68_error_get(emu68_t * const emu68); + +/** + * @} + */ + +#endif /* #ifndef _EMU68_ERROR68_H_ */ Index: apps/codecs/libsc68/emu68/inl68_systctrl.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_systctrl.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_systctrl.h (revision 0) @@ -0,0 +1,88 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_systctrl.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k system control operation inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_SYSTCTRL_H_ +#define _INL68_SYSTCTRL_H_ + +static inline +void inl_andtosr68(emu68_t * const emu68, int68_t v) +{ + emu68->reg.sr &= v; +} + +static inline +void inl_orrtosr68(emu68_t * const emu68, int68_t v) +{ + emu68->reg.sr |= v; +} + +static inline +void inl_eortosr68(emu68_t * const emu68, int68_t v) +{ + emu68->reg.sr ^= v; +} + +static inline +void inl_reset68(emu68_t * const emu68) +{ + /* $$$ TODO */ +} + +static inline +void inl_stop68(emu68_t * const emu68) +{ + u16 sr = (u16) get_nextw(); + if ( emu68->reg.sr & SR_S ) { + emu68->reg.sr = sr; + emu68->status = EMU68_STP; + } else { + exception68(emu68, PRIVV_VECTOR, -1); + } +} + +static inline +void inl_trapv68(emu68_t * const emu68) +{ + if (REG68.sr & SR_V) { + inl_exception68(emu68, TRAPV_VECTOR, -1); + } +} + +static inline +void inl_trap68(emu68_t * const emu68, const int n) +{ + inl_exception68(emu68,TRAP_VECTOR(n), -1); +} + +static inline +void inl_chk68(emu68_t * const emu68, const int68_t a, const int68_t b) +{ + REG68.sr &= 0xFF00 | (SR_X|SR_N); + REG68.sr |= !b << SR_Z_BIT; + if ( b < 0 ) { + REG68.sr |= SR_N; + inl_exception68(emu68, CHK_VECTOR, -1); + } else if ( b > a ) { + REG68.sr &= ~SR_N; + inl_exception68(emu68, CHK_VECTOR, -1); + } +} + +static inline +void inl_illegal68(emu68_t * const emu68) +{ + + inl_exception68(emu68, ILLEGAL_VECTOR, -1); +} + +#endif /* #ifndef _INL68_SYSTCTRL_H_ */ Index: apps/codecs/libsc68/emu68/inl68_arithmetic.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_arithmetic.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_arithmetic.h (revision 0) @@ -0,0 +1,176 @@ +/** + * @ingroup emu68_lib + * @file emu68/inl68_arithmetic.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k arithmetical instruction inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_ARITHMETIC_H_ +#define _INL68_ARITHMETIC_H_ + +static inline +int68_t inl_add68(emu68_t * const emu68, int68_t s, int68_t d, int68_t c) +{ + /* + Official version from 68K RPM : + V = (s & d & ~r) | (~s & ~d & r); // MSBit only + C = (s & d) | (~r & d) | (s & ~r); // MSBit only + X = C; + Z = !r; + N = r; // MSBit only + */ + const int68_t r = ( c += s + d ); + c = ( ( r >> SIGN_BIT ) & ( SR_V | SR_C | SR_X | SR_N ) ) ^ SR_V; + s = ( ( s >> SIGN_BIT ) & ( SR_V | SR_C | SR_X ) ) ^ c; + d = ( ( d >> SIGN_BIT ) & ( SR_V | SR_C | SR_X ) ) ^ c; + c &= ~SR_N; + c |= SR_V | ( !r << SR_Z_BIT ); + c ^= s | d; + REG68.sr = ( REG68.sr & 0xFF00 ) | c; + return r; +} + +static inline +int68_t inl_sub68(emu68_t * const emu68, int68_t s, int68_t d, int68_t c) +{ + /* + Official version from 68K RPM : + V = (~s & d & ~r) | (s & ~d & r); // MSBit only + C = (s & ~d) | (r & ~d) | (s & r); // MSBit only + X = C + Z = !r; + N = r; // MSBit only + */ + const int68_t r = d - s - c; + REG68.sr = ( REG68.sr & 0xFF00 ) + | (!r << SR_Z_BIT) + | (( r >> SIGN_BIT ) & SR_N) + | (((((d ^ ~r) & (s ^ r)) ^ r) >> SIGN_BIT) & (SR_C|SR_X)) + | ((((d ^ r) & (~s ^ r)) >> SIGN_BIT) & SR_V) + ; + return r; +} + +static inline +void inl_cmp68(emu68_t * const emu68, int68_t s, int68_t d) +{ + /* Like SUB but X is not taken into account nor affected. */ + const int68_t r = d - s; + REG68.sr = ( REG68.sr & ( 0xFF00 | SR_X ) ) + | (!r << SR_Z_BIT) + | (( r >> SIGN_BIT ) & SR_N) + | (((((d ^ ~r) & (s ^ r)) ^ r) >> SIGN_BIT) & SR_C) + | ((((d ^ r) & (~s ^ r)) >> SIGN_BIT) & SR_V) + ; +} + +static inline +int68_t inl_neg68(emu68_t * const emu68, int68_t d, int68_t c) +{ + /* + Official version from 68K RPM : + V = (d & r) // MSBit only + C = (d | r) // MSBit only + X = C + Z = !r; + N = r; // MSBit only + */ + int sr = REG68.sr & 0xFF00; + const int68_t r = ( c = -d - c ); + sr |= !r << SR_Z_BIT; + d >>= SIGN_BIT; + c >>= SIGN_BIT; + sr |= c & SR_N; + sr |= ( d | c ) & (SR_C|SR_X); + sr |= ( d & c ) & SR_V; + REG68.sr = sr; + return r; +} + + +static inline +int68_t inl_muls68(emu68_t * const emu68, int68_t s, int68_t d) +{ + d = ( d >> WORD_FIX ) * ( s >> WORD_FIX ); + REG68.sr = ( REG68.sr & ( 0xFF00 | SR_X ) ) + | ( !d << SR_Z_BIT ) + | ( (d >> (31 - SR_N_BIT)) & SR_N ); + return d << LONG_FIX; +} + +static inline +int68_t inl_mulu68(emu68_t * const emu68, uint68_t s, uint68_t d) +{ + d = ( d >> WORD_FIX ) * ( s >> WORD_FIX ); + REG68.sr = ( REG68.sr & ( 0xFF00 | SR_X ) ) + | ( !d << SR_Z_BIT ) + | ( (d >> (31 - SR_N_BIT)) & SR_N ); + return d << LONG_FIX; +} + +static inline +int68_t inl_divs68(emu68_t * const emu68, int68_t s, int68_t d) +{ + int sr = REG68.sr & (0xFF00 | SR_X); /* X unaffected; C cleared */ + if ( s >>= WORD_FIX ) { + int68_t res, rem; + d >>= LONG_FIX; + res = d / s; + rem = d % s; + + if ( (s16)res != res ) + sr |= SR_V; /* V on overflow */ + else + d = ( (int68_t) (u16) res ) | ( (int68_t) (u16) rem << 16 ); + sr |= !res << SR_Z_BIT; /* Z */ + sr |= ( res >> ( 15 - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = sr; + d <<= LONG_FIX; + } else { + /* Divide by zero */ + REG68.sr = sr; + inl_exception68(emu68, DIVIDE_VECTOR, -1); + } + return d; +} + +static inline +int68_t inl_divu68(emu68_t * const emu68, uint68_t s, uint68_t d) +{ + int sr = REG68.sr & (0xFF00 | SR_X); /* X unaffected; C cleared */ + if ( s >>= WORD_FIX ) { + uint68_t res, rem; + d >>= LONG_FIX; + res = d / s; + rem = d % s; + + if ( (u16)res != res ) + sr |= SR_V; /* V on overflow */ + else + d = ( res ) | ( rem << 16 ); + sr |= !res << SR_Z_BIT; /* Z */ + sr |= ( res >> ( 15 - SR_N_BIT ) ) & SR_N; /* N */ + REG68.sr = sr; + d <<= LONG_FIX; + } else { + /* Divide by zero */ + REG68.sr = sr; + inl_exception68(emu68, DIVIDE_VECTOR, -1); + } + return d; +} + +static inline +int68_t inl_clr68(emu68_t * const emu68) +{ + REG68.sr = ( REG68.sr & ( 0xFF00 | SR_X ) ) | SR_Z; + return 0; +} + +#endif /* #ifndef _INL68_ARITHMETIC_H_ */ Index: apps/codecs/libsc68/emu68/inl68_progctrl.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_progctrl.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_progctrl.h (revision 0) @@ -0,0 +1,79 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_progctrl.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k program control inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_PROGCTRL_H_ +#define _INL68_PROGCTRL_H_ + +static inline +void inl_tst68(emu68_t * const emu68, const int68_t a) +{ + REG68.sr = ( REG68.sr & ( 0xFF00 | SR_X ) ) + | ( !a << SR_Z_BIT ) + | ( ( a >> ( SIGN_FIX - SR_N_BIT ) ) & SR_N ) + ; +} + +static inline +int68_t inl_tas68(emu68_t * const emu68, int68_t d) +{ + inl_tst68(emu68, d << BYTE_FIX); + return d | 0x80; +} + +static inline +void inl_rts68(emu68_t * const emu68) +{ + REG68.pc = popl(); +} + +static inline +void inl_rte68(emu68_t * const emu68) +{ + REG68.sr = popw(); + REG68.pc = popl(); +} + +static inline +void inl_rtr68(emu68_t * const emu68) +{ + REG68.sr = ( REG68.sr & 0xFF00 ) | (u8)popw(); + REG68.pc = popl(); +} + +static inline +void inl_bsr68(emu68_t * const emu68, const addr68_t addr) +{ + pushl(REG68.pc); + REG68.pc = addr; + inl_addcycle68(emu68,12); +} + +static inline +void inl_jmp68(emu68_t * const emu68, const addr68_t addr) +{ + REG68.pc = addr; + inl_addcycle68(emu68,4); +} + +static inline +void inl_jsr68(emu68_t * const emu68, const addr68_t addr) +{ + pushl(REG68.pc); + REG68.pc = addr; + inl_addcycle68(emu68,4); +} + +static inline +void inl_nop68(emu68_t * const emu68) { } + +#endif /* #ifndef _INL68_PROGCTRL_H_ */ Index: apps/codecs/libsc68/emu68/macro68.h =================================================================== --- apps/codecs/libsc68/emu68/macro68.h (revision 0) +++ apps/codecs/libsc68/emu68/macro68.h (revision 0) @@ -0,0 +1,362 @@ +/** + * @ingroup emu68_lib + * @file emu68/macro68.h + * @author Benjamin Gerard + * @date 1999/13/03 + * @brief 68K instruction emulation macro definitions. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_MACRO68_H_ +#define _EMU68_MACRO68_H_ + +/* Determine what instruction to inline. + * + * EMU68_INLINE_LVL + */ + +#define EMU68_INLINE_MAX 1000 /**< Inlines all, */ +#define EMU68_INLINE_RAR 999 /**< Inlines almost all */ +#define EMU68_INLINE_MID 50 /**< Inlines balanced */ +#define EMU68_INLINE_NON 0 /**< Inlines not forced */ +#define EMU68_INLINE_YES 1 /**< Inline almost all */ +#define EMU68_INLINE_ONE 1 /**< Inline one */ + +#ifndef EMU68_INLINE_LVL +# if defined(EMU68_INLINE_ALL) +# define EMU68_INLINE_LVL EMU68_INLINE_MAX /* All would be inlined */ +# elif defined(EMU68_MONOLITIC) +# define EMU68_INLINE_LVL EMU68_INLINE_MAX /* Monolitic; compiler rules */ +# elif defined(DEBUG) +# define EMU68_INLINE_LVL EMU68_INLINE_NON /* Debug; do not force */ +# elif defined(LIBSC68_NDEBUG) +# define EMU68_INLINE_LVL EMU68_INLINE_YES /* Release; almost all */ +# else +# define EMU68_INLINE_LVL EMU68_INLINE_MID /* Standard; balanced */ +# endif +#endif + + +/* Instruction family (cnt) + ------------------ --- */ +#define EMU68_INLINE_ARI 278 /* Arithmetic (278) */ +#define EMU68_INLINE_BCD EMU68_INLINE_RAR /* Binary coded decimal ( 6) */ +#define EMU68_INLINE_BIT 36 /* Bit Operation ( 36) */ +#define EMU68_INLINE_LOG 171 /* Logic (171) */ +#define EMU68_INLINE_SHT 56 /* Shifting ( 56) */ +#define EMU68_INLINE_TST 240 /* Test and move (240) */ +#define EMU68_INLINE_BSR EMU68_INLINE_YES /* Branch ( ) */ + + +#define ADDCYCLE(N) inl_addcycle68(emu68,N) +#define SETCYCLE(N) inl_setcycle68(emu68,N) +#define EXCEPTION(VECTOR,LEVEL) inl_exception68(emu68,VECTOR,LEVEL) + + +/* ,---------------------------------------------------------------------. + * | BRANCH | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_BSR < EMU68_INLINE_LVL +# define JSR(PC) inl_jsr68(emu68,PC) +# define JMP(PC) inl_jmp68(emu68,PC) +#else +# define JSR(PC) jsr68(emu68,PC) +# define JMP(PC) jmp68(emu68,PC) +#endif + +/* ,---------------------------------------------------------------------. + * | BIT MANIPULATION | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_LOG < EMU68_INLINE_LVL +# define _BTST(V,BIT) inl_btst68(emu68, V, BIT) +# define _BCHG(V,BIT) inl_bchg68(emu68, V, BIT) +# define _BCLR(V,BIT) inl_bclr68(emu68, V, BIT) +# define _BSET(V,BIT) inl_bset68(emu68, V, BIT) +#else +# define _BTST(V,BIT) btst68(emu68, V, BIT) +# define _BCHG(V,BIT) bchg68(emu68, V, BIT) +# define _BCLR(V,BIT) bclr68(emu68, V, BIT) +# define _BSET(V,BIT) bset68(emu68, V, BIT) +#endif +#define BTSTB(R, V, BIT) _BTST(V, BIT & 7) +#define BTSTL(R, V, BIT) _BTST(V, BIT & 31) +#define BCHGB(R, V, BIT) R = _BCHG(V, BIT & 7) +#define BCHGL(R, V, BIT) R = _BCHG(V, BIT & 31) +#define BSETB(R, V, BIT) R = _BSET(V, BIT & 7) +#define BSETL(R, V, BIT) R = _BSET(V, BIT & 31) +#define BCLRB(R, V, BIT) R = _BCLR(V, BIT & 7) +#define BCLRL(R, V, BIT) R = _BCLR(V, BIT & 31) + +/* ,---------------------------------------------------------------------. + * | MOVE AND TEST | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_TST < EMU68_INLINE_LVL +# define _TST(A) inl_tst68(emu68, A) +# define _TAS(A) inl_tas68(emu68, A) +#else +# define _TST(A) tst68(emu68, A) +# define _TAS(A) tas68(emu68, A) +#endif +#define TSTB(R, A) _TST(A) +#define TSTW(R, A) _TST(A) +#define TSTL(R, A) _TST(A) +#define TASB(R, A) R = _TAS(A) + +#define MOVEB(A) _TST(A) +#define MOVEW(A) _TST(A) +#define MOVEL(A) _TST(A) + +#define EXTW(A) _TST(A) +#define EXTL(A) _TST(A) + + +/* ,---------------------------------------------------------------------. + * | LOGIC | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_LOG < EMU68_INLINE_LVL +# define _AND68(A,B) inl_and68(emu68, A, B) +# define _ORR68(A,B) inl_orr68(emu68, A, B) +# define _EOR68(A,B) inl_eor68(emu68, A, B) +# define _NOT68(A) inl_not68(emu68, A) +#else +# define _AND68(A,B) and68(emu68, A, B) +# define _ORR68(A,B) orr68(emu68, A, B) +# define _EOR68(A,B) eor68(emu68, A, B) +# define _NOT68(A) not68(emu68, A) +#endif + +#define ANDB(S, A, B) S = _AND68(A, B) +#define ANDW(S, A, B) S = _AND68(A, B) +#define ANDL(S, A, B) S = _AND68(A, B) +#define ORRB(S, A, B) S = _ORR68(A, B) +#define ORRW(S, A, B) S = _ORR68(A, B) +#define ORRL(S, A, B) S = _ORR68(A, B) +#define EORB(S, A, B) S = _EOR68(A, B) +#define EORW(S, A, B) S = _EOR68(A, B) +#define EORL(S, A, B) S = _EOR68(A, B) +#define NOTB(S, A) S = _NOT68(A) +#define NOTW(S, A) S = _NOT68(A) +#define NOTL(S, A) S = _NOT68(A) + + +#define BYTE_SR_X ( (int68_t)(REG68.sr&SR_X) << (BYTE_FIX-SR_X_BIT) ) +#define WORD_SR_X ( (int68_t)(REG68.sr&SR_X) << (WORD_FIX-SR_X_BIT) ) +#define LONG_SR_X ( (int68_t)((REG68.sr>>SR_X_BIT) & 1) << LONG_FIX ) + + +/* ,---------------------------------------------------------------------. + * | ARITHMETIC | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_ARI < EMU68_INLINE_LVL +# define _ADD68(A, B, X) inl_add68(emu68, A, B, X) +# define _SUB68(A, B, X) inl_sub68(emu68, A, B, X) +# define _CMP68(A, B) inl_cmp68(emu68, A, B ) +# define _NEG68(B, X) inl_neg68(emu68, B, X) +# define _CLR68() inl_clr68(emu68) +# define _MULS(A, B) inl_muls68(emu68, A, B) +# define _MULU(A, B) inl_mulu68(emu68, A, B) +# define _DIVS(A, B) inl_divs68(emu68, A, B) +# define _DIVU(A, B) inl_divu68(emu68, A, B) +#else +# define _ADD68(A, B, X) add68(emu68, A, B, X) +# define _SUB68(A, B, X) sub68(emu68, A, B, X) +# define _CMP68(A, B) cmp68(emu68, A, B ) +# define _NEG68(B, X) neg68(emu68, B, X) +# define _CLR68() clr68(emu68) +# define _MULS(A, B) muls68(emu68, A, B) +# define _MULU(A, B) mulu68(emu68, A, B) +# define _DIVS(A, B) divs68(emu68, A, B) +# define _DIVU(A, B) divu68(emu68, A, B) +#endif +#define _ADDA(A, B) (B) + (A) +#define _SUBA(A, B) (B) - (A) +#define _CMPA(A, B) _CMP68(A, B) + +#define ADDB(S, A, B) S = _ADD68(A, B, 0) +#define ADDW(S, A, B) S = _ADD68(A, B, 0) +#define ADDL(S, A, B) S = _ADD68(A, B, 0) +#define SUBB(S, A, B) S = _SUB68(A, B, 0) +#define SUBW(S, A, B) S = _SUB68(A, B, 0) +#define SUBL(S, A, B) S = _SUB68(A, B, 0) +#define CMPB(A, B) _CMP68(A, B ) +#define CMPW(A, B) _CMP68(A, B ) +#define CMPL(A, B) _CMP68(A, B ) +#define NEGB(S, B) S = _NEG68( B, 0) +#define NEGW(S, B) S = _NEG68( B, 0) +#define NEGL(S, B) S = _NEG68( B, 0) +#define CLRB(S, B) S = _CLR68() +#define CLRW(S, B) S = _CLR68() +#define CLRL(S, B) S = _CLR68() + +#define ADDXB(S, A, B) S = _ADD68(A, B, BYTE_SR_X) +#define ADDXW(S, A, B) S = _ADD68(A, B, WORD_SR_X) +#define ADDXL(S, A, B) S = _ADD68(A, B, LONG_SR_X) +#define SUBXB(S, A, B) S = _SUB68(A, B, BYTE_SR_X) +#define SUBXW(S, A, B) S = _SUB68(A, B, WORD_SR_X) +#define SUBXL(S, A, B) S = _SUB68(A, B, LONG_SR_X) +#define NEGXB(S, B) S = _NEG68( B, BYTE_SR_X) +#define NEGXW(S, B) S = _NEG68( B, WORD_SR_X) +#define NEGXL(S, B) S = _NEG68( B, LONG_SR_X) + +#define ADDAW(S, A, B) S = _ADDA(A, B) +#define ADDAL(S, A, B) S = _ADDA(A, B) +#define SUBAW(S, A, B) S = _SUBA(A, B) +#define SUBAL(S, A, B) S = _SUBA(A, B) +#define CMPAW(A, B) _CMPA(A, B) +#define CMPAL(A, B) _CMPA(A, B) + +#define MULSW(S, A, B) S = _MULS(A, B) +#define MULUW(S, A, B) S = _MULU(A, B) +#define DIVSW(S, A, B) S = _DIVS(A, B) +#define DIVUW(S, A, B) S = _DIVU(A, B) + + +/* ,---------------------------------------------------------------------. + * | SHIFTING | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_SHT < EMU68_INLINE_LVL +# define _LSL(D,CNT,SZ) inl_lsl68(emu68,D,CNT,SZ) +# define _LSR(D,CNT,SZ) inl_lsr68(emu68,D,CNT,SZ) +# define _ASL(D,CNT,SZ) inl_asl68(emu68,D,CNT,SZ) +# define _ASR(D,CNT,SZ) inl_asr68(emu68,D,CNT,SZ) +# define _ROL(D,CNT,SZ) inl_rol68(emu68,D,CNT,SZ) +# define _ROR(D,CNT,SZ) inl_ror68(emu68,D,CNT,SZ) +# define _ROXL(D,CNT,SZ) inl_roxl68(emu68,D,CNT,SZ) +# define _ROXR(D,CNT,SZ) inl_roxr68(emu68,D,CNT,SZ) +#else +# define _LSL(D,CNT,SZ) lsl68(emu68,D,CNT,SZ) +# define _LSR(D,CNT,SZ) lsr68(emu68,D,CNT,SZ) +# define _ASL(D,CNT,SZ) asl68(emu68,D,CNT,SZ) +# define _ASR(D,CNT,SZ) asr68(emu68,D,CNT,SZ) +# define _ROL(D,CNT,SZ) rol68(emu68,D,CNT,SZ) +# define _ROR(D,CNT,SZ) ror68(emu68,D,CNT,SZ) +# define _ROXL(D,CNT,SZ) roxl68(emu68,D,CNT,SZ) +# define _ROXR(D,CNT,SZ) roxr68(emu68,D,CNT,SZ) +#endif + + +#define LSRB(R, A, B) R = _LSR(A, B, 8-1) +#define LSRW(R, A, B) R = _LSR(A, B, 16-1) +#define LSRL(R, A, B) R = _LSR(A, B, 32-1) +#define LSLB(R, A, B) R = _LSL(A, B, 8-1) +#define LSLW(R, A, B) R = _LSL(A, B, 16-1) +#define LSLL(R, A, B) R = _LSL(A, B, 32-1) + +#define ASRB(R, A, B) R = _ASR(A, B, 8-1) +#define ASRW(R, A, B) R = _ASR(A, B, 16-1) +#define ASRL(R, A, B) R = _ASR(A, B, 32-1) +#define ASLB(R, A, B) R = _ASL(A, B, 8-1) +#define ASLW(R, A, B) R = _ASL(A, B, 16-1) +#define ASLL(R, A, B) R = _ASL(A, B, 32-1) + +#define RORB(R, A, B) R = _ROR(A, B, 8-1) +#define RORW(R, A, B) R = _ROR(A, B, 16-1) +#define RORL(R, A, B) R = _ROR(A, B, 32-1) +#define ROLB(R, A, B) R = _ROL(A, B, 8-1) +#define ROLW(R, A, B) R = _ROL(A, B, 16-1) +#define ROLL(R, A, B) R = _ROL(A, B, 32-1) + +#define ROXRB(R, A, B) R = _ROXR(A ,B, 8-1) +#define ROXRW(R, A, B) R = _ROXR(A ,B, 16-1) +#define ROXRL(R, A, B) R = _ROXR(A ,B, 32-1) +#define ROXLB(R, A, B) R = _ROXL(A ,B, 8-1) +#define ROXLW(R, A, B) R = _ROXL(A ,B, 16-1) +#define ROXLL(R, A, B) R = _ROXL(A ,B, 32-1) + + + +/* ,---------------------------------------------------------------------. + * | BINARY CODED DECIMAL | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_BCD < EMU68_INLINE_LVL +# define _ABCD(A,B) inl_abcd68(emu68, A, B) +# define _SBCD(A,B) inl_sbcd68(emu68, A, B) +# define _NBCD(A) inl_nbcd68(emu68, A) +#else +# define _ABCD(A,B) abcd68(emu68, A, B) +# define _SBCD(A,B) sbcd68(emu68, A, B) +# define _NBCD(A) nbcd68(emu68, A) +#endif +#define ABCDB(S, A, B) S = _ABCD(A, B) +#define SBCDB(S, A, B) S = _SBCD(A, B) +#define NBCDB(S, A) S = _NBCD(A) + + +/* ,---------------------------------------------------------------------. + * | INSTRUCTIONS ALMOST NEVER INLINED | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_RAR < EMU68_INLINE_LVL +# define CHKW(A,B) inl_chk68(emu68, A, B) +#else +# define CHKW(A,B) chk68(emu68, A, B) +#endif + +/* ,---------------------------------------------------------------------. + * | INSTRUCTIONS ALMOST ALWAYS INLINED | + * `---------------------------------------------------------------------' + */ + +#if EMU68_INLINE_ONE < EMU68_INLINE_LVL +# define SWAP(R) inl_swap68(emu68,R) +# define RTS inl_rts68(emu68) +# define RTE inl_rte68(emu68) +# define RTR inl_rtr68(emu68) +# define ILLEGAL inl_illegal68(emu68) +# define TRAP(N) inl_trap68(emu68,N) +# define TRAPV inl_trapv68(emu68) +# define NOP inl_nop68(emu68) +# define RESET emu68_reset(emu68) +# define STOP inl_stop68(emu68) +# define LINK(R) inl_link68(emu68,R) +# define UNLK(R) inl_unlk68(emu68,R) +# define LINEA inl_linea68(emu68) +# define LINEF inl_linef68(emu68) +# define EXG(RX,RY) inl_exg68(emu68,RX,RY) +#else +# define SWAP(R) swap68(emu68,R) +# define RTS rts68(emu68) +# define RTE rte68(emu68) +# define RTR rtr68(emu68) +# define ILLEGAL illegal68(emu68) +# define TRAP(N) trap68(emu68,N) +# define TRAPV trapv68(emu68) +# define NOP nop68(emu68) +# define RESET reset68(emu68) +# define STOP stop68(emu68) +# define LINK(R) link68(emu68,R) +# define UNLK(R) unlk68(emu68,R) +# define LINEA linea68(emu68) +# define LINEF linef68(emu68) +# define EXG(RX,RY) exg68(emu68,RX,RY) +#endif + +/* ,---------------------------------------------------------------------. + * | CODE CONDITIONS TABLE | + * `---------------------------------------------------------------------' + */ + +#define SCC(CC) scc68[CC](emu68) +#define BCC(PC,CC) bcc68[CC](emu68,PC) +#define DBCC(DN,CC) dbcc68[CC](emu68,DN) + +#endif /* #ifdefndef _EMU68_MACRO68_H_ */ Index: apps/codecs/libsc68/emu68/inl68_datamove.h =================================================================== --- apps/codecs/libsc68/emu68/inl68_datamove.h (revision 0) +++ apps/codecs/libsc68/emu68/inl68_datamove.h (revision 0) @@ -0,0 +1,54 @@ +/** + * @ingroup emu68_lib_inline + * @file emu68/inl68_datamove.h + * @author Benjamin Gerard + * @date 2009/05/18 + * @brief 68k program control inlines. + * + */ + +/* $Id: inst68.h 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _INL68_DATAMOVE_H_ +#define _INL68_DATAMOVE_H_ + +static inline +void inl_link68(emu68_t * const emu68, const int reg) +{ + pushl(REG68.a[reg]); + REG68.a[reg] = REG68.a[7]; + REG68.a[7] = (u32)(REG68.a[7]+get_nextw()); +} + +static inline +void inl_unlk68(emu68_t * const emu68, const int reg) +{ + REG68.a[7] = REG68.a[reg]; + REG68.a[reg] = (u32)popl(); +} + +static inline +void inl_exg68(emu68_t * const emu68, const int reg0, const int reg9) +{ + s32 * const reg = REG68.d, tmp = reg[reg0]; + reg[reg0] = reg[reg9]; + reg[reg9] = tmp; +} + +static inline +addr68_t inl_lea68(emu68_t * const emu68, const int mode, const int reg) +{ + return get_eal68[mode](emu68,reg); +} + +static inline +addr68_t inl_pea68(emu68_t * const emu68, const int mode, const int reg) +{ + const addr68_t ea = get_eal68[mode](emu68,reg); + pushl(ea); + return ea; +} + +#endif /* #ifndef _INL68_DATAMOVE_H_ */ Index: apps/codecs/libsc68/emu68/srdef68.h =================================================================== --- apps/codecs/libsc68/emu68/srdef68.h (revision 0) +++ apps/codecs/libsc68/emu68/srdef68.h (revision 0) @@ -0,0 +1,103 @@ +/** + * @ingroup emu68_lib + * @file emu68/srdef68.h + * @author Benjamin Gerard + * @date 1999/13/03 + * @brief Status Register (SR) definition header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _EMU68_SRDEF68_H_ +#define _EMU68_SRDEF68_H_ + +/** @defgroup emu68_lib_srdef Status Register (SR) definitions + * @ingroup emu68_lib + * + * 68K status register definitions. + * The SR is composed of condition code register (CCR) located in + * the LSB and privileged processor status in MSB. EMU68 does not + * currently handle supervisor and trace mode. Internal processor level is + * partially managed. Each SR bit is defined by its bit number (SR_x_BIT) + * and the corresponding value (SR_x) where x is one of C,V,Z,N,X,S or T. + * SR_IPL_BIT is used to locate the less significant bit position of the 3 + * IPL bits. Macros are available to help with SR bit manipulations. + * + * SR := T.S. .IPL ...X NZVC + * + * @{ + */ + +/** @name SR bit definitions. + * @{ + */ + +enum { + SR_C_BIT = 0 /**< Carry bit number. */, + SR_V_BIT = 1 /**< Overflow bit number. */, + SR_Z_BIT = 2 /**< Zero bit number. */, + SR_N_BIT = 3 /**< Negative bit number. */, + SR_X_BIT = 4 /**< eXtended carry bit number. */, + SR_I_BIT = 8 /**< Internal Processor Level bit number. */, + SR_S_BIT = 13 /**< Superuser bit number. */, + SR_T_BIT = 15 /**< Trace bit number. */, +}; + +enum { + SR_C = (1<>SR_I_BIT)&7 + */ +#define GET_IPL(SR) ( ( (SR) >> SR_I_BIT ) & 7 ) + +/** Change IPL value of SR. + * @param SR current SR value + * @param IPL new IPL value [0..7] + * @return new SR value + * @retval ((SR)&~SR_I)|((IPL)< + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "inst68.h" +#include "assert68.h" +#include "srdef68.h" +#include "struct68.h" +#include "excep68.h" +#include "cc68.h" +#include "mem68.h" +#include "emu68.h" + +/* ,-----------. + | Exception | + `-----------' */ + +#include "inl68_exception.h" + +void exception68(emu68_t * const emu68, const int vector, const int level) +{ + if ( vector & 0x100 ) { + /* Those are specific to EMU68 */ + switch (vector) { + case HWBREAK_VECTOR: + case HWTRACE_VECTOR: + break; + default: + assert(!"invalid eception vector"); + } + } else { + int savesr = REG68.sr; + int savest = emu68->status; + + emu68->status = EMU68_XCT; /* enter exception stat */ + REG68.sr &= ~SR_T; /* no TRACE */ + REG68.sr |= SR_S; /* Supervisor */ + + if ( savest == EMU68_XCT && + ( vector == BUSERR_VECTOR || vector == ADRERR_VECTOR ) ) { + /* Double fault ! */ + emu68->status = EMU68_ERR; /* Halt processor */ + } else if ( vector == RESET_VECTOR ) { + REG68.sr |= SR_I; + REG68.a[7] = read_L(RESET_SP_VECTOR << 2); + REG68.pc = read_L(RESET_PC_VECTOR << 2); + } else { + if ( (unsigned int)level < 8u ) { + SET_IPL(REG68.sr,level); + } + pushl(REG68.pc); + pushw(savesr); + REG68.pc = read_L(vector << 2); + emu68->status = EMU68_NRM; /* Back to normal mode */ + } + } + if (emu68->handler && emu68->handler(emu68, vector, emu68->cookie) ) { + emu68->status = EMU68_BRK; /* User forced exit */ + } +} + +void buserror68(emu68_t * const emu68, const int addr, const int mode) +{ + inl_buserror68(emu68, addr, mode); +} + +void linea68(emu68_t * const emu68) +{ + inl_linea68(emu68); +} + +void linef68(emu68_t * const emu68) +{ + inl_linef68(emu68); +} + + +/* ,------------. + | Arithmetic | + `------------' */ + +#include "inl68_arithmetic.h" + +int68_t add68(emu68_t * const emu68, int68_t s, int68_t d, int68_t c) +{ + return inl_add68(emu68, s, d, c); +} + +int68_t sub68(emu68_t * const emu68, int68_t s, int68_t d, int68_t c) +{ + return inl_sub68(emu68, s, d, c); +} + +void cmp68(emu68_t * const emu68, int68_t s, int68_t d) +{ + inl_cmp68(emu68, s, d); +} + +int68_t muls68(emu68_t * const emu68, int68_t s, int68_t d) +{ + return inl_muls68(emu68, s, d); +} + +int68_t mulu68(emu68_t * const emu68, uint68_t s, uint68_t d) +{ + return inl_mulu68(emu68, s, d); +} + +int68_t divs68(emu68_t * const emu68, int68_t s, int68_t d) +{ + return inl_divs68(emu68, s, d); +} + +int68_t divu68(emu68_t * const emu68, uint68_t s, uint68_t d) +{ + return inl_divu68(emu68, s, d); +} + +int68_t clr68(emu68_t * const emu68) +{ + return inl_clr68(emu68); +} + +int68_t neg68(emu68_t * const emu68, int68_t d, int68_t c) +{ + return inl_neg68(emu68, d, c); +} + + +/* ,-------. + | Logic | + `-------' */ + +#include "inl68_logic.h" + +int68_t and68(emu68_t * const emu68, const int68_t s, int68_t d) +{ + return inl_and68(emu68, s, d); +} + +int68_t orr68(emu68_t * const emu68, const int68_t s, int68_t d) +{ + return inl_orr68(emu68, s, d); +} + +int68_t eor68(emu68_t * const emu68, const int68_t s, int68_t d) +{ + return inl_eor68(emu68, s, d); +} + +int68_t not68(emu68_t * const emu68, const int68_t d) +{ + return inl_not68(emu68, d); +} + + +/* ,----------------. + | System Control | + `----------------' */ + +#include "inl68_systctrl.h" + +void illegal68(emu68_t * const emu68) +{ + inl_illegal68(emu68); +} + +void trapv68(emu68_t * const emu68) +{ + inl_trapv68(emu68); +} + +void trap68(emu68_t * const emu68, const int trap_n) +{ + inl_trap68(emu68, trap_n); +} + +void chk68(emu68_t * const emu68, const int68_t a, const int68_t b) +{ + inl_chk68(emu68, a, b); +} + +void andtosr68(emu68_t * const emu68, int68_t v) +{ + inl_andtosr68(emu68, v); +} + +void orrtosr68(emu68_t * const emu68, int68_t v) +{ + inl_orrtosr68(emu68, v); +} + +void eortosr68(emu68_t * const emu68, int68_t v) +{ + inl_eortosr68(emu68, v); +} + +void reset68(emu68_t * const emu68) +{ + inl_reset68(emu68); +} + +void stop68(emu68_t * const emu68) +{ + inl_stop68(emu68); +} + + +/* ,------------------. + | Bit manipulation | + `------------------' */ + +#include "inl68_bitmanip.h" + +void btst68(emu68_t * const emu68, const int68_t v, const int bit) +{ + inl_btst68(emu68, v, bit); +} + +int68_t bset68(emu68_t * const emu68, const int68_t v, const int bit) +{ + return inl_bset68(emu68, v, bit); +} + +int68_t bclr68(emu68_t * const emu68, const int68_t v, const int bit) +{ + return inl_bclr68(emu68, v, bit); +} + +int68_t bchg68(emu68_t * const emu68, const int68_t v, const int bit) +{ + return inl_bchg68(emu68, v, bit); +} + + +/* ,----------------------. + | Binary Coded Decimal | + `----------------------' */ + +#include "inl68_bcd.h" + +int68_t abcd68(emu68_t * const emu68, int68_t a, int68_t b) +{ + return inl_abcd68(emu68, a, b); +} + +int68_t sbcd68(emu68_t * const emu68, int68_t a, int68_t b) +{ + return inl_sbcd68(emu68, a, b); +} + +int68_t nbcd68(emu68_t * const emu68, int68_t a) +{ + return inl_nbcd68(emu68, a); +} + + +/* ,-----------------. + | Program Control | + `-----------------' */ + +#include "inl68_progctrl.h" + +void rts68(emu68_t * const emu68) +{ + inl_rts68(emu68); +} + +void rte68(emu68_t * const emu68) +{ + inl_rte68(emu68); +} + +void rtr68(emu68_t * const emu68) +{ + inl_rtr68(emu68); +} + +void bsr68(emu68_t * const emu68, const addr68_t addr) +{ + inl_bsr68(emu68, addr); +} + +#define BCC_TEMPLATE(CC) \ + static void bcc_##CC(emu68_t * const emu68, const addr68_t addr) { \ + if (inl_is_cc##CC(REG68.sr)) \ + REG68.pc = addr; \ + } + +static void bcc_0(emu68_t * const emu68, const addr68_t addr) +{ + REG68.pc = addr; +} + +static void bcc_1(emu68_t * const emu68, const addr68_t addr) +{ + inl_bsr68(emu68, addr); +} + +BCC_TEMPLATE(2) +BCC_TEMPLATE(3) +BCC_TEMPLATE(4) +BCC_TEMPLATE(5) +BCC_TEMPLATE(6) +BCC_TEMPLATE(7) +BCC_TEMPLATE(8) +BCC_TEMPLATE(9) +BCC_TEMPLATE(A) +BCC_TEMPLATE(B) +BCC_TEMPLATE(C) +BCC_TEMPLATE(D) +BCC_TEMPLATE(E) +BCC_TEMPLATE(F) + +void (* const bcc68[16])(emu68_t * const, const addr68_t) = { + bcc_0, bcc_1, bcc_2, bcc_3, bcc_4, bcc_5, bcc_6, bcc_7, + bcc_8, bcc_9, bcc_A, bcc_B, bcc_C, bcc_D, bcc_E, bcc_F +}; + +void jmp68(emu68_t * const emu68, const addr68_t addr) +{ + inl_jmp68(emu68, addr); +} + +void jsr68(emu68_t * const emu68, const addr68_t addr) +{ + inl_jsr68(emu68, addr); +} + +void nop68(emu68_t * const emu68) +{ + inl_nop68(emu68); +} + +void tst68(emu68_t * const emu68, const int68_t a) +{ + inl_tst68(emu68, a); +} + +int68_t tas68(emu68_t * const emu68, int68_t d) +{ + return inl_tas68(emu68, d); +} + +#define DBCC_TEMPLATE(CC) \ + static void dbcc_##CC(emu68_t * const emu68, const int dn) { \ + const uint68_t pc = REG68.pc; \ + if (!inl_is_cc##CC(REG68.sr)) { \ + int68_t a = (u16)(REG68.d[dn]-1); \ + REG68.d[dn] = (REG68.d[dn] & 0xFFFF0000) | a; \ + if (a != 0xFFFF) { \ + REG68.pc = pc + get_nextw(); \ + } else { \ + REG68.pc = pc + 2; \ + } \ + } else { \ + REG68.pc = pc + 2; \ + } \ + } + +DBCC_TEMPLATE(0) +DBCC_TEMPLATE(1) +DBCC_TEMPLATE(2) +DBCC_TEMPLATE(3) +DBCC_TEMPLATE(4) +DBCC_TEMPLATE(5) +DBCC_TEMPLATE(6) +DBCC_TEMPLATE(7) +DBCC_TEMPLATE(8) +DBCC_TEMPLATE(9) +DBCC_TEMPLATE(A) +DBCC_TEMPLATE(B) +DBCC_TEMPLATE(C) +DBCC_TEMPLATE(D) +DBCC_TEMPLATE(E) +DBCC_TEMPLATE(F) + +void (* const dbcc68[])(emu68_t * const, const int) = { + dbcc_0, dbcc_1, dbcc_2, dbcc_3, dbcc_4, dbcc_5, dbcc_6, dbcc_7, + dbcc_8, dbcc_9, dbcc_A, dbcc_B, dbcc_C, dbcc_D, dbcc_E, dbcc_F +}; + +#define SCC_TEMPLATE(CC) \ + static int scc_##CC(emu68_t * const emu68) \ + { \ + return (u8) -inl_is_cc##CC(REG68.sr); \ + } + +SCC_TEMPLATE(0) +SCC_TEMPLATE(1) +SCC_TEMPLATE(2) +SCC_TEMPLATE(3) +SCC_TEMPLATE(4) +SCC_TEMPLATE(5) +SCC_TEMPLATE(6) +SCC_TEMPLATE(7) +SCC_TEMPLATE(8) +SCC_TEMPLATE(9) +SCC_TEMPLATE(A) +SCC_TEMPLATE(B) +SCC_TEMPLATE(C) +SCC_TEMPLATE(D) +SCC_TEMPLATE(E) +SCC_TEMPLATE(F) + +int (* const scc68[])(emu68_t * const) = { + scc_0, scc_1, scc_2, scc_3, scc_4, scc_5, scc_6, scc_7, + scc_8, scc_9, scc_A, scc_B, scc_C, scc_D, scc_E, scc_F +}; + +/* ,----------. + | Shifting | + `----------' */ + +#include "inl68_shifting.h" + +void swap68(emu68_t * const emu68, const int dn) +{ + inl_swap68(emu68, dn); +} + +int68_t lsl68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + return inl_lsl68(emu68, d, s, l); +} + +int68_t lsr68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + return inl_lsr68(emu68, d, s, l); +} + +int68_t asl68(emu68_t * const emu68, int68_t d, int s, const int l) +{ + return inl_asl68(emu68, d, s, l); +} + +int68_t asr68(emu68_t * const emu68, int68_t d, int s, const int l) +{ + return inl_asr68(emu68, d, s, l); +} + +int68_t rol68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + return inl_rol68(emu68, d, s, l); +} + +int68_t ror68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + return inl_ror68(emu68, d, s, l); +} + +int68_t roxl68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + return inl_roxl68(emu68, d, s, l); +} + +int68_t roxr68(emu68_t * const emu68, uint68_t d, int s, const int l) +{ + return inl_roxr68(emu68, d, s, l); +} + +/* ,-----------. + | Data Move | + `-----------' */ + +#include "inl68_datamove.h" + +void exg68(emu68_t * const emu68, const int reg0, const int reg9) +{ + inl_exg68(emu68, reg0, reg9); +} + +addr68_t lea68(emu68_t * const emu68, const int mode, const int reg) +{ + return inl_lea68(emu68, mode, reg); +} + +addr68_t pea68(emu68_t * const emu68, const int mode, const int reg) +{ + return inl_pea68(emu68, mode, reg); +} + +void link68(emu68_t * const emu68, const int reg) +{ + inl_link68(emu68, reg); +} + +void unlk68(emu68_t * const emu68, const int reg) +{ + inl_unlk68(emu68, reg); +} Index: apps/codecs/libsc68/io68/paula_io.h =================================================================== --- apps/codecs/libsc68/io68/paula_io.h (revision 0) +++ apps/codecs/libsc68/io68/paula_io.h (revision 0) @@ -0,0 +1,69 @@ +/** + * @ingroup io68_paula_devel + * @file io68/paula_io.h + * @author Benjamin Gerard + * @date 1998/06/18 + * @brief Paula IO plugin header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_PAULA_IO_H_ +#define _IO68_PAULA_IO_H_ + +#if defined(INCLUDE_SHARED68) +#include "emu68/struct68.h" +#endif + +#include "paulaemul.h" + +/** @addtogroup io68_paula_devel + * @{ + */ + +/** @name Paula (Amiga soundchip) IO plugin + * @{ + */ + +IO68_EXTERN +/** Initialize paula library. */ +int paulaio_init(int * argc, char ** argv); + +IO68_EXTERN +/** Shutdown paula library. */ +void paulaio_shutdown(void); + +IO68_EXTERN +/** Create paula io instance. + * + * @param emu68 68000 emulator instance + * @param parms Paula parameters + * + * @return Created shifter instance + * @retval 0 + */ +io68_t * paulaio_create(emu68_t * const emu68, paula_parms_t * const parms); + +IO68_EXTERN +/** Get/Set sampling rate. + * + * @param io Paula IO instance + * @param hz @ref paula_hz_e "sampling rate" in hz + * @return Actual @ref paula_hz_e "sampling rate". + */ +int paulaio_sampling_rate(io68_t * const io, int hz); + +IO68_EXTERN +/** Get paula emulator instance. */ +paula_t * paulaio_emulator(io68_t * const io); + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _IO68_PAULA_IO_H_ */ Index: apps/codecs/libsc68/io68/default_option68.h =================================================================== --- apps/codecs/libsc68/io68/default_option68.h (revision 0) +++ apps/codecs/libsc68/io68/default_option68.h (revision 0) @@ -0,0 +1,18 @@ +/* $Id$ */ + +#ifndef _IO68_DEFAULT_OPTION68_H_ +#define _IO68_DEFAULT_OPTION68_H_ + +# ifndef SAMPLING_RATE_DEF +# define SAMPLING_RATE_DEF 44100 +# endif + +# ifndef SAMPLING_RATE_MIN +# define SAMPLING_RATE_MIN 8000 +# endif + +# ifndef SAMPLING_RATE_MAX +# define SAMPLING_RATE_MAX 62500 +# endif + +#endif /* #ifndef _IO68_DEFAULT_OPTION68_H_ */ Index: apps/codecs/libsc68/io68/mfpemul.c =================================================================== --- apps/codecs/libsc68/io68/mfpemul.c (revision 0) +++ apps/codecs/libsc68/io68/mfpemul.c (revision 0) @@ -0,0 +1,552 @@ +/* + * sc68 - MFP 68901 emulator + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +/* #include //$$$DEBUG */ + +#include "mfpemul.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/assert68.h" +#include "file68/msg68.h" +#endif + +#define cpp(V) (V*prediv_width[(int)ptimer->tcr]) +#define timerfrq(V) ((8000000u*192u)/cpp(V)) + +#define MFP_VECTOR_BASE (mfp->map[0x17] & 0xF0) +#define SEI (mfp->map[0x17] & 0x08) +#define AEI (!SEI) + +#ifndef DEBUG_MFP_O +# define DEBUG_MFP_O 0 +#endif +int mfp_cat = msg68_DEFAULT; + +/* Define for more accurate emulation (about pending bit...) + $$$ May be broken $$$ +*/ +#undef _MFPIO68_SUPER_EMUL_ + +/* About cycles. + * + * The MFP uses its own crystal clock. Its frequency is not a + * multiple of the 68K one (8Mhz). + * In order to convert 68K cycles to MFP ones the emulator use an + * internal cycle unit : a "BOGO" cycle. + * - 1 "BOGO" cycle => 192 "8mhz 68K" cycles + * - 1 "BOGO" cycle => 625 "mfp" cycle + */ + +static const mfp_timer_def_t timer_def[4] = +{ +/* Vector level bit chan letter */ + /* Timer A */ { 0x34>>2, 6, 1<<5, 0, 'A' }, + /* Timer B */ { 0x20>>2, 6, 1<<0, 0, 'B' }, + /* Timer C */ { 0x14>>2, 6, 1<<5, 2, 'C' }, + /* Timer D */ { 0x10>>2, 6, 1<<4, 2, 'D' }, +}; + +/* MFP prediviser value in ``bogo-cycle''. */ +static const bogoc68_t prediv_width[8] = { + 0*625, 4*625, 10*625, 16*625, + 50*625, 64*625, 100*625, 200*625 +}; + +/* Which timer will first interrupt ? + * It's the running timer (tcr!=0) with the lowest Cycle To Interrupt. + */ +static mfp_timer_t * find_next_int(const mfp_t * const mfp) +{ + const mfp_timer_t *ptimer, *itimer; + + /* find first running timer */ + for(itimer=0, ptimer=mfp->timers; + ptimertimers+4 && !ptimer->tcr; + ++ptimer) + ; + if (ptimer < mfp->timers+4) { + /* Got one. */ + bogoc68_t cti = ptimer->cti; + itimer = ptimer; + /* Now testing remaining timers for a lower CTI */ + while (++ptimer < mfp->timers+4) { + if (ptimer->tcr && ptimer->cticti; + itimer = ptimer; + } + } + } + return (mfp_timer_t *)itimer; +} + +/* Number of bogo-cycle before this timer interruption. */ +/* static inline bogoc68_t timer_ncti(const mfp_timer_t * const ptimer) */ +/* { */ +/* return ptimer->tdr_cur * ptimer->psc_width - ptimer->psc_cnt; */ +/* } */ + +/* Get number of tdr_cur decrements after nbogoc cycle. */ +/* static inline uint68_t timer_ntdr(const mfp_timer_t * const ptimer, */ +/* const bogoc68_t nbogoc) */ +/* { */ +/* ncti = tdr_cur * psc_width - psc_cnt */ +/* ncti + psc_cnt = tdr_cur * psc_width */ +/* tdr_cur = (ncti + psc_cnt) / psc_width */ +/* return (nbogoc+ptimer->psc_cnt) / ptimer->psc_width; */ +/* } */ + + +/* ,-----------------------------------------------------------------. + * | MFP timer register access | + * `-----------------------------------------------------------------' + */ + +/* + + I 4 | 3 | 2 | 1 I 4 | 3 | 2 | 1 I 4 | 3 | 2 | 1 I + 444444333333222222111111444444333333222222111111444444333333222222111111 + BBBBBBAAAAAA999999888888777777666666555555444444333333222222111111000000 +*/ + +static inline +int timer_get_tdr(const mfp_timer_t * const ptimer, const bogoc68_t bogoc) +{ + const bogoc68_t cti = ptimer->cti - bogoc; /* cycles to interrupt */ + const uint68_t psw = prediv_width[ptimer->tcr]; /* cycles count-down */ + const uint68_t cnt = cti/psw; /* count-down */ + const uint68_t tdr = cnt%ptimer->tdr_res+1; + return tdr; +} + +/* Control register changes, adjust ``cti'' (cycle to next interrupt) + * + * This case is a bit tricky : Changing timer prescale on the fly + * may have unpredictable result mostly because we dunno how + * prescaler works exactly. Here I assume the prescaler is + * resetted. + * + * !!! chipmon of synergy does !!! + * + */ +static inline +void reconf_timer(mfp_timer_t * const ptimer, int tcr, const bogoc68_t bogoc) +{ + uint_t frq = timerfrq(ptimer->tdr_res); /* old frequency */ + const bogoc68_t cti = ptimer->cti - bogoc; /* cycles to interrupt */ + const uint_t psw = prediv_width[ptimer->tcr]; /* cycles count-down */ + const uint_t cnt = cti/psw; /* count-down */ + const uint_t psr = cti % psw; + /* const uint68_t psc = psw-psr; */ + + /* cnt%ptimer->tdr_res+1; no MODULO since TDR may have change and anyway + cti was calculated with 1 timer cycle !!! */ + const uint_t tdr = cnt+1; + const cycle68_t new_psw = prediv_width[(int)tcr]; + + if (bogoc > ptimer->cti) { + msg68(mfp_cat, + "mfp: timer-%c -- reconf out of range -- @%u > cti:%u\n", + ptimer->def.letter, bogoc, ptimer->cti); + ptimer->cti = bogoc + psw * ptimer->tdr_res; + } else { + ptimer->cti = bogoc + psr + (tdr-1) * new_psw; + ptimer->cti = bogoc + /* psr + */ (tdr/* -1 */) * new_psw; + } + + ptimer->tcr = tcr; + + msg68(mfp_cat, + "mfp: timer-%c -- reconf @%u cti:%u cpp:%u -- %d:%dhz\n", + ptimer->def.letter, bogoc, + ptimer->cti, cpp(ptimer->tdr_res), + frq,timerfrq(ptimer->tdr_res)); +} + +/* Stop a running timer: tcr !0->0 + + $$$ Must check whether: + - 1) tdr is reset when timer stop. + - 2) tdr keeps its current value and can be resume later. + + $$$ Testing with Scavenger Leif Sid Version tend to prove the 2) + case is good. However the version of emulator used does not + work properly with Scavenger DBA tune so this deduction may be + a side effect of the bug. + + $$$ After verification on a real ST the previous assumption is + true. Definitively mfp timers can resume. We just need to know + more about the predivisor. Currently assuming the predivisor + count is reset when the timer resumes which seems much more + likely. + + $$$ Motorola Datasheet: The content of the timer's main counter are + not affected although any residual count in prescaler is lost. + +*/ +static inline +void stop_timer(mfp_timer_t * const ptimer, const bogoc68_t bogoc) +{ + ptimer->tdr_cur = timer_get_tdr(ptimer, bogoc); + ptimer->tcr = 0; + ptimer->psc = 0; +} + +/* Resume a stopped timer: tcr 0->!0 + */ +static inline +void resume_timer(mfp_timer_t * const ptimer, int tcr, bogoc68_t bogoc) +{ + ptimer->tcr = tcr; + ptimer->cti = bogoc + ptimer->tdr_cur * prediv_width[tcr] - ptimer->psc; + + msg68(mfp_cat, + "mfp: timer-%c -- resume @%u cti:%u cpp:%u " + "tdr:%u/%u psw:%u(%u) -- %dhz\n", + ptimer->def.letter, bogoc, ptimer->cti, + cpp(ptimer->tdr_res), + (int)ptimer->tdr_cur,(int)ptimer->tdr_res, + prediv_width[ptimer->tcr],ptimer->tcr, + timerfrq(ptimer->tdr_res)); +} + +/* Read timer data register: + + $$$ TO VERIFY: May be reset value is reload when timer is stopped! + Anyway the stop timer take care of that so returning tdr_cur + here sohould be safe. + + $$$ VERIFIED: Both experience and Motorola Datasheet verify that + the timer counter value is not affected unless TDR is written. + +*/ + +int68_t mfp_get_tdr(mfp_t * const mfp, const int timer, const bogoc68_t bogoc) +{ + mfp_timer_t * const ptimer = &mfp->timers[timer&3]; + + if (ptimer->tcr) { + ptimer->tdr_cur = timer_get_tdr(ptimer, bogoc); + } + return(u8)ptimer->tdr_cur; +} + +/* Write Timer Data Register: + + Changing the value of the TDR change the value of the internal + reset latch. However when the timer is stopped the reset value is + reload into TDR in the next MFP cycle (so it seems to be the case + according to my test on a real ST). The tricky point is that as MFP + and CPU clock are separate (for Atari-ST) reading the value just + after a write can occur before the next MFP cycle in which case the + current TDR (not the one written) is returned! Fortunatly we don't + really need to emulate this since it is more a glitch than anything + and no one should have used it! + + Motorola Datasheet: the TDRs contain the value of their respective + main counter. This value was captured on the last low-to-high + transistion of the data strobe pin. The main counter is initialized + by writting the to the TDR. If the timer is stopped the data is + loaded simultaneously into both TDR and maincounter. If the TDR is + written to while the timer is enabled, the value is not loaded into + the timer until the timer counts through 01. If a write is + performed while the timer is counting through 01 then an + INDETERMINATE value is loaded into the main counter. + +*/ +void mfp_put_tdr(mfp_t * const mfp, int timer, int68_t v, bogoc68_t bogoc) +{ + mfp_timer_t * const ptimer = &mfp->timers[timer&3]; + const uint_t old_tdr = ptimer->tdr_res; + + /* Interrupt when count down to 0 so 0 is 256 */ + v = (u8)v; v += (!v)<<8; + ptimer->tdr_res = v; + + if (!ptimer->tcr) { + ptimer->tdr_cur = v; + msg68(mfp_cat, + "mfp: timer-%c -- reload TDR @%u -- %u\n", + ptimer->def.letter, bogoc, ptimer->tdr_res); + } else if (ptimer->tcr && (unsigned) v != old_tdr) { + uint_t old_frq = timerfrq(old_tdr); + msg68(mfp_cat, + "mfp: timer-%c -- change @%u cti:%u psw:%u(%u) cpp:%u" + " -- %u(%u) -> %u(%u)hz\n", + ptimer->def.letter, bogoc, ptimer->cti, + prediv_width[ptimer->tcr], ptimer->tcr, + cpp(ptimer->tdr_res), + old_frq,old_tdr, + timerfrq(ptimer->tdr_res), ptimer->tdr_res); + } +} + +/* Write Timer Control Register + + $$$ From Motorola Datasheet: when resetting ta0/tb0 (set bit 4) of + TDCRA/B the other bits in TCR must be written with their + previous value to avoid altering the operating mode; this + verify the fact than writting 2 times the same value in the + predivisor does not affect its count. + +*/ +static void mfp_put_tcr_bogo(mfp_timer_t * const ptimer, + int v, const bogoc68_t bogoc) +{ + if (v != (int) ptimer->tcr) { + if (!v) { + stop_timer(ptimer,bogoc); + } else if (!ptimer->tcr) { + resume_timer(ptimer, v, bogoc); /* hz=8000000*192/cpp */ + } else { + reconf_timer(ptimer, v, bogoc); + } + } +} + +void mfp_put_tcr(mfp_t * const mfp, + int timer, int68_t v, const bogoc68_t bogoc) +{ + timer &= 3; + + if (timer < TIMER_C) { + /* Timer A or B */ + mfp->map[0x19+2*timer] = v; + /* $$$ Event mode + Pulse mode not emulate */ + if (v&0x10) { + msg68(mfp_cat, + "mfp: timer-%c -- mode not supported -- %02x\n", + timer_def[timer].letter,(int)(u8)v); + } + mfp_put_tcr_bogo(mfp->timers+timer, v&7, bogoc); + } else { + /* Timer C and D */ + mfp->map[0x1D] = v; + mfp_put_tcr_bogo(mfp->timers+TIMER_C, (v>>4)&7, bogoc); + mfp_put_tcr_bogo(mfp->timers+TIMER_D, v &7, bogoc); + } +} + +/* ,-----------------------------------------------------------------. + * | MFP next interuption | + * `-----------------------------------------------------------------' + */ + +bogoc68_t mfp_nextinterrupt(const mfp_t * const mfp) +{ + const mfp_timer_t * itimer = find_next_int(mfp); + const bogoc68_t bogoc = + (!itimer) ? IO68_NO_INT : itimer->cti; + return bogoc; +} + +static inline +void timer_interrupt(mfp_t * const mfp, mfp_timer_t * const ptimer) +{ + /* Fill interrupt info struct. */ + ptimer->interrupt.vector = MFP_VECTOR_BASE + ptimer->def.vector; + ptimer->interrupt.level = ptimer->def.level; + ptimer->interrupt.cycle = ptimer->cti; + ptimer->cti += prediv_width[ptimer->tcr] * ptimer->tdr_res; + ptimer->tdr_cur = ptimer->tdr_res; +} + +interrupt68_t * mfp_interrupt(mfp_t * const mfp, const bogoc68_t bogoc) +{ + mfp_timer_t * itimer; + + /* Better recheck which timer interrupts because previous interrupt + code may have modified timer. + */ + while ((itimer = find_next_int(mfp)) && itimer->cti < bogoc) { + /* Have a candidate */ + mfp_timer_t * const ptimer = itimer; + + /* Process interruption. */ + timer_interrupt(mfp,ptimer); + +#ifndef _MFPIO68_SUPER_EMUL_ + /* ======================== */ + /* Simple Emulation Version */ + /* ======================== */ + if (mfp->map[0x07+ptimer->def.channel] & + mfp->map[0x13+ptimer->def.channel] & + ptimer->def.bit ) + { + ++ptimer->int_fall; + return &ptimer->interrupt; + } +#else + /* ========================== */ + /* Accurate Emulation Version */ + /* ========================== */ + + /* Test Interrupt Enable */ + if ( mfp->map[0x07+ptimer->channel] & ptimer->bit ) { + /* Set Interrupt Pending Bit */ + mfp->map[0x0B+ptimer->channel] |= ptimer->bit; + + /* Test Interrupt In Service */ + if (!(mfp->map[0x0F+ptimer->channel]&ptimer->bit)) { + /* SEI : Set Interrupt In Service */ + if (SEI) mfp->map[0x0B+ptimer->channel] |= ptimer->bit; + /* Test Interrupt Mask */ + if (mfp->map[0x13+ptimer->channel] & ptimer->bit) { + ++ptimer->int_fall; + return &ptimer->interrupt; + } + } + } +#endif + /* For some reason interruption was cancelled. */ + ++ptimer->int_mask; + } + return 0; +} + +/* ,-----------------------------------------------------------------. + * | MFP adjust cycle base | + * `-----------------------------------------------------------------' + */ + +void mfp_adjust_bogoc(mfp_t * const mfp, const bogoc68_t bogoc) +{ + mfp_timer_t *ptimer; + + if (!bogoc) return; + for (ptimer = mfp->timers; ptimer != mfp->timers+4; ++ptimer) { + if (ptimer->tcr) { + if (ptimer->cti < bogoc) { + msg68(mfp_cat, + "mfp: timer-%c -- adjust -- cti:%u cycle:%u\n", + ptimer->def.letter,ptimer->cti, bogoc); + } + assert(ptimer->cti >= bogoc); + while (ptimer->cti < bogoc) { + /* $$$ !!! SHOULD NOT HAPPEN !!! */ + ++ptimer->int_lost; + ptimer->cti += cpp(ptimer->tdr_res); + } + if (ptimer->int_lost) { + msg68_critical("mfp: timer-%c -- adjust has lost interrupt -- %d\n", + ptimer->def.letter, ptimer->int_lost); + ptimer->int_lost = 0; + } + ptimer->cti -= bogoc; + } + } +} + +/* ,-----------------------------------------------------------------. + * | MFP reset | + * `-----------------------------------------------------------------' + */ + +static void reset_timer(mfp_timer_t * const ptimer, bogoc68_t bogoc) +{ + ptimer->cti = bogoc; + ptimer->tcr = 0; + ptimer->psc = 0; + + /* $$$ Motorola Datasheet: timer counters should not be cleared + but we don't really care + */ + ptimer->tdr_res = 256; + ptimer->tdr_cur = ptimer->tdr_res; + ptimer->int_lost = 0; + ptimer->int_mask = 0; + ptimer->int_fall = 0; +} + +static int mfp_reset_bogo(mfp_t * const mfp, const bogoc68_t bogoc) +{ + int i; + + for (i=0; i<(int)sizeof(mfp->map); i++) { + mfp->map[i]=0; + } + mfp->map[0x17] = 0x40; + mfp->map[0x01] = 0x80; + for (i=0; i<4;i++) { + reset_timer(mfp->timers+i, bogoc); + } + return 0; +} + +int mfp_reset(mfp_t * const mfp, const bogoc68_t bogoc) +{ + return mfp_reset_bogo(mfp, bogoc); +} + +/* ,-----------------------------------------------------------------. + * | MFP setup | + * `-----------------------------------------------------------------' + */ + +static void setup_timer(mfp_timer_t * const ptimer, int idx, bogoc68_t bogoc) +{ + ptimer->def = timer_def[idx&3]; + ptimer->tdr_res = 256; + ptimer->tdr_cur = ptimer->tdr_res; + reset_timer(ptimer, bogoc); +} + +int mfp_setup(mfp_t * const mfp) +{ + int ret = -1; + + if (mfp) { + setup_timer(&mfp->timers[0], 0, 0); + setup_timer(&mfp->timers[1], 1, 0); + setup_timer(&mfp->timers[2], 2, 0); + setup_timer(&mfp->timers[3], 3, 0); + ret = mfp_reset_bogo(mfp, 0); + } + return ret; +} + +void mfp_cleanup(mfp_t * const mfp) +{ +} + + +/* ,-----------------------------------------------------------------. + * | MFP init | + * `-----------------------------------------------------------------' + */ + +int mfp_init(void) +{ + if (mfp_cat == msg68_DEFAULT) + mfp_cat = msg68_cat("mfp","MFP-68901 emulator", DEBUG_MFP_O); + return 0; +} + +void mfp_shutdown(void) +{ + msg68_cat_free(mfp_cat); + mfp_cat = msg68_DEFAULT; +} Index: apps/codecs/libsc68/io68/mwemul.c =================================================================== --- apps/codecs/libsc68/io68/mwemul.c (revision 0) +++ apps/codecs/libsc68/io68/mwemul.c (revision 0) @@ -0,0 +1,705 @@ +/* + * sc68 - MicroWire - STE soundchip emulator + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + * $Id$ + * + */ + +/** @todo + * + * - Stereo !! + * - Check overflow in mix routine. + * - Verify STE / YM volume ratio + * - Special case for not mixing in Db_alone. + * - And in the YM emul, skip emulation !!! + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef HAVE_CONFIG_OPTION68_H +# include "config_option68.h" +#else +# include "default_option68.h" +#endif +#include "mwemul.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/assert68.h" +#include "file68/msg68.h" +#endif + +#ifndef DEBUG_MW_O +# define DEBUG_MW_O 0 +#endif +int mw_cat = msg68_DEFAULT; + +/* #define MW_CALCUL_TABLE 1 */ + +#define MW_N_DECIBEL 121 + +#define MW_MIX_FIX 10 + +#define MW_STE_MULT ((1< /* $$$ Calcul DB table */ +# include /* $$$ For display table */ + +static int Db_alone[MW_N_DECIBEL]; +static int Db_mix[MW_N_DECIBEL]; +static int Db_mix12[MW_N_DECIBEL]; + +#define LN_10_OVER_10 0.230258509299 + +/* + + A,B signal intensity + 1.Db = 10*LOG( A/B ) = 10*LN(A/B)/LN(10) + => A = B * EXP( Decibel*LN(10)/10 ) + => A = B * R + with R=EXP( Decibel*LN(10)/10 ) + + R1,R2 rate of 2 signal for D1,D2 in decibel + A = B*R1*R2 <=> B*R3 + with R3 = rate for (D1+D2) decibel + +*/ + +static u32 calc_volume(s32 decibel, u32 mult) +{ + double r; + r = exp( (double)decibel*LN_10_OVER_10 ); + r *= (double)mult; + return (u32)r; +} + +static void init_volume(void) +{ + int i; + + fprintf(stderr, "\n"); + for(i=0; iengine : default_parms.engine; + break; + + default: + msg68_warning("microwire: invalid engine -- %d\n", engine); + + case MW_ENGINE_DEFAULT: + engine = default_parms.engine; + + case MW_ENGINE_SIMPLE: + case MW_ENGINE_LINEAR: + *(mw ? &mw->engine : &default_parms.engine) = engine; + msg68(mw_cat, "microwire: %s engine -- *%s*\n", + mw ? "select" : "default", + mw_engine_name(engine)); + break; + } + return engine; +} + + +/* ,-----------------------------------------------------------------. + * | Set/Get replay frequency | + * `-----------------------------------------------------------------' + */ +int mw_sampling_rate(mw_t * const mw, int hz) +{ + switch (hz) { + + case MW_HZ_QUERY: + hz = mw ? mw->hz : default_parms.hz; + break; + + case MW_HZ_DEFAULT: + hz = default_parms.hz; + + default: + if (hz < SAMPLING_RATE_MIN) { + msg68_warning("microwire: sampling rate out of range -- %dhz\n", hz); + hz = SAMPLING_RATE_MIN; + } + if (hz > SAMPLING_RATE_MAX) { + msg68_warning("microwire: sampling rate out of range -- %dhz\n", hz); + hz = SAMPLING_RATE_MAX; + } + *(mw ? &mw->hz : &default_parms.hz) = hz; + msg68(mw_cat, "microwire: %s sampling rate -- *%dhz*\n", + mw ? "select" : "default", hz); + break; + } + return hz; +} + +/* ,-----------------------------------------------------------------. + * | Set master volume 0=-80 Db, 40=0 Db | + * | Set left volume 0=-40 Db, 40=0 Db | + * | Set right volume 0=-40 Db, 40=0 Db | + * | Set high frequency 0=-12 Db, 40=12 Db | + * | Set low frequency 0=-12 Db, 40=12 Db | + * | Set mixer type : 0=-12 Db 1=YM+STE 2=STE-only 3=reserved | + * `-----------------------------------------------------------------' + */ + +static +const char * const mixermode[4] = { + "-12-Db", "YM+STE", "STE-ONLY", "RESERVED" +}; + +int mw_lmc_mixer(mw_t * const mw, int n) +{ + static const int * const table[3] = { Db_mix12, Db_mix, Db_alone }; + + if (n == MW_LMC_QUERY) { + n = mw->lmc.mixer; + } else { + n &= 3; + mw->lmc.mixer = n; + if (n != 3) { + mw->db_conv = table[n]; + } else { + msg68_warning("microwire: invalid LMC mixer mode -- 3\n"); + } + } + TRACE68(mw_cat,"microwire: LMC mixer mode -- *%s*\n", + mixermode[mw->lmc.mixer]); + return n; +} + +/* range [0..40] -> [80..0] (-dB) */ +int mw_lmc_master(mw_t * const mw, int n) +{ + if (n == MW_LMC_QUERY) { + n = ( 80 - mw->lmc.master ) >> 1; + } else { + if (n < 0) n = 0; + if (n > 40) n = 40; + mw->lmc.master = 80 - (n << 1 ); + TRACE68(mw_cat,"microwire: LMC -- master -- *-%02ddB*\n", mw->lmc.master); + } + return n; +} + +/* range [0..20] -> [40..0] (-dB) */ +static int lmc_lr(mw_t * const mw, const int lr, int n) +{ + u8 * pval = lr ? &mw->lmc.left : &mw->lmc.right; + + if (n == MW_LMC_QUERY) { + n = ( 40 - *pval ) >> 1; + } else { + if (n < 0) n = 0; + if (n > 20) n = 20; + *pval = 40 - ( n << 1 ); + mw->lmc.lr = ( mw->lmc.left + mw->lmc.right ) >> 1; + TRACE68(mw_cat,"microwire: LMC -- %s channel -- *-%02ddB*\n", + lr ? "left" : "right", *pval); + } + return n; +} + +int mw_lmc_left(mw_t * const mw, int n) +{ + return lmc_lr(mw,0,n); +} + +int mw_lmc_right(mw_t * const mw, int n) +{ + return lmc_lr(mw,1,n); +} + +/* range [0..12] -> [12..0] (-dB) */ +static int lmc_hl(mw_t * const mw, const int hl, int n) +{ + u8 * pval = hl ? &mw->lmc.high : &mw->lmc.low; + + if (n == MW_LMC_QUERY) { + n = 12 - *pval; + } else { + if (n < 0) n = 0; + if (n > 12) n = 12; + *pval = 12 - n; + TRACE68(mw_cat,"microwire: LMC -- %s pass filter -- *-%02ddB*\n", + hl ? "high" : "low", *pval); + } + return n; +} + +int mw_lmc_high(mw_t * const mw, int n) +{ + return lmc_hl(mw,0,n); +} + +int mw_lmc_low(mw_t * const mw, int n) +{ + return lmc_hl(mw,1,n); +} + +static int command_dispatcher(mw_t * const mw, int n) +{ + const int c = n & 0700; + n -= c; + + TRACE68(mw_cat,"microwire: dispatch -- %o:%02x\n", c>>6, n); + switch(c) { + case 0000: + mw_lmc_mixer(mw, n&3); + break; + case 0100: + mw_lmc_low(mw, n&15); + break; + case 0200: + mw_lmc_high(mw, n&15); + break; + case 0300: + mw_lmc_master(mw, n&63); + break; + case 0400: + mw_lmc_right(mw, n&31); + break; + case 0500: + mw_lmc_left(mw, n&31); + break; + default: + TRACE68(mw_cat,"microwire: unknown command -- %04o\n", c); + return -1; + } + return 0; +} + +int mw_command(mw_t * const mw) +{ + uint_t ctrl, data; + + if (!mw) { + return -1; + } + + ctrl = ( mw->map[MW_CTRL] << 8 ) + mw->map[MW_CTRL+1]; + data = ( mw->map[MW_DATA] << 8 ) + mw->map[MW_DATA+1]; + + TRACE68(mw_cat,"microwire: shiting -- %04x:%04x\n", ctrl, data); + + /* Find first address */ + for(; ctrl && ( ctrl & 0xC000 ) != 0xC000; ctrl<<=1, data<<=1) + ; + + if (!ctrl) { + TRACE68(mw_cat,"microwire: address -- not found\n"); + return -1; + } else { + const uint_t addr = ( data >> 14 ) & 3; + assert( ( ctrl & 0xC000 ) == 0xC000); + TRACE68(mw_cat,"microwire: address -- %d\n", addr); + if ( addr != 2 ) + return -1; + } + + for (ctrl<<=2, data<<=2; ctrl && ( ctrl & 0xFF80 ) != 0xFF80; + ctrl<<=1, data<<=1) + ; + + if (ctrl) { + const uint_t cmd = (data >>7 ) & 0x1ff; + assert( ( ctrl & 0xFF80 ) == 0xFF80 ); + TRACE68(mw_cat,"microwire: command -- %04o\n", cmd); + return command_dispatcher(mw, cmd); + } else { + TRACE68(mw_cat,"microwire: command -- not found\n"); + } + + return -1; +} + + +/* ,-----------------------------------------------------------------. + * | Microwire reset | + * `-----------------------------------------------------------------' + */ + +static void lmc_reset(mw_t * const mw) +{ + mw_lmc_mixer(mw,MW_MIXER_BOTH); + mw_lmc_master(mw,40); + mw_lmc_left(mw,20); + mw_lmc_right(mw,20); + mw_lmc_high(mw,12); + mw_lmc_low(mw,12); +} + +int mw_reset(mw_t * const mw) +{ + unsigned i; + + for ( i=0; imap); i++ ) { + mw->map[i] = 0; + } + mw->ct = mw->end = 0; + lmc_reset(mw); + + msg68(mw_cat,"microwire: chip reset\n"); + return 0; +} + +void mw_cleanup(mw_t * const mw) {} + +int mw_setup(mw_t * const mw, + mw_setup_t * const setup) +{ + if (!mw || !setup || !setup->mem) { + msg68_error("microwire: invalid parameter\n"); + return -1; + } + + /* setup emulation mode */ + setup->parms.engine = mw_engine(mw, setup->parms.engine); + + /* setup sampling rate */ + setup->parms.hz = mw_sampling_rate(mw, setup->parms.hz); + + /* setup memory access */ + mw->mem = setup->mem; + mw->log2mem = setup->log2mem; + mw->ct_fix = ( sizeof(mwct_t) << 3 ) - mw->log2mem; + + msg68(mw_cat,"microwire: %d-bit memory, %d-bit precision\n", + setup->log2mem, mw->ct_fix); + mw_reset(mw); + + return 0; +} + +/* ,-----------------------------------------------------------------. + * | Microwire initialization | + * `-----------------------------------------------------------------' + */ + +int mw_init(int * argc, char ** argv) +{ + if (mw_cat == msg68_DEFAULT) + mw_cat = msg68_cat("mw","microwire emulator", DEBUG_MW_O); + + /* Setup defaults */ + default_parms.engine = MW_ENGINE_LINEAR; + default_parms.hz = SAMPLING_RATE_DEF; + + /* Init volume table */ + init_volume(); + + return 0; +} + +void mw_shutdown(void) +{ + msg68_cat_free(mw_cat); + mw_cat = msg68_DEFAULT; +} + +/* Rescale n sample of b with f ( << MW_MIX_FIX ) */ +static void rescale(s32 * b, int f, int n) +{ + if (!f) { + do { *b++ = 0; } while (--n); + } else if (f != (1<> MW_MIX_FIX; + *b++ = ( v << 16 ) | ( v & 0xFFFF ); + } while (--n); + } +} + +/* --- Rescale n sample of b with r ( << mw_MIX_FIX ) --- */ +static void no_mix_ste(mw_t * const mw, s32 * b, int n) +{ + rescale(b, (mw->db_conv == Db_alone) ? 0 : MW_YM_MULT, n); +} + +static void skip_ste(mw_t * const mw, int n) +{ + mwct_t base, end2, ct, end, stp; + + const int loop = mw->map[MW_ACTI] & 2; + const int mono = (mw->map[MW_MODE]>>7) & 1; + const uint_t frq = 50066u >> ((mw->map[MW_MODE]&3)^3); + const int ct_fix = mw->ct_fix; + + /* Get internal register for sample base and sample end + * $$$ ??? what if base > end2 ??? + */ + base = mw_counter_read(mw, MW_BASH); + end2 = mw_counter_read(mw, MW_ENDH); + + /* Get counters */ + ct = mw->ct; + end = mw->end; + stp = ( (mwct_t) ( frq * n ) << ( ct_fix + 1 - mono ) ) / mw->hz; + + if ( stp >= end - ct ) { + if ( ! loop ) goto out; + stp -= end - ct; + ct = base; + end = end2; + if ( ct == end ) { + stp = 0; + } else { + stp %= end - ct; + } + ct += stp; + } + +out: + if ( !loop && ct >= end ) { + mw->map[MW_ACTI] = 0; + ct = base; + end = end2; + } + mw->ct = ct; + mw->end = end; +} + +static void mix_ste(mw_t * const mw, s32 *b, int n) +{ + mwct_t base, end2, ct, end, stp; + const int vl = mw->db_conv[mw->lmc.master+mw->lmc.left]; + const int vr = mw->db_conv[mw->lmc.master+mw->lmc.right]; + const int loop = mw->map[MW_ACTI] & 2; + const int mono = (mw->map[MW_MODE]>>7) & 1; + const uint_t frq = 50066u >> ((mw->map[MW_MODE]&3)^3); + const int68_t ym_mult = (mw->db_conv == Db_alone) ? 0 : MW_YM_MULT; + const int ct_fix = mw->ct_fix; + const s8 * spl = (const s8 *)mw->mem; + + /* Get internal register for sample base and sample end + * $$$ ??? what if base > end2 ??? + */ + base = mw_counter_read(mw, MW_BASH); + end2 = mw_counter_read(mw, MW_ENDH); + + /* Get current sample counter and end */ + ct = mw->ct; + end = mw->end; + + if (ct >= end) { + if (!loop) { + goto out; + } else { + mwct_t overflow = ct - end; + mwct_t length = end - base; + ct = base; + if (length) { + ct += overflow > length ? overflow % length : overflow; + } + end = end2; + } + } + /* Calculate sample step. + * Stereo trick : Advance 2 times faster, take care of word alignment later. + */ + stp = ( (mwct_t) frq << ( ct_fix + 1 - mono ) ) / mw->hz; + + if (mono) { + /* mix mono */ + do { + int68_t v, ym; + + ym = (*b) * ym_mult; + v = spl[ (int)( ct >> ct_fix ) ]; + *b++ = + ( + (u16)((v*vl + ym) >> MW_MIX_FIX) + + + (((v*vr + ym)>>MW_MIX_FIX)<<16) + ); + + ct += stp; + if (ct >= end) { + if (!loop) { + --n; + break; + } else { + mwct_t overflow = ct-end; + mwct_t length = end-base; + ct = base; + if (length) { + ct += overflow>length ? overflow%length : overflow; + } + end = end2; + } + } + } while (--n); + + } else { + /* mix stereo */ + do { + int68_t l,r,ym; + int addr; + + ym = (*b) * ym_mult; + addr = ( ct >> ct_fix ) & ~1; + l = spl[addr+0]; + r = spl[addr+1]; + *b++ = + ( + (u16)((l*vl + ym)>>MW_MIX_FIX) + + + (((r*vr + ym)>>MW_MIX_FIX)<<16) + ); + + ct += stp; + if (ct >= end) { + if (!loop) { + --n; + break; + } else { + mwct_t overflow = ct-end; + mwct_t length = end-base; + ct = base; + if (length) { + ct += overflow>length ? overflow%length : overflow; + } + end = end2; + } + } + } while (--n); + } + + out: + if (!loop && ct >= end) { + mw->map[MW_ACTI] = 0; + ct = base; + end = end2; + } + mw->ct = ct; + mw->end = end; + + /* Finish the buffer */ + if (n>0) { + no_mix_ste(mw,b,n); + } +} + +/* ,-----------------------------------------------------------------. + * | Microwire process | + * `-----------------------------------------------------------------' + */ + +void mw_mix(mw_t * const mw, s32 * b, int n) +{ + if ( n <= 0 ) { + return; + } + + if ( !b ) { + if ( mw->map[MW_ACTI] & 1 ) { + /* no buffer and active : advance counters only */ + skip_ste(mw,n); + } + } else if ( ! (mw->map[MW_ACTI] & 1 ) ) { + /* Microwire desactivated */ + no_mix_ste(mw,b,n); + } else { + /* Microwire activated */ + mix_ste(mw,b,n); + } +} Index: apps/codecs/libsc68/io68/ymout2k9.h =================================================================== --- apps/codecs/libsc68/io68/ymout2k9.h (revision 0) +++ apps/codecs/libsc68/io68/ymout2k9.h (revision 0) @@ -0,0 +1,5154 @@ +{ +/* A: 968D89C0 */ +/* A:00 B:00 */ +0x0000,0x0021,0x0049,0x0079,0x00B1,0x00F4,0x0144,0x01A3, +0x0214,0x029A,0x0339,0x03F6,0x04D7,0x05E2,0x0720,0x089A, +0x0A5B,0x0C70,0x0EEA,0x11DB,0x155B,0x1983,0x1E74,0x2453, +0x2B4E,0x3399,0x3D75,0x492C,0x5719,0x67A6,0x7B51,0x92B2, +/* A:00 B:01 */ +0x0021,0x0043,0x006B,0x009A,0x00D3,0x0116,0x0166,0x01C4, +0x0235,0x02BB,0x035A,0x0417,0x04F8,0x0603,0x0741,0x08BA, +0x0A7B,0x0C90,0x0F0A,0x11FB,0x157A,0x19A2,0x1E92,0x2471, +0x2B6A,0x33B5,0x3D8F,0x4946,0x5731,0x67BC,0x7B65,0x92C3, +/* A:00 B:02 */ +0x0049,0x006B,0x0093,0x00C2,0x00FB,0x013E,0x018D,0x01EC, +0x025D,0x02E3,0x0382,0x043F,0x0520,0x062B,0x0768,0x08E1, +0x0AA2,0x0CB6,0x0F30,0x1220,0x159F,0x19C6,0x1EB6,0x2494, +0x2B8D,0x33D6,0x3DAF,0x4964,0x574D,0x67D6,0x7B7C,0x92D7, +/* A:00 B:03 */ +0x0079,0x009A,0x00C2,0x00F2,0x012A,0x016D,0x01BD,0x021C, +0x028C,0x0312,0x03B1,0x046E,0x054E,0x0659,0x0796,0x090F, +0x0ACF,0x0CE4,0x0F5D,0x124D,0x15CB,0x19F2,0x1EE0,0x24BD, +0x2BB5,0x33FD,0x3DD5,0x4987,0x576E,0x67F4,0x7B98,0x92EF, +/* A:00 B:04 */ +0x00B1,0x00D3,0x00FB,0x012A,0x0162,0x01A5,0x01F5,0x0254, +0x02C4,0x034A,0x03E9,0x04A5,0x0586,0x0691,0x07CE,0x0946, +0x0B06,0x0D1A,0x0F93,0x1282,0x15FF,0x1A25,0x1F13,0x24EF, +0x2BE5,0x342C,0x3E01,0x49B2,0x5796,0x6819,0x7BB8,0x930B, +/* A:00 B:05 */ +0x00F4,0x0116,0x013E,0x016D,0x01A5,0x01E8,0x0238,0x0296, +0x0307,0x038C,0x042B,0x04E8,0x05C8,0x06D2,0x080F,0x0987, +0x0B47,0x0D5A,0x0FD2,0x12C1,0x163E,0x1A63,0x1F4F,0x252A, +0x2C1E,0x3463,0x3E37,0x49E4,0x57C5,0x6844,0x7BE0,0x932D, +/* A:00 B:06 */ +0x0144,0x0166,0x018D,0x01BD,0x01F5,0x0238,0x0287,0x02E6, +0x0356,0x03DB,0x047A,0x0536,0x0616,0x0721,0x085D,0x09D5, +0x0B94,0x0DA7,0x101E,0x130C,0x1688,0x1AAB,0x1F97,0x2570, +0x2C63,0x34A5,0x3E76,0x4A20,0x57FE,0x6878,0x7C0E,0x9355, +/* A:00 B:07 */ +0x01A3,0x01C4,0x01EC,0x021C,0x0254,0x0296,0x02E6,0x0344, +0x03B4,0x0439,0x04D8,0x0594,0x0674,0x077E,0x08B9,0x0A31, +0x0BEF,0x0E02,0x1078,0x1365,0x16E0,0x1B02,0x1FEC,0x25C3, +0x2CB3,0x34F3,0x3EC1,0x4A67,0x5840,0x68B6,0x7C45,0x9384, +/* A:00 B:08 */ +0x0214,0x0235,0x025D,0x028C,0x02C4,0x0307,0x0356,0x03B4, +0x0424,0x04A9,0x0547,0x0603,0x06E3,0x07EC,0x0927,0x0A9E, +0x0C5C,0x0E6E,0x10E3,0x13CF,0x1748,0x1B69,0x2051,0x2626, +0x2D14,0x3550,0x3F1A,0x4ABC,0x5890,0x68FF,0x7C86,0x93BD, +/* A:00 B:09 */ +0x029A,0x02BB,0x02E3,0x0312,0x034A,0x038C,0x03DB,0x0439, +0x04A9,0x052E,0x05CC,0x0687,0x0766,0x086F,0x09AA,0x0B20, +0x0CDD,0x0EEE,0x1162,0x144D,0x17C5,0x1BE3,0x20C9,0x269B, +0x2D86,0x35BF,0x3F84,0x4B21,0x58EE,0x6955,0x7CD4,0x9400, +/* A:00 B:0a */ +0x0339,0x035A,0x0382,0x03B1,0x03E9,0x042B,0x047A,0x04D8, +0x0547,0x05CC,0x0669,0x0725,0x0803,0x090B,0x0A46,0x0BBB, +0x0D77,0x0F86,0x11F9,0x14E3,0x1858,0x1C75,0x2158,0x2727, +0x2E0E,0x3642,0x4002,0x4B98,0x595E,0x69BD,0x7D31,0x9450, +/* A:00 B:0b */ +0x03F6,0x0417,0x043F,0x046E,0x04A5,0x04E8,0x0536,0x0594, +0x0603,0x0687,0x0725,0x07DF,0x08BD,0x09C5,0x0AFE,0x0C73, +0x0E2E,0x103C,0x12AD,0x1594,0x1908,0x1D22,0x2201,0x27CC, +0x2EAF,0x36DE,0x4098,0x4C27,0x59E3,0x6A37,0x7D9F,0x94AF, +/* A:00 B:0c */ +0x04D7,0x04F8,0x0520,0x054E,0x0586,0x05C8,0x0616,0x0674, +0x06E3,0x0766,0x0803,0x08BD,0x099A,0x0AA1,0x0BDA,0x0D4D, +0x0F07,0x1113,0x1383,0x1668,0x19D8,0x1DEF,0x22CB,0x2892, +0x2F6F,0x3797,0x414A,0x4CD0,0x5A82,0x6AC9,0x7E21,0x9520, +/* A:00 B:0d */ +0x05E2,0x0603,0x062B,0x0659,0x0691,0x06D2,0x0721,0x077E, +0x07EC,0x086F,0x090B,0x09C5,0x0AA1,0x0BA7,0x0CDF,0x0E51, +0x1008,0x1213,0x1480,0x1763,0x1AD0,0x1EE3,0x23BB,0x297C, +0x3053,0x3874,0x421D,0x4D99,0x5B3E,0x6B76,0x7EBD,0x95A6, +/* A:00 B:0e */ +0x0720,0x0741,0x0768,0x0796,0x07CE,0x080F,0x085D,0x08B9, +0x0927,0x09AA,0x0A46,0x0AFE,0x0BDA,0x0CDF,0x0E15,0x0F85, +0x113B,0x1343,0x15AE,0x188D,0x1BF7,0x2005,0x24D8,0x2A92, +0x3162,0x397A,0x4318,0x4E87,0x5C1E,0x6C44,0x7F75,0x9645, +/* A:00 B:0f */ +0x089A,0x08BA,0x08E1,0x090F,0x0946,0x0987,0x09D5,0x0A31, +0x0A9E,0x0B20,0x0BBB,0x0C73,0x0D4D,0x0E51,0x0F85,0x10F4, +0x12A7,0x14AD,0x1714,0x19F0,0x1D55,0x215E,0x262A,0x2BDD, +0x32A4,0x3AB1,0x4443,0x4FA3,0x5D28,0x6D39,0x8051,0x9703, +/* A:00 B:10 */ +0x0A5B,0x0A7B,0x0AA2,0x0ACF,0x0B06,0x0B47,0x0B94,0x0BEF, +0x0C5C,0x0CDD,0x0D77,0x0E2E,0x0F07,0x1008,0x113B,0x12A7, +0x1458,0x165B,0x18BF,0x1B95,0x1EF5,0x22F8,0x27BD,0x2D67, +0x3423,0x3C23,0x45A6,0x50F4,0x5E64,0x6E5B,0x8156,0x97E4, +/* A:00 B:11 */ +0x0C70,0x0C90,0x0CB6,0x0CE4,0x0D1A,0x0D5A,0x0DA7,0x0E02, +0x0E6E,0x0EEE,0x0F86,0x103C,0x1113,0x1213,0x1343,0x14AD, +0x165B,0x185A,0x1AB9,0x1D8A,0x20E4,0x24DF,0x299B,0x2F3A, +0x35EA,0x3DDB,0x474C,0x5285,0x5FDB,0x6FB5,0x828B,0x98EF, +/* A:00 B:12 */ +0x0EEA,0x0F0A,0x0F30,0x0F5D,0x0F93,0x0FD2,0x101E,0x1078, +0x10E3,0x1162,0x11F9,0x12AD,0x1383,0x1480,0x15AE,0x1714, +0x18BF,0x1AB9,0x1D13,0x1FDE,0x2330,0x2722,0x2BD3,0x3166, +0x3806,0x3FE6,0x4942,0x5461,0x6199,0x7150,0x83FC,0x9A2D, +/* A:00 B:13 */ +0x11DB,0x11FB,0x1220,0x124D,0x1282,0x12C1,0x130C,0x1365, +0x13CF,0x144D,0x14E3,0x1594,0x1668,0x1763,0x188D,0x19F0, +0x1B95,0x1D8A,0x1FDE,0x22A2,0x25EB,0x29D2,0x2E76,0x33FB, +0x3A89,0x4253,0x4B96,0x5697,0x63AC,0x7338,0x85B2,0x9BA7, +/* A:00 B:14 */ +0x155B,0x157A,0x159F,0x15CB,0x15FF,0x163E,0x1688,0x16E0, +0x1748,0x17C5,0x1858,0x1908,0x19D8,0x1AD0,0x1BF7,0x1D55, +0x1EF5,0x20E4,0x2330,0x25EB,0x2929,0x2D04,0x3199,0x370B, +0x3D84,0x4536,0x4E5A,0x5938,0x6622,0x757C,0x87BA,0x9D68, +/* A:00 B:15 */ +0x1983,0x19A2,0x19C6,0x19F2,0x1A25,0x1A63,0x1AAB,0x1B02, +0x1B69,0x1BE3,0x1C75,0x1D22,0x1DEF,0x1EE3,0x2005,0x215E, +0x22F8,0x24DF,0x2722,0x29D2,0x2D04,0x30D0,0x3553,0x3AB0, +0x4110,0x48A3,0x51A4,0x5C58,0x6910,0x782D,0x8A24,0x9F7E, +/* A:00 B:16 */ +0x1E74,0x1E92,0x1EB6,0x1EE0,0x1F13,0x1F4F,0x1F97,0x1FEC, +0x2051,0x20C9,0x2158,0x2201,0x22CB,0x23BB,0x24D8,0x262A, +0x27BD,0x299B,0x2BD3,0x2E76,0x3199,0x3553,0x39C1,0x3F05, +0x4547,0x4CB7,0x558D,0x600E,0x6C8A,0x7B61,0x8D03,0xA1F8, +/* A:00 B:17 */ +0x2453,0x2471,0x2494,0x24BD,0x24EF,0x252A,0x2570,0x25C3, +0x2626,0x269B,0x2727,0x27CC,0x2892,0x297C,0x2A92,0x2BDD, +0x2D67,0x2F3A,0x3166,0x33FB,0x370B,0x3AB0,0x3F05,0x442B, +0x4A49,0x518E,0x5A33,0x6478,0x70AD,0x7F2E,0x906C,0xA4EA, +/* A:00 B:18 */ +0x2B4E,0x2B6A,0x2B8D,0x2BB5,0x2BE5,0x2C1E,0x2C63,0x2CB3, +0x2D14,0x2D86,0x2E0E,0x2EAF,0x2F6F,0x3053,0x3162,0x32A4, +0x3423,0x35EA,0x3806,0x3A89,0x3D84,0x4110,0x4547,0x4A49, +0x503D,0x5750,0x5FB8,0x69B6,0x7597,0x83B4,0x947B,0xA86B, +/* A:00 B:19 */ +0x3399,0x33B5,0x33D6,0x33FD,0x342C,0x3463,0x34A5,0x34F3, +0x3550,0x35BF,0x3642,0x36DE,0x3797,0x3874,0x397A,0x3AB1, +0x3C23,0x3DDB,0x3FE6,0x4253,0x4536,0x48A3,0x4CB7,0x518E, +0x5750,0x5E27,0x6648,0x6FF2,0x7B6E,0x8914,0x994C,0xAC94, +/* A:00 B:1a */ +0x3D75,0x3D8F,0x3DAF,0x3DD5,0x3E01,0x3E37,0x3E76,0x3EC1, +0x3F1A,0x3F84,0x4002,0x4098,0x414A,0x421D,0x4318,0x4443, +0x45A6,0x474C,0x4942,0x4B96,0x4E5A,0x51A4,0x558D,0x5A33, +0x5FB8,0x6648,0x6E15,0x775A,0x825E,0x8F77,0x9F07,0xB186, +/* A:00 B:1b */ +0x492C,0x4946,0x4964,0x4987,0x49B2,0x49E4,0x4A20,0x4A67, +0x4ABC,0x4B21,0x4B98,0x4C27,0x4CD0,0x4D99,0x4E87,0x4FA3, +0x50F4,0x5285,0x5461,0x5697,0x5938,0x5C58,0x600E,0x6478, +0x69B6,0x6FF2,0x775A,0x8028,0x8A9E,0x970E,0xA5D5,0xB766, +/* A:00 B:1c */ +0x5719,0x5731,0x574D,0x576E,0x5796,0x57C5,0x57FE,0x5840, +0x5890,0x58EE,0x595E,0x59E3,0x5A82,0x5B3E,0x5C1E,0x5D28, +0x5E64,0x5FDB,0x6199,0x63AC,0x6622,0x6910,0x6C8A,0x70AD, +0x7597,0x7B6E,0x825E,0x8A9E,0x946C,0xA013,0xADEC,0xBE62, +/* A:00 B:1d */ +0x67A6,0x67BC,0x67D6,0x67F4,0x6819,0x6844,0x6878,0x68B6, +0x68FF,0x6955,0x69BD,0x6A37,0x6AC9,0x6B76,0x6C44,0x6D39, +0x6E5B,0x6FB5,0x7150,0x7338,0x757C,0x782D,0x7B61,0x7F2E, +0x83B4,0x8914,0x8F77,0x970E,0xA013,0xAACC,0xB78A,0xC6AF, +/* A:00 B:1e */ +0x7B51,0x7B65,0x7B7C,0x7B98,0x7BB8,0x7BE0,0x7C0E,0x7C45, +0x7C86,0x7CD4,0x7D31,0x7D9F,0x7E21,0x7EBD,0x7F75,0x8051, +0x8156,0x828B,0x83FC,0x85B2,0x87BA,0x8A24,0x8D03,0x906C, +0x947B,0x994C,0x9F07,0xA5D5,0xADEC,0xB78A,0xC2F8,0xD08D, +/* A:00 B:1f */ +0x92B2,0x92C3,0x92D7,0x92EF,0x930B,0x932D,0x9355,0x9384, +0x93BD,0x9400,0x9450,0x94AF,0x9520,0x95A6,0x9645,0x9703, +0x97E4,0x98EF,0x9A2D,0x9BA7,0x9D68,0x9F7E,0xA1F8,0xA4EA, +0xA86B,0xAC94,0xB186,0xB766,0xBE62,0xC6AF,0xD08D,0xDC47, +/* A: 968D89C0 */ +/* A:01 B:00 */ +0x0021,0x0043,0x006B,0x009A,0x00D3,0x0116,0x0166,0x01C4, +0x0235,0x02BB,0x035A,0x0417,0x04F8,0x0603,0x0741,0x08BA, +0x0A7B,0x0C90,0x0F0A,0x11FB,0x157A,0x19A2,0x1E92,0x2471, +0x2B6A,0x33B5,0x3D8F,0x4946,0x5731,0x67BC,0x7B65,0x92C3, +/* A:01 B:01 */ +0x0043,0x0064,0x008C,0x00BC,0x00F4,0x0137,0x0187,0x01E6, +0x0257,0x02DC,0x037B,0x0439,0x0519,0x0624,0x0762,0x08DB, +0x0A9B,0x0CB0,0x0F2A,0x121A,0x1599,0x19C0,0x1EB0,0x248E, +0x2B87,0x33D1,0x3DAA,0x495F,0x5748,0x67D1,0x7B78,0x92D4, +/* A:01 B:02 */ +0x006B,0x008C,0x00B4,0x00E4,0x011C,0x015F,0x01AF,0x020E, +0x027E,0x0304,0x03A3,0x0460,0x0541,0x064C,0x0789,0x0902, +0x0AC2,0x0CD7,0x0F50,0x1240,0x15BE,0x19E5,0x1ED4,0x24B1, +0x2BA9,0x33F2,0x3DCA,0x497D,0x5765,0x67EB,0x7B90,0x92E8, +/* A:01 B:03 */ +0x009A,0x00BC,0x00E4,0x0113,0x014C,0x018F,0x01DE,0x023D, +0x02AD,0x0333,0x03D2,0x048F,0x056F,0x067A,0x07B7,0x0930, +0x0AF0,0x0D04,0x0F7D,0x126D,0x15EA,0x1A10,0x1EFF,0x24DB, +0x2BD2,0x3419,0x3DEF,0x49A1,0x5786,0x680A,0x7BAB,0x9300, +/* A:01 B:04 */ +0x00D3,0x00F4,0x011C,0x014C,0x0184,0x01C7,0x0216,0x0275, +0x02E5,0x036B,0x040A,0x04C7,0x05A7,0x06B1,0x07EE,0x0967, +0x0B26,0x0D3A,0x0FB2,0x12A2,0x161F,0x1A44,0x1F31,0x250C, +0x2C02,0x3447,0x3E1C,0x49CB,0x57AE,0x682F,0x7BCC,0x931C, +/* A:01 B:05 */ +0x0116,0x0137,0x015F,0x018F,0x01C7,0x020A,0x0259,0x02B8, +0x0328,0x03AE,0x044C,0x0509,0x05E9,0x06F3,0x0830,0x09A8, +0x0B67,0x0D7B,0x0FF2,0x12E1,0x165D,0x1A81,0x1F6D,0x2547, +0x2C3B,0x347F,0x3E51,0x49FD,0x57DD,0x685A,0x7BF3,0x933E, +/* A:01 B:06 */ +0x0166,0x0187,0x01AF,0x01DE,0x0216,0x0259,0x02A9,0x0307, +0x0377,0x03FD,0x049B,0x0558,0x0637,0x0741,0x087E,0x09F5, +0x0BB4,0x0DC7,0x103E,0x132C,0x16A7,0x1ACA,0x1FB5,0x258D, +0x2C7F,0x34C0,0x3E90,0x4A39,0x5815,0x688E,0x7C21,0x9366, +/* A:01 B:07 */ +0x01C4,0x01E6,0x020E,0x023D,0x0275,0x02B8,0x0307,0x0365, +0x03D5,0x045B,0x04F9,0x05B5,0x0695,0x079E,0x08DA,0x0A51, +0x0C10,0x0E22,0x1098,0x1385,0x16FF,0x1B21,0x200A,0x25E0, +0x2CD0,0x350F,0x3EDB,0x4A81,0x5858,0x68CB,0x7C58,0x9395, +/* A:01 B:08 */ +0x0235,0x0257,0x027E,0x02AD,0x02E5,0x0328,0x0377,0x03D5, +0x0445,0x04CA,0x0568,0x0624,0x0703,0x080D,0x0948,0x0ABF, +0x0C7C,0x0E8E,0x1103,0x13EF,0x1767,0x1B88,0x206F,0x2643, +0x2D30,0x356C,0x3F34,0x4AD5,0x58A7,0x6914,0x7C9A,0x93CE, +/* A:01 B:09 */ +0x02BB,0x02DC,0x0304,0x0333,0x036B,0x03AE,0x03FD,0x045B, +0x04CA,0x054F,0x05ED,0x06A8,0x0787,0x0890,0x09CB,0x0B41, +0x0CFD,0x0F0E,0x1182,0x146C,0x17E3,0x1C02,0x20E7,0x26B8, +0x2DA2,0x35DA,0x3F9E,0x4B3A,0x5906,0x696B,0x7CE8,0x9411, +/* A:01 B:0a */ +0x035A,0x037B,0x03A3,0x03D2,0x040A,0x044C,0x049B,0x04F9, +0x0568,0x05ED,0x068A,0x0745,0x0824,0x092C,0x0A66,0x0BDB, +0x0D97,0x0FA6,0x1219,0x1502,0x1877,0x1C93,0x2176,0x2744, +0x2E2A,0x365D,0x401C,0x4BB1,0x5976,0x69D2,0x7D44,0x9461, +/* A:01 B:0b */ +0x0417,0x0439,0x0460,0x048F,0x04C7,0x0509,0x0558,0x05B5, +0x0624,0x06A8,0x0745,0x0800,0x08DE,0x09E5,0x0B1F,0x0C93, +0x0E4E,0x105C,0x12CD,0x15B4,0x1927,0x1D40,0x221F,0x27EA, +0x2ECB,0x36F9,0x40B2,0x4C40,0x59FB,0x6A4D,0x7DB2,0x94BF, +/* A:01 B:0c */ +0x04F8,0x0519,0x0541,0x056F,0x05A7,0x05E9,0x0637,0x0695, +0x0703,0x0787,0x0824,0x08DE,0x09BB,0x0AC2,0x0BFA,0x0D6D, +0x0F26,0x1133,0x13A2,0x1687,0x19F7,0x1E0D,0x22E9,0x28AF, +0x2F8B,0x37B3,0x4164,0x4CE9,0x5A99,0x6ADE,0x7E35,0x9530, +/* A:01 B:0d */ +0x0603,0x0624,0x064C,0x067A,0x06B1,0x06F3,0x0741,0x079E, +0x080D,0x0890,0x092C,0x09E5,0x0AC2,0x0BC8,0x0CFF,0x0E71, +0x1028,0x1233,0x14A0,0x1782,0x1AEF,0x1F01,0x23D8,0x2999, +0x306F,0x388F,0x4237,0x4DB1,0x5B55,0x6B8B,0x7ED0,0x95B6, +/* A:01 B:0e */ +0x0741,0x0762,0x0789,0x07B7,0x07EE,0x0830,0x087E,0x08DA, +0x0948,0x09CB,0x0A66,0x0B1F,0x0BFA,0x0CFF,0x0E35,0x0FA5, +0x115B,0x1363,0x15CD,0x18AC,0x1C15,0x2023,0x24F5,0x2AAF, +0x317E,0x3995,0x4332,0x4EA0,0x5C35,0x6C59,0x7F88,0x9656, +/* A:01 B:0f */ +0x08BA,0x08DB,0x0902,0x0930,0x0967,0x09A8,0x09F5,0x0A51, +0x0ABF,0x0B41,0x0BDB,0x0C93,0x0D6D,0x0E71,0x0FA5,0x1113, +0x12C7,0x14CC,0x1734,0x1A0F,0x1D73,0x217C,0x2647,0x2BFA, +0x32C0,0x3ACC,0x445D,0x4FBC,0x5D3F,0x6D4E,0x8064,0x9713, +/* A:01 B:10 */ +0x0A7B,0x0A9B,0x0AC2,0x0AF0,0x0B26,0x0B67,0x0BB4,0x0C10, +0x0C7C,0x0CFD,0x0D97,0x0E4E,0x0F26,0x1028,0x115B,0x12C7, +0x1478,0x167A,0x18DD,0x1BB4,0x1F13,0x2316,0x27DA,0x2D83, +0x343E,0x3C3E,0x45C0,0x510D,0x5E7A,0x6E70,0x8168,0x97F4, +/* A:01 B:11 */ +0x0C90,0x0CB0,0x0CD7,0x0D04,0x0D3A,0x0D7B,0x0DC7,0x0E22, +0x0E8E,0x0F0E,0x0FA6,0x105C,0x1133,0x1233,0x1363,0x14CC, +0x167A,0x1879,0x1AD7,0x1DA9,0x2102,0x24FD,0x29B8,0x2F57, +0x3605,0x3DF6,0x4766,0x529D,0x5FF2,0x6FCA,0x829E,0x98FF, +/* A:01 B:12 */ +0x0F0A,0x0F2A,0x0F50,0x0F7D,0x0FB2,0x0FF2,0x103E,0x1098, +0x1103,0x1182,0x1219,0x12CD,0x13A2,0x14A0,0x15CD,0x1734, +0x18DD,0x1AD7,0x1D31,0x1FFC,0x234E,0x273F,0x2BF0,0x3182, +0x3821,0x4000,0x495B,0x5479,0x61B0,0x7164,0x840E,0x9A3D, +/* A:01 B:13 */ +0x11FB,0x121A,0x1240,0x126D,0x12A2,0x12E1,0x132C,0x1385, +0x13EF,0x146C,0x1502,0x15B4,0x1687,0x1782,0x18AC,0x1A0F, +0x1BB4,0x1DA9,0x1FFC,0x22BF,0x2608,0x29EF,0x2E93,0x3416, +0x3AA4,0x426D,0x4BAF,0x56AF,0x63C2,0x734C,0x85C4,0x9BB7, +/* A:01 B:14 */ +0x157A,0x1599,0x15BE,0x15EA,0x161F,0x165D,0x16A7,0x16FF, +0x1767,0x17E3,0x1877,0x1927,0x19F7,0x1AEF,0x1C15,0x1D73, +0x1F13,0x2102,0x234E,0x2608,0x2946,0x2D21,0x31B5,0x3727, +0x3D9F,0x4550,0x4E73,0x5950,0x6638,0x7590,0x87CC,0x9D78, +/* A:01 B:15 */ +0x19A2,0x19C0,0x19E5,0x1A10,0x1A44,0x1A81,0x1ACA,0x1B21, +0x1B88,0x1C02,0x1C93,0x1D40,0x1E0D,0x1F01,0x2023,0x217C, +0x2316,0x24FD,0x273F,0x29EF,0x2D21,0x30EC,0x356F,0x3ACB, +0x412A,0x48BD,0x51BD,0x5C6F,0x6925,0x7841,0x8A36,0x9F8D, +/* A:01 B:16 */ +0x1E92,0x1EB0,0x1ED4,0x1EFF,0x1F31,0x1F6D,0x1FB5,0x200A, +0x206F,0x20E7,0x2176,0x221F,0x22E9,0x23D8,0x24F5,0x2647, +0x27DA,0x29B8,0x2BF0,0x2E93,0x31B5,0x356F,0x39DC,0x3F20, +0x4561,0x4CCF,0x55A5,0x6025,0x6C9F,0x7B74,0x8D15,0xA207, +/* A:01 B:17 */ +0x2471,0x248E,0x24B1,0x24DB,0x250C,0x2547,0x258D,0x25E0, +0x2643,0x26B8,0x2744,0x27EA,0x28AF,0x2999,0x2AAF,0x2BFA, +0x2D83,0x2F57,0x3182,0x3416,0x3727,0x3ACB,0x3F20,0x4445, +0x4A62,0x51A7,0x5A4A,0x648E,0x70C1,0x7F42,0x907E,0xA4F9, +/* A:01 B:18 */ +0x2B6A,0x2B87,0x2BA9,0x2BD2,0x2C02,0x2C3B,0x2C7F,0x2CD0, +0x2D30,0x2DA2,0x2E2A,0x2ECB,0x2F8B,0x306F,0x317E,0x32C0, +0x343E,0x3605,0x3821,0x3AA4,0x3D9F,0x412A,0x4561,0x4A62, +0x5055,0x5767,0x5FCF,0x69CC,0x75AB,0x83C6,0x948B,0xA879, +/* A:01 B:19 */ +0x33B5,0x33D1,0x33F2,0x3419,0x3447,0x347F,0x34C0,0x350F, +0x356C,0x35DA,0x365D,0x36F9,0x37B3,0x388F,0x3995,0x3ACC, +0x3C3E,0x3DF6,0x4000,0x426D,0x4550,0x48BD,0x4CCF,0x51A7, +0x5767,0x5E3E,0x665E,0x7007,0x7B81,0x8926,0x995C,0xACA2, +/* A:01 B:1a */ +0x3D8F,0x3DAA,0x3DCA,0x3DEF,0x3E1C,0x3E51,0x3E90,0x3EDB, +0x3F34,0x3F9E,0x401C,0x40B2,0x4164,0x4237,0x4332,0x445D, +0x45C0,0x4766,0x495B,0x4BAF,0x4E73,0x51BD,0x55A5,0x5A4A, +0x5FCF,0x665E,0x6E2A,0x776E,0x8271,0x8F88,0x9F16,0xB193, +/* A:01 B:1b */ +0x4946,0x495F,0x497D,0x49A1,0x49CB,0x49FD,0x4A39,0x4A81, +0x4AD5,0x4B3A,0x4BB1,0x4C40,0x4CE9,0x4DB1,0x4EA0,0x4FBC, +0x510D,0x529D,0x5479,0x56AF,0x5950,0x5C6F,0x6025,0x648E, +0x69CC,0x7007,0x776E,0x803B,0x8AB0,0x971E,0xA5E4,0xB773, +/* A:01 B:1c */ +0x5731,0x5748,0x5765,0x5786,0x57AE,0x57DD,0x5815,0x5858, +0x58A7,0x5906,0x5976,0x59FB,0x5A99,0x5B55,0x5C35,0x5D3F, +0x5E7A,0x5FF2,0x61B0,0x63C2,0x6638,0x6925,0x6C9F,0x70C1, +0x75AB,0x7B81,0x8271,0x8AB0,0x947D,0xA022,0xADFA,0xBE6E, +/* A:01 B:1d */ +0x67BC,0x67D1,0x67EB,0x680A,0x682F,0x685A,0x688E,0x68CB, +0x6914,0x696B,0x69D2,0x6A4D,0x6ADE,0x6B8B,0x6C59,0x6D4E, +0x6E70,0x6FCA,0x7164,0x734C,0x7590,0x7841,0x7B74,0x7F42, +0x83C6,0x8926,0x8F88,0x971E,0xA022,0xAADA,0xB797,0xC6BA, +/* A:01 B:1e */ +0x7B65,0x7B78,0x7B90,0x7BAB,0x7BCC,0x7BF3,0x7C21,0x7C58, +0x7C9A,0x7CE8,0x7D44,0x7DB2,0x7E35,0x7ED0,0x7F88,0x8064, +0x8168,0x829E,0x840E,0x85C4,0x87CC,0x8A36,0x8D15,0x907E, +0x948B,0x995C,0x9F16,0xA5E4,0xADFA,0xB797,0xC303,0xD097, +/* A:01 B:1f */ +0x92C3,0x92D4,0x92E8,0x9300,0x931C,0x933E,0x9366,0x9395, +0x93CE,0x9411,0x9461,0x94BF,0x9530,0x95B6,0x9656,0x9713, +0x97F4,0x98FF,0x9A3D,0x9BB7,0x9D78,0x9F8D,0xA207,0xA4F9, +0xA879,0xACA2,0xB193,0xB773,0xBE6E,0xC6BA,0xD097,0xDC4F, +/* A: 968D89C0 */ +/* A:02 B:00 */ +0x0049,0x006B,0x0093,0x00C2,0x00FB,0x013E,0x018D,0x01EC, +0x025D,0x02E3,0x0382,0x043F,0x0520,0x062B,0x0768,0x08E1, +0x0AA2,0x0CB6,0x0F30,0x1220,0x159F,0x19C6,0x1EB6,0x2494, +0x2B8D,0x33D6,0x3DAF,0x4964,0x574D,0x67D6,0x7B7C,0x92D7, +/* A:02 B:01 */ +0x006B,0x008C,0x00B4,0x00E4,0x011C,0x015F,0x01AF,0x020E, +0x027E,0x0304,0x03A3,0x0460,0x0541,0x064C,0x0789,0x0902, +0x0AC2,0x0CD7,0x0F50,0x1240,0x15BE,0x19E5,0x1ED4,0x24B1, +0x2BA9,0x33F2,0x3DCA,0x497D,0x5765,0x67EB,0x7B90,0x92E8, +/* A:02 B:02 */ +0x0093,0x00B4,0x00DC,0x010C,0x0144,0x0187,0x01D7,0x0235, +0x02A6,0x032C,0x03CB,0x0487,0x0568,0x0673,0x07B0,0x0929, +0x0AE9,0x0CFD,0x0F76,0x1266,0x15E3,0x1A09,0x1EF8,0x24D4, +0x2BCB,0x3413,0x3DE9,0x499B,0x5781,0x6805,0x7BA7,0x92FC, +/* A:02 B:03 */ +0x00C2,0x00E4,0x010C,0x013B,0x0173,0x01B6,0x0206,0x0265, +0x02D5,0x035B,0x03FA,0x04B6,0x0597,0x06A1,0x07DE,0x0957, +0x0B16,0x0D2A,0x0FA3,0x1292,0x160F,0x1A35,0x1F22,0x24FE, +0x2BF4,0x343A,0x3E0F,0x49BF,0x57A2,0x6824,0x7BC2,0x9314, +/* A:02 B:04 */ +0x00FB,0x011C,0x0144,0x0173,0x01AC,0x01EF,0x023E,0x029D, +0x030D,0x0393,0x0431,0x04EE,0x05CE,0x06D9,0x0815,0x098E, +0x0B4D,0x0D60,0x0FD8,0x12C7,0x1644,0x1A68,0x1F55,0x252F, +0x2C24,0x3468,0x3E3C,0x49E9,0x57CA,0x6849,0x7BE3,0x9330, +/* A:02 B:05 */ +0x013E,0x015F,0x0187,0x01B6,0x01EF,0x0232,0x0281,0x02DF, +0x0350,0x03D5,0x0474,0x0530,0x0610,0x071A,0x0857,0x09CF, +0x0B8E,0x0DA1,0x1018,0x1306,0x1682,0x1AA6,0x1F91,0x256A, +0x2C5D,0x34A0,0x3E71,0x4A1B,0x57F9,0x6874,0x7C0A,0x9352, +/* A:02 B:06 */ +0x018D,0x01AF,0x01D7,0x0206,0x023E,0x0281,0x02D0,0x032F, +0x039F,0x0424,0x04C3,0x057F,0x065F,0x0768,0x08A4,0x0A1C, +0x0BDB,0x0DED,0x1064,0x1351,0x16CC,0x1AEE,0x1FD9,0x25B0, +0x2CA1,0x34E1,0x3EB0,0x4A57,0x5831,0x68A8,0x7C38,0x937A, +/* A:02 B:07 */ +0x01EC,0x020E,0x0235,0x0265,0x029D,0x02DF,0x032F,0x038D, +0x03FD,0x0482,0x0520,0x05DC,0x06BC,0x07C5,0x0901,0x0A78, +0x0C36,0x0E48,0x10BE,0x13AA,0x1724,0x1B45,0x202E,0x2603, +0x2CF2,0x352F,0x3EFB,0x4A9E,0x5874,0x68E5,0x7C70,0x93A9, +/* A:02 B:08 */ +0x025D,0x027E,0x02A6,0x02D5,0x030D,0x0350,0x039F,0x03FD, +0x046D,0x04F2,0x0590,0x064B,0x072B,0x0834,0x096F,0x0AE5, +0x0CA3,0x0EB4,0x1129,0x1414,0x178C,0x1BAC,0x2092,0x2666, +0x2D52,0x358C,0x3F54,0x4AF3,0x58C3,0x692E,0x7CB1,0x93E2, +/* A:02 B:09 */ +0x02E3,0x0304,0x032C,0x035B,0x0393,0x03D5,0x0424,0x0482, +0x04F2,0x0576,0x0614,0x06CF,0x07AE,0x08B7,0x09F1,0x0B67, +0x0D24,0x0F34,0x11A8,0x1492,0x1808,0x1C26,0x210A,0x26DB, +0x2DC4,0x35FB,0x3FBE,0x4B58,0x5921,0x6985,0x7CFF,0x9425, +/* A:02 B:0a */ +0x0382,0x03A3,0x03CB,0x03FA,0x0431,0x0474,0x04C3,0x0520, +0x0590,0x0614,0x06B1,0x076C,0x084B,0x0953,0x0A8D,0x0C02, +0x0DBD,0x0FCC,0x123F,0x1527,0x189C,0x1CB7,0x2199,0x2766, +0x2E4C,0x367E,0x403C,0x4BCF,0x5991,0x69EC,0x7D5B,0x9474, +/* A:02 B:0b */ +0x043F,0x0460,0x0487,0x04B6,0x04EE,0x0530,0x057F,0x05DC, +0x064B,0x06CF,0x076C,0x0827,0x0905,0x0A0C,0x0B45,0x0CB9, +0x0E74,0x1081,0x12F2,0x15D9,0x194B,0x1D64,0x2243,0x280C, +0x2EED,0x371A,0x40D1,0x4C5D,0x5A17,0x6A66,0x7DC9,0x94D3, +/* A:02 B:0c */ +0x0520,0x0541,0x0568,0x0597,0x05CE,0x0610,0x065F,0x06BC, +0x072B,0x07AE,0x084B,0x0905,0x09E2,0x0AE8,0x0C20,0x0D93, +0x0F4C,0x1159,0x13C7,0x16AC,0x1A1C,0x1E31,0x230C,0x28D1, +0x2FAD,0x37D3,0x4183,0x4D06,0x5AB5,0x6AF8,0x7E4C,0x9544, +/* A:02 B:0d */ +0x062B,0x064C,0x0673,0x06A1,0x06D9,0x071A,0x0768,0x07C5, +0x0834,0x08B7,0x0953,0x0A0C,0x0AE8,0x0BEE,0x0D25,0x0E97, +0x104E,0x1258,0x14C5,0x17A7,0x1B13,0x1F25,0x23FB,0x29BB, +0x3090,0x38AF,0x4256,0x4DCF,0x5B71,0x6BA5,0x7EE7,0x95CA, +/* A:02 B:0e */ +0x0768,0x0789,0x07B0,0x07DE,0x0815,0x0857,0x08A4,0x0901, +0x096F,0x09F1,0x0A8D,0x0B45,0x0C20,0x0D25,0x0E5B,0x0FCB, +0x1180,0x1388,0x15F2,0x18D1,0x1C3A,0x2047,0x2518,0x2AD1, +0x319F,0x39B5,0x4351,0x4EBD,0x5C50,0x6C72,0x7F9F,0x9669, +/* A:02 B:0f */ +0x08E1,0x0902,0x0929,0x0957,0x098E,0x09CF,0x0A1C,0x0A78, +0x0AE5,0x0B67,0x0C02,0x0CB9,0x0D93,0x0E97,0x0FCB,0x1139, +0x12EC,0x14F2,0x1758,0x1A33,0x1D97,0x21A0,0x266A,0x2C1C, +0x32E1,0x3AEC,0x447C,0x4FD9,0x5D5A,0x6D67,0x807A,0x9726, +/* A:02 B:10 */ +0x0AA2,0x0AC2,0x0AE9,0x0B16,0x0B4D,0x0B8E,0x0BDB,0x0C36, +0x0CA3,0x0D24,0x0DBD,0x0E74,0x0F4C,0x104E,0x1180,0x12EC, +0x149D,0x169F,0x1902,0x1BD8,0x1F37,0x2339,0x27FC,0x2DA5, +0x345F,0x3C5E,0x45DE,0x512A,0x5E96,0x6E89,0x817F,0x9807, +/* A:02 B:11 */ +0x0CB6,0x0CD7,0x0CFD,0x0D2A,0x0D60,0x0DA1,0x0DED,0x0E48, +0x0EB4,0x0F34,0x0FCC,0x1081,0x1159,0x1258,0x1388,0x14F2, +0x169F,0x189D,0x1AFC,0x1DCD,0x2125,0x2520,0x29DA,0x2F78, +0x3626,0x3E15,0x4784,0x52BA,0x600D,0x6FE2,0x82B4,0x9912, +/* A:02 B:12 */ +0x0F30,0x0F50,0x0F76,0x0FA3,0x0FD8,0x1018,0x1064,0x10BE, +0x1129,0x11A8,0x123F,0x12F2,0x13C7,0x14C5,0x15F2,0x1758, +0x1902,0x1AFC,0x1D55,0x2020,0x2371,0x2762,0x2C12,0x31A3, +0x3842,0x4020,0x4979,0x5496,0x61CB,0x717D,0x8424,0x9A50, +/* A:02 B:13 */ +0x1220,0x1240,0x1266,0x1292,0x12C7,0x1306,0x1351,0x13AA, +0x1414,0x1492,0x1527,0x15D9,0x16AC,0x17A7,0x18D1,0x1A33, +0x1BD8,0x1DCD,0x2020,0x22E3,0x262B,0x2A12,0x2EB5,0x3437, +0x3AC4,0x428C,0x4BCD,0x56CB,0x63DD,0x7364,0x85DA,0x9BCA, +/* A:02 B:14 */ +0x159F,0x15BE,0x15E3,0x160F,0x1644,0x1682,0x16CC,0x1724, +0x178C,0x1808,0x189C,0x194B,0x1A1C,0x1B13,0x1C3A,0x1D97, +0x1F37,0x2125,0x2371,0x262B,0x2969,0x2D43,0x31D7,0x3747, +0x3DBF,0x456E,0x4E90,0x596B,0x6652,0x75A8,0x87E1,0x9D8A, +/* A:02 B:15 */ +0x19C6,0x19E5,0x1A09,0x1A35,0x1A68,0x1AA6,0x1AEE,0x1B45, +0x1BAC,0x1C26,0x1CB7,0x1D64,0x1E31,0x1F25,0x2047,0x21A0, +0x2339,0x2520,0x2762,0x2A12,0x2D43,0x310E,0x3590,0x3AEB, +0x4149,0x48DB,0x51DA,0x5C8A,0x693F,0x7859,0x8A4B,0x9FA0, +/* A:02 B:16 */ +0x1EB6,0x1ED4,0x1EF8,0x1F22,0x1F55,0x1F91,0x1FD9,0x202E, +0x2092,0x210A,0x2199,0x2243,0x230C,0x23FB,0x2518,0x266A, +0x27FC,0x29DA,0x2C12,0x2EB5,0x31D7,0x3590,0x39FD,0x3F3F, +0x457F,0x4CED,0x55C1,0x6040,0x6CB9,0x7B8B,0x8D29,0xA219, +/* A:02 B:17 */ +0x2494,0x24B1,0x24D4,0x24FE,0x252F,0x256A,0x25B0,0x2603, +0x2666,0x26DB,0x2766,0x280C,0x28D1,0x29BB,0x2AD1,0x2C1C, +0x2DA5,0x2F78,0x31A3,0x3437,0x3747,0x3AEB,0x3F3F,0x4463, +0x4A80,0x51C4,0x5A66,0x64A8,0x70DA,0x7F58,0x9092,0xA50B, +/* A:02 B:18 */ +0x2B8D,0x2BA9,0x2BCB,0x2BF4,0x2C24,0x2C5D,0x2CA1,0x2CF2, +0x2D52,0x2DC4,0x2E4C,0x2EED,0x2FAD,0x3090,0x319F,0x32E1, +0x345F,0x3626,0x3842,0x3AC4,0x3DBF,0x4149,0x457F,0x4A80, +0x5072,0x5783,0x5FEA,0x69E5,0x75C3,0x83DD,0x949F,0xA88A, +/* A:02 B:19 */ +0x33D6,0x33F2,0x3413,0x343A,0x3468,0x34A0,0x34E1,0x352F, +0x358C,0x35FB,0x367E,0x371A,0x37D3,0x38AF,0x39B5,0x3AEC, +0x3C5E,0x3E15,0x4020,0x428C,0x456E,0x48DB,0x4CED,0x51C4, +0x5783,0x5E59,0x6678,0x701F,0x7B98,0x893B,0x996F,0xACB2, +/* A:02 B:1a */ +0x3DAF,0x3DCA,0x3DE9,0x3E0F,0x3E3C,0x3E71,0x3EB0,0x3EFB, +0x3F54,0x3FBE,0x403C,0x40D1,0x4183,0x4256,0x4351,0x447C, +0x45DE,0x4784,0x4979,0x4BCD,0x4E90,0x51DA,0x55C1,0x5A66, +0x5FEA,0x6678,0x6E43,0x7786,0x8287,0x8F9C,0x9F28,0xB1A3, +/* A:02 B:1b */ +0x4964,0x497D,0x499B,0x49BF,0x49E9,0x4A1B,0x4A57,0x4A9E, +0x4AF3,0x4B58,0x4BCF,0x4C5D,0x4D06,0x4DCF,0x4EBD,0x4FD9, +0x512A,0x52BA,0x5496,0x56CB,0x596B,0x5C8A,0x6040,0x64A8, +0x69E5,0x701F,0x7786,0x8051,0x8AC5,0x9731,0xA5F5,0xB782, +/* A:02 B:1c */ +0x574D,0x5765,0x5781,0x57A2,0x57CA,0x57F9,0x5831,0x5874, +0x58C3,0x5921,0x5991,0x5A17,0x5AB5,0x5B71,0x5C50,0x5D5A, +0x5E96,0x600D,0x61CB,0x63DD,0x6652,0x693F,0x6CB9,0x70DA, +0x75C3,0x7B98,0x8287,0x8AC5,0x9490,0xA035,0xAE0A,0xBE7C, +/* A:02 B:1d */ +0x67D6,0x67EB,0x6805,0x6824,0x6849,0x6874,0x68A8,0x68E5, +0x692E,0x6985,0x69EC,0x6A66,0x6AF8,0x6BA5,0x6C72,0x6D67, +0x6E89,0x6FE2,0x717D,0x7364,0x75A8,0x7859,0x7B8B,0x7F58, +0x83DD,0x893B,0x8F9C,0x9731,0xA035,0xAAEB,0xB7A6,0xC6C7, +/* A:02 B:1e */ +0x7B7C,0x7B90,0x7BA7,0x7BC2,0x7BE3,0x7C0A,0x7C38,0x7C70, +0x7CB1,0x7CFF,0x7D5B,0x7DC9,0x7E4C,0x7EE7,0x7F9F,0x807A, +0x817F,0x82B4,0x8424,0x85DA,0x87E1,0x8A4B,0x8D29,0x9092, +0x949F,0x996F,0x9F28,0xA5F5,0xAE0A,0xB7A6,0xC310,0xD0A2, +/* A:02 B:1f */ +0x92D7,0x92E8,0x92FC,0x9314,0x9330,0x9352,0x937A,0x93A9, +0x93E2,0x9425,0x9474,0x94D3,0x9544,0x95CA,0x9669,0x9726, +0x9807,0x9912,0x9A50,0x9BCA,0x9D8A,0x9FA0,0xA219,0xA50B, +0xA88A,0xACB2,0xB1A3,0xB782,0xBE7C,0xC6C7,0xD0A2,0xDC59, +/* A: 968D89C0 */ +/* A:03 B:00 */ +0x0079,0x009A,0x00C2,0x00F2,0x012A,0x016D,0x01BD,0x021C, +0x028C,0x0312,0x03B1,0x046E,0x054E,0x0659,0x0796,0x090F, +0x0ACF,0x0CE4,0x0F5D,0x124D,0x15CB,0x19F2,0x1EE0,0x24BD, +0x2BB5,0x33FD,0x3DD5,0x4987,0x576E,0x67F4,0x7B98,0x92EF, +/* A:03 B:01 */ +0x009A,0x00BC,0x00E4,0x0113,0x014C,0x018F,0x01DE,0x023D, +0x02AD,0x0333,0x03D2,0x048F,0x056F,0x067A,0x07B7,0x0930, +0x0AF0,0x0D04,0x0F7D,0x126D,0x15EA,0x1A10,0x1EFF,0x24DB, +0x2BD2,0x3419,0x3DEF,0x49A1,0x5786,0x680A,0x7BAB,0x9300, +/* A:03 B:02 */ +0x00C2,0x00E4,0x010C,0x013B,0x0173,0x01B6,0x0206,0x0265, +0x02D5,0x035B,0x03FA,0x04B6,0x0597,0x06A1,0x07DE,0x0957, +0x0B16,0x0D2A,0x0FA3,0x1292,0x160F,0x1A35,0x1F22,0x24FE, +0x2BF4,0x343A,0x3E0F,0x49BF,0x57A2,0x6824,0x7BC2,0x9314, +/* A:03 B:03 */ +0x00F2,0x0113,0x013B,0x016A,0x01A3,0x01E6,0x0235,0x0294, +0x0304,0x038A,0x0428,0x04E5,0x05C5,0x06D0,0x080C,0x0985, +0x0B44,0x0D58,0x0FD0,0x12BF,0x163B,0x1A60,0x1F4D,0x2527, +0x2C1C,0x3461,0x3E34,0x49E2,0x57C4,0x6843,0x7BDE,0x932B, +/* A:03 B:04 */ +0x012A,0x014C,0x0173,0x01A3,0x01DB,0x021E,0x026D,0x02CC, +0x033C,0x03C2,0x0460,0x051D,0x05FD,0x0707,0x0844,0x09BC, +0x0B7B,0x0D8E,0x1005,0x12F4,0x1670,0x1A94,0x1F7F,0x2559, +0x2C4C,0x348F,0x3E61,0x4A0D,0x57EB,0x6867,0x7BFF,0x9348, +/* A:03 B:05 */ +0x016D,0x018F,0x01B6,0x01E6,0x021E,0x0261,0x02B0,0x030F, +0x037F,0x0404,0x04A3,0x055F,0x063F,0x0749,0x0885,0x09FD, +0x0BBB,0x0DCE,0x1045,0x1333,0x16AE,0x1AD1,0x1FBC,0x2594, +0x2C86,0x34C7,0x3E96,0x4A3F,0x581A,0x6893,0x7C26,0x9369, +/* A:03 B:06 */ +0x01BD,0x01DE,0x0206,0x0235,0x026D,0x02B0,0x0300,0x035E, +0x03CE,0x0453,0x04F1,0x05AD,0x068D,0x0797,0x08D3,0x0A4A, +0x0C08,0x0E1A,0x1091,0x137E,0x16F8,0x1B1A,0x2003,0x25D9, +0x2CC9,0x3508,0x3ED5,0x4A7B,0x5853,0x68C6,0x7C54,0x9391, +/* A:03 B:07 */ +0x021C,0x023D,0x0265,0x0294,0x02CC,0x030F,0x035E,0x03BC, +0x042C,0x04B1,0x054F,0x060B,0x06EA,0x07F4,0x092F,0x0AA6, +0x0C64,0x0E75,0x10EA,0x13D7,0x1750,0x1B70,0x2058,0x262C, +0x2D1A,0x3556,0x3F20,0x4AC2,0x5895,0x6904,0x7C8B,0x93C1, +/* A:03 B:08 */ +0x028C,0x02AD,0x02D5,0x0304,0x033C,0x037F,0x03CE,0x042C, +0x049C,0x0520,0x05BE,0x067A,0x0759,0x0862,0x099D,0x0B13, +0x0CD0,0x0EE1,0x1155,0x1440,0x17B8,0x1BD7,0x20BD,0x268F, +0x2D7A,0x35B3,0x3F79,0x4B17,0x58E4,0x694D,0x7CCC,0x93F9, +/* A:03 B:09 */ +0x0312,0x0333,0x035B,0x038A,0x03C2,0x0404,0x0453,0x04B1, +0x0520,0x05A5,0x0643,0x06FE,0x07DC,0x08E5,0x0A1F,0x0B95, +0x0D51,0x0F61,0x11D4,0x14BE,0x1834,0x1C51,0x2135,0x2704, +0x2DEC,0x3622,0x3FE3,0x4B7B,0x5943,0x69A3,0x7D1A,0x943C, +/* A:03 B:0a */ +0x03B1,0x03D2,0x03FA,0x0428,0x0460,0x04A3,0x04F1,0x054F, +0x05BE,0x0643,0x06E0,0x079B,0x0879,0x0981,0x0ABB,0x0C2F, +0x0DEB,0x0FF9,0x126B,0x1553,0x18C7,0x1CE2,0x21C3,0x2790, +0x2E74,0x36A5,0x4061,0x4BF2,0x59B3,0x6A0A,0x7D76,0x948C, +/* A:03 B:0b */ +0x046E,0x048F,0x04B6,0x04E5,0x051D,0x055F,0x05AD,0x060B, +0x067A,0x06FE,0x079B,0x0855,0x0933,0x0A3A,0x0B73,0x0CE7, +0x0EA1,0x10AE,0x131F,0x1605,0x1977,0x1D8F,0x226D,0x2835, +0x2F15,0x3740,0x40F6,0x4C80,0x5A38,0x6A85,0x7DE4,0x94EB, +/* A:03 B:0c */ +0x054E,0x056F,0x0597,0x05C5,0x05FD,0x063F,0x068D,0x06EA, +0x0759,0x07DC,0x0879,0x0933,0x0A10,0x0B16,0x0C4E,0x0DC1, +0x0F7A,0x1185,0x13F4,0x16D8,0x1A47,0x1E5C,0x2336,0x28FA, +0x2FD5,0x37FA,0x41A8,0x4D29,0x5AD6,0x6B16,0x7E67,0x955B, +/* A:03 B:0d */ +0x0659,0x067A,0x06A1,0x06D0,0x0707,0x0749,0x0797,0x07F4, +0x0862,0x08E5,0x0981,0x0A3A,0x0B16,0x0C1C,0x0D52,0x0EC4, +0x107B,0x1285,0x14F1,0x17D2,0x1B3E,0x1F50,0x2425,0x29E4, +0x30B8,0x38D6,0x427B,0x4DF2,0x5B92,0x6BC3,0x7F02,0x95E1, +/* A:03 B:0e */ +0x0796,0x07B7,0x07DE,0x080C,0x0844,0x0885,0x08D3,0x092F, +0x099D,0x0A1F,0x0ABB,0x0B73,0x0C4E,0x0D52,0x0E88,0x0FF8, +0x11AD,0x13B5,0x161E,0x18FC,0x1C65,0x2071,0x2542,0x2AFA, +0x31C7,0x39DB,0x4376,0x4EE0,0x5C71,0x6C90,0x7FBA,0x9680, +/* A:03 B:0f */ +0x090F,0x0930,0x0957,0x0985,0x09BC,0x09FD,0x0A4A,0x0AA6, +0x0B13,0x0B95,0x0C2F,0x0CE7,0x0DC1,0x0EC4,0x0FF8,0x1166, +0x1319,0x151E,0x1784,0x1A5E,0x1DC2,0x21CA,0x2694,0x2C45, +0x3308,0x3B12,0x44A0,0x4FFB,0x5D7A,0x6D85,0x8095,0x973D, +/* A:03 B:10 */ +0x0ACF,0x0AF0,0x0B16,0x0B44,0x0B7B,0x0BBB,0x0C08,0x0C64, +0x0CD0,0x0D51,0x0DEB,0x0EA1,0x0F7A,0x107B,0x11AD,0x1319, +0x14C9,0x16CB,0x192E,0x1C03,0x1F62,0x2363,0x2825,0x2DCD, +0x3486,0x3C84,0x4603,0x514C,0x5EB6,0x6EA7,0x8199,0x981E, +/* A:03 B:11 */ +0x0CE4,0x0D04,0x0D2A,0x0D58,0x0D8E,0x0DCE,0x0E1A,0x0E75, +0x0EE1,0x0F61,0x0FF9,0x10AE,0x1185,0x1285,0x13B5,0x151E, +0x16CB,0x18C9,0x1B27,0x1DF7,0x2150,0x2549,0x2A03,0x2FA0, +0x364D,0x3E3B,0x47A8,0x52DC,0x602D,0x7000,0x82CF,0x9929, +/* A:03 B:12 */ +0x0F5D,0x0F7D,0x0FA3,0x0FD0,0x1005,0x1045,0x1091,0x10EA, +0x1155,0x11D4,0x126B,0x131F,0x13F4,0x14F1,0x161E,0x1784, +0x192E,0x1B27,0x1D80,0x204A,0x239B,0x278B,0x2C3A,0x31CB, +0x3868,0x4045,0x499D,0x54B8,0x61EA,0x719A,0x843F,0x9A67, +/* A:03 B:13 */ +0x124D,0x126D,0x1292,0x12BF,0x12F4,0x1333,0x137E,0x13D7, +0x1440,0x14BE,0x1553,0x1605,0x16D8,0x17D2,0x18FC,0x1A5E, +0x1C03,0x1DF7,0x204A,0x230D,0x2654,0x2A3A,0x2EDD,0x345E, +0x3AEA,0x42B1,0x4BF0,0x56ED,0x63FC,0x7381,0x85F4,0x9BE0, +/* A:03 B:14 */ +0x15CB,0x15EA,0x160F,0x163B,0x1670,0x16AE,0x16F8,0x1750, +0x17B8,0x1834,0x18C7,0x1977,0x1A47,0x1B3E,0x1C65,0x1DC2, +0x1F62,0x2150,0x239B,0x2654,0x2991,0x2D6B,0x31FE,0x376E, +0x3DE4,0x4592,0x4EB3,0x598D,0x6671,0x75C4,0x87FB,0x9DA0, +/* A:03 B:15 */ +0x19F2,0x1A10,0x1A35,0x1A60,0x1A94,0x1AD1,0x1B1A,0x1B70, +0x1BD7,0x1C51,0x1CE2,0x1D8F,0x1E5C,0x1F50,0x2071,0x21CA, +0x2363,0x2549,0x278B,0x2A3A,0x2D6B,0x3135,0x35B7,0x3B11, +0x416E,0x48FF,0x51FC,0x5CAB,0x695D,0x7875,0x8A64,0x9FB5, +/* A:03 B:16 */ +0x1EE0,0x1EFF,0x1F22,0x1F4D,0x1F7F,0x1FBC,0x2003,0x2058, +0x20BD,0x2135,0x21C3,0x226D,0x2336,0x2425,0x2542,0x2694, +0x2825,0x2A03,0x2C3A,0x2EDD,0x31FE,0x35B7,0x3A23,0x3F64, +0x45A3,0x4D10,0x55E3,0x6060,0x6CD7,0x7BA7,0x8D42,0xA22F, +/* A:03 B:17 */ +0x24BD,0x24DB,0x24FE,0x2527,0x2559,0x2594,0x25D9,0x262C, +0x268F,0x2704,0x2790,0x2835,0x28FA,0x29E4,0x2AFA,0x2C45, +0x2DCD,0x2FA0,0x31CB,0x345E,0x376E,0x3B11,0x3F64,0x4488, +0x4AA3,0x51E6,0x5A86,0x64C7,0x70F7,0x7F73,0x90AA,0xA51F, +/* A:03 B:18 */ +0x2BB5,0x2BD2,0x2BF4,0x2C1C,0x2C4C,0x2C86,0x2CC9,0x2D1A, +0x2D7A,0x2DEC,0x2E74,0x2F15,0x2FD5,0x30B8,0x31C7,0x3308, +0x3486,0x364D,0x3868,0x3AEA,0x3DE4,0x416E,0x45A3,0x4AA3, +0x5095,0x57A5,0x600A,0x6A04,0x75DF,0x83F7,0x94B6,0xA89E, +/* A:03 B:19 */ +0x33FD,0x3419,0x343A,0x3461,0x348F,0x34C7,0x3508,0x3556, +0x35B3,0x3622,0x36A5,0x3740,0x37FA,0x38D6,0x39DB,0x3B12, +0x3C84,0x3E3B,0x4045,0x42B1,0x4592,0x48FF,0x4D10,0x51E6, +0x57A5,0x5E79,0x6697,0x703D,0x7BB4,0x8954,0x9986,0xACC5, +/* A:03 B:1a */ +0x3DD5,0x3DEF,0x3E0F,0x3E34,0x3E61,0x3E96,0x3ED5,0x3F20, +0x3F79,0x3FE3,0x4061,0x40F6,0x41A8,0x427B,0x4376,0x44A0, +0x4603,0x47A8,0x499D,0x4BF0,0x4EB3,0x51FC,0x55E3,0x5A86, +0x600A,0x6697,0x6E61,0x77A2,0x82A2,0x8FB4,0x9F3E,0xB1B5, +/* A:03 B:1b */ +0x4987,0x49A1,0x49BF,0x49E2,0x4A0D,0x4A3F,0x4A7B,0x4AC2, +0x4B17,0x4B7B,0x4BF2,0x4C80,0x4D29,0x4DF2,0x4EE0,0x4FFB, +0x514C,0x52DC,0x54B8,0x56ED,0x598D,0x5CAB,0x6060,0x64C7, +0x6A04,0x703D,0x77A2,0x806C,0x8ADE,0x9748,0xA60A,0xB793, +/* A:03 B:1c */ +0x576E,0x5786,0x57A2,0x57C4,0x57EB,0x581A,0x5853,0x5895, +0x58E4,0x5943,0x59B3,0x5A38,0x5AD6,0x5B92,0x5C71,0x5D7A, +0x5EB6,0x602D,0x61EA,0x63FC,0x6671,0x695D,0x6CD7,0x70F7, +0x75DF,0x7BB4,0x82A2,0x8ADE,0x94A8,0xA04A,0xAE1E,0xBE8C, +/* A:03 B:1d */ +0x67F4,0x680A,0x6824,0x6843,0x6867,0x6893,0x68C6,0x6904, +0x694D,0x69A3,0x6A0A,0x6A85,0x6B16,0x6BC3,0x6C90,0x6D85, +0x6EA7,0x7000,0x719A,0x7381,0x75C4,0x7875,0x7BA7,0x7F73, +0x83F7,0x8954,0x8FB4,0x9748,0xA04A,0xAAFE,0xB7B7,0xC6D6, +/* A:03 B:1e */ +0x7B98,0x7BAB,0x7BC2,0x7BDE,0x7BFF,0x7C26,0x7C54,0x7C8B, +0x7CCC,0x7D1A,0x7D76,0x7DE4,0x7E67,0x7F02,0x7FBA,0x8095, +0x8199,0x82CF,0x843F,0x85F4,0x87FB,0x8A64,0x8D42,0x90AA, +0x94B6,0x9986,0x9F3E,0xA60A,0xAE1E,0xB7B7,0xC320,0xD0AF, +/* A:03 B:1f */ +0x92EF,0x9300,0x9314,0x932B,0x9348,0x9369,0x9391,0x93C1, +0x93F9,0x943C,0x948C,0x94EB,0x955B,0x95E1,0x9680,0x973D, +0x981E,0x9929,0x9A67,0x9BE0,0x9DA0,0x9FB5,0xA22F,0xA51F, +0xA89E,0xACC5,0xB1B5,0xB793,0xBE8C,0xC6D6,0xD0AF,0xDC64, +/* A: 968D89C0 */ +/* A:04 B:00 */ +0x00B1,0x00D3,0x00FB,0x012A,0x0162,0x01A5,0x01F5,0x0254, +0x02C4,0x034A,0x03E9,0x04A5,0x0586,0x0691,0x07CE,0x0946, +0x0B06,0x0D1A,0x0F93,0x1282,0x15FF,0x1A25,0x1F13,0x24EF, +0x2BE5,0x342C,0x3E01,0x49B2,0x5796,0x6819,0x7BB8,0x930B, +/* A:04 B:01 */ +0x00D3,0x00F4,0x011C,0x014C,0x0184,0x01C7,0x0216,0x0275, +0x02E5,0x036B,0x040A,0x04C7,0x05A7,0x06B1,0x07EE,0x0967, +0x0B26,0x0D3A,0x0FB2,0x12A2,0x161F,0x1A44,0x1F31,0x250C, +0x2C02,0x3447,0x3E1C,0x49CB,0x57AE,0x682F,0x7BCC,0x931C, +/* A:04 B:02 */ +0x00FB,0x011C,0x0144,0x0173,0x01AC,0x01EF,0x023E,0x029D, +0x030D,0x0393,0x0431,0x04EE,0x05CE,0x06D9,0x0815,0x098E, +0x0B4D,0x0D60,0x0FD8,0x12C7,0x1644,0x1A68,0x1F55,0x252F, +0x2C24,0x3468,0x3E3C,0x49E9,0x57CA,0x6849,0x7BE3,0x9330, +/* A:04 B:03 */ +0x012A,0x014C,0x0173,0x01A3,0x01DB,0x021E,0x026D,0x02CC, +0x033C,0x03C2,0x0460,0x051D,0x05FD,0x0707,0x0844,0x09BC, +0x0B7B,0x0D8E,0x1005,0x12F4,0x1670,0x1A94,0x1F7F,0x2559, +0x2C4C,0x348F,0x3E61,0x4A0D,0x57EB,0x6867,0x7BFF,0x9348, +/* A:04 B:04 */ +0x0162,0x0184,0x01AC,0x01DB,0x0213,0x0256,0x02A6,0x0304, +0x0374,0x03FA,0x0498,0x0554,0x0634,0x073E,0x087B,0x09F2, +0x0BB1,0x0DC4,0x103B,0x1329,0x16A4,0x1AC7,0x1FB2,0x258A, +0x2C7C,0x34BE,0x3E8E,0x4A37,0x5813,0x688C,0x7C1F,0x9364, +/* A:04 B:05 */ +0x01A5,0x01C7,0x01EF,0x021E,0x0256,0x0299,0x02E8,0x0347, +0x03B7,0x043C,0x04DA,0x0596,0x0676,0x0780,0x08BC,0x0A33, +0x0BF2,0x0E04,0x107A,0x1368,0x16E2,0x1B04,0x1FEE,0x25C5, +0x2CB6,0x34F5,0x3EC3,0x4A69,0x5842,0x68B7,0x7C46,0x9386, +/* A:04 B:06 */ +0x01F5,0x0216,0x023E,0x026D,0x02A6,0x02E8,0x0338,0x0396, +0x0406,0x048B,0x0529,0x05E5,0x06C4,0x07CE,0x090A,0x0A81, +0x0C3E,0x0E50,0x10C6,0x13B2,0x172C,0x1B4D,0x2035,0x260B, +0x2CF9,0x3537,0x3F02,0x4AA5,0x587A,0x68EB,0x7C75,0x93AD, +/* A:04 B:07 */ +0x0254,0x0275,0x029D,0x02CC,0x0304,0x0347,0x0396,0x03F4, +0x0464,0x04E9,0x0587,0x0642,0x0721,0x082B,0x0966,0x0ADD, +0x0C9A,0x0EAB,0x1120,0x140B,0x1784,0x1BA3,0x208A,0x265E, +0x2D4A,0x3585,0x3F4D,0x4AEC,0x58BD,0x6928,0x7CAC,0x93DD, +/* A:04 B:08 */ +0x02C4,0x02E5,0x030D,0x033C,0x0374,0x03B7,0x0406,0x0464, +0x04D3,0x0558,0x05F6,0x06B1,0x0790,0x0899,0x09D4,0x0B4A, +0x0D06,0x0F17,0x118B,0x1475,0x17EC,0x1C0A,0x20EF,0x26C0, +0x2DAA,0x35E2,0x3FA5,0x4B41,0x590C,0x6971,0x7CED,0x9415, +/* A:04 B:09 */ +0x034A,0x036B,0x0393,0x03C2,0x03FA,0x043C,0x048B,0x04E9, +0x0558,0x05DD,0x067A,0x0735,0x0814,0x091C,0x0A56,0x0BCB, +0x0D87,0x0F97,0x1209,0x14F2,0x1868,0x1C84,0x2167,0x2735, +0x2E1C,0x3650,0x400F,0x4BA5,0x596A,0x69C7,0x7D3B,0x9458, +/* A:04 B:0a */ +0x03E9,0x040A,0x0431,0x0460,0x0498,0x04DA,0x0529,0x0587, +0x05F6,0x067A,0x0717,0x07D2,0x08B0,0x09B8,0x0AF1,0x0C66, +0x0E20,0x102F,0x12A0,0x1588,0x18FB,0x1D15,0x21F5,0x27C1, +0x2EA4,0x36D3,0x408D,0x4C1C,0x59DA,0x6A2E,0x7D97,0x94A8, +/* A:04 B:0b */ +0x04A5,0x04C7,0x04EE,0x051D,0x0554,0x0596,0x05E5,0x0642, +0x06B1,0x0735,0x07D2,0x088C,0x096A,0x0A71,0x0BA9,0x0D1D, +0x0ED7,0x10E4,0x1354,0x1639,0x19AA,0x1DC2,0x229F,0x2866, +0x2F45,0x376E,0x4122,0x4CAA,0x5A5F,0x6AA9,0x7E05,0x9507, +/* A:04 B:0c */ +0x0586,0x05A7,0x05CE,0x05FD,0x0634,0x0676,0x06C4,0x0721, +0x0790,0x0814,0x08B0,0x096A,0x0A46,0x0B4D,0x0C84,0x0DF7, +0x0FAF,0x11BB,0x1429,0x170C,0x1A7A,0x1E8F,0x2368,0x292B, +0x3004,0x3828,0x41D4,0x4D53,0x5AFD,0x6B3A,0x7E87,0x9577, +/* A:04 B:0d */ +0x0691,0x06B1,0x06D9,0x0707,0x073E,0x0780,0x07CE,0x082B, +0x0899,0x091C,0x09B8,0x0A71,0x0B4D,0x0C52,0x0D89,0x0EFA, +0x10B0,0x12BA,0x1526,0x1806,0x1B72,0x1F82,0x2457,0x2A15, +0x30E7,0x3903,0x42A7,0x4E1B,0x5BB9,0x6BE7,0x7F22,0x95FD, +/* A:04 B:0e */ +0x07CE,0x07EE,0x0815,0x0844,0x087B,0x08BC,0x090A,0x0966, +0x09D4,0x0A56,0x0AF1,0x0BA9,0x0C84,0x0D89,0x0EBE,0x102D, +0x11E2,0x13EA,0x1653,0x1930,0x1C98,0x20A4,0x2573,0x2B2A, +0x31F6,0x3A09,0x43A2,0x4F09,0x5C98,0x6CB4,0x7FDA,0x969C, +/* A:04 B:0f */ +0x0946,0x0967,0x098E,0x09BC,0x09F2,0x0A33,0x0A81,0x0ADD, +0x0B4A,0x0BCB,0x0C66,0x0D1D,0x0DF7,0x0EFA,0x102D,0x119B, +0x134E,0x1552,0x17B8,0x1A92,0x1DF5,0x21FC,0x26C5,0x2C75, +0x3337,0x3B40,0x44CC,0x5025,0x5DA1,0x6DA8,0x80B5,0x9759, +/* A:04 B:10 */ +0x0B06,0x0B26,0x0B4D,0x0B7B,0x0BB1,0x0BF2,0x0C3E,0x0C9A, +0x0D06,0x0D87,0x0E20,0x0ED7,0x0FAF,0x10B0,0x11E2,0x134E, +0x14FE,0x16FF,0x1961,0x1C36,0x1F94,0x2395,0x2856,0x2DFD, +0x34B5,0x3CB1,0x462E,0x5175,0x5EDC,0x6ECA,0x81B9,0x983A, +/* A:04 B:11 */ +0x0D1A,0x0D3A,0x0D60,0x0D8E,0x0DC4,0x0E04,0x0E50,0x0EAB, +0x0F17,0x0F97,0x102F,0x10E4,0x11BB,0x12BA,0x13EA,0x1552, +0x16FF,0x18FD,0x1B5A,0x1E2A,0x2182,0x257B,0x2A33,0x2FD0, +0x367B,0x3E68,0x47D3,0x5305,0x6053,0x7023,0x82EE,0x9944, +/* A:04 B:12 */ +0x0F93,0x0FB2,0x0FD8,0x1005,0x103B,0x107A,0x10C6,0x1120, +0x118B,0x1209,0x12A0,0x1354,0x1429,0x1526,0x1653,0x17B8, +0x1961,0x1B5A,0x1DB3,0x207C,0x23CC,0x27BC,0x2C6A,0x31FA, +0x3896,0x4071,0x49C7,0x54E0,0x6210,0x71BD,0x845E,0x9A82, +/* A:04 B:13 */ +0x1282,0x12A2,0x12C7,0x12F4,0x1329,0x1368,0x13B2,0x140B, +0x1475,0x14F2,0x1588,0x1639,0x170C,0x1806,0x1930,0x1A92, +0x1C36,0x1E2A,0x207C,0x233E,0x2686,0x2A6B,0x2F0C,0x348D, +0x3B17,0x42DD,0x4C1A,0x5715,0x6421,0x73A4,0x8612,0x9BFB, +/* A:04 B:14 */ +0x15FF,0x161F,0x1644,0x1670,0x16A4,0x16E2,0x172C,0x1784, +0x17EC,0x1868,0x18FB,0x19AA,0x1A7A,0x1B72,0x1C98,0x1DF5, +0x1F94,0x2182,0x23CC,0x2686,0x29C2,0x2D9B,0x322D,0x379C, +0x3E11,0x45BE,0x4EDD,0x59B4,0x6696,0x75E6,0x8819,0x9DBB, +/* A:04 B:15 */ +0x1A25,0x1A44,0x1A68,0x1A94,0x1AC7,0x1B04,0x1B4D,0x1BA3, +0x1C0A,0x1C84,0x1D15,0x1DC2,0x1E8F,0x1F82,0x20A4,0x21FC, +0x2395,0x257B,0x27BC,0x2A6B,0x2D9B,0x3164,0x35E5,0x3B3F, +0x419A,0x4929,0x5225,0x5CD2,0x6982,0x7896,0x8A82,0x9FCF, +/* A:04 B:16 */ +0x1F13,0x1F31,0x1F55,0x1F7F,0x1FB2,0x1FEE,0x2035,0x208A, +0x20EF,0x2167,0x21F5,0x229F,0x2368,0x2457,0x2573,0x26C5, +0x2856,0x2A33,0x2C6A,0x2F0C,0x322D,0x35E5,0x3A50,0x3F91, +0x45CF,0x4D3A,0x560B,0x6086,0x6CFA,0x7BC8,0x8D5F,0xA248, +/* A:04 B:17 */ +0x24EF,0x250C,0x252F,0x2559,0x258A,0x25C5,0x260B,0x265E, +0x26C0,0x2735,0x27C1,0x2866,0x292B,0x2A15,0x2B2A,0x2C75, +0x2DFD,0x2FD0,0x31FA,0x348D,0x379C,0x3B3F,0x3F91,0x44B3, +0x4ACE,0x520F,0x5AAE,0x64ED,0x711A,0x7F93,0x90C7,0xA538, +/* A:04 B:18 */ +0x2BE5,0x2C02,0x2C24,0x2C4C,0x2C7C,0x2CB6,0x2CF9,0x2D4A, +0x2DAA,0x2E1C,0x2EA4,0x2F45,0x3004,0x30E7,0x31F6,0x3337, +0x34B5,0x367B,0x3896,0x3B17,0x3E11,0x419A,0x45CF,0x4ACE, +0x50BE,0x57CD,0x6030,0x6A28,0x7601,0x8416,0x94D2,0xA8B6, +/* A:04 B:19 */ +0x342C,0x3447,0x3468,0x348F,0x34BE,0x34F5,0x3537,0x3585, +0x35E2,0x3650,0x36D3,0x376E,0x3828,0x3903,0x3A09,0x3B40, +0x3CB1,0x3E68,0x4071,0x42DD,0x45BE,0x4929,0x4D3A,0x520F, +0x57CD,0x5EA0,0x66BC,0x7060,0x7BD4,0x8972,0x99A1,0xACDD, +/* A:04 B:1a */ +0x3E01,0x3E1C,0x3E3C,0x3E61,0x3E8E,0x3EC3,0x3F02,0x3F4D, +0x3FA5,0x400F,0x408D,0x4122,0x41D4,0x42A7,0x43A2,0x44CC, +0x462E,0x47D3,0x49C7,0x4C1A,0x4EDD,0x5225,0x560B,0x5AAE, +0x6030,0x66BC,0x6E84,0x77C3,0x82C1,0x8FD1,0x9F58,0xB1CB, +/* A:04 B:1b */ +0x49B2,0x49CB,0x49E9,0x4A0D,0x4A37,0x4A69,0x4AA5,0x4AEC, +0x4B41,0x4BA5,0x4C1C,0x4CAA,0x4D53,0x4E1B,0x4F09,0x5025, +0x5175,0x5305,0x54E0,0x5715,0x59B4,0x5CD2,0x6086,0x64ED, +0x6A28,0x7060,0x77C3,0x808C,0x8AFC,0x9764,0xA622,0xB7A8, +/* A:04 B:1c */ +0x5796,0x57AE,0x57CA,0x57EB,0x5813,0x5842,0x587A,0x58BD, +0x590C,0x596A,0x59DA,0x5A5F,0x5AFD,0x5BB9,0x5C98,0x5DA1, +0x5EDC,0x6053,0x6210,0x6421,0x6696,0x6982,0x6CFA,0x711A, +0x7601,0x7BD4,0x82C1,0x8AFC,0x94C4,0xA064,0xAE34,0xBEA0, +/* A:04 B:1d */ +0x6819,0x682F,0x6849,0x6867,0x688C,0x68B7,0x68EB,0x6928, +0x6971,0x69C7,0x6A2E,0x6AA9,0x6B3A,0x6BE7,0x6CB4,0x6DA8, +0x6ECA,0x7023,0x71BD,0x73A4,0x75E6,0x7896,0x7BC8,0x7F93, +0x8416,0x8972,0x8FD1,0x9764,0xA064,0xAB16,0xB7CC,0xC6E8, +/* A:04 B:1e */ +0x7BB8,0x7BCC,0x7BE3,0x7BFF,0x7C1F,0x7C46,0x7C75,0x7CAC, +0x7CED,0x7D3B,0x7D97,0x7E05,0x7E87,0x7F22,0x7FDA,0x80B5, +0x81B9,0x82EE,0x845E,0x8612,0x8819,0x8A82,0x8D5F,0x90C7, +0x94D2,0x99A1,0x9F58,0xA622,0xAE34,0xB7CC,0xC333,0xD0C0, +/* A:04 B:1f */ +0x930B,0x931C,0x9330,0x9348,0x9364,0x9386,0x93AD,0x93DD, +0x9415,0x9458,0x94A8,0x9507,0x9577,0x95FD,0x969C,0x9759, +0x983A,0x9944,0x9A82,0x9BFB,0x9DBB,0x9FCF,0xA248,0xA538, +0xA8B6,0xACDD,0xB1CB,0xB7A8,0xBEA0,0xC6E8,0xD0C0,0xDC72, +/* A: 968D89C0 */ +/* A:05 B:00 */ +0x00F4,0x0116,0x013E,0x016D,0x01A5,0x01E8,0x0238,0x0296, +0x0307,0x038C,0x042B,0x04E8,0x05C8,0x06D2,0x080F,0x0987, +0x0B47,0x0D5A,0x0FD2,0x12C1,0x163E,0x1A63,0x1F4F,0x252A, +0x2C1E,0x3463,0x3E37,0x49E4,0x57C5,0x6844,0x7BE0,0x932D, +/* A:05 B:01 */ +0x0116,0x0137,0x015F,0x018F,0x01C7,0x020A,0x0259,0x02B8, +0x0328,0x03AE,0x044C,0x0509,0x05E9,0x06F3,0x0830,0x09A8, +0x0B67,0x0D7B,0x0FF2,0x12E1,0x165D,0x1A81,0x1F6D,0x2547, +0x2C3B,0x347F,0x3E51,0x49FD,0x57DD,0x685A,0x7BF3,0x933E, +/* A:05 B:02 */ +0x013E,0x015F,0x0187,0x01B6,0x01EF,0x0232,0x0281,0x02DF, +0x0350,0x03D5,0x0474,0x0530,0x0610,0x071A,0x0857,0x09CF, +0x0B8E,0x0DA1,0x1018,0x1306,0x1682,0x1AA6,0x1F91,0x256A, +0x2C5D,0x34A0,0x3E71,0x4A1B,0x57F9,0x6874,0x7C0A,0x9352, +/* A:05 B:03 */ +0x016D,0x018F,0x01B6,0x01E6,0x021E,0x0261,0x02B0,0x030F, +0x037F,0x0404,0x04A3,0x055F,0x063F,0x0749,0x0885,0x09FD, +0x0BBB,0x0DCE,0x1045,0x1333,0x16AE,0x1AD1,0x1FBC,0x2594, +0x2C86,0x34C7,0x3E96,0x4A3F,0x581A,0x6893,0x7C26,0x9369, +/* A:05 B:04 */ +0x01A5,0x01C7,0x01EF,0x021E,0x0256,0x0299,0x02E8,0x0347, +0x03B7,0x043C,0x04DA,0x0596,0x0676,0x0780,0x08BC,0x0A33, +0x0BF2,0x0E04,0x107A,0x1368,0x16E2,0x1B04,0x1FEE,0x25C5, +0x2CB6,0x34F5,0x3EC3,0x4A69,0x5842,0x68B7,0x7C46,0x9386, +/* A:05 B:05 */ +0x01E8,0x020A,0x0232,0x0261,0x0299,0x02DC,0x032B,0x0389, +0x03F9,0x047E,0x051C,0x05D8,0x06B8,0x07C2,0x08FD,0x0A74, +0x0C32,0x0E44,0x10BA,0x13A6,0x1720,0x1B41,0x202A,0x2600, +0x2CEF,0x352C,0x3EF8,0x4A9C,0x5871,0x68E3,0x7C6D,0x93A7, +/* A:05 B:06 */ +0x0238,0x0259,0x0281,0x02B0,0x02E8,0x032B,0x037A,0x03D8, +0x0448,0x04CD,0x056B,0x0627,0x0706,0x080F,0x094B,0x0AC2, +0x0C7F,0x0E90,0x1105,0x13F1,0x176A,0x1B8A,0x2071,0x2645, +0x2D32,0x356E,0x3F37,0x4AD7,0x58A9,0x6916,0x7C9C,0x93CF, +/* A:05 B:07 */ +0x0296,0x02B8,0x02DF,0x030F,0x0347,0x0389,0x03D8,0x0436, +0x04A6,0x052B,0x05C9,0x0684,0x0763,0x086C,0x09A7,0x0B1D, +0x0CDA,0x0EEB,0x115F,0x144A,0x17C2,0x1BE0,0x20C6,0x2698, +0x2D83,0x35BC,0x3F81,0x4B1E,0x58EC,0x6953,0x7CD2,0x93FE, +/* A:05 B:08 */ +0x0307,0x0328,0x0350,0x037F,0x03B7,0x03F9,0x0448,0x04A6, +0x0516,0x059A,0x0638,0x06F3,0x07D2,0x08DA,0x0A15,0x0B8A, +0x0D47,0x0F56,0x11CA,0x14B4,0x182A,0x1C47,0x212B,0x26FB, +0x2DE3,0x3619,0x3FDA,0x4B73,0x593B,0x699C,0x7D14,0x9437, +/* A:05 B:09 */ +0x038C,0x03AE,0x03D5,0x0404,0x043C,0x047E,0x04CD,0x052B, +0x059A,0x061F,0x06BC,0x0777,0x0855,0x095D,0x0A97,0x0C0C, +0x0DC7,0x0FD6,0x1249,0x1531,0x18A6,0x1CC1,0x21A3,0x2770, +0x2E55,0x3687,0x4044,0x4BD7,0x5999,0x69F3,0x7D61,0x947A, +/* A:05 B:0a */ +0x042B,0x044C,0x0474,0x04A3,0x04DA,0x051C,0x056B,0x05C9, +0x0638,0x06BC,0x0759,0x0813,0x08F1,0x09F9,0x0B32,0x0CA6, +0x0E61,0x106E,0x12DF,0x15C6,0x1939,0x1D52,0x2231,0x27FB, +0x2EDC,0x370A,0x40C1,0x4C4E,0x5A09,0x6A59,0x7DBE,0x94C9, +/* A:05 B:0b */ +0x04E8,0x0509,0x0530,0x055F,0x0596,0x05D8,0x0627,0x0684, +0x06F3,0x0777,0x0813,0x08CD,0x09AB,0x0AB2,0x0BEA,0x0D5D, +0x0F17,0x1123,0x1392,0x1677,0x19E8,0x1DFE,0x22DA,0x28A0, +0x2F7D,0x37A5,0x4157,0x4CDC,0x5A8D,0x6AD4,0x7E2B,0x9528, +/* A:05 B:0c */ +0x05C8,0x05E9,0x0610,0x063F,0x0676,0x06B8,0x0706,0x0763, +0x07D2,0x0855,0x08F1,0x09AB,0x0A87,0x0B8D,0x0CC5,0x0E37, +0x0FEF,0x11FA,0x1467,0x174A,0x1AB8,0x1ECB,0x23A3,0x2965, +0x303C,0x385E,0x4208,0x4D85,0x5B2B,0x6B65,0x7EAD,0x9598, +/* A:05 B:0d */ +0x06D2,0x06F3,0x071A,0x0749,0x0780,0x07C2,0x080F,0x086C, +0x08DA,0x095D,0x09F9,0x0AB2,0x0B8D,0x0C92,0x0DC9,0x0F3A, +0x10F0,0x12F9,0x1564,0x1844,0x1BAF,0x1FBE,0x2492,0x2A4E, +0x3120,0x393A,0x42DB,0x4E4D,0x5BE7,0x6C11,0x7F48,0x961E, +/* A:05 B:0e */ +0x080F,0x0830,0x0857,0x0885,0x08BC,0x08FD,0x094B,0x09A7, +0x0A15,0x0A97,0x0B32,0x0BEA,0x0CC5,0x0DC9,0x0EFE,0x106D, +0x1221,0x1428,0x1691,0x196E,0x1CD5,0x20E0,0x25AE,0x2B64, +0x322E,0x3A3F,0x43D5,0x4F3B,0x5CC6,0x6CDF,0x8000,0x96BD, +/* A:05 B:0f */ +0x0987,0x09A8,0x09CF,0x09FD,0x0A33,0x0A74,0x0AC2,0x0B1D, +0x0B8A,0x0C0C,0x0CA6,0x0D5D,0x0E37,0x0F3A,0x106D,0x11DA, +0x138D,0x1591,0x17F6,0x1ACF,0x1E32,0x2237,0x26FF,0x2CAE, +0x336F,0x3B75,0x44FF,0x5055,0x5DCF,0x6DD2,0x80DB,0x977A, +/* A:05 B:10 */ +0x0B47,0x0B67,0x0B8E,0x0BBB,0x0BF2,0x0C32,0x0C7F,0x0CDA, +0x0D47,0x0DC7,0x0E61,0x0F17,0x0FEF,0x10F0,0x1221,0x138D, +0x153C,0x173D,0x199F,0x1C73,0x1FD0,0x23D0,0x2890,0x2E36, +0x34EC,0x3CE6,0x4661,0x51A6,0x5F0A,0x6EF4,0x81DF,0x985A, +/* A:05 B:11 */ +0x0D5A,0x0D7B,0x0DA1,0x0DCE,0x0E04,0x0E44,0x0E90,0x0EEB, +0x0F56,0x0FD6,0x106E,0x1123,0x11FA,0x12F9,0x1428,0x1591, +0x173D,0x193A,0x1B97,0x1E67,0x21BE,0x25B5,0x2A6D,0x3008, +0x36B2,0x3E9D,0x4806,0x5335,0x6080,0x704D,0x8314,0x9965, +/* A:05 B:12 */ +0x0FD2,0x0FF2,0x1018,0x1045,0x107A,0x10BA,0x1105,0x115F, +0x11CA,0x1249,0x12DF,0x1392,0x1467,0x1564,0x1691,0x17F6, +0x199F,0x1B97,0x1DEF,0x20B8,0x2408,0x27F7,0x2CA3,0x3232, +0x38CC,0x40A6,0x49FA,0x5510,0x623D,0x71E6,0x8483,0x9AA2, +/* A:05 B:13 */ +0x12C1,0x12E1,0x1306,0x1333,0x1368,0x13A6,0x13F1,0x144A, +0x14B4,0x1531,0x15C6,0x1677,0x174A,0x1844,0x196E,0x1ACF, +0x1C73,0x1E67,0x20B8,0x237A,0x26C0,0x2AA4,0x2F45,0x34C4, +0x3B4D,0x4311,0x4C4C,0x5744,0x644E,0x73CC,0x8637,0x9C1A, +/* A:05 B:14 */ +0x163E,0x165D,0x1682,0x16AE,0x16E2,0x1720,0x176A,0x17C2, +0x182A,0x18A6,0x1939,0x19E8,0x1AB8,0x1BAF,0x1CD5,0x1E32, +0x1FD0,0x21BE,0x2408,0x26C0,0x29FC,0x2DD4,0x3265,0x37D2, +0x3E46,0x45F1,0x4F0E,0x59E3,0x66C2,0x760F,0x883D,0x9DDA, +/* A:05 B:15 */ +0x1A63,0x1A81,0x1AA6,0x1AD1,0x1B04,0x1B41,0x1B8A,0x1BE0, +0x1C47,0x1CC1,0x1D52,0x1DFE,0x1ECB,0x1FBE,0x20E0,0x2237, +0x23D0,0x25B5,0x27F7,0x2AA4,0x2DD4,0x319C,0x361C,0x3B74, +0x41CF,0x495C,0x5255,0x5D00,0x69AD,0x78BE,0x8AA6,0x9FEE, +/* A:05 B:16 */ +0x1F4F,0x1F6D,0x1F91,0x1FBC,0x1FEE,0x202A,0x2071,0x20C6, +0x212B,0x21A3,0x2231,0x22DA,0x23A3,0x2492,0x25AE,0x26FF, +0x2890,0x2A6D,0x2CA3,0x2F45,0x3265,0x361C,0x3A86,0x3FC5, +0x4602,0x4D6B,0x563B,0x60B3,0x6D24,0x7BEF,0x8D82,0xA266, +/* A:05 B:17 */ +0x252A,0x2547,0x256A,0x2594,0x25C5,0x2600,0x2645,0x2698, +0x26FB,0x2770,0x27FB,0x28A0,0x2965,0x2A4E,0x2B64,0x2CAE, +0x2E36,0x3008,0x3232,0x34C4,0x37D2,0x3B74,0x3FC5,0x44E7, +0x4B00,0x523F,0x5ADC,0x6519,0x7143,0x7FB9,0x90E9,0xA556, +/* A:05 B:18 */ +0x2C1E,0x2C3B,0x2C5D,0x2C86,0x2CB6,0x2CEF,0x2D32,0x2D83, +0x2DE3,0x2E55,0x2EDC,0x2F7D,0x303C,0x3120,0x322E,0x336F, +0x34EC,0x36B2,0x38CC,0x3B4D,0x3E46,0x41CF,0x4602,0x4B00, +0x50EF,0x57FC,0x605D,0x6A53,0x7629,0x843B,0x94F3,0xA8D3, +/* A:05 B:19 */ +0x3463,0x347F,0x34A0,0x34C7,0x34F5,0x352C,0x356E,0x35BC, +0x3619,0x3687,0x370A,0x37A5,0x385E,0x393A,0x3A3F,0x3B75, +0x3CE6,0x3E9D,0x40A6,0x4311,0x45F1,0x495C,0x4D6B,0x523F, +0x57FC,0x5ECD,0x66E8,0x7089,0x7BFB,0x8996,0x99C1,0xACF8, +/* A:05 B:1a */ +0x3E37,0x3E51,0x3E71,0x3E96,0x3EC3,0x3EF8,0x3F37,0x3F81, +0x3FDA,0x4044,0x40C1,0x4157,0x4208,0x42DB,0x43D5,0x44FF, +0x4661,0x4806,0x49FA,0x4C4C,0x4F0E,0x5255,0x563B,0x5ADC, +0x605D,0x66E8,0x6EAE,0x77EB,0x82E6,0x8FF3,0x9F76,0xB1E6, +/* A:05 B:1b */ +0x49E4,0x49FD,0x4A1B,0x4A3F,0x4A69,0x4A9C,0x4AD7,0x4B1E, +0x4B73,0x4BD7,0x4C4E,0x4CDC,0x4D85,0x4E4D,0x4F3B,0x5055, +0x51A6,0x5335,0x5510,0x5744,0x59E3,0x5D00,0x60B3,0x6519, +0x6A53,0x7089,0x77EB,0x80B1,0x8B1F,0x9784,0xA63F,0xB7C1, +/* A:05 B:1c */ +0x57C5,0x57DD,0x57F9,0x581A,0x5842,0x5871,0x58A9,0x58EC, +0x593B,0x5999,0x5A09,0x5A8D,0x5B2B,0x5BE7,0x5CC6,0x5DCF, +0x5F0A,0x6080,0x623D,0x644E,0x66C2,0x69AD,0x6D24,0x7143, +0x7629,0x7BFB,0x82E6,0x8B1F,0x94E5,0xA082,0xAE50,0xBEB7, +/* A:05 B:1d */ +0x6844,0x685A,0x6874,0x6893,0x68B7,0x68E3,0x6916,0x6953, +0x699C,0x69F3,0x6A59,0x6AD4,0x6B65,0x6C11,0x6CDF,0x6DD2, +0x6EF4,0x704D,0x71E6,0x73CC,0x760F,0x78BE,0x7BEF,0x7FB9, +0x843B,0x8996,0x8FF3,0x9784,0xA082,0xAB32,0xB7E5,0xC6FD, +/* A:05 B:1e */ +0x7BE0,0x7BF3,0x7C0A,0x7C26,0x7C46,0x7C6D,0x7C9C,0x7CD2, +0x7D14,0x7D61,0x7DBE,0x7E2B,0x7EAD,0x7F48,0x8000,0x80DB, +0x81DF,0x8314,0x8483,0x8637,0x883D,0x8AA6,0x8D82,0x90E9, +0x94F3,0x99C1,0x9F76,0xA63F,0xAE50,0xB7E5,0xC349,0xD0D3, +/* A:05 B:1f */ +0x932D,0x933E,0x9352,0x9369,0x9386,0x93A7,0x93CF,0x93FE, +0x9437,0x947A,0x94C9,0x9528,0x9598,0x961E,0x96BD,0x977A, +0x985A,0x9965,0x9AA2,0x9C1A,0x9DDA,0x9FEE,0xA266,0xA556, +0xA8D3,0xACF8,0xB1E6,0xB7C1,0xBEB7,0xC6FD,0xD0D3,0xDC82, +/* A: 968D89C0 */ +/* A:06 B:00 */ +0x0144,0x0166,0x018D,0x01BD,0x01F5,0x0238,0x0287,0x02E6, +0x0356,0x03DB,0x047A,0x0536,0x0616,0x0721,0x085D,0x09D5, +0x0B94,0x0DA7,0x101E,0x130C,0x1688,0x1AAB,0x1F97,0x2570, +0x2C63,0x34A5,0x3E76,0x4A20,0x57FE,0x6878,0x7C0E,0x9355, +/* A:06 B:01 */ +0x0166,0x0187,0x01AF,0x01DE,0x0216,0x0259,0x02A9,0x0307, +0x0377,0x03FD,0x049B,0x0558,0x0637,0x0741,0x087E,0x09F5, +0x0BB4,0x0DC7,0x103E,0x132C,0x16A7,0x1ACA,0x1FB5,0x258D, +0x2C7F,0x34C0,0x3E90,0x4A39,0x5815,0x688E,0x7C21,0x9366, +/* A:06 B:02 */ +0x018D,0x01AF,0x01D7,0x0206,0x023E,0x0281,0x02D0,0x032F, +0x039F,0x0424,0x04C3,0x057F,0x065F,0x0768,0x08A4,0x0A1C, +0x0BDB,0x0DED,0x1064,0x1351,0x16CC,0x1AEE,0x1FD9,0x25B0, +0x2CA1,0x34E1,0x3EB0,0x4A57,0x5831,0x68A8,0x7C38,0x937A, +/* A:06 B:03 */ +0x01BD,0x01DE,0x0206,0x0235,0x026D,0x02B0,0x0300,0x035E, +0x03CE,0x0453,0x04F1,0x05AD,0x068D,0x0797,0x08D3,0x0A4A, +0x0C08,0x0E1A,0x1091,0x137E,0x16F8,0x1B1A,0x2003,0x25D9, +0x2CC9,0x3508,0x3ED5,0x4A7B,0x5853,0x68C6,0x7C54,0x9391, +/* A:06 B:04 */ +0x01F5,0x0216,0x023E,0x026D,0x02A6,0x02E8,0x0338,0x0396, +0x0406,0x048B,0x0529,0x05E5,0x06C4,0x07CE,0x090A,0x0A81, +0x0C3E,0x0E50,0x10C6,0x13B2,0x172C,0x1B4D,0x2035,0x260B, +0x2CF9,0x3537,0x3F02,0x4AA5,0x587A,0x68EB,0x7C75,0x93AD, +/* A:06 B:05 */ +0x0238,0x0259,0x0281,0x02B0,0x02E8,0x032B,0x037A,0x03D8, +0x0448,0x04CD,0x056B,0x0627,0x0706,0x080F,0x094B,0x0AC2, +0x0C7F,0x0E90,0x1105,0x13F1,0x176A,0x1B8A,0x2071,0x2645, +0x2D32,0x356E,0x3F37,0x4AD7,0x58A9,0x6916,0x7C9C,0x93CF, +/* A:06 B:06 */ +0x0287,0x02A9,0x02D0,0x0300,0x0338,0x037A,0x03C9,0x0427, +0x0497,0x051C,0x05BA,0x0675,0x0754,0x085D,0x0998,0x0B0F, +0x0CCC,0x0EDC,0x1151,0x143C,0x17B4,0x1BD3,0x20B9,0x268B, +0x2D76,0x35AF,0x3F75,0x4B13,0x58E1,0x694A,0x7CCA,0x93F7, +/* A:06 B:07 */ +0x02E6,0x0307,0x032F,0x035E,0x0396,0x03D8,0x0427,0x0485, +0x04F5,0x0579,0x0617,0x06D3,0x07B1,0x08BA,0x09F4,0x0B6A, +0x0D27,0x0F37,0x11AB,0x1495,0x180B,0x1C29,0x210D,0x26DE, +0x2DC7,0x35FD,0x3FC0,0x4B5A,0x5924,0x6987,0x7D01,0x9426, +/* A:06 B:08 */ +0x0356,0x0377,0x039F,0x03CE,0x0406,0x0448,0x0497,0x04F5, +0x0564,0x05E9,0x0686,0x0741,0x0820,0x0928,0x0A62,0x0BD7, +0x0D93,0x0FA2,0x1215,0x14FE,0x1873,0x1C8F,0x2172,0x2740, +0x2E27,0x365A,0x4019,0x4BAE,0x5973,0x69CF,0x7D42,0x945E, +/* A:06 B:09 */ +0x03DB,0x03FD,0x0424,0x0453,0x048B,0x04CD,0x051C,0x0579, +0x05E9,0x066D,0x070A,0x07C5,0x08A3,0x09AB,0x0AE4,0x0C59, +0x0E14,0x1022,0x1294,0x157B,0x18EF,0x1D09,0x21EA,0x27B5, +0x2E98,0x36C8,0x4082,0x4C13,0x59D1,0x6A26,0x7D8F,0x94A1, +/* A:06 B:0a */ +0x047A,0x049B,0x04C3,0x04F1,0x0529,0x056B,0x05BA,0x0617, +0x0686,0x070A,0x07A7,0x0861,0x093F,0x0A46,0x0B7F,0x0CF3, +0x0EAD,0x10BA,0x132A,0x1610,0x1982,0x1D9A,0x2278,0x2840, +0x2F20,0x374B,0x4100,0x4C8A,0x5A40,0x6A8D,0x7DEB,0x94F1, +/* A:06 B:0b */ +0x0536,0x0558,0x057F,0x05AD,0x05E5,0x0627,0x0675,0x06D3, +0x0741,0x07C5,0x0861,0x091B,0x09F8,0x0AFF,0x0C37,0x0DAA, +0x0F63,0x116E,0x13DD,0x16C1,0x1A31,0x1E46,0x2321,0x28E5, +0x2FC0,0x37E6,0x4195,0x4D17,0x5AC5,0x6B07,0x7E59,0x954F, +/* A:06 B:0c */ +0x0616,0x0637,0x065F,0x068D,0x06C4,0x0706,0x0754,0x07B1, +0x0820,0x08A3,0x093F,0x09F8,0x0AD4,0x0BDA,0x0D11,0x0E83, +0x103B,0x1245,0x14B2,0x1794,0x1B00,0x1F13,0x23E9,0x29AA, +0x307F,0x389F,0x4246,0x4DC0,0x5B63,0x6B98,0x7EDB,0x95C0, +/* A:06 B:0d */ +0x0721,0x0741,0x0768,0x0797,0x07CE,0x080F,0x085D,0x08BA, +0x0928,0x09AB,0x0A46,0x0AFF,0x0BDA,0x0CDF,0x0E15,0x0F85, +0x113B,0x1344,0x15AE,0x188E,0x1BF7,0x2006,0x24D8,0x2A93, +0x3162,0x397A,0x4319,0x4E88,0x5C1E,0x6C44,0x7F76,0x9645, +/* A:06 B:0e */ +0x085D,0x087E,0x08A4,0x08D3,0x090A,0x094B,0x0998,0x09F4, +0x0A62,0x0AE4,0x0B7F,0x0C37,0x0D11,0x0E15,0x0F4A,0x10B9, +0x126D,0x1473,0x16DB,0x19B7,0x1D1D,0x2127,0x25F4,0x2BA8, +0x3270,0x3A7F,0x4413,0x4F75,0x5CFD,0x6D11,0x802D,0x96E4, +/* A:06 B:0f */ +0x09D5,0x09F5,0x0A1C,0x0A4A,0x0A81,0x0AC2,0x0B0F,0x0B6A, +0x0BD7,0x0C59,0x0CF3,0x0DAA,0x0E83,0x0F85,0x10B9,0x1226, +0x13D7,0x15DB,0x1840,0x1B18,0x1E79,0x227E,0x2745,0x2CF2, +0x33B1,0x3BB5,0x453C,0x5090,0x5E05,0x6E05,0x8108,0x97A0, +/* A:06 B:10 */ +0x0B94,0x0BB4,0x0BDB,0x0C08,0x0C3E,0x0C7F,0x0CCC,0x0D27, +0x0D93,0x0E14,0x0EAD,0x0F63,0x103B,0x113B,0x126D,0x13D7, +0x1586,0x1787,0x19E8,0x1CBC,0x2018,0x2416,0x28D5,0x2E79, +0x352E,0x3D26,0x469E,0x51DF,0x5F40,0x6F26,0x820B,0x9881, +/* A:06 B:11 */ +0x0DA7,0x0DC7,0x0DED,0x0E1A,0x0E50,0x0E90,0x0EDC,0x0F37, +0x0FA2,0x1022,0x10BA,0x116E,0x1245,0x1344,0x1473,0x15DB, +0x1787,0x1984,0x1BE0,0x1EAE,0x2204,0x25FB,0x2AB1,0x304B, +0x36F3,0x3EDC,0x4842,0x536E,0x60B6,0x707E,0x8340,0x998B, +/* A:06 B:12 */ +0x101E,0x103E,0x1064,0x1091,0x10C6,0x1105,0x1151,0x11AB, +0x1215,0x1294,0x132A,0x13DD,0x14B2,0x15AE,0x16DB,0x1840, +0x19E8,0x1BE0,0x1E37,0x20FF,0x244E,0x283C,0x2CE7,0x3274, +0x390D,0x40E4,0x4A36,0x5549,0x6272,0x7217,0x84AF,0x9AC7, +/* A:06 B:13 */ +0x130C,0x132C,0x1351,0x137E,0x13B2,0x13F1,0x143C,0x1495, +0x14FE,0x157B,0x1610,0x16C1,0x1794,0x188E,0x19B7,0x1B18, +0x1CBC,0x1EAE,0x20FF,0x23C0,0x2706,0x2AE9,0x2F88,0x3506, +0x3B8D,0x434F,0x4C87,0x577C,0x6482,0x73FD,0x8662,0x9C40, +/* A:06 B:14 */ +0x1688,0x16A7,0x16CC,0x16F8,0x172C,0x176A,0x17B4,0x180B, +0x1873,0x18EF,0x1982,0x1A31,0x1B00,0x1BF7,0x1D1D,0x1E79, +0x2018,0x2204,0x244E,0x2706,0x2A40,0x2E17,0x32A7,0x3813, +0x3E85,0x462E,0x4F48,0x5A1A,0x66F6,0x763F,0x8868,0x9DFF, +/* A:06 B:15 */ +0x1AAB,0x1ACA,0x1AEE,0x1B1A,0x1B4D,0x1B8A,0x1BD3,0x1C29, +0x1C8F,0x1D09,0x1D9A,0x1E46,0x1F13,0x2006,0x2127,0x227E, +0x2416,0x25FB,0x283C,0x2AE9,0x2E17,0x31DF,0x365D,0x3BB4, +0x420D,0x4998,0x528F,0x5D36,0x69E0,0x78ED,0x8AD0,0xA012, +/* A:06 B:16 */ +0x1F97,0x1FB5,0x1FD9,0x2003,0x2035,0x2071,0x20B9,0x210D, +0x2172,0x21EA,0x2278,0x2321,0x23E9,0x24D8,0x25F4,0x2745, +0x28D5,0x2AB1,0x2CE7,0x2F88,0x32A7,0x365D,0x3AC6,0x4004, +0x463F,0x4DA6,0x5673,0x60E9,0x6D57,0x7C1D,0x8DAC,0xA28A, +/* A:06 B:17 */ +0x2570,0x258D,0x25B0,0x25D9,0x260B,0x2645,0x268B,0x26DE, +0x2740,0x27B5,0x2840,0x28E5,0x29AA,0x2A93,0x2BA8,0x2CF2, +0x2E79,0x304B,0x3274,0x3506,0x3813,0x3BB4,0x4004,0x4524, +0x4B3B,0x5279,0x5B13,0x654D,0x7175,0x7FE6,0x9111,0xA579, +/* A:06 B:18 */ +0x2C63,0x2C7F,0x2CA1,0x2CC9,0x2CF9,0x2D32,0x2D76,0x2DC7, +0x2E27,0x2E98,0x2F20,0x2FC0,0x307F,0x3162,0x3270,0x33B1, +0x352E,0x36F3,0x390D,0x3B8D,0x3E85,0x420D,0x463F,0x4B3B, +0x5129,0x5834,0x6093,0x6A86,0x7659,0x8467,0x951B,0xA8F5, +/* A:06 B:19 */ +0x34A5,0x34C0,0x34E1,0x3508,0x3537,0x356E,0x35AF,0x35FD, +0x365A,0x36C8,0x374B,0x37E6,0x389F,0x397A,0x3A7F,0x3BB5, +0x3D26,0x3EDC,0x40E4,0x434F,0x462E,0x4998,0x4DA6,0x5279, +0x5834,0x5F03,0x671C,0x70BA,0x7C2A,0x89C0,0x99E7,0xAD19, +/* A:06 B:1a */ +0x3E76,0x3E90,0x3EB0,0x3ED5,0x3F02,0x3F37,0x3F75,0x3FC0, +0x4019,0x4082,0x4100,0x4195,0x4246,0x4319,0x4413,0x453C, +0x469E,0x4842,0x4A36,0x4C87,0x4F48,0x528F,0x5673,0x5B13, +0x6093,0x671C,0x6EE0,0x781A,0x8313,0x901C,0x9F9B,0xB205, +/* A:06 B:1b */ +0x4A20,0x4A39,0x4A57,0x4A7B,0x4AA5,0x4AD7,0x4B13,0x4B5A, +0x4BAE,0x4C13,0x4C8A,0x4D17,0x4DC0,0x4E88,0x4F75,0x5090, +0x51DF,0x536E,0x5549,0x577C,0x5A1A,0x5D36,0x60E9,0x654D, +0x6A86,0x70BA,0x781A,0x80DE,0x8B49,0x97AB,0xA662,0xB7DF, +/* A:06 B:1c */ +0x57FE,0x5815,0x5831,0x5853,0x587A,0x58A9,0x58E1,0x5924, +0x5973,0x59D1,0x5A40,0x5AC5,0x5B63,0x5C1E,0x5CFD,0x5E05, +0x5F40,0x60B6,0x6272,0x6482,0x66F6,0x69E0,0x6D57,0x7175, +0x7659,0x7C2A,0x8313,0x8B49,0x950C,0xA0A6,0xAE70,0xBED3, +/* A:06 B:1d */ +0x6878,0x688E,0x68A8,0x68C6,0x68EB,0x6916,0x694A,0x6987, +0x69CF,0x6A26,0x6A8D,0x6B07,0x6B98,0x6C44,0x6D11,0x6E05, +0x6F26,0x707E,0x7217,0x73FD,0x763F,0x78ED,0x7C1D,0x7FE6, +0x8467,0x89C0,0x901C,0x97AB,0xA0A6,0xAB53,0xB803,0xC717, +/* A:06 B:1e */ +0x7C0E,0x7C21,0x7C38,0x7C54,0x7C75,0x7C9C,0x7CCA,0x7D01, +0x7D42,0x7D8F,0x7DEB,0x7E59,0x7EDB,0x7F76,0x802D,0x8108, +0x820B,0x8340,0x84AF,0x8662,0x8868,0x8AD0,0x8DAC,0x9111, +0x951B,0x99E7,0x9F9B,0xA662,0xAE70,0xB803,0xC364,0xD0E9, +/* A:06 B:1f */ +0x9355,0x9366,0x937A,0x9391,0x93AD,0x93CF,0x93F7,0x9426, +0x945E,0x94A1,0x94F1,0x954F,0x95C0,0x9645,0x96E4,0x97A0, +0x9881,0x998B,0x9AC7,0x9C40,0x9DFF,0xA012,0xA28A,0xA579, +0xA8F5,0xAD19,0xB205,0xB7DF,0xBED3,0xC717,0xD0E9,0xDC96, +/* A: 968D89C0 */ +/* A:07 B:00 */ +0x01A3,0x01C4,0x01EC,0x021C,0x0254,0x0296,0x02E6,0x0344, +0x03B4,0x0439,0x04D8,0x0594,0x0674,0x077E,0x08B9,0x0A31, +0x0BEF,0x0E02,0x1078,0x1365,0x16E0,0x1B02,0x1FEC,0x25C3, +0x2CB3,0x34F3,0x3EC1,0x4A67,0x5840,0x68B6,0x7C45,0x9384, +/* A:07 B:01 */ +0x01C4,0x01E6,0x020E,0x023D,0x0275,0x02B8,0x0307,0x0365, +0x03D5,0x045B,0x04F9,0x05B5,0x0695,0x079E,0x08DA,0x0A51, +0x0C10,0x0E22,0x1098,0x1385,0x16FF,0x1B21,0x200A,0x25E0, +0x2CD0,0x350F,0x3EDB,0x4A81,0x5858,0x68CB,0x7C58,0x9395, +/* A:07 B:02 */ +0x01EC,0x020E,0x0235,0x0265,0x029D,0x02DF,0x032F,0x038D, +0x03FD,0x0482,0x0520,0x05DC,0x06BC,0x07C5,0x0901,0x0A78, +0x0C36,0x0E48,0x10BE,0x13AA,0x1724,0x1B45,0x202E,0x2603, +0x2CF2,0x352F,0x3EFB,0x4A9E,0x5874,0x68E5,0x7C70,0x93A9, +/* A:07 B:03 */ +0x021C,0x023D,0x0265,0x0294,0x02CC,0x030F,0x035E,0x03BC, +0x042C,0x04B1,0x054F,0x060B,0x06EA,0x07F4,0x092F,0x0AA6, +0x0C64,0x0E75,0x10EA,0x13D7,0x1750,0x1B70,0x2058,0x262C, +0x2D1A,0x3556,0x3F20,0x4AC2,0x5895,0x6904,0x7C8B,0x93C1, +/* A:07 B:04 */ +0x0254,0x0275,0x029D,0x02CC,0x0304,0x0347,0x0396,0x03F4, +0x0464,0x04E9,0x0587,0x0642,0x0721,0x082B,0x0966,0x0ADD, +0x0C9A,0x0EAB,0x1120,0x140B,0x1784,0x1BA3,0x208A,0x265E, +0x2D4A,0x3585,0x3F4D,0x4AEC,0x58BD,0x6928,0x7CAC,0x93DD, +/* A:07 B:05 */ +0x0296,0x02B8,0x02DF,0x030F,0x0347,0x0389,0x03D8,0x0436, +0x04A6,0x052B,0x05C9,0x0684,0x0763,0x086C,0x09A7,0x0B1D, +0x0CDA,0x0EEB,0x115F,0x144A,0x17C2,0x1BE0,0x20C6,0x2698, +0x2D83,0x35BC,0x3F81,0x4B1E,0x58EC,0x6953,0x7CD2,0x93FE, +/* A:07 B:06 */ +0x02E6,0x0307,0x032F,0x035E,0x0396,0x03D8,0x0427,0x0485, +0x04F5,0x0579,0x0617,0x06D3,0x07B1,0x08BA,0x09F4,0x0B6A, +0x0D27,0x0F37,0x11AB,0x1495,0x180B,0x1C29,0x210D,0x26DE, +0x2DC7,0x35FD,0x3FC0,0x4B5A,0x5924,0x6987,0x7D01,0x9426, +/* A:07 B:07 */ +0x0344,0x0365,0x038D,0x03BC,0x03F4,0x0436,0x0485,0x04E3, +0x0552,0x05D7,0x0674,0x0730,0x080E,0x0916,0x0A51,0x0BC6, +0x0D82,0x0F91,0x1204,0x14ED,0x1863,0x1C7F,0x2162,0x2730, +0x2E17,0x364B,0x400B,0x4BA1,0x5966,0x69C4,0x7D37,0x9456, +/* A:07 B:08 */ +0x03B4,0x03D5,0x03FD,0x042C,0x0464,0x04A6,0x04F5,0x0552, +0x05C2,0x0646,0x06E3,0x079E,0x087C,0x0984,0x0ABE,0x0C33, +0x0DEE,0x0FFD,0x126F,0x1556,0x18CB,0x1CE5,0x21C6,0x2793, +0x2E77,0x36A8,0x4063,0x4BF5,0x59B5,0x6A0C,0x7D78,0x948E, +/* A:07 B:09 */ +0x0439,0x045B,0x0482,0x04B1,0x04E9,0x052B,0x0579,0x05D7, +0x0646,0x06CA,0x0767,0x0822,0x08FF,0x0A07,0x0B40,0x0CB4, +0x0E6E,0x107C,0x12ED,0x15D4,0x1946,0x1D5F,0x223E,0x2807, +0x2EE8,0x3715,0x40CD,0x4C59,0x5A13,0x6A63,0x7DC6,0x94D1, +/* A:07 B:0a */ +0x04D8,0x04F9,0x0520,0x054F,0x0587,0x05C9,0x0617,0x0674, +0x06E3,0x0767,0x0804,0x08BE,0x099B,0x0AA2,0x0BDA,0x0D4E, +0x0F07,0x1114,0x1383,0x1668,0x19D9,0x1DF0,0x22CC,0x2892, +0x2F70,0x3798,0x414A,0x4CD0,0x5A82,0x6AC9,0x7E22,0x9520, +/* A:07 B:0b */ +0x0594,0x05B5,0x05DC,0x060B,0x0642,0x0684,0x06D3,0x0730, +0x079E,0x0822,0x08BE,0x0977,0x0A54,0x0B5A,0x0C92,0x0E05, +0x0FBD,0x11C8,0x1436,0x1719,0x1A88,0x1E9C,0x2374,0x2937, +0x3010,0x3833,0x41DF,0x4D5E,0x5B07,0x6B43,0x7E8F,0x957E, +/* A:07 B:0c */ +0x0674,0x0695,0x06BC,0x06EA,0x0721,0x0763,0x07B1,0x080E, +0x087C,0x08FF,0x099B,0x0A54,0x0B30,0x0C36,0x0D6C,0x0EDE, +0x1095,0x129E,0x150A,0x17EB,0x1B57,0x1F68,0x243D,0x29FB, +0x30CF,0x38EC,0x4290,0x4E06,0x5BA4,0x6BD4,0x7F11,0x95EE, +/* A:07 B:0d */ +0x077E,0x079E,0x07C5,0x07F4,0x082B,0x086C,0x08BA,0x0916, +0x0984,0x0A07,0x0AA2,0x0B5A,0x0C36,0x0D3A,0x0E70,0x0FE0, +0x1195,0x139D,0x1607,0x18E5,0x1C4E,0x205B,0x252B,0x2AE4, +0x31B1,0x39C7,0x4362,0x4ECD,0x5C5F,0x6C80,0x7FAC,0x9674, +/* A:07 B:0e */ +0x08B9,0x08DA,0x0901,0x092F,0x0966,0x09A7,0x09F4,0x0A51, +0x0ABE,0x0B40,0x0BDA,0x0C92,0x0D6C,0x0E70,0x0FA4,0x1112, +0x12C6,0x14CB,0x1733,0x1A0E,0x1D73,0x217B,0x2647,0x2BF9, +0x32BF,0x3ACB,0x445C,0x4FBB,0x5D3E,0x6D4D,0x8063,0x9712, +/* A:07 B:0f */ +0x0A31,0x0A51,0x0A78,0x0AA6,0x0ADD,0x0B1D,0x0B6A,0x0BC6, +0x0C33,0x0CB4,0x0D4E,0x0E05,0x0EDE,0x0FE0,0x1112,0x127F, +0x1430,0x1633,0x1897,0x1B6E,0x1ECF,0x22D2,0x2797,0x2D42, +0x33FF,0x3C01,0x4585,0x50D5,0x5E46,0x6E40,0x813D,0x97CF, +/* A:07 B:10 */ +0x0BEF,0x0C10,0x0C36,0x0C64,0x0C9A,0x0CDA,0x0D27,0x0D82, +0x0DEE,0x0E6E,0x0F07,0x0FBD,0x1095,0x1195,0x12C6,0x1430, +0x15DF,0x17DF,0x1A3F,0x1D12,0x206D,0x246A,0x2927,0x2ECA, +0x357C,0x3D71,0x46E6,0x5224,0x5F80,0x6F61,0x8241,0x98AE, +/* A:07 B:11 */ +0x0E02,0x0E22,0x0E48,0x0E75,0x0EAB,0x0EEB,0x0F37,0x0F91, +0x0FFD,0x107C,0x1114,0x11C8,0x129E,0x139D,0x14CB,0x1633, +0x17DF,0x19DB,0x1C36,0x1F04,0x2259,0x264E,0x2B03,0x309B, +0x3740,0x3F26,0x488A,0x53B3,0x60F6,0x70B9,0x8375,0x99B8, +/* A:07 B:12 */ +0x1078,0x1098,0x10BE,0x10EA,0x1120,0x115F,0x11AB,0x1204, +0x126F,0x12ED,0x1383,0x1436,0x150A,0x1607,0x1733,0x1897, +0x1A3F,0x1C36,0x1E8D,0x2154,0x24A1,0x288E,0x2D38,0x32C3, +0x395A,0x412E,0x4A7D,0x558C,0x62B2,0x7251,0x84E3,0x9AF5, +/* A:07 B:13 */ +0x1365,0x1385,0x13AA,0x13D7,0x140B,0x144A,0x1495,0x14ED, +0x1556,0x15D4,0x1668,0x1719,0x17EB,0x18E5,0x1A0E,0x1B6E, +0x1D12,0x1F04,0x2154,0x2414,0x2758,0x2B3A,0x2FD8,0x3554, +0x3BD9,0x4398,0x4CCE,0x57BF,0x64C1,0x7437,0x8696,0x9C6C, +/* A:07 B:14 */ +0x16E0,0x16FF,0x1724,0x1750,0x1784,0x17C2,0x180B,0x1863, +0x18CB,0x1946,0x19D9,0x1A88,0x1B57,0x1C4E,0x1D73,0x1ECF, +0x206D,0x2259,0x24A1,0x2758,0x2A92,0x2E67,0x32F6,0x3860, +0x3ED0,0x4677,0x4F8E,0x5A5C,0x6734,0x7677,0x889B,0x9E2B, +/* A:07 B:15 */ +0x1B02,0x1B21,0x1B45,0x1B70,0x1BA3,0x1BE0,0x1C29,0x1C7F, +0x1CE5,0x1D5F,0x1DF0,0x1E9C,0x1F68,0x205B,0x217B,0x22D2, +0x246A,0x264E,0x288E,0x2B3A,0x2E67,0x322E,0x36AB,0x3C00, +0x4257,0x49DF,0x52D3,0x5D77,0x6A1D,0x7925,0x8B02,0xA03E, +/* A:07 B:16 */ +0x1FEC,0x200A,0x202E,0x2058,0x208A,0x20C6,0x210D,0x2162, +0x21C6,0x223E,0x22CC,0x2374,0x243D,0x252B,0x2647,0x2797, +0x2927,0x2B03,0x2D38,0x2FD8,0x32F6,0x36AB,0x3B12,0x404F, +0x4687,0x4DED,0x56B6,0x6128,0x6D93,0x7C54,0x8DDD,0xA2B4, +/* A:07 B:17 */ +0x25C3,0x25E0,0x2603,0x262C,0x265E,0x2698,0x26DE,0x2730, +0x2793,0x2807,0x2892,0x2937,0x29FB,0x2AE4,0x2BF9,0x2D42, +0x2ECA,0x309B,0x32C3,0x3554,0x3860,0x3C00,0x404F,0x456D, +0x4B82,0x52BD,0x5B55,0x658C,0x71AF,0x801C,0x9141,0xA5A2, +/* A:07 B:18 */ +0x2CB3,0x2CD0,0x2CF2,0x2D1A,0x2D4A,0x2D83,0x2DC7,0x2E17, +0x2E77,0x2EE8,0x2F70,0x3010,0x30CF,0x31B1,0x32BF,0x33FF, +0x357C,0x3740,0x395A,0x3BD9,0x3ED0,0x4257,0x4687,0x4B82, +0x516E,0x5876,0x60D3,0x6AC3,0x7692,0x849B,0x954A,0xA91D, +/* A:07 B:19 */ +0x34F3,0x350F,0x352F,0x3556,0x3585,0x35BC,0x35FD,0x364B, +0x36A8,0x3715,0x3798,0x3833,0x38EC,0x39C7,0x3ACB,0x3C01, +0x3D71,0x3F26,0x412E,0x4398,0x4677,0x49DF,0x4DED,0x52BD, +0x5876,0x5F44,0x6759,0x70F5,0x7C60,0x89F3,0x9A14,0xAD40, +/* A:07 B:1a */ +0x3EC1,0x3EDB,0x3EFB,0x3F20,0x3F4D,0x3F81,0x3FC0,0x400B, +0x4063,0x40CD,0x414A,0x41DF,0x4290,0x4362,0x445C,0x4585, +0x46E6,0x488A,0x4A7D,0x4CCE,0x4F8E,0x52D3,0x56B6,0x5B55, +0x60D3,0x6759,0x6F1B,0x7853,0x8347,0x904D,0x9FC6,0xB22B, +/* A:07 B:1b */ +0x4A67,0x4A81,0x4A9E,0x4AC2,0x4AEC,0x4B1E,0x4B5A,0x4BA1, +0x4BF5,0x4C59,0x4CD0,0x4D5E,0x4E06,0x4ECD,0x4FBB,0x50D5, +0x5224,0x53B3,0x558C,0x57BF,0x5A5C,0x5D77,0x6128,0x658C, +0x6AC3,0x70F5,0x7853,0x8114,0x8B7B,0x97D9,0xA68B,0xB802, +/* A:07 B:1c */ +0x5840,0x5858,0x5874,0x5895,0x58BD,0x58EC,0x5924,0x5966, +0x59B5,0x5A13,0x5A82,0x5B07,0x5BA4,0x5C5F,0x5D3E,0x5E46, +0x5F80,0x60F6,0x62B2,0x64C1,0x6734,0x6A1D,0x6D93,0x71AF, +0x7692,0x7C60,0x8347,0x8B7B,0x953B,0xA0D1,0xAE96,0xBEF4, +/* A:07 B:1d */ +0x68B6,0x68CB,0x68E5,0x6904,0x6928,0x6953,0x6987,0x69C4, +0x6A0C,0x6A63,0x6AC9,0x6B43,0x6BD4,0x6C80,0x6D4D,0x6E40, +0x6F61,0x70B9,0x7251,0x7437,0x7677,0x7925,0x7C54,0x801C, +0x849B,0x89F3,0x904D,0x97D9,0xA0D1,0xAB7A,0xB826,0xC735, +/* A:07 B:1e */ +0x7C45,0x7C58,0x7C70,0x7C8B,0x7CAC,0x7CD2,0x7D01,0x7D37, +0x7D78,0x7DC6,0x7E22,0x7E8F,0x7F11,0x7FAC,0x8063,0x813D, +0x8241,0x8375,0x84E3,0x8696,0x889B,0x8B02,0x8DDD,0x9141, +0x954A,0x9A14,0x9FC6,0xA68B,0xAE96,0xB826,0xC383,0xD104, +/* A:07 B:1f */ +0x9384,0x9395,0x93A9,0x93C1,0x93DD,0x93FE,0x9426,0x9456, +0x948E,0x94D1,0x9520,0x957E,0x95EE,0x9674,0x9712,0x97CF, +0x98AE,0x99B8,0x9AF5,0x9C6C,0x9E2B,0xA03E,0xA2B4,0xA5A2, +0xA91D,0xAD40,0xB22B,0xB802,0xBEF4,0xC735,0xD104,0xDCAD, +/* A: 968D89C0 */ +/* A:08 B:00 */ +0x0214,0x0235,0x025D,0x028C,0x02C4,0x0307,0x0356,0x03B4, +0x0424,0x04A9,0x0547,0x0603,0x06E3,0x07EC,0x0927,0x0A9E, +0x0C5C,0x0E6E,0x10E3,0x13CF,0x1748,0x1B69,0x2051,0x2626, +0x2D14,0x3550,0x3F1A,0x4ABC,0x5890,0x68FF,0x7C86,0x93BD, +/* A:08 B:01 */ +0x0235,0x0257,0x027E,0x02AD,0x02E5,0x0328,0x0377,0x03D5, +0x0445,0x04CA,0x0568,0x0624,0x0703,0x080D,0x0948,0x0ABF, +0x0C7C,0x0E8E,0x1103,0x13EF,0x1767,0x1B88,0x206F,0x2643, +0x2D30,0x356C,0x3F34,0x4AD5,0x58A7,0x6914,0x7C9A,0x93CE, +/* A:08 B:02 */ +0x025D,0x027E,0x02A6,0x02D5,0x030D,0x0350,0x039F,0x03FD, +0x046D,0x04F2,0x0590,0x064B,0x072B,0x0834,0x096F,0x0AE5, +0x0CA3,0x0EB4,0x1129,0x1414,0x178C,0x1BAC,0x2092,0x2666, +0x2D52,0x358C,0x3F54,0x4AF3,0x58C3,0x692E,0x7CB1,0x93E2, +/* A:08 B:03 */ +0x028C,0x02AD,0x02D5,0x0304,0x033C,0x037F,0x03CE,0x042C, +0x049C,0x0520,0x05BE,0x067A,0x0759,0x0862,0x099D,0x0B13, +0x0CD0,0x0EE1,0x1155,0x1440,0x17B8,0x1BD7,0x20BD,0x268F, +0x2D7A,0x35B3,0x3F79,0x4B17,0x58E4,0x694D,0x7CCC,0x93F9, +/* A:08 B:04 */ +0x02C4,0x02E5,0x030D,0x033C,0x0374,0x03B7,0x0406,0x0464, +0x04D3,0x0558,0x05F6,0x06B1,0x0790,0x0899,0x09D4,0x0B4A, +0x0D06,0x0F17,0x118B,0x1475,0x17EC,0x1C0A,0x20EF,0x26C0, +0x2DAA,0x35E2,0x3FA5,0x4B41,0x590C,0x6971,0x7CED,0x9415, +/* A:08 B:05 */ +0x0307,0x0328,0x0350,0x037F,0x03B7,0x03F9,0x0448,0x04A6, +0x0516,0x059A,0x0638,0x06F3,0x07D2,0x08DA,0x0A15,0x0B8A, +0x0D47,0x0F56,0x11CA,0x14B4,0x182A,0x1C47,0x212B,0x26FB, +0x2DE3,0x3619,0x3FDA,0x4B73,0x593B,0x699C,0x7D14,0x9437, +/* A:08 B:06 */ +0x0356,0x0377,0x039F,0x03CE,0x0406,0x0448,0x0497,0x04F5, +0x0564,0x05E9,0x0686,0x0741,0x0820,0x0928,0x0A62,0x0BD7, +0x0D93,0x0FA2,0x1215,0x14FE,0x1873,0x1C8F,0x2172,0x2740, +0x2E27,0x365A,0x4019,0x4BAE,0x5973,0x69CF,0x7D42,0x945E, +/* A:08 B:07 */ +0x03B4,0x03D5,0x03FD,0x042C,0x0464,0x04A6,0x04F5,0x0552, +0x05C2,0x0646,0x06E3,0x079E,0x087C,0x0984,0x0ABE,0x0C33, +0x0DEE,0x0FFD,0x126F,0x1556,0x18CB,0x1CE5,0x21C6,0x2793, +0x2E77,0x36A8,0x4063,0x4BF5,0x59B5,0x6A0C,0x7D78,0x948E, +/* A:08 B:08 */ +0x0424,0x0445,0x046D,0x049C,0x04D3,0x0516,0x0564,0x05C2, +0x0631,0x06B5,0x0752,0x080D,0x08EA,0x09F2,0x0B2B,0x0C9F, +0x0E5A,0x1068,0x12D9,0x15C0,0x1932,0x1D4C,0x222B,0x27F5, +0x2ED6,0x3704,0x40BC,0x4C49,0x5A04,0x6A55,0x7DB9,0x94C6, +/* A:08 B:09 */ +0x04A9,0x04CA,0x04F2,0x0520,0x0558,0x059A,0x05E9,0x0646, +0x06B5,0x0739,0x07D6,0x0890,0x096D,0x0A74,0x0BAD,0x0D21, +0x0EDA,0x10E7,0x1357,0x163D,0x19AE,0x1DC5,0x22A2,0x2869, +0x2F48,0x3772,0x4125,0x4CAD,0x5A61,0x6AAB,0x7E07,0x9509, +/* A:08 B:0a */ +0x0547,0x0568,0x0590,0x05BE,0x05F6,0x0638,0x0686,0x06E3, +0x0752,0x07D6,0x0872,0x092C,0x0A09,0x0B0F,0x0C47,0x0DBA, +0x0F73,0x117F,0x13ED,0x16D1,0x1A40,0x1E56,0x2330,0x28F4, +0x2FCF,0x37F4,0x41A2,0x4D24,0x5AD1,0x6B12,0x7E63,0x9558, +/* A:08 B:0b */ +0x0603,0x0624,0x064B,0x067A,0x06B1,0x06F3,0x0741,0x079E, +0x080D,0x0890,0x092C,0x09E5,0x0AC2,0x0BC7,0x0CFF,0x0E70, +0x1028,0x1233,0x14A0,0x1782,0x1AEF,0x1F01,0x23D8,0x2999, +0x306F,0x388F,0x4237,0x4DB1,0x5B55,0x6B8B,0x7ED0,0x95B6, +/* A:08 B:0c */ +0x06E3,0x0703,0x072B,0x0759,0x0790,0x07D2,0x0820,0x087C, +0x08EA,0x096D,0x0A09,0x0AC2,0x0B9D,0x0CA2,0x0DD9,0x0F49, +0x1100,0x1308,0x1574,0x1853,0x1BBE,0x1FCD,0x24A0,0x2A5C, +0x312D,0x3947,0x42E8,0x4E59,0x5BF2,0x6C1C,0x7F52,0x9626, +/* A:08 B:0d */ +0x07EC,0x080D,0x0834,0x0862,0x0899,0x08DA,0x0928,0x0984, +0x09F2,0x0A74,0x0B0F,0x0BC7,0x0CA2,0x0DA6,0x0EDC,0x104B, +0x1200,0x1407,0x1670,0x194D,0x1CB4,0x20C0,0x258E,0x2B45, +0x3210,0x3A22,0x43BA,0x4F20,0x5CAD,0x6CC8,0x7FEC,0x96AB, +/* A:08 B:0e */ +0x0927,0x0948,0x096F,0x099D,0x09D4,0x0A15,0x0A62,0x0ABE, +0x0B2B,0x0BAD,0x0C47,0x0CFF,0x0DD9,0x0EDC,0x100F,0x117D, +0x1330,0x1535,0x179B,0x1A75,0x1DD9,0x21E0,0x26A9,0x2C5A, +0x331D,0x3B26,0x44B3,0x500D,0x5D8B,0x6D94,0x80A3,0x9749, +/* A:08 B:0f */ +0x0A9E,0x0ABF,0x0AE5,0x0B13,0x0B4A,0x0B8A,0x0BD7,0x0C33, +0x0C9F,0x0D21,0x0DBA,0x0E70,0x0F49,0x104B,0x117D,0x12E9, +0x149A,0x169C,0x18FF,0x1BD5,0x1F34,0x2336,0x27F9,0x2DA2, +0x345C,0x3C5B,0x45DC,0x5127,0x5E93,0x6E87,0x817D,0x9805, +/* A:08 B:10 */ +0x0C5C,0x0C7C,0x0CA3,0x0CD0,0x0D06,0x0D47,0x0D93,0x0DEE, +0x0E5A,0x0EDA,0x0F73,0x1028,0x1100,0x1200,0x1330,0x149A, +0x1648,0x1847,0x1AA6,0x1D78,0x20D2,0x24CD,0x2989,0x2F29, +0x35D9,0x3DCB,0x473C,0x5276,0x5FCD,0x6FA8,0x8280,0x98E5, +/* A:08 B:11 */ +0x0E6E,0x0E8E,0x0EB4,0x0EE1,0x0F17,0x0F56,0x0FA2,0x0FFD, +0x1068,0x10E7,0x117F,0x1233,0x1308,0x1407,0x1535,0x169C, +0x1847,0x1A42,0x1C9D,0x1F69,0x22BD,0x26B1,0x2B64,0x30F9, +0x379C,0x3F7F,0x48DF,0x5404,0x6142,0x70FF,0x83B3,0x99EE, +/* A:08 B:12 */ +0x10E3,0x1103,0x1129,0x1155,0x118B,0x11CA,0x1215,0x126F, +0x12D9,0x1357,0x13ED,0x14A0,0x1574,0x1670,0x179B,0x18FF, +0x1AA6,0x1C9D,0x1EF2,0x21B8,0x2505,0x28F0,0x2D98,0x3321, +0x39B5,0x4187,0x4AD1,0x55DD,0x62FD,0x7297,0x8521,0x9B2A, +/* A:08 B:13 */ +0x13CF,0x13EF,0x1414,0x1440,0x1475,0x14B4,0x14FE,0x1556, +0x15C0,0x163D,0x16D1,0x1782,0x1853,0x194D,0x1A75,0x1BD5, +0x1D78,0x1F69,0x21B8,0x2477,0x27BA,0x2B9B,0x3037,0x35B1, +0x3C33,0x43EF,0x4D21,0x580F,0x650C,0x747B,0x86D4,0x9CA1, +/* A:08 B:14 */ +0x1748,0x1767,0x178C,0x17B8,0x17EC,0x182A,0x1873,0x18CB, +0x1932,0x19AE,0x1A40,0x1AEF,0x1BBE,0x1CB4,0x1DD9,0x1F34, +0x20D2,0x22BD,0x2505,0x27BA,0x2AF3,0x2EC7,0x3354,0x38BC, +0x3F29,0x46CD,0x4FE1,0x5AAB,0x677E,0x76BB,0x88D8,0x9E5F, +/* A:08 B:15 */ +0x1B69,0x1B88,0x1BAC,0x1BD7,0x1C0A,0x1C47,0x1C8F,0x1CE5, +0x1D4C,0x1DC5,0x1E56,0x1F01,0x1FCD,0x20C0,0x21E0,0x2336, +0x24CD,0x26B1,0x28F0,0x2B9B,0x2EC7,0x328C,0x3707,0x3C5A, +0x42AE,0x4A34,0x5325,0x5DC5,0x6A65,0x7968,0x8B3E,0xA071, +/* A:08 B:16 */ +0x2051,0x206F,0x2092,0x20BD,0x20EF,0x212B,0x2172,0x21C6, +0x222B,0x22A2,0x2330,0x23D8,0x24A0,0x258E,0x26A9,0x27F9, +0x2989,0x2B64,0x2D98,0x3037,0x3354,0x3707,0x3B6D,0x40A7, +0x46DE,0x4E40,0x5706,0x6174,0x6DDA,0x7C95,0x8E18,0xA2E7, +/* A:08 B:17 */ +0x2626,0x2643,0x2666,0x268F,0x26C0,0x26FB,0x2740,0x2793, +0x27F5,0x2869,0x28F4,0x2999,0x2A5C,0x2B45,0x2C5A,0x2DA2, +0x2F29,0x30F9,0x3321,0x35B1,0x38BC,0x3C5A,0x40A7,0x45C4, +0x4BD7,0x530F,0x5BA3,0x65D6,0x71F4,0x805C,0x917B,0xA5D3, +/* A:08 B:18 */ +0x2D14,0x2D30,0x2D52,0x2D7A,0x2DAA,0x2DE3,0x2E27,0x2E77, +0x2ED6,0x2F48,0x2FCF,0x306F,0x312D,0x3210,0x331D,0x345C, +0x35D9,0x379C,0x39B5,0x3C33,0x3F29,0x42AE,0x46DE,0x4BD7, +0x51BF,0x58C6,0x611F,0x6B0B,0x76D5,0x84D9,0x9581,0xA94D, +/* A:08 B:19 */ +0x3550,0x356C,0x358C,0x35B3,0x35E2,0x3619,0x365A,0x36A8, +0x3704,0x3772,0x37F4,0x388F,0x3947,0x3A22,0x3B26,0x3C5B, +0x3DCB,0x3F7F,0x4187,0x43EF,0x46CD,0x4A34,0x4E40,0x530F, +0x58C6,0x5F90,0x67A3,0x713B,0x7CA2,0x8A2F,0x9A4A,0xAD6E, +/* A:08 B:1a */ +0x3F1A,0x3F34,0x3F54,0x3F79,0x3FA5,0x3FDA,0x4019,0x4063, +0x40BC,0x4125,0x41A2,0x4237,0x42E8,0x43BA,0x44B3,0x45DC, +0x473C,0x48DF,0x4AD1,0x4D21,0x4FE1,0x5325,0x5706,0x5BA3, +0x611F,0x67A3,0x6F61,0x7895,0x8386,0x9086,0x9FFA,0xB257, +/* A:08 B:1b */ +0x4ABC,0x4AD5,0x4AF3,0x4B17,0x4B41,0x4B73,0x4BAE,0x4BF5, +0x4C49,0x4CAD,0x4D24,0x4DB1,0x4E59,0x4F20,0x500D,0x5127, +0x5276,0x5404,0x55DD,0x580F,0x5AAB,0x5DC5,0x6174,0x65D6, +0x6B0B,0x713B,0x7895,0x8153,0x8BB7,0x980F,0xA6BC,0xB82C, +/* A:08 B:1c */ +0x5890,0x58A7,0x58C3,0x58E4,0x590C,0x593B,0x5973,0x59B5, +0x5A04,0x5A61,0x5AD1,0x5B55,0x5BF2,0x5CAD,0x5D8B,0x5E93, +0x5FCD,0x6142,0x62FD,0x650C,0x677E,0x6A65,0x6DDA,0x71F4, +0x76D5,0x7CA2,0x8386,0x8BB7,0x9572,0xA104,0xAEC4,0xBF1C, +/* A:08 B:1d */ +0x68FF,0x6914,0x692E,0x694D,0x6971,0x699C,0x69CF,0x6A0C, +0x6A55,0x6AAB,0x6B12,0x6B8B,0x6C1C,0x6CC8,0x6D94,0x6E87, +0x6FA8,0x70FF,0x7297,0x747B,0x76BB,0x7968,0x7C95,0x805C, +0x84D9,0x8A2F,0x9086,0x980F,0xA104,0xABA9,0xB850,0xC759, +/* A:08 B:1e */ +0x7C86,0x7C9A,0x7CB1,0x7CCC,0x7CED,0x7D14,0x7D42,0x7D78, +0x7DB9,0x7E07,0x7E63,0x7ED0,0x7F52,0x7FEC,0x80A3,0x817D, +0x8280,0x83B3,0x8521,0x86D4,0x88D8,0x8B3E,0x8E18,0x917B, +0x9581,0x9A4A,0x9FFA,0xA6BC,0xAEC4,0xB850,0xC3A8,0xD124, +/* A:08 B:1f */ +0x93BD,0x93CE,0x93E2,0x93F9,0x9415,0x9437,0x945E,0x948E, +0x94C6,0x9509,0x9558,0x95B6,0x9626,0x96AB,0x9749,0x9805, +0x98E5,0x99EE,0x9B2A,0x9CA1,0x9E5F,0xA071,0xA2E7,0xA5D3, +0xA94D,0xAD6E,0xB257,0xB82C,0xBF1C,0xC759,0xD124,0xDCC8, +/* A: 968D89C0 */ +/* A:09 B:00 */ +0x029A,0x02BB,0x02E3,0x0312,0x034A,0x038C,0x03DB,0x0439, +0x04A9,0x052E,0x05CC,0x0687,0x0766,0x086F,0x09AA,0x0B20, +0x0CDD,0x0EEE,0x1162,0x144D,0x17C5,0x1BE3,0x20C9,0x269B, +0x2D86,0x35BF,0x3F84,0x4B21,0x58EE,0x6955,0x7CD4,0x9400, +/* A:09 B:01 */ +0x02BB,0x02DC,0x0304,0x0333,0x036B,0x03AE,0x03FD,0x045B, +0x04CA,0x054F,0x05ED,0x06A8,0x0787,0x0890,0x09CB,0x0B41, +0x0CFD,0x0F0E,0x1182,0x146C,0x17E3,0x1C02,0x20E7,0x26B8, +0x2DA2,0x35DA,0x3F9E,0x4B3A,0x5906,0x696B,0x7CE8,0x9411, +/* A:09 B:02 */ +0x02E3,0x0304,0x032C,0x035B,0x0393,0x03D5,0x0424,0x0482, +0x04F2,0x0576,0x0614,0x06CF,0x07AE,0x08B7,0x09F1,0x0B67, +0x0D24,0x0F34,0x11A8,0x1492,0x1808,0x1C26,0x210A,0x26DB, +0x2DC4,0x35FB,0x3FBE,0x4B58,0x5921,0x6985,0x7CFF,0x9425, +/* A:09 B:03 */ +0x0312,0x0333,0x035B,0x038A,0x03C2,0x0404,0x0453,0x04B1, +0x0520,0x05A5,0x0643,0x06FE,0x07DC,0x08E5,0x0A1F,0x0B95, +0x0D51,0x0F61,0x11D4,0x14BE,0x1834,0x1C51,0x2135,0x2704, +0x2DEC,0x3622,0x3FE3,0x4B7B,0x5943,0x69A3,0x7D1A,0x943C, +/* A:09 B:04 */ +0x034A,0x036B,0x0393,0x03C2,0x03FA,0x043C,0x048B,0x04E9, +0x0558,0x05DD,0x067A,0x0735,0x0814,0x091C,0x0A56,0x0BCB, +0x0D87,0x0F97,0x1209,0x14F2,0x1868,0x1C84,0x2167,0x2735, +0x2E1C,0x3650,0x400F,0x4BA5,0x596A,0x69C7,0x7D3B,0x9458, +/* A:09 B:05 */ +0x038C,0x03AE,0x03D5,0x0404,0x043C,0x047E,0x04CD,0x052B, +0x059A,0x061F,0x06BC,0x0777,0x0855,0x095D,0x0A97,0x0C0C, +0x0DC7,0x0FD6,0x1249,0x1531,0x18A6,0x1CC1,0x21A3,0x2770, +0x2E55,0x3687,0x4044,0x4BD7,0x5999,0x69F3,0x7D61,0x947A, +/* A:09 B:06 */ +0x03DB,0x03FD,0x0424,0x0453,0x048B,0x04CD,0x051C,0x0579, +0x05E9,0x066D,0x070A,0x07C5,0x08A3,0x09AB,0x0AE4,0x0C59, +0x0E14,0x1022,0x1294,0x157B,0x18EF,0x1D09,0x21EA,0x27B5, +0x2E98,0x36C8,0x4082,0x4C13,0x59D1,0x6A26,0x7D8F,0x94A1, +/* A:09 B:07 */ +0x0439,0x045B,0x0482,0x04B1,0x04E9,0x052B,0x0579,0x05D7, +0x0646,0x06CA,0x0767,0x0822,0x08FF,0x0A07,0x0B40,0x0CB4, +0x0E6E,0x107C,0x12ED,0x15D4,0x1946,0x1D5F,0x223E,0x2807, +0x2EE8,0x3715,0x40CD,0x4C59,0x5A13,0x6A63,0x7DC6,0x94D1, +/* A:09 B:08 */ +0x04A9,0x04CA,0x04F2,0x0520,0x0558,0x059A,0x05E9,0x0646, +0x06B5,0x0739,0x07D6,0x0890,0x096D,0x0A74,0x0BAD,0x0D21, +0x0EDA,0x10E7,0x1357,0x163D,0x19AE,0x1DC5,0x22A2,0x2869, +0x2F48,0x3772,0x4125,0x4CAD,0x5A61,0x6AAB,0x7E07,0x9509, +/* A:09 B:09 */ +0x052E,0x054F,0x0576,0x05A5,0x05DD,0x061F,0x066D,0x06CA, +0x0739,0x07BC,0x0859,0x0913,0x09F0,0x0AF6,0x0C2F,0x0DA1, +0x0F5A,0x1166,0x13D5,0x16B9,0x1A29,0x1E3E,0x2319,0x28DE, +0x2FB9,0x37DF,0x418E,0x4D11,0x5ABF,0x6B01,0x7E54,0x954B, +/* A:09 B:0a */ +0x05CC,0x05ED,0x0614,0x0643,0x067A,0x06BC,0x070A,0x0767, +0x07D6,0x0859,0x08F5,0x09AF,0x0A8B,0x0B91,0x0CC9,0x0E3B, +0x0FF3,0x11FE,0x146B,0x174E,0x1ABB,0x1ECF,0x23A7,0x2968, +0x3040,0x3861,0x420B,0x4D87,0x5B2E,0x6B67,0x7EB0,0x959A, +/* A:09 B:0b */ +0x0687,0x06A8,0x06CF,0x06FE,0x0735,0x0777,0x07C5,0x0822, +0x0890,0x0913,0x09AF,0x0A68,0x0B44,0x0C49,0x0D80,0x0EF1, +0x10A8,0x12B1,0x151D,0x17FE,0x1B69,0x1F7A,0x244F,0x2A0D, +0x30E0,0x38FC,0x42A0,0x4E14,0x5BB2,0x6BE1,0x7F1D,0x95F8, +/* A:09 B:0c */ +0x0766,0x0787,0x07AE,0x07DC,0x0814,0x0855,0x08A3,0x08FF, +0x096D,0x09F0,0x0A8B,0x0B44,0x0C1F,0x0D23,0x0E59,0x0FC9, +0x117F,0x1387,0x15F1,0x18CF,0x1C38,0x2046,0x2517,0x2AD0, +0x319E,0x39B4,0x4350,0x4EBC,0x5C4F,0x6C71,0x7F9E,0x9668, +/* A:09 B:0d */ +0x086F,0x0890,0x08B7,0x08E5,0x091C,0x095D,0x09AB,0x0A07, +0x0A74,0x0AF6,0x0B91,0x0C49,0x0D23,0x0E27,0x0F5C,0x10CA, +0x127E,0x1484,0x16EC,0x19C8,0x1D2E,0x2137,0x2604,0x2BB8, +0x3280,0x3A8E,0x4422,0x4F83,0x5D0A,0x6D1D,0x8038,0x96ED, +/* A:09 B:0e */ +0x09AA,0x09CB,0x09F1,0x0A1F,0x0A56,0x0A97,0x0AE4,0x0B40, +0x0BAD,0x0C2F,0x0CC9,0x0D80,0x0E59,0x0F5C,0x108F,0x11FC, +0x13AE,0x15B2,0x1817,0x1AF0,0x1E52,0x2257,0x271E,0x2CCC, +0x338C,0x3B92,0x451B,0x5070,0x5DE7,0x6DE9,0x80EF,0x978B, +/* A:09 B:0f */ +0x0B20,0x0B41,0x0B67,0x0B95,0x0BCB,0x0C0C,0x0C59,0x0CB4, +0x0D21,0x0DA1,0x0E3B,0x0EF1,0x0FC9,0x10CA,0x11FC,0x1367, +0x1517,0x1718,0x197A,0x1C4F,0x1FAD,0x23AD,0x286E,0x2E14, +0x34CB,0x3CC7,0x4643,0x5189,0x5EEF,0x6EDB,0x81C8,0x9847, +/* A:09 B:10 */ +0x0CDD,0x0CFD,0x0D24,0x0D51,0x0D87,0x0DC7,0x0E14,0x0E6E, +0x0EDA,0x0F5A,0x0FF3,0x10A8,0x117F,0x127E,0x13AE,0x1517, +0x16C4,0x18C2,0x1B21,0x1DF1,0x2149,0x2543,0x29FD,0x2F9A, +0x3647,0x3E35,0x47A3,0x52D7,0x6028,0x6FFB,0x82CB,0x9926, +/* A:09 B:11 */ +0x0EEE,0x0F0E,0x0F34,0x0F61,0x0F97,0x0FD6,0x1022,0x107C, +0x10E7,0x1166,0x11FE,0x12B1,0x1387,0x1484,0x15B2,0x1718, +0x18C2,0x1ABD,0x1D17,0x1FE2,0x2334,0x2726,0x2BD7,0x316A, +0x380A,0x3FE9,0x4945,0x5464,0x619C,0x7152,0x83FE,0x9A2F, +/* A:09 B:12 */ +0x1162,0x1182,0x11A8,0x11D4,0x1209,0x1249,0x1294,0x12ED, +0x1357,0x13D5,0x146B,0x151D,0x15F1,0x16EC,0x1817,0x197A, +0x1B21,0x1D17,0x1F6B,0x2230,0x257A,0x2964,0x2E0A,0x3390, +0x3A21,0x41EF,0x4B36,0x563C,0x6356,0x72E9,0x856B,0x9B6A, +/* A:09 B:13 */ +0x144D,0x146C,0x1492,0x14BE,0x14F2,0x1531,0x157B,0x15D4, +0x163D,0x16B9,0x174E,0x17FE,0x18CF,0x19C8,0x1AF0,0x1C4F, +0x1DF1,0x1FE2,0x2230,0x24ED,0x282F,0x2C0E,0x30A7,0x361F, +0x3C9E,0x4457,0x4D85,0x586D,0x6564,0x74CD,0x871D,0x9CE0, +/* A:09 B:14 */ +0x17C5,0x17E3,0x1808,0x1834,0x1868,0x18A6,0x18EF,0x1946, +0x19AE,0x1A29,0x1ABB,0x1B69,0x1C38,0x1D2E,0x1E52,0x1FAD, +0x2149,0x2334,0x257A,0x282F,0x2B66,0x2F38,0x33C3,0x3929, +0x3F93,0x4733,0x5043,0x5B08,0x67D5,0x770B,0x8920,0x9E9D, +/* A:09 B:15 */ +0x1BE3,0x1C02,0x1C26,0x1C51,0x1C84,0x1CC1,0x1D09,0x1D5F, +0x1DC5,0x1E3E,0x1ECF,0x1F7A,0x2046,0x2137,0x2257,0x23AD, +0x2543,0x2726,0x2964,0x2C0E,0x2F38,0x32FC,0x3775,0x3CC5, +0x4317,0x4A99,0x5385,0x5E21,0x6ABB,0x79B7,0x8B85,0xA0AE, +/* A:09 B:16 */ +0x20C9,0x20E7,0x210A,0x2135,0x2167,0x21A3,0x21EA,0x223E, +0x22A2,0x2319,0x23A7,0x244F,0x2517,0x2604,0x271E,0x286E, +0x29FD,0x2BD7,0x2E0A,0x30A7,0x33C3,0x3775,0x3BD9,0x4110, +0x4744,0x4EA3,0x5765,0x61CE,0x6E2E,0x7CE3,0x8E5D,0xA323, +/* A:09 B:17 */ +0x269B,0x26B8,0x26DB,0x2704,0x2735,0x2770,0x27B5,0x2807, +0x2869,0x28DE,0x2968,0x2A0D,0x2AD0,0x2BB8,0x2CCC,0x2E14, +0x2F9A,0x316A,0x3390,0x361F,0x3929,0x3CC5,0x4110,0x462A, +0x4C3B,0x536F,0x5C00,0x662E,0x7247,0x80A8,0x91BF,0xA60E, +/* A:09 B:18 */ +0x2D86,0x2DA2,0x2DC4,0x2DEC,0x2E1C,0x2E55,0x2E98,0x2EE8, +0x2F48,0x2FB9,0x3040,0x30E0,0x319E,0x3280,0x338C,0x34CB, +0x3647,0x380A,0x3A21,0x3C9E,0x3F93,0x4317,0x4744,0x4C3B, +0x5221,0x5924,0x6179,0x6B60,0x7726,0x8523,0x95C3,0xA986, +/* A:09 B:19 */ +0x35BF,0x35DA,0x35FB,0x3622,0x3650,0x3687,0x36C8,0x3715, +0x3772,0x37DF,0x3861,0x38FC,0x39B4,0x3A8E,0x3B92,0x3CC7, +0x3E35,0x3FE9,0x41EF,0x4457,0x4733,0x4A99,0x4EA3,0x536F, +0x5924,0x5FEB,0x67FA,0x718E,0x7CEF,0x8A76,0x9A8A,0xADA5, +/* A:09 B:1a */ +0x3F84,0x3F9E,0x3FBE,0x3FE3,0x400F,0x4044,0x4082,0x40CD, +0x4125,0x418E,0x420B,0x42A0,0x4350,0x4422,0x451B,0x4643, +0x47A3,0x4945,0x4B36,0x4D85,0x5043,0x5385,0x5765,0x5C00, +0x6179,0x67FA,0x6FB5,0x78E5,0x83D0,0x90CA,0xA037,0xB28C, +/* A:09 B:1b */ +0x4B21,0x4B3A,0x4B58,0x4B7B,0x4BA5,0x4BD7,0x4C13,0x4C59, +0x4CAD,0x4D11,0x4D87,0x4E14,0x4EBC,0x4F83,0x5070,0x5189, +0x52D7,0x5464,0x563C,0x586D,0x5B08,0x5E21,0x61CE,0x662E, +0x6B60,0x718E,0x78E5,0x819E,0x8BFD,0x9850,0xA6F6,0xB85E, +/* A:09 B:1c */ +0x58EE,0x5906,0x5921,0x5943,0x596A,0x5999,0x59D1,0x5A13, +0x5A61,0x5ABF,0x5B2E,0x5BB2,0x5C4F,0x5D0A,0x5DE7,0x5EEF, +0x6028,0x619C,0x6356,0x6564,0x67D5,0x6ABB,0x6E2E,0x7247, +0x7726,0x7CEF,0x83D0,0x8BFD,0x95B5,0xA141,0xAEFA,0xBF4A, +/* A:09 B:1d */ +0x6955,0x696B,0x6985,0x69A3,0x69C7,0x69F3,0x6A26,0x6A63, +0x6AAB,0x6B01,0x6B67,0x6BE1,0x6C71,0x6D1D,0x6DE9,0x6EDB, +0x6FFB,0x7152,0x72E9,0x74CD,0x770B,0x79B7,0x7CE3,0x80A8, +0x8523,0x8A76,0x90CA,0x9850,0xA141,0xABE1,0xB882,0xC784, +/* A:09 B:1e */ +0x7CD4,0x7CE8,0x7CFF,0x7D1A,0x7D3B,0x7D61,0x7D8F,0x7DC6, +0x7E07,0x7E54,0x7EB0,0x7F1D,0x7F9E,0x8038,0x80EF,0x81C8, +0x82CB,0x83FE,0x856B,0x871D,0x8920,0x8B85,0x8E5D,0x91BF, +0x95C3,0x9A8A,0xA037,0xA6F6,0xAEFA,0xB882,0xC3D5,0xD14B, +/* A:09 B:1f */ +0x9400,0x9411,0x9425,0x943C,0x9458,0x947A,0x94A1,0x94D1, +0x9509,0x954B,0x959A,0x95F8,0x9668,0x96ED,0x978B,0x9847, +0x9926,0x9A2F,0x9B6A,0x9CE0,0x9E9D,0xA0AE,0xA323,0xA60E, +0xA986,0xADA5,0xB28C,0xB85E,0xBF4A,0xC784,0xD14B,0xDCE9, +/* A: 968D89C0 */ +/* A:0a B:00 */ +0x0339,0x035A,0x0382,0x03B1,0x03E9,0x042B,0x047A,0x04D8, +0x0547,0x05CC,0x0669,0x0725,0x0803,0x090B,0x0A46,0x0BBB, +0x0D77,0x0F86,0x11F9,0x14E3,0x1858,0x1C75,0x2158,0x2727, +0x2E0E,0x3642,0x4002,0x4B98,0x595E,0x69BD,0x7D31,0x9450, +/* A:0a B:01 */ +0x035A,0x037B,0x03A3,0x03D2,0x040A,0x044C,0x049B,0x04F9, +0x0568,0x05ED,0x068A,0x0745,0x0824,0x092C,0x0A66,0x0BDB, +0x0D97,0x0FA6,0x1219,0x1502,0x1877,0x1C93,0x2176,0x2744, +0x2E2A,0x365D,0x401C,0x4BB1,0x5976,0x69D2,0x7D44,0x9461, +/* A:0a B:02 */ +0x0382,0x03A3,0x03CB,0x03FA,0x0431,0x0474,0x04C3,0x0520, +0x0590,0x0614,0x06B1,0x076C,0x084B,0x0953,0x0A8D,0x0C02, +0x0DBD,0x0FCC,0x123F,0x1527,0x189C,0x1CB7,0x2199,0x2766, +0x2E4C,0x367E,0x403C,0x4BCF,0x5991,0x69EC,0x7D5B,0x9474, +/* A:0a B:03 */ +0x03B1,0x03D2,0x03FA,0x0428,0x0460,0x04A3,0x04F1,0x054F, +0x05BE,0x0643,0x06E0,0x079B,0x0879,0x0981,0x0ABB,0x0C2F, +0x0DEB,0x0FF9,0x126B,0x1553,0x18C7,0x1CE2,0x21C3,0x2790, +0x2E74,0x36A5,0x4061,0x4BF2,0x59B3,0x6A0A,0x7D76,0x948C, +/* A:0a B:04 */ +0x03E9,0x040A,0x0431,0x0460,0x0498,0x04DA,0x0529,0x0587, +0x05F6,0x067A,0x0717,0x07D2,0x08B0,0x09B8,0x0AF1,0x0C66, +0x0E20,0x102F,0x12A0,0x1588,0x18FB,0x1D15,0x21F5,0x27C1, +0x2EA4,0x36D3,0x408D,0x4C1C,0x59DA,0x6A2E,0x7D97,0x94A8, +/* A:0a B:05 */ +0x042B,0x044C,0x0474,0x04A3,0x04DA,0x051C,0x056B,0x05C9, +0x0638,0x06BC,0x0759,0x0813,0x08F1,0x09F9,0x0B32,0x0CA6, +0x0E61,0x106E,0x12DF,0x15C6,0x1939,0x1D52,0x2231,0x27FB, +0x2EDC,0x370A,0x40C1,0x4C4E,0x5A09,0x6A59,0x7DBE,0x94C9, +/* A:0a B:06 */ +0x047A,0x049B,0x04C3,0x04F1,0x0529,0x056B,0x05BA,0x0617, +0x0686,0x070A,0x07A7,0x0861,0x093F,0x0A46,0x0B7F,0x0CF3, +0x0EAD,0x10BA,0x132A,0x1610,0x1982,0x1D9A,0x2278,0x2840, +0x2F20,0x374B,0x4100,0x4C8A,0x5A40,0x6A8D,0x7DEB,0x94F1, +/* A:0a B:07 */ +0x04D8,0x04F9,0x0520,0x054F,0x0587,0x05C9,0x0617,0x0674, +0x06E3,0x0767,0x0804,0x08BE,0x099B,0x0AA2,0x0BDA,0x0D4E, +0x0F07,0x1114,0x1383,0x1668,0x19D9,0x1DF0,0x22CC,0x2892, +0x2F70,0x3798,0x414A,0x4CD0,0x5A82,0x6AC9,0x7E22,0x9520, +/* A:0a B:08 */ +0x0547,0x0568,0x0590,0x05BE,0x05F6,0x0638,0x0686,0x06E3, +0x0752,0x07D6,0x0872,0x092C,0x0A09,0x0B0F,0x0C47,0x0DBA, +0x0F73,0x117F,0x13ED,0x16D1,0x1A40,0x1E56,0x2330,0x28F4, +0x2FCF,0x37F4,0x41A2,0x4D24,0x5AD1,0x6B12,0x7E63,0x9558, +/* A:0a B:09 */ +0x05CC,0x05ED,0x0614,0x0643,0x067A,0x06BC,0x070A,0x0767, +0x07D6,0x0859,0x08F5,0x09AF,0x0A8B,0x0B91,0x0CC9,0x0E3B, +0x0FF3,0x11FE,0x146B,0x174E,0x1ABB,0x1ECF,0x23A7,0x2968, +0x3040,0x3861,0x420B,0x4D87,0x5B2E,0x6B67,0x7EB0,0x959A, +/* A:0a B:0a */ +0x0669,0x068A,0x06B1,0x06E0,0x0717,0x0759,0x07A7,0x0804, +0x0872,0x08F5,0x0991,0x0A4A,0x0B26,0x0C2B,0x0D62,0x0ED4, +0x108B,0x1294,0x1500,0x17E1,0x1B4D,0x1F5E,0x2434,0x29F2, +0x30C6,0x38E3,0x4288,0x4DFE,0x5B9D,0x6BCD,0x7F0B,0x95E9, +/* A:0a B:0b */ +0x0725,0x0745,0x076C,0x079B,0x07D2,0x0813,0x0861,0x08BE, +0x092C,0x09AF,0x0A4A,0x0B03,0x0BDE,0x0CE3,0x0E19,0x0F89, +0x113F,0x1348,0x15B2,0x1891,0x1BFB,0x2009,0x24DB,0x2A96, +0x3166,0x397D,0x431C,0x4E8A,0x5C21,0x6C47,0x7F78,0x9647, +/* A:0a B:0c */ +0x0803,0x0824,0x084B,0x0879,0x08B0,0x08F1,0x093F,0x099B, +0x0A09,0x0A8B,0x0B26,0x0BDE,0x0CB9,0x0DBD,0x0EF2,0x1061, +0x1216,0x141D,0x1685,0x1962,0x1CC9,0x20D5,0x25A3,0x2B59, +0x3223,0x3A35,0x43CC,0x4F32,0x5CBD,0x6CD7,0x7FF9,0x96B7, +/* A:0a B:0d */ +0x090B,0x092C,0x0953,0x0981,0x09B8,0x09F9,0x0A46,0x0AA2, +0x0B0F,0x0B91,0x0C2B,0x0CE3,0x0DBD,0x0EC0,0x0FF4,0x1162, +0x1315,0x151A,0x1780,0x1A5B,0x1DBE,0x21C6,0x2690,0x2C41, +0x3305,0x3B0F,0x449D,0x4FF8,0x5D77,0x6D82,0x8093,0x973B, +/* A:0a B:0e */ +0x0A46,0x0A66,0x0A8D,0x0ABB,0x0AF1,0x0B32,0x0B7F,0x0BDA, +0x0C47,0x0CC9,0x0D62,0x0E19,0x0EF2,0x0FF4,0x1127,0x1293, +0x1444,0x1647,0x18AB,0x1B82,0x1EE2,0x22E5,0x27AA,0x2D54, +0x3411,0x3C12,0x4596,0x50E4,0x5E55,0x6E4D,0x8149,0x97D9, +/* A:0a B:0f */ +0x0BBB,0x0BDB,0x0C02,0x0C2F,0x0C66,0x0CA6,0x0CF3,0x0D4E, +0x0DBA,0x0E3B,0x0ED4,0x0F89,0x1061,0x1162,0x1293,0x13FE, +0x15AC,0x17AD,0x1A0D,0x1CE1,0x203C,0x243A,0x28F8,0x2E9C, +0x354F,0x3D46,0x46BD,0x51FD,0x5F5C,0x6F3F,0x8222,0x9894, +/* A:0a B:10 */ +0x0D77,0x0D97,0x0DBD,0x0DEB,0x0E20,0x0E61,0x0EAD,0x0F07, +0x0F73,0x0FF3,0x108B,0x113F,0x1216,0x1315,0x1444,0x15AC, +0x1759,0x1956,0x1BB3,0x1E81,0x21D8,0x25CF,0x2A86,0x3021, +0x36CA,0x3EB4,0x481C,0x534A,0x6094,0x705F,0x8324,0x9973, +/* A:0a B:11 */ +0x0F86,0x0FA6,0x0FCC,0x0FF9,0x102F,0x106E,0x10BA,0x1114, +0x117F,0x11FE,0x1294,0x1348,0x141D,0x151A,0x1647,0x17AD, +0x1956,0x1B4F,0x1DA7,0x2071,0x23C1,0x27B1,0x2C5F,0x31EF, +0x388C,0x4067,0x49BE,0x54D7,0x6207,0x71B5,0x8456,0x9A7B, +/* A:0a B:12 */ +0x11F9,0x1219,0x123F,0x126B,0x12A0,0x12DF,0x132A,0x1383, +0x13ED,0x146B,0x1500,0x15B2,0x1685,0x1780,0x18AB,0x1A0D, +0x1BB3,0x1DA7,0x1FFB,0x22BE,0x2607,0x29EE,0x2E91,0x3415, +0x3AA2,0x426C,0x4BAE,0x56AE,0x63C1,0x734B,0x85C2,0x9BB5, +/* A:0a B:13 */ +0x14E3,0x1502,0x1527,0x1553,0x1588,0x15C6,0x1610,0x1668, +0x16D1,0x174E,0x17E1,0x1891,0x1962,0x1A5B,0x1B82,0x1CE1, +0x1E81,0x2071,0x22BE,0x257A,0x28BA,0x2C96,0x312D,0x36A2, +0x3D1E,0x44D3,0x4DFB,0x58DE,0x65CD,0x752D,0x8773,0x9D2B, +/* A:0a B:14 */ +0x1858,0x1877,0x189C,0x18C7,0x18FB,0x1939,0x1982,0x19D9, +0x1A40,0x1ABB,0x1B4D,0x1BFB,0x1CC9,0x1DBE,0x1EE2,0x203C, +0x21D8,0x23C1,0x2607,0x28BA,0x2BEF,0x2FBF,0x3447,0x39AA, +0x4011,0x47AD,0x50B8,0x5B77,0x683D,0x776B,0x8976,0x9EE7, +/* A:0a B:15 */ +0x1C75,0x1C93,0x1CB7,0x1CE2,0x1D15,0x1D52,0x1D9A,0x1DF0, +0x1E56,0x1ECF,0x1F5E,0x2009,0x20D5,0x21C6,0x22E5,0x243A, +0x25CF,0x27B1,0x29EE,0x2C96,0x2FBF,0x3381,0x37F7,0x3D45, +0x4393,0x4B11,0x53F8,0x5E8E,0x6B22,0x7A15,0x8BD9,0xA0F7, +/* A:0a B:16 */ +0x2158,0x2176,0x2199,0x21C3,0x21F5,0x2231,0x2278,0x22CC, +0x2330,0x23A7,0x2434,0x24DB,0x25A3,0x2690,0x27AA,0x28F8, +0x2A86,0x2C5F,0x2E91,0x312D,0x3447,0x37F7,0x3C59,0x418D, +0x47BE,0x4F18,0x57D6,0x623A,0x6E92,0x7D3F,0x8EB0,0xA36A, +/* A:0a B:17 */ +0x2727,0x2744,0x2766,0x2790,0x27C1,0x27FB,0x2840,0x2892, +0x28F4,0x2968,0x29F2,0x2A96,0x2B59,0x2C41,0x2D54,0x2E9C, +0x3021,0x31EF,0x3415,0x36A2,0x39AA,0x3D45,0x418D,0x46A5, +0x4CB2,0x53E2,0x5C6E,0x6697,0x72A9,0x8102,0x920F,0xA654, +/* A:0a B:18 */ +0x2E0E,0x2E2A,0x2E4C,0x2E74,0x2EA4,0x2EDC,0x2F20,0x2F70, +0x2FCF,0x3040,0x30C6,0x3166,0x3223,0x3305,0x3411,0x354F, +0x36CA,0x388C,0x3AA2,0x3D1E,0x4011,0x4393,0x47BE,0x4CB2, +0x5295,0x5994,0x61E4,0x6BC6,0x7785,0x857B,0x9612,0xA9CA, +/* A:0a B:19 */ +0x3642,0x365D,0x367E,0x36A5,0x36D3,0x370A,0x374B,0x3798, +0x37F4,0x3861,0x38E3,0x397D,0x3A35,0x3B0F,0x3C12,0x3D46, +0x3EB4,0x4067,0x426C,0x44D3,0x47AD,0x4B11,0x4F18,0x53E2, +0x5994,0x6057,0x6862,0x71F0,0x7D4B,0x8ACB,0x9AD6,0xADE7, +/* A:0a B:1a */ +0x4002,0x401C,0x403C,0x4061,0x408D,0x40C1,0x4100,0x414A, +0x41A2,0x420B,0x4288,0x431C,0x43CC,0x449D,0x4596,0x46BD, +0x481C,0x49BE,0x4BAE,0x4DFB,0x50B8,0x53F8,0x57D6,0x5C6E, +0x61E4,0x6862,0x7018,0x7943,0x8429,0x911C,0xA080,0xB2CA, +/* A:0a B:1b */ +0x4B98,0x4BB1,0x4BCF,0x4BF2,0x4C1C,0x4C4E,0x4C8A,0x4CD0, +0x4D24,0x4D87,0x4DFE,0x4E8A,0x4F32,0x4FF8,0x50E4,0x51FD, +0x534A,0x54D7,0x56AE,0x58DE,0x5B77,0x5E8E,0x623A,0x6697, +0x6BC6,0x71F0,0x7943,0x81F8,0x8C51,0x989D,0xA73B,0xB89A, +/* A:0a B:1c */ +0x595E,0x5976,0x5991,0x59B3,0x59DA,0x5A09,0x5A40,0x5A82, +0x5AD1,0x5B2E,0x5B9D,0x5C21,0x5CBD,0x5D77,0x5E55,0x5F5C, +0x6094,0x6207,0x63C1,0x65CD,0x683D,0x6B22,0x6E92,0x72A9, +0x7785,0x7D4B,0x8429,0x8C51,0x9603,0xA189,0xAF3B,0xBF82, +/* A:0a B:1d */ +0x69BD,0x69D2,0x69EC,0x6A0A,0x6A2E,0x6A59,0x6A8D,0x6AC9, +0x6B12,0x6B67,0x6BCD,0x6C47,0x6CD7,0x6D82,0x6E4D,0x6F3F, +0x705F,0x71B5,0x734B,0x752D,0x776B,0x7A15,0x7D3F,0x8102, +0x857B,0x8ACB,0x911C,0x989D,0xA189,0xAC23,0xB8BD,0xC7B7, +/* A:0a B:1e */ +0x7D31,0x7D44,0x7D5B,0x7D76,0x7D97,0x7DBE,0x7DEB,0x7E22, +0x7E63,0x7EB0,0x7F0B,0x7F78,0x7FF9,0x8093,0x8149,0x8222, +0x8324,0x8456,0x85C2,0x8773,0x8976,0x8BD9,0x8EB0,0x920F, +0x9612,0x9AD6,0xA080,0xA73B,0xAF3B,0xB8BD,0xC40A,0xD178, +/* A:0a B:1f */ +0x9450,0x9461,0x9474,0x948C,0x94A8,0x94C9,0x94F1,0x9520, +0x9558,0x959A,0x95E9,0x9647,0x96B7,0x973B,0x97D9,0x9894, +0x9973,0x9A7B,0x9BB5,0x9D2B,0x9EE7,0xA0F7,0xA36A,0xA654, +0xA9CA,0xADE7,0xB2CA,0xB89A,0xBF82,0xC7B7,0xD178,0xDD10, +/* A: 968D89C0 */ +/* A:0b B:00 */ +0x03F6,0x0417,0x043F,0x046E,0x04A5,0x04E8,0x0536,0x0594, +0x0603,0x0687,0x0725,0x07DF,0x08BD,0x09C5,0x0AFE,0x0C73, +0x0E2E,0x103C,0x12AD,0x1594,0x1908,0x1D22,0x2201,0x27CC, +0x2EAF,0x36DE,0x4098,0x4C27,0x59E3,0x6A37,0x7D9F,0x94AF, +/* A:0b B:01 */ +0x0417,0x0439,0x0460,0x048F,0x04C7,0x0509,0x0558,0x05B5, +0x0624,0x06A8,0x0745,0x0800,0x08DE,0x09E5,0x0B1F,0x0C93, +0x0E4E,0x105C,0x12CD,0x15B4,0x1927,0x1D40,0x221F,0x27EA, +0x2ECB,0x36F9,0x40B2,0x4C40,0x59FB,0x6A4D,0x7DB2,0x94BF, +/* A:0b B:02 */ +0x043F,0x0460,0x0487,0x04B6,0x04EE,0x0530,0x057F,0x05DC, +0x064B,0x06CF,0x076C,0x0827,0x0905,0x0A0C,0x0B45,0x0CB9, +0x0E74,0x1081,0x12F2,0x15D9,0x194B,0x1D64,0x2243,0x280C, +0x2EED,0x371A,0x40D1,0x4C5D,0x5A17,0x6A66,0x7DC9,0x94D3, +/* A:0b B:03 */ +0x046E,0x048F,0x04B6,0x04E5,0x051D,0x055F,0x05AD,0x060B, +0x067A,0x06FE,0x079B,0x0855,0x0933,0x0A3A,0x0B73,0x0CE7, +0x0EA1,0x10AE,0x131F,0x1605,0x1977,0x1D8F,0x226D,0x2835, +0x2F15,0x3740,0x40F6,0x4C80,0x5A38,0x6A85,0x7DE4,0x94EB, +/* A:0b B:04 */ +0x04A5,0x04C7,0x04EE,0x051D,0x0554,0x0596,0x05E5,0x0642, +0x06B1,0x0735,0x07D2,0x088C,0x096A,0x0A71,0x0BA9,0x0D1D, +0x0ED7,0x10E4,0x1354,0x1639,0x19AA,0x1DC2,0x229F,0x2866, +0x2F45,0x376E,0x4122,0x4CAA,0x5A5F,0x6AA9,0x7E05,0x9507, +/* A:0b B:05 */ +0x04E8,0x0509,0x0530,0x055F,0x0596,0x05D8,0x0627,0x0684, +0x06F3,0x0777,0x0813,0x08CD,0x09AB,0x0AB2,0x0BEA,0x0D5D, +0x0F17,0x1123,0x1392,0x1677,0x19E8,0x1DFE,0x22DA,0x28A0, +0x2F7D,0x37A5,0x4157,0x4CDC,0x5A8D,0x6AD4,0x7E2B,0x9528, +/* A:0b B:06 */ +0x0536,0x0558,0x057F,0x05AD,0x05E5,0x0627,0x0675,0x06D3, +0x0741,0x07C5,0x0861,0x091B,0x09F8,0x0AFF,0x0C37,0x0DAA, +0x0F63,0x116E,0x13DD,0x16C1,0x1A31,0x1E46,0x2321,0x28E5, +0x2FC0,0x37E6,0x4195,0x4D17,0x5AC5,0x6B07,0x7E59,0x954F, +/* A:0b B:07 */ +0x0594,0x05B5,0x05DC,0x060B,0x0642,0x0684,0x06D3,0x0730, +0x079E,0x0822,0x08BE,0x0977,0x0A54,0x0B5A,0x0C92,0x0E05, +0x0FBD,0x11C8,0x1436,0x1719,0x1A88,0x1E9C,0x2374,0x2937, +0x3010,0x3833,0x41DF,0x4D5E,0x5B07,0x6B43,0x7E8F,0x957E, +/* A:0b B:08 */ +0x0603,0x0624,0x064B,0x067A,0x06B1,0x06F3,0x0741,0x079E, +0x080D,0x0890,0x092C,0x09E5,0x0AC2,0x0BC7,0x0CFF,0x0E70, +0x1028,0x1233,0x14A0,0x1782,0x1AEF,0x1F01,0x23D8,0x2999, +0x306F,0x388F,0x4237,0x4DB1,0x5B55,0x6B8B,0x7ED0,0x95B6, +/* A:0b B:09 */ +0x0687,0x06A8,0x06CF,0x06FE,0x0735,0x0777,0x07C5,0x0822, +0x0890,0x0913,0x09AF,0x0A68,0x0B44,0x0C49,0x0D80,0x0EF1, +0x10A8,0x12B1,0x151D,0x17FE,0x1B69,0x1F7A,0x244F,0x2A0D, +0x30E0,0x38FC,0x42A0,0x4E14,0x5BB2,0x6BE1,0x7F1D,0x95F8, +/* A:0b B:0a */ +0x0725,0x0745,0x076C,0x079B,0x07D2,0x0813,0x0861,0x08BE, +0x092C,0x09AF,0x0A4A,0x0B03,0x0BDE,0x0CE3,0x0E19,0x0F89, +0x113F,0x1348,0x15B2,0x1891,0x1BFB,0x2009,0x24DB,0x2A96, +0x3166,0x397D,0x431C,0x4E8A,0x5C21,0x6C47,0x7F78,0x9647, +/* A:0b B:0b */ +0x07DF,0x0800,0x0827,0x0855,0x088C,0x08CD,0x091B,0x0977, +0x09E5,0x0A68,0x0B03,0x0BBB,0x0C96,0x0D9A,0x0ECF,0x103F, +0x11F3,0x13FA,0x1663,0x1941,0x1CA8,0x20B4,0x2583,0x2B3A, +0x3205,0x3A17,0x43B0,0x4F17,0x5CA4,0x6CC0,0x7FE4,0x96A5, +/* A:0b B:0c */ +0x08BD,0x08DE,0x0905,0x0933,0x096A,0x09AB,0x09F8,0x0A54, +0x0AC2,0x0B44,0x0BDE,0x0C96,0x0D70,0x0E73,0x0FA8,0x1116, +0x12C9,0x14CF,0x1736,0x1A11,0x1D76,0x217F,0x264A,0x2BFC, +0x32C2,0x3ACE,0x445F,0x4FBD,0x5D40,0x6D4F,0x8065,0x9714, +/* A:0b B:0d */ +0x09C5,0x09E5,0x0A0C,0x0A3A,0x0A71,0x0AB2,0x0AFF,0x0B5A, +0x0BC7,0x0C49,0x0CE3,0x0D9A,0x0E73,0x0F76,0x10A9,0x1216, +0x13C8,0x15CC,0x1830,0x1B09,0x1E6A,0x226F,0x2736,0x2CE4, +0x33A3,0x3BA8,0x4530,0x5084,0x5DFA,0x6DFA,0x80FE,0x9798, +/* A:0b B:0e */ +0x0AFE,0x0B1F,0x0B45,0x0B73,0x0BA9,0x0BEA,0x0C37,0x0C92, +0x0CFF,0x0D80,0x0E19,0x0ECF,0x0FA8,0x10A9,0x11DB,0x1346, +0x14F6,0x16F8,0x195A,0x1C2F,0x1F8D,0x238E,0x284F,0x2DF6, +0x34AE,0x3CAA,0x4628,0x516F,0x5ED7,0x6EC5,0x81B4,0x9835, +/* A:0b B:0f */ +0x0C73,0x0C93,0x0CB9,0x0CE7,0x0D1D,0x0D5D,0x0DAA,0x0E05, +0x0E70,0x0EF1,0x0F89,0x103F,0x1116,0x1216,0x1346,0x14B0, +0x165E,0x185C,0x1ABC,0x1D8D,0x20E7,0x24E2,0x299D,0x2F3D, +0x35EC,0x3DDD,0x474E,0x5287,0x5FDD,0x6FB6,0x828D,0x98F0, +/* A:0b B:10 */ +0x0E2E,0x0E4E,0x0E74,0x0EA1,0x0ED7,0x0F17,0x0F63,0x0FBD, +0x1028,0x10A8,0x113F,0x11F3,0x12C9,0x13C8,0x14F6,0x165E, +0x1809,0x1A04,0x1C60,0x1F2D,0x2281,0x2676,0x2B2A,0x30C1, +0x3765,0x3F4B,0x48AD,0x53D3,0x6114,0x70D5,0x838E,0x99CE, +/* A:0b B:11 */ +0x103C,0x105C,0x1081,0x10AE,0x10E4,0x1123,0x116E,0x11C8, +0x1233,0x12B1,0x1348,0x13FA,0x14CF,0x15CC,0x16F8,0x185C, +0x1A04,0x1BFC,0x1E53,0x211B,0x2469,0x2857,0x2D02,0x328E, +0x3926,0x40FC,0x4A4D,0x555F,0x6287,0x722A,0x84C0,0x9AD6, +/* A:0b B:12 */ +0x12AD,0x12CD,0x12F2,0x131F,0x1354,0x1392,0x13DD,0x1436, +0x14A0,0x151D,0x15B2,0x1663,0x1736,0x1830,0x195A,0x1ABC, +0x1C60,0x1E53,0x20A5,0x2367,0x26AD,0x2A92,0x2F32,0x34B2, +0x3B3C,0x4300,0x4C3C,0x5735,0x643F,0x73BF,0x862B,0x9C0F, +/* A:0b B:13 */ +0x1594,0x15B4,0x15D9,0x1605,0x1639,0x1677,0x16C1,0x1719, +0x1782,0x17FE,0x1891,0x1941,0x1A11,0x1B09,0x1C2F,0x1D8D, +0x1F2D,0x211B,0x2367,0x2621,0x295F,0x2D39,0x31CD,0x373E, +0x3DB5,0x4565,0x4E88,0x5963,0x664A,0x75A0,0x87DA,0x9D84, +/* A:0b B:14 */ +0x1908,0x1927,0x194B,0x1977,0x19AA,0x19E8,0x1A31,0x1A88, +0x1AEF,0x1B69,0x1BFB,0x1CA8,0x1D76,0x1E6A,0x1F8D,0x20E7, +0x2281,0x2469,0x26AD,0x295F,0x2C92,0x305F,0x34E5,0x3A44, +0x40A7,0x483D,0x5142,0x5BFB,0x68B8,0x77DD,0x89DC,0x9F3F, +/* A:0b B:15 */ +0x1D22,0x1D40,0x1D64,0x1D8F,0x1DC2,0x1DFE,0x1E46,0x1E9C, +0x1F01,0x1F7A,0x2009,0x20B4,0x217F,0x226F,0x238E,0x24E2, +0x2676,0x2857,0x2A92,0x2D39,0x305F,0x341E,0x3892,0x3DDC, +0x4426,0x4B9F,0x5481,0x5F0F,0x6B9B,0x7A85,0x8C3D,0xA14D, +/* A:0b B:16 */ +0x2201,0x221F,0x2243,0x226D,0x229F,0x22DA,0x2321,0x2374, +0x23D8,0x244F,0x24DB,0x2583,0x264A,0x2736,0x284F,0x299D, +0x2B2A,0x2D02,0x2F32,0x31CD,0x34E5,0x3892,0x3CF1,0x4222, +0x484E,0x4FA4,0x585C,0x62B9,0x6F0A,0x7DAD,0x8F12,0xA3BF, +/* A:0b B:17 */ +0x27CC,0x27EA,0x280C,0x2835,0x2866,0x28A0,0x28E5,0x2937, +0x2999,0x2A0D,0x2A96,0x2B3A,0x2BFC,0x2CE4,0x2DF6,0x2F3D, +0x30C1,0x328E,0x34B2,0x373E,0x3A44,0x3DDC,0x4222,0x4736, +0x4D3F,0x546B,0x5CF1,0x6713,0x731E,0x816D,0x9270,0xA6A7, +/* A:0b B:18 */ +0x2EAF,0x2ECB,0x2EED,0x2F15,0x2F45,0x2F7D,0x2FC0,0x3010, +0x306F,0x30E0,0x3166,0x3205,0x32C2,0x33A3,0x34AE,0x35EC, +0x3765,0x3926,0x3B3C,0x3DB5,0x40A7,0x4426,0x484E,0x4D3F, +0x531E,0x5A19,0x6264,0x6C3F,0x77F6,0x85E3,0x966F,0xAA1A, +/* A:0b B:19 */ +0x36DE,0x36F9,0x371A,0x3740,0x376E,0x37A5,0x37E6,0x3833, +0x388F,0x38FC,0x397D,0x3A17,0x3ACE,0x3BA8,0x3CAA,0x3DDD, +0x3F4B,0x40FC,0x4300,0x4565,0x483D,0x4B9F,0x4FA4,0x546B, +0x5A19,0x60D8,0x68DD,0x7265,0x7DB9,0x8B30,0x9B30,0xAE35, +/* A:0b B:1a */ +0x4098,0x40B2,0x40D1,0x40F6,0x4122,0x4157,0x4195,0x41DF, +0x4237,0x42A0,0x431C,0x43B0,0x445F,0x4530,0x4628,0x474E, +0x48AD,0x4A4D,0x4C3C,0x4E88,0x5142,0x5481,0x585C,0x5CF1, +0x6264,0x68DD,0x708F,0x79B4,0x8492,0x917C,0xA0D6,0xB315, +/* A:0b B:1b */ +0x4C27,0x4C40,0x4C5D,0x4C80,0x4CAA,0x4CDC,0x4D17,0x4D5E, +0x4DB1,0x4E14,0x4E8A,0x4F17,0x4FBD,0x5084,0x516F,0x5287, +0x53D3,0x555F,0x5735,0x5963,0x5BFB,0x5F0F,0x62B9,0x6713, +0x6C3F,0x7265,0x79B4,0x8263,0x8CB5,0x98F9,0xA78D,0xB8E0, +/* A:0b B:1c */ +0x59E3,0x59FB,0x5A17,0x5A38,0x5A5F,0x5A8D,0x5AC5,0x5B07, +0x5B55,0x5BB2,0x5C21,0x5CA4,0x5D40,0x5DFA,0x5ED7,0x5FDD, +0x6114,0x6287,0x643F,0x664A,0x68B8,0x6B9B,0x6F0A,0x731E, +0x77F6,0x7DB9,0x8492,0x8CB5,0x9660,0xA1DF,0xAF87,0xBFC4, +/* A:0b B:1d */ +0x6A37,0x6A4D,0x6A66,0x6A85,0x6AA9,0x6AD4,0x6B07,0x6B43, +0x6B8B,0x6BE1,0x6C47,0x6CC0,0x6D4F,0x6DFA,0x6EC5,0x6FB6, +0x70D5,0x722A,0x73BF,0x75A0,0x77DD,0x7A85,0x7DAD,0x816D, +0x85E3,0x8B30,0x917C,0x98F9,0xA1DF,0xAC72,0xB903,0xC7F3, +/* A:0b B:1e */ +0x7D9F,0x7DB2,0x7DC9,0x7DE4,0x7E05,0x7E2B,0x7E59,0x7E8F, +0x7ED0,0x7F1D,0x7F78,0x7FE4,0x8065,0x80FE,0x81B4,0x828D, +0x838E,0x84C0,0x862B,0x87DA,0x89DC,0x8C3D,0x8F12,0x9270, +0x966F,0x9B30,0xA0D6,0xA78D,0xAF87,0xB903,0xC449,0xD1AE, +/* A:0b B:1f */ +0x94AF,0x94BF,0x94D3,0x94EB,0x9507,0x9528,0x954F,0x957E, +0x95B6,0x95F8,0x9647,0x96A5,0x9714,0x9798,0x9835,0x98F0, +0x99CE,0x9AD6,0x9C0F,0x9D84,0x9F3F,0xA14D,0xA3BF,0xA6A7, +0xAA1A,0xAE35,0xB315,0xB8E0,0xBFC4,0xC7F3,0xD1AE,0xDD3E, +/* A: 968D89C0 */ +/* A:0c B:00 */ +0x04D7,0x04F8,0x0520,0x054E,0x0586,0x05C8,0x0616,0x0674, +0x06E3,0x0766,0x0803,0x08BD,0x099A,0x0AA1,0x0BDA,0x0D4D, +0x0F07,0x1113,0x1383,0x1668,0x19D8,0x1DEF,0x22CB,0x2892, +0x2F6F,0x3797,0x414A,0x4CD0,0x5A82,0x6AC9,0x7E21,0x9520, +/* A:0c B:01 */ +0x04F8,0x0519,0x0541,0x056F,0x05A7,0x05E9,0x0637,0x0695, +0x0703,0x0787,0x0824,0x08DE,0x09BB,0x0AC2,0x0BFA,0x0D6D, +0x0F26,0x1133,0x13A2,0x1687,0x19F7,0x1E0D,0x22E9,0x28AF, +0x2F8B,0x37B3,0x4164,0x4CE9,0x5A99,0x6ADE,0x7E35,0x9530, +/* A:0c B:02 */ +0x0520,0x0541,0x0568,0x0597,0x05CE,0x0610,0x065F,0x06BC, +0x072B,0x07AE,0x084B,0x0905,0x09E2,0x0AE8,0x0C20,0x0D93, +0x0F4C,0x1159,0x13C7,0x16AC,0x1A1C,0x1E31,0x230C,0x28D1, +0x2FAD,0x37D3,0x4183,0x4D06,0x5AB5,0x6AF8,0x7E4C,0x9544, +/* A:0c B:03 */ +0x054E,0x056F,0x0597,0x05C5,0x05FD,0x063F,0x068D,0x06EA, +0x0759,0x07DC,0x0879,0x0933,0x0A10,0x0B16,0x0C4E,0x0DC1, +0x0F7A,0x1185,0x13F4,0x16D8,0x1A47,0x1E5C,0x2336,0x28FA, +0x2FD5,0x37FA,0x41A8,0x4D29,0x5AD6,0x6B16,0x7E67,0x955B, +/* A:0c B:04 */ +0x0586,0x05A7,0x05CE,0x05FD,0x0634,0x0676,0x06C4,0x0721, +0x0790,0x0814,0x08B0,0x096A,0x0A46,0x0B4D,0x0C84,0x0DF7, +0x0FAF,0x11BB,0x1429,0x170C,0x1A7A,0x1E8F,0x2368,0x292B, +0x3004,0x3828,0x41D4,0x4D53,0x5AFD,0x6B3A,0x7E87,0x9577, +/* A:0c B:05 */ +0x05C8,0x05E9,0x0610,0x063F,0x0676,0x06B8,0x0706,0x0763, +0x07D2,0x0855,0x08F1,0x09AB,0x0A87,0x0B8D,0x0CC5,0x0E37, +0x0FEF,0x11FA,0x1467,0x174A,0x1AB8,0x1ECB,0x23A3,0x2965, +0x303C,0x385E,0x4208,0x4D85,0x5B2B,0x6B65,0x7EAD,0x9598, +/* A:0c B:06 */ +0x0616,0x0637,0x065F,0x068D,0x06C4,0x0706,0x0754,0x07B1, +0x0820,0x08A3,0x093F,0x09F8,0x0AD4,0x0BDA,0x0D11,0x0E83, +0x103B,0x1245,0x14B2,0x1794,0x1B00,0x1F13,0x23E9,0x29AA, +0x307F,0x389F,0x4246,0x4DC0,0x5B63,0x6B98,0x7EDB,0x95C0, +/* A:0c B:07 */ +0x0674,0x0695,0x06BC,0x06EA,0x0721,0x0763,0x07B1,0x080E, +0x087C,0x08FF,0x099B,0x0A54,0x0B30,0x0C36,0x0D6C,0x0EDE, +0x1095,0x129E,0x150A,0x17EB,0x1B57,0x1F68,0x243D,0x29FB, +0x30CF,0x38EC,0x4290,0x4E06,0x5BA4,0x6BD4,0x7F11,0x95EE, +/* A:0c B:08 */ +0x06E3,0x0703,0x072B,0x0759,0x0790,0x07D2,0x0820,0x087C, +0x08EA,0x096D,0x0A09,0x0AC2,0x0B9D,0x0CA2,0x0DD9,0x0F49, +0x1100,0x1308,0x1574,0x1853,0x1BBE,0x1FCD,0x24A0,0x2A5C, +0x312D,0x3947,0x42E8,0x4E59,0x5BF2,0x6C1C,0x7F52,0x9626, +/* A:0c B:09 */ +0x0766,0x0787,0x07AE,0x07DC,0x0814,0x0855,0x08A3,0x08FF, +0x096D,0x09F0,0x0A8B,0x0B44,0x0C1F,0x0D23,0x0E59,0x0FC9, +0x117F,0x1387,0x15F1,0x18CF,0x1C38,0x2046,0x2517,0x2AD0, +0x319E,0x39B4,0x4350,0x4EBC,0x5C4F,0x6C71,0x7F9E,0x9668, +/* A:0c B:0a */ +0x0803,0x0824,0x084B,0x0879,0x08B0,0x08F1,0x093F,0x099B, +0x0A09,0x0A8B,0x0B26,0x0BDE,0x0CB9,0x0DBD,0x0EF2,0x1061, +0x1216,0x141D,0x1685,0x1962,0x1CC9,0x20D5,0x25A3,0x2B59, +0x3223,0x3A35,0x43CC,0x4F32,0x5CBD,0x6CD7,0x7FF9,0x96B7, +/* A:0c B:0b */ +0x08BD,0x08DE,0x0905,0x0933,0x096A,0x09AB,0x09F8,0x0A54, +0x0AC2,0x0B44,0x0BDE,0x0C96,0x0D70,0x0E73,0x0FA8,0x1116, +0x12C9,0x14CF,0x1736,0x1A11,0x1D76,0x217F,0x264A,0x2BFC, +0x32C2,0x3ACE,0x445F,0x4FBD,0x5D40,0x6D4F,0x8065,0x9714, +/* A:0c B:0c */ +0x099A,0x09BB,0x09E2,0x0A10,0x0A46,0x0A87,0x0AD4,0x0B30, +0x0B9D,0x0C1F,0x0CB9,0x0D70,0x0E49,0x0F4C,0x107F,0x11ED, +0x139F,0x15A3,0x1808,0x1AE1,0x1E43,0x2249,0x2710,0x2CBE, +0x337F,0x3B85,0x450E,0x5064,0x5DDC,0x6DDF,0x80E6,0x9783, +/* A:0c B:0d */ +0x0AA1,0x0AC2,0x0AE8,0x0B16,0x0B4D,0x0B8D,0x0BDA,0x0C36, +0x0CA2,0x0D23,0x0DBD,0x0E73,0x0F4C,0x104E,0x1180,0x12EC, +0x149C,0x169F,0x1902,0x1BD8,0x1F37,0x2339,0x27FC,0x2DA5, +0x345F,0x3C5E,0x45DE,0x5129,0x5E95,0x6E89,0x817E,0x9807, +/* A:0c B:0e */ +0x0BDA,0x0BFA,0x0C20,0x0C4E,0x0C84,0x0CC5,0x0D11,0x0D6C, +0x0DD9,0x0E59,0x0EF2,0x0FA8,0x107F,0x1180,0x12B1,0x141B, +0x15CA,0x17CA,0x1A2A,0x1CFD,0x2059,0x2456,0x2914,0x2EB7, +0x3569,0x3D5F,0x46D5,0x5214,0x5F71,0x6F53,0x8234,0x98A3, +/* A:0c B:0f */ +0x0D4D,0x0D6D,0x0D93,0x0DC1,0x0DF7,0x0E37,0x0E83,0x0EDE, +0x0F49,0x0FC9,0x1061,0x1116,0x11ED,0x12EC,0x141B,0x1584, +0x1730,0x192E,0x1B8B,0x1E5A,0x21B1,0x25A9,0x2A61,0x2FFC, +0x36A6,0x3E91,0x47FB,0x532B,0x6077,0x7044,0x830B,0x995E, +/* A:0c B:10 */ +0x0F07,0x0F26,0x0F4C,0x0F7A,0x0FAF,0x0FEF,0x103B,0x1095, +0x1100,0x117F,0x1216,0x12C9,0x139F,0x149C,0x15CA,0x1730, +0x18DA,0x1AD4,0x1D2E,0x1FF9,0x234A,0x273C,0x2BED,0x317F, +0x381E,0x3FFD,0x4958,0x5476,0x61AD,0x7162,0x840C,0x9A3B, +/* A:0c B:11 */ +0x1113,0x1133,0x1159,0x1185,0x11BB,0x11FA,0x1245,0x129E, +0x1308,0x1387,0x141D,0x14CF,0x15A3,0x169F,0x17CA,0x192E, +0x1AD4,0x1CCB,0x1F20,0x21E6,0x2531,0x291B,0x2DC3,0x334B, +0x39DE,0x41AE,0x4AF7,0x5601,0x631E,0x72B5,0x853D,0x9B42, +/* A:0c B:12 */ +0x1383,0x13A2,0x13C7,0x13F4,0x1429,0x1467,0x14B2,0x150A, +0x1574,0x15F1,0x1685,0x1736,0x1808,0x1902,0x1A2A,0x1B8B, +0x1D2E,0x1F20,0x2170,0x242F,0x2773,0x2B55,0x2FF2,0x356D, +0x3BF2,0x43B0,0x4CE4,0x57D5,0x64D5,0x7449,0x86A7,0x9C7A, +/* A:0c B:13 */ +0x1668,0x1687,0x16AC,0x16D8,0x170C,0x174A,0x1794,0x17EB, +0x1853,0x18CF,0x1962,0x1A11,0x1AE1,0x1BD8,0x1CFD,0x1E5A, +0x1FF9,0x21E6,0x242F,0x26E7,0x2A22,0x2DFA,0x328A,0x37F7, +0x3E6A,0x4613,0x4F2F,0x5A02,0x66DF,0x7629,0x8855,0x9DEE, +/* A:0c B:14 */ +0x19D8,0x19F7,0x1A1C,0x1A47,0x1A7A,0x1AB8,0x1B00,0x1B57, +0x1BBE,0x1C38,0x1CC9,0x1D76,0x1E43,0x1F37,0x2059,0x21B1, +0x234A,0x2531,0x2773,0x2A22,0x2D53,0x311E,0x35A0,0x3AFB, +0x4159,0x48E9,0x51E7,0x5C97,0x694B,0x7863,0x8A55,0x9FA7, +/* A:0c B:15 */ +0x1DEF,0x1E0D,0x1E31,0x1E5C,0x1E8F,0x1ECB,0x1F13,0x1F68, +0x1FCD,0x2046,0x20D5,0x217F,0x2249,0x2339,0x2456,0x25A9, +0x273C,0x291B,0x2B55,0x2DFA,0x311E,0x34DA,0x394A,0x3E90, +0x44D5,0x4C49,0x5523,0x5FAA,0x6C2C,0x7B09,0x8CB4,0xA1B4, +/* A:0c B:16 */ +0x22CB,0x22E9,0x230C,0x2336,0x2368,0x23A3,0x23E9,0x243D, +0x24A0,0x2517,0x25A3,0x264A,0x2710,0x27FC,0x2914,0x2A61, +0x2BED,0x2DC3,0x2FF2,0x328A,0x35A0,0x394A,0x3DA5,0x42D3, +0x48FA,0x504A,0x58FC,0x6350,0x6F97,0x7E2F,0x8F87,0xA424, +/* A:0c B:17 */ +0x2892,0x28AF,0x28D1,0x28FA,0x292B,0x2965,0x29AA,0x29FB, +0x2A5C,0x2AD0,0x2B59,0x2BFC,0x2CBE,0x2DA5,0x2EB7,0x2FFC, +0x317F,0x334B,0x356D,0x37F7,0x3AFB,0x3E90,0x42D3,0x47E3, +0x4DE7,0x550E,0x5D8D,0x67A7,0x73A8,0x81ED,0x92E2,0xA709, +/* A:0c B:18 */ +0x2F6F,0x2F8B,0x2FAD,0x2FD5,0x3004,0x303C,0x307F,0x30CF, +0x312D,0x319E,0x3223,0x32C2,0x337F,0x345F,0x3569,0x36A6, +0x381E,0x39DE,0x3BF2,0x3E6A,0x4159,0x44D5,0x48FA,0x4DE7, +0x53C2,0x5AB7,0x62FB,0x6CCF,0x787D,0x865F,0x96DE,0xAA7A, +/* A:0c B:19 */ +0x3797,0x37B3,0x37D3,0x37FA,0x3828,0x385E,0x389F,0x38EC, +0x3947,0x39B4,0x3A35,0x3ACE,0x3B85,0x3C5E,0x3D5F,0x3E91, +0x3FFD,0x41AE,0x43B0,0x4613,0x48E9,0x4C49,0x504A,0x550E, +0x5AB7,0x6171,0x696F,0x72F0,0x7E3B,0x8BA7,0x9B9B,0xAE91, +/* A:0c B:1a */ +0x414A,0x4164,0x4183,0x41A8,0x41D4,0x4208,0x4246,0x4290, +0x42E8,0x4350,0x43CC,0x445F,0x450E,0x45DE,0x46D5,0x47FB, +0x4958,0x4AF7,0x4CE4,0x4F2F,0x51E7,0x5523,0x58FC,0x5D8D, +0x62FB,0x696F,0x711B,0x7A39,0x850E,0x91EF,0xA13D,0xB36D, +/* A:0c B:1b */ +0x4CD0,0x4CE9,0x4D06,0x4D29,0x4D53,0x4D85,0x4DC0,0x4E06, +0x4E59,0x4EBC,0x4F32,0x4FBD,0x5064,0x5129,0x5214,0x532B, +0x5476,0x5601,0x57D5,0x5A02,0x5C97,0x5FAA,0x6350,0x67A7, +0x6CCF,0x72F0,0x7A39,0x82E1,0x8D2B,0x9966,0xA7EE,0xB934, +/* A:0c B:1c */ +0x5A82,0x5A99,0x5AB5,0x5AD6,0x5AFD,0x5B2B,0x5B63,0x5BA4, +0x5BF2,0x5C4F,0x5CBD,0x5D40,0x5DDC,0x5E95,0x5F71,0x6077, +0x61AD,0x631E,0x64D5,0x66DF,0x694B,0x6C2C,0x6F97,0x73A8, +0x787D,0x7E3B,0x850E,0x8D2B,0x96CF,0xA244,0xAFE3,0xC012, +/* A:0c B:1d */ +0x6AC9,0x6ADE,0x6AF8,0x6B16,0x6B3A,0x6B65,0x6B98,0x6BD4, +0x6C1C,0x6C71,0x6CD7,0x6D4F,0x6DDF,0x6E89,0x6F53,0x7044, +0x7162,0x72B5,0x7449,0x7629,0x7863,0x7B09,0x7E2F,0x81ED, +0x865F,0x8BA7,0x91EF,0x9966,0xA244,0xACCF,0xB957,0xC83B, +/* A:0c B:1e */ +0x7E21,0x7E35,0x7E4C,0x7E67,0x7E87,0x7EAD,0x7EDB,0x7F11, +0x7F52,0x7F9E,0x7FF9,0x8065,0x80E6,0x817E,0x8234,0x830B, +0x840C,0x853D,0x86A7,0x8855,0x8A55,0x8CB4,0x8F87,0x92E2, +0x96DE,0x9B9B,0xA13D,0xA7EE,0xAFE3,0xB957,0xC493,0xD1EE, +/* A:0c B:1f */ +0x9520,0x9530,0x9544,0x955B,0x9577,0x9598,0x95C0,0x95EE, +0x9626,0x9668,0x96B7,0x9714,0x9783,0x9807,0x98A3,0x995E, +0x9A3B,0x9B42,0x9C7A,0x9DEE,0x9FA7,0xA1B4,0xA424,0xA709, +0xAA7A,0xAE91,0xB36D,0xB934,0xC012,0xC83B,0xD1EE,0xDD75, +/* A: 968D89C0 */ +/* A:0d B:00 */ +0x05E2,0x0603,0x062B,0x0659,0x0691,0x06D2,0x0721,0x077E, +0x07EC,0x086F,0x090B,0x09C5,0x0AA1,0x0BA7,0x0CDF,0x0E51, +0x1008,0x1213,0x1480,0x1763,0x1AD0,0x1EE3,0x23BB,0x297C, +0x3053,0x3874,0x421D,0x4D99,0x5B3E,0x6B76,0x7EBD,0x95A6, +/* A:0d B:01 */ +0x0603,0x0624,0x064C,0x067A,0x06B1,0x06F3,0x0741,0x079E, +0x080D,0x0890,0x092C,0x09E5,0x0AC2,0x0BC8,0x0CFF,0x0E71, +0x1028,0x1233,0x14A0,0x1782,0x1AEF,0x1F01,0x23D8,0x2999, +0x306F,0x388F,0x4237,0x4DB1,0x5B55,0x6B8B,0x7ED0,0x95B6, +/* A:0d B:02 */ +0x062B,0x064C,0x0673,0x06A1,0x06D9,0x071A,0x0768,0x07C5, +0x0834,0x08B7,0x0953,0x0A0C,0x0AE8,0x0BEE,0x0D25,0x0E97, +0x104E,0x1258,0x14C5,0x17A7,0x1B13,0x1F25,0x23FB,0x29BB, +0x3090,0x38AF,0x4256,0x4DCF,0x5B71,0x6BA5,0x7EE7,0x95CA, +/* A:0d B:03 */ +0x0659,0x067A,0x06A1,0x06D0,0x0707,0x0749,0x0797,0x07F4, +0x0862,0x08E5,0x0981,0x0A3A,0x0B16,0x0C1C,0x0D52,0x0EC4, +0x107B,0x1285,0x14F1,0x17D2,0x1B3E,0x1F50,0x2425,0x29E4, +0x30B8,0x38D6,0x427B,0x4DF2,0x5B92,0x6BC3,0x7F02,0x95E1, +/* A:0d B:04 */ +0x0691,0x06B1,0x06D9,0x0707,0x073E,0x0780,0x07CE,0x082B, +0x0899,0x091C,0x09B8,0x0A71,0x0B4D,0x0C52,0x0D89,0x0EFA, +0x10B0,0x12BA,0x1526,0x1806,0x1B72,0x1F82,0x2457,0x2A15, +0x30E7,0x3903,0x42A7,0x4E1B,0x5BB9,0x6BE7,0x7F22,0x95FD, +/* A:0d B:05 */ +0x06D2,0x06F3,0x071A,0x0749,0x0780,0x07C2,0x080F,0x086C, +0x08DA,0x095D,0x09F9,0x0AB2,0x0B8D,0x0C92,0x0DC9,0x0F3A, +0x10F0,0x12F9,0x1564,0x1844,0x1BAF,0x1FBE,0x2492,0x2A4E, +0x3120,0x393A,0x42DB,0x4E4D,0x5BE7,0x6C11,0x7F48,0x961E, +/* A:0d B:06 */ +0x0721,0x0741,0x0768,0x0797,0x07CE,0x080F,0x085D,0x08BA, +0x0928,0x09AB,0x0A46,0x0AFF,0x0BDA,0x0CDF,0x0E15,0x0F85, +0x113B,0x1344,0x15AE,0x188E,0x1BF7,0x2006,0x24D8,0x2A93, +0x3162,0x397A,0x4319,0x4E88,0x5C1E,0x6C44,0x7F76,0x9645, +/* A:0d B:07 */ +0x077E,0x079E,0x07C5,0x07F4,0x082B,0x086C,0x08BA,0x0916, +0x0984,0x0A07,0x0AA2,0x0B5A,0x0C36,0x0D3A,0x0E70,0x0FE0, +0x1195,0x139D,0x1607,0x18E5,0x1C4E,0x205B,0x252B,0x2AE4, +0x31B1,0x39C7,0x4362,0x4ECD,0x5C5F,0x6C80,0x7FAC,0x9674, +/* A:0d B:08 */ +0x07EC,0x080D,0x0834,0x0862,0x0899,0x08DA,0x0928,0x0984, +0x09F2,0x0A74,0x0B0F,0x0BC7,0x0CA2,0x0DA6,0x0EDC,0x104B, +0x1200,0x1407,0x1670,0x194D,0x1CB4,0x20C0,0x258E,0x2B45, +0x3210,0x3A22,0x43BA,0x4F20,0x5CAD,0x6CC8,0x7FEC,0x96AB, +/* A:0d B:09 */ +0x086F,0x0890,0x08B7,0x08E5,0x091C,0x095D,0x09AB,0x0A07, +0x0A74,0x0AF6,0x0B91,0x0C49,0x0D23,0x0E27,0x0F5C,0x10CA, +0x127E,0x1484,0x16EC,0x19C8,0x1D2E,0x2137,0x2604,0x2BB8, +0x3280,0x3A8E,0x4422,0x4F83,0x5D0A,0x6D1D,0x8038,0x96ED, +/* A:0d B:0a */ +0x090B,0x092C,0x0953,0x0981,0x09B8,0x09F9,0x0A46,0x0AA2, +0x0B0F,0x0B91,0x0C2B,0x0CE3,0x0DBD,0x0EC0,0x0FF4,0x1162, +0x1315,0x151A,0x1780,0x1A5B,0x1DBE,0x21C6,0x2690,0x2C41, +0x3305,0x3B0F,0x449D,0x4FF8,0x5D77,0x6D82,0x8093,0x973B, +/* A:0d B:0b */ +0x09C5,0x09E5,0x0A0C,0x0A3A,0x0A71,0x0AB2,0x0AFF,0x0B5A, +0x0BC7,0x0C49,0x0CE3,0x0D9A,0x0E73,0x0F76,0x10A9,0x1216, +0x13C8,0x15CC,0x1830,0x1B09,0x1E6A,0x226F,0x2736,0x2CE4, +0x33A3,0x3BA8,0x4530,0x5084,0x5DFA,0x6DFA,0x80FE,0x9798, +/* A:0d B:0c */ +0x0AA1,0x0AC2,0x0AE8,0x0B16,0x0B4D,0x0B8D,0x0BDA,0x0C36, +0x0CA2,0x0D23,0x0DBD,0x0E73,0x0F4C,0x104E,0x1180,0x12EC, +0x149C,0x169F,0x1902,0x1BD8,0x1F37,0x2339,0x27FC,0x2DA5, +0x345F,0x3C5E,0x45DE,0x5129,0x5E95,0x6E89,0x817E,0x9807, +/* A:0d B:0d */ +0x0BA7,0x0BC8,0x0BEE,0x0C1C,0x0C52,0x0C92,0x0CDF,0x0D3A, +0x0DA6,0x0E27,0x0EC0,0x0F76,0x104E,0x114E,0x1280,0x13EA, +0x1599,0x179A,0x19FA,0x1CCE,0x202A,0x2428,0x28E7,0x2E8A, +0x353E,0x3D36,0x46AD,0x51EE,0x5F4E,0x6F32,0x8216,0x988A, +/* A:0d B:0e */ +0x0CDF,0x0CFF,0x0D25,0x0D52,0x0D89,0x0DC9,0x0E15,0x0E70, +0x0EDC,0x0F5C,0x0FF4,0x10A9,0x1180,0x1280,0x13AF,0x1518, +0x16C6,0x18C4,0x1B22,0x1DF2,0x214B,0x2544,0x29FE,0x2F9B, +0x3648,0x3E36,0x47A4,0x52D8,0x6029,0x6FFC,0x82CB,0x9926, +/* A:0d B:0f */ +0x0E51,0x0E71,0x0E97,0x0EC4,0x0EFA,0x0F3A,0x0F85,0x0FE0, +0x104B,0x10CA,0x1162,0x1216,0x12EC,0x13EA,0x1518,0x1680, +0x182B,0x1A26,0x1C81,0x1F4E,0x22A2,0x2696,0x2B4A,0x30E0, +0x3783,0x3F67,0x48C8,0x53EE,0x612D,0x70EC,0x83A2,0x99E0, +/* A:0d B:10 */ +0x1008,0x1028,0x104E,0x107B,0x10B0,0x10F0,0x113B,0x1195, +0x1200,0x127E,0x1315,0x13C8,0x149C,0x1599,0x16C6,0x182B, +0x19D3,0x1BCB,0x1E23,0x20EB,0x243A,0x2828,0x2CD4,0x3261, +0x38FA,0x40D2,0x4A24,0x5538,0x6263,0x7209,0x84A2,0x9ABC, +/* A:0d B:11 */ +0x1213,0x1233,0x1258,0x1285,0x12BA,0x12F9,0x1344,0x139D, +0x1407,0x1484,0x151A,0x15CC,0x169F,0x179A,0x18C4,0x1A26, +0x1BCB,0x1DC0,0x2013,0x22D6,0x261E,0x2A05,0x2EA8,0x342B, +0x3AB8,0x4281,0x4BC2,0x56C1,0x63D3,0x735B,0x85D1,0x9BC2, +/* A:0d B:12 */ +0x1480,0x14A0,0x14C5,0x14F1,0x1526,0x1564,0x15AE,0x1607, +0x1670,0x16EC,0x1780,0x1830,0x1902,0x19FA,0x1B22,0x1C81, +0x1E23,0x2013,0x2261,0x251E,0x285F,0x2C3D,0x30D5,0x364C, +0x3CCA,0x4481,0x4DAD,0x5894,0x6588,0x74ED,0x873A,0x9CF9, +/* A:0d B:13 */ +0x1763,0x1782,0x17A7,0x17D2,0x1806,0x1844,0x188E,0x18E5, +0x194D,0x19C8,0x1A5B,0x1B09,0x1BD8,0x1CCE,0x1DF2,0x1F4E, +0x20EB,0x22D6,0x251E,0x27D3,0x2B0B,0x2EDF,0x336B,0x38D3, +0x3F40,0x46E2,0x4FF5,0x5ABE,0x6790,0x76CC,0x88E7,0x9E6C, +/* A:0d B:14 */ +0x1AD0,0x1AEF,0x1B13,0x1B3E,0x1B72,0x1BAF,0x1BF7,0x1C4E, +0x1CB4,0x1D2E,0x1DBE,0x1E6A,0x1F37,0x202A,0x214B,0x22A2, +0x243A,0x261E,0x285F,0x2B0B,0x2E39,0x3200,0x367E,0x3BD4, +0x422C,0x49B6,0x52AB,0x5D51,0x69F9,0x7904,0x8AE4,0xA023, +/* A:0d B:15 */ +0x1EE3,0x1F01,0x1F25,0x1F50,0x1F82,0x1FBE,0x2006,0x205B, +0x20C0,0x2137,0x21C6,0x226F,0x2339,0x2428,0x2544,0x2696, +0x2828,0x2A05,0x2C3D,0x2EDF,0x3200,0x35B9,0x3A25,0x3F66, +0x45A5,0x4D12,0x55E4,0x6061,0x6CD7,0x7BA7,0x8D42,0xA22E, +/* A:0d B:16 */ +0x23BB,0x23D8,0x23FB,0x2425,0x2457,0x2492,0x24D8,0x252B, +0x258E,0x2604,0x2690,0x2736,0x27FC,0x28E7,0x29FE,0x2B4A, +0x2CD4,0x2EA8,0x30D5,0x336B,0x367E,0x3A25,0x3E7C,0x43A5, +0x49C6,0x5110,0x59B9,0x6404,0x7040,0x7ECA,0x9012,0xA49C, +/* A:0d B:17 */ +0x297C,0x2999,0x29BB,0x29E4,0x2A15,0x2A4E,0x2A93,0x2AE4, +0x2B45,0x2BB8,0x2C41,0x2CE4,0x2DA5,0x2E8A,0x2F9B,0x30E0, +0x3261,0x342B,0x364C,0x38D3,0x3BD4,0x3F66,0x43A5,0x48B0, +0x4EAF,0x55CF,0x5E46,0x6857,0x744D,0x8284,0x9369,0xA77E, +/* A:0d B:18 */ +0x3053,0x306F,0x3090,0x30B8,0x30E7,0x3120,0x3162,0x31B1, +0x3210,0x3280,0x3305,0x33A3,0x345F,0x353E,0x3648,0x3783, +0x38FA,0x3AB8,0x3CCA,0x3F40,0x422C,0x45A5,0x49C6,0x4EAF, +0x5484,0x5B72,0x63AF,0x6D7A,0x791D,0x86F2,0x9762,0xAAEC, +/* A:0d B:19 */ +0x3874,0x388F,0x38AF,0x38D6,0x3903,0x393A,0x397A,0x39C7, +0x3A22,0x3A8E,0x3B0F,0x3BA8,0x3C5E,0x3D36,0x3E36,0x3F67, +0x40D2,0x4281,0x4481,0x46E2,0x49B6,0x4D12,0x5110,0x55CF, +0x5B72,0x6226,0x6A1E,0x7395,0x7ED6,0x8C36,0x9C1B,0xAEFF, +/* A:0d B:1a */ +0x421D,0x4237,0x4256,0x427B,0x42A7,0x42DB,0x4319,0x4362, +0x43BA,0x4422,0x449D,0x4530,0x45DE,0x46AD,0x47A4,0x48C8, +0x4A24,0x4BC2,0x4DAD,0x4FF5,0x52AB,0x55E4,0x59B9,0x5E46, +0x63AF,0x6A1E,0x71C2,0x7AD7,0x85A3,0x9277,0xA1B7,0xB3D6, +/* A:0d B:1b */ +0x4D99,0x4DB1,0x4DCF,0x4DF2,0x4E1B,0x4E4D,0x4E88,0x4ECD, +0x4F20,0x4F83,0x4FF8,0x5084,0x5129,0x51EE,0x52D8,0x53EE, +0x5538,0x56C1,0x5894,0x5ABE,0x5D51,0x6061,0x6404,0x6857, +0x6D7A,0x7395,0x7AD7,0x8377,0x8DB8,0x99E7,0xA862,0xB998, +/* A:0d B:1c */ +0x5B3E,0x5B55,0x5B71,0x5B92,0x5BB9,0x5BE7,0x5C1E,0x5C5F, +0x5CAD,0x5D0A,0x5D77,0x5DFA,0x5E95,0x5F4E,0x6029,0x612D, +0x6263,0x63D3,0x6588,0x6790,0x69F9,0x6CD7,0x7040,0x744D, +0x791D,0x7ED6,0x85A3,0x8DB8,0x9753,0xA2BD,0xB04F,0xC06F, +/* A:0d B:1d */ +0x6B76,0x6B8B,0x6BA5,0x6BC3,0x6BE7,0x6C11,0x6C44,0x6C80, +0x6CC8,0x6D1D,0x6D82,0x6DFA,0x6E89,0x6F32,0x6FFC,0x70EC, +0x7209,0x735B,0x74ED,0x76CC,0x7904,0x7BA7,0x7ECA,0x8284, +0x86F2,0x8C36,0x9277,0x99E7,0xA2BD,0xAD3E,0xB9BA,0xC890, +/* A:0d B:1e */ +0x7EBD,0x7ED0,0x7EE7,0x7F02,0x7F22,0x7F48,0x7F76,0x7FAC, +0x7FEC,0x8038,0x8093,0x80FE,0x817E,0x8216,0x82CB,0x83A2, +0x84A2,0x85D1,0x873A,0x88E7,0x8AE4,0x8D42,0x9012,0x9369, +0x9762,0x9C1B,0xA1B7,0xA862,0xB04F,0xB9BA,0xC4EC,0xD23A, +/* A:0d B:1f */ +0x95A6,0x95B6,0x95CA,0x95E1,0x95FD,0x961E,0x9645,0x9674, +0x96AB,0x96ED,0x973B,0x9798,0x9807,0x988A,0x9926,0x99E0, +0x9ABC,0x9BC2,0x9CF9,0x9E6C,0xA023,0xA22E,0xA49C,0xA77E, +0xAAEC,0xAEFF,0xB3D6,0xB998,0xC06F,0xC890,0xD23A,0xDDB6, +/* A: 968D89C0 */ +/* A:0e B:00 */ +0x0720,0x0741,0x0768,0x0796,0x07CE,0x080F,0x085D,0x08B9, +0x0927,0x09AA,0x0A46,0x0AFE,0x0BDA,0x0CDF,0x0E15,0x0F85, +0x113B,0x1343,0x15AE,0x188D,0x1BF7,0x2005,0x24D8,0x2A92, +0x3162,0x397A,0x4318,0x4E87,0x5C1E,0x6C44,0x7F75,0x9645, +/* A:0e B:01 */ +0x0741,0x0762,0x0789,0x07B7,0x07EE,0x0830,0x087E,0x08DA, +0x0948,0x09CB,0x0A66,0x0B1F,0x0BFA,0x0CFF,0x0E35,0x0FA5, +0x115B,0x1363,0x15CD,0x18AC,0x1C15,0x2023,0x24F5,0x2AAF, +0x317E,0x3995,0x4332,0x4EA0,0x5C35,0x6C59,0x7F88,0x9656, +/* A:0e B:02 */ +0x0768,0x0789,0x07B0,0x07DE,0x0815,0x0857,0x08A4,0x0901, +0x096F,0x09F1,0x0A8D,0x0B45,0x0C20,0x0D25,0x0E5B,0x0FCB, +0x1180,0x1388,0x15F2,0x18D1,0x1C3A,0x2047,0x2518,0x2AD1, +0x319F,0x39B5,0x4351,0x4EBD,0x5C50,0x6C72,0x7F9F,0x9669, +/* A:0e B:03 */ +0x0796,0x07B7,0x07DE,0x080C,0x0844,0x0885,0x08D3,0x092F, +0x099D,0x0A1F,0x0ABB,0x0B73,0x0C4E,0x0D52,0x0E88,0x0FF8, +0x11AD,0x13B5,0x161E,0x18FC,0x1C65,0x2071,0x2542,0x2AFA, +0x31C7,0x39DB,0x4376,0x4EE0,0x5C71,0x6C90,0x7FBA,0x9680, +/* A:0e B:04 */ +0x07CE,0x07EE,0x0815,0x0844,0x087B,0x08BC,0x090A,0x0966, +0x09D4,0x0A56,0x0AF1,0x0BA9,0x0C84,0x0D89,0x0EBE,0x102D, +0x11E2,0x13EA,0x1653,0x1930,0x1C98,0x20A4,0x2573,0x2B2A, +0x31F6,0x3A09,0x43A2,0x4F09,0x5C98,0x6CB4,0x7FDA,0x969C, +/* A:0e B:05 */ +0x080F,0x0830,0x0857,0x0885,0x08BC,0x08FD,0x094B,0x09A7, +0x0A15,0x0A97,0x0B32,0x0BEA,0x0CC5,0x0DC9,0x0EFE,0x106D, +0x1221,0x1428,0x1691,0x196E,0x1CD5,0x20E0,0x25AE,0x2B64, +0x322E,0x3A3F,0x43D5,0x4F3B,0x5CC6,0x6CDF,0x8000,0x96BD, +/* A:0e B:06 */ +0x085D,0x087E,0x08A4,0x08D3,0x090A,0x094B,0x0998,0x09F4, +0x0A62,0x0AE4,0x0B7F,0x0C37,0x0D11,0x0E15,0x0F4A,0x10B9, +0x126D,0x1473,0x16DB,0x19B7,0x1D1D,0x2127,0x25F4,0x2BA8, +0x3270,0x3A7F,0x4413,0x4F75,0x5CFD,0x6D11,0x802D,0x96E4, +/* A:0e B:07 */ +0x08B9,0x08DA,0x0901,0x092F,0x0966,0x09A7,0x09F4,0x0A51, +0x0ABE,0x0B40,0x0BDA,0x0C92,0x0D6C,0x0E70,0x0FA4,0x1112, +0x12C6,0x14CB,0x1733,0x1A0E,0x1D73,0x217B,0x2647,0x2BF9, +0x32BF,0x3ACB,0x445C,0x4FBB,0x5D3E,0x6D4D,0x8063,0x9712, +/* A:0e B:08 */ +0x0927,0x0948,0x096F,0x099D,0x09D4,0x0A15,0x0A62,0x0ABE, +0x0B2B,0x0BAD,0x0C47,0x0CFF,0x0DD9,0x0EDC,0x100F,0x117D, +0x1330,0x1535,0x179B,0x1A75,0x1DD9,0x21E0,0x26A9,0x2C5A, +0x331D,0x3B26,0x44B3,0x500D,0x5D8B,0x6D94,0x80A3,0x9749, +/* A:0e B:09 */ +0x09AA,0x09CB,0x09F1,0x0A1F,0x0A56,0x0A97,0x0AE4,0x0B40, +0x0BAD,0x0C2F,0x0CC9,0x0D80,0x0E59,0x0F5C,0x108F,0x11FC, +0x13AE,0x15B2,0x1817,0x1AF0,0x1E52,0x2257,0x271E,0x2CCC, +0x338C,0x3B92,0x451B,0x5070,0x5DE7,0x6DE9,0x80EF,0x978B, +/* A:0e B:0a */ +0x0A46,0x0A66,0x0A8D,0x0ABB,0x0AF1,0x0B32,0x0B7F,0x0BDA, +0x0C47,0x0CC9,0x0D62,0x0E19,0x0EF2,0x0FF4,0x1127,0x1293, +0x1444,0x1647,0x18AB,0x1B82,0x1EE2,0x22E5,0x27AA,0x2D54, +0x3411,0x3C12,0x4596,0x50E4,0x5E55,0x6E4D,0x8149,0x97D9, +/* A:0e B:0b */ +0x0AFE,0x0B1F,0x0B45,0x0B73,0x0BA9,0x0BEA,0x0C37,0x0C92, +0x0CFF,0x0D80,0x0E19,0x0ECF,0x0FA8,0x10A9,0x11DB,0x1346, +0x14F6,0x16F8,0x195A,0x1C2F,0x1F8D,0x238E,0x284F,0x2DF6, +0x34AE,0x3CAA,0x4628,0x516F,0x5ED7,0x6EC5,0x81B4,0x9835, +/* A:0e B:0c */ +0x0BDA,0x0BFA,0x0C20,0x0C4E,0x0C84,0x0CC5,0x0D11,0x0D6C, +0x0DD9,0x0E59,0x0EF2,0x0FA8,0x107F,0x1180,0x12B1,0x141B, +0x15CA,0x17CA,0x1A2A,0x1CFD,0x2059,0x2456,0x2914,0x2EB7, +0x3569,0x3D5F,0x46D5,0x5214,0x5F71,0x6F53,0x8234,0x98A3, +/* A:0e B:0d */ +0x0CDF,0x0CFF,0x0D25,0x0D52,0x0D89,0x0DC9,0x0E15,0x0E70, +0x0EDC,0x0F5C,0x0FF4,0x10A9,0x1180,0x1280,0x13AF,0x1518, +0x16C6,0x18C4,0x1B22,0x1DF2,0x214B,0x2544,0x29FE,0x2F9B, +0x3648,0x3E36,0x47A4,0x52D8,0x6029,0x6FFC,0x82CB,0x9926, +/* A:0e B:0e */ +0x0E15,0x0E35,0x0E5B,0x0E88,0x0EBE,0x0EFE,0x0F4A,0x0FA4, +0x100F,0x108F,0x1127,0x11DB,0x12B1,0x13AF,0x14DE,0x1645, +0x17F1,0x19ED,0x1C48,0x1F16,0x226A,0x265F,0x2B14,0x30AB, +0x3750,0x3F36,0x4899,0x53C1,0x6103,0x70C5,0x837F,0x99C1, +/* A:0e B:0f */ +0x0F85,0x0FA5,0x0FCB,0x0FF8,0x102D,0x106D,0x10B9,0x1112, +0x117D,0x11FC,0x1293,0x1346,0x141B,0x1518,0x1645,0x17AB, +0x1954,0x1B4D,0x1DA6,0x2070,0x23C0,0x27B0,0x2C5E,0x31EE, +0x388A,0x4066,0x49BC,0x54D5,0x6206,0x71B3,0x8455,0x9A7A, +/* A:0e B:10 */ +0x113B,0x115B,0x1180,0x11AD,0x11E2,0x1221,0x126D,0x12C6, +0x1330,0x13AE,0x1444,0x14F6,0x15CA,0x16C6,0x17F1,0x1954, +0x1AFB,0x1CF1,0x1F46,0x220B,0x2556,0x2940,0x2DE7,0x336E, +0x3A00,0x41CF,0x4B17,0x561E,0x633A,0x72CF,0x8554,0x9B56, +/* A:0e B:11 */ +0x1343,0x1363,0x1388,0x13B5,0x13EA,0x1428,0x1473,0x14CB, +0x1535,0x15B2,0x1647,0x16F8,0x17CA,0x18C4,0x19ED,0x1B4D, +0x1CF1,0x1EE3,0x2134,0x23F4,0x2739,0x2B1B,0x2FB9,0x3536, +0x3BBC,0x437C,0x4CB2,0x57A5,0x64A9,0x7420,0x8682,0x9C5A, +/* A:0e B:12 */ +0x15AE,0x15CD,0x15F2,0x161E,0x1653,0x1691,0x16DB,0x1733, +0x179B,0x1817,0x18AB,0x195A,0x1A2A,0x1B22,0x1C48,0x1DA6, +0x1F46,0x2134,0x237F,0x2639,0x2976,0x2D50,0x31E4,0x3754, +0x3DCB,0x457A,0x4E9C,0x5976,0x665C,0x75B1,0x87E9,0x9D90, +/* A:0e B:13 */ +0x188D,0x18AC,0x18D1,0x18FC,0x1930,0x196E,0x19B7,0x1A0E, +0x1A75,0x1AF0,0x1B82,0x1C2F,0x1CFD,0x1DF2,0x1F16,0x2070, +0x220B,0x23F4,0x2639,0x28EB,0x2C20,0x2FEF,0x3477,0x39D9, +0x403E,0x47D8,0x50E1,0x5B9E,0x6862,0x778D,0x8994,0x9F01, +/* A:0e B:14 */ +0x1BF7,0x1C15,0x1C3A,0x1C65,0x1C98,0x1CD5,0x1D1D,0x1D73, +0x1DD9,0x1E52,0x1EE2,0x1F8D,0x2059,0x214B,0x226A,0x23C0, +0x2556,0x2739,0x2976,0x2C20,0x2F4A,0x330D,0x3786,0x3CD6, +0x4327,0x4AA9,0x5394,0x5E2F,0x6AC9,0x79C3,0x8B8F,0xA0B7, +/* A:0e B:15 */ +0x2005,0x2023,0x2047,0x2071,0x20A4,0x20E0,0x2127,0x217B, +0x21E0,0x2257,0x22E5,0x238E,0x2456,0x2544,0x265F,0x27B0, +0x2940,0x2B1B,0x2D50,0x2FEF,0x330D,0x36C2,0x3B29,0x4065, +0x469D,0x4E01,0x56CA,0x613B,0x6DA3,0x7C63,0x8DEA,0xA2BF, +/* A:0e B:16 */ +0x24D8,0x24F5,0x2518,0x2542,0x2573,0x25AE,0x25F4,0x2647, +0x26A9,0x271E,0x27AA,0x284F,0x2914,0x29FE,0x2B14,0x2C5E, +0x2DE7,0x2FB9,0x31E4,0x3477,0x3786,0x3B29,0x3F7B,0x449E, +0x4AB9,0x51FB,0x5A9A,0x64DA,0x7108,0x7F82,0x90B7,0xA52A, +/* A:0e B:17 */ +0x2A92,0x2AAF,0x2AD1,0x2AFA,0x2B2A,0x2B64,0x2BA8,0x2BF9, +0x2C5A,0x2CCC,0x2D54,0x2DF6,0x2EB7,0x2F9B,0x30AB,0x31EE, +0x336E,0x3536,0x3754,0x39D9,0x3CD6,0x4065,0x449E,0x49A4, +0x4F9C,0x56B4,0x5F22,0x6928,0x7511,0x8338,0x940B,0xA809, +/* A:0e B:18 */ +0x3162,0x317E,0x319F,0x31C7,0x31F6,0x322E,0x3270,0x32BF, +0x331D,0x338C,0x3411,0x34AE,0x3569,0x3648,0x3750,0x388A, +0x3A00,0x3BBC,0x3DCB,0x403E,0x4327,0x469D,0x4AB9,0x4F9C, +0x556B,0x5C52,0x6486,0x6E45,0x79DC,0x87A1,0x97FF,0xAB73, +/* A:0e B:19 */ +0x397A,0x3995,0x39B5,0x39DB,0x3A09,0x3A3F,0x3A7F,0x3ACB, +0x3B26,0x3B92,0x3C12,0x3CAA,0x3D5F,0x3E36,0x3F36,0x4066, +0x41CF,0x437C,0x457A,0x47D8,0x4AA9,0x4E01,0x51FB,0x56B4, +0x5C52,0x62FE,0x6AED,0x745A,0x7F8E,0x8CDF,0x9CB2,0xAF81, +/* A:0e B:1a */ +0x4318,0x4332,0x4351,0x4376,0x43A2,0x43D5,0x4413,0x445C, +0x44B3,0x451B,0x4596,0x4628,0x46D5,0x47A4,0x4899,0x49BC, +0x4B17,0x4CB2,0x4E9C,0x50E1,0x5394,0x56CA,0x5A9A,0x5F22, +0x6486,0x6AED,0x7288,0x7B94,0x8653,0x9319,0xA248,0xB453, +/* A:0e B:1b */ +0x4E87,0x4EA0,0x4EBD,0x4EE0,0x4F09,0x4F3B,0x4F75,0x4FBB, +0x500D,0x5070,0x50E4,0x516F,0x5214,0x52D8,0x53C1,0x54D5, +0x561E,0x57A5,0x5976,0x5B9E,0x5E2F,0x613B,0x64DA,0x6928, +0x6E45,0x745A,0x7B94,0x842A,0x8E5F,0x9A81,0xA8EC,0xBA0E, +/* A:0e B:1c */ +0x5C1E,0x5C35,0x5C50,0x5C71,0x5C98,0x5CC6,0x5CFD,0x5D3E, +0x5D8B,0x5DE7,0x5E55,0x5ED7,0x5F71,0x6029,0x6103,0x6206, +0x633A,0x64A9,0x665C,0x6862,0x6AC9,0x6DA3,0x7108,0x7511, +0x79DC,0x7F8E,0x8653,0x8E5F,0x97EF,0xA34D,0xB0D0,0xC0DE, +/* A:0e B:1d */ +0x6C44,0x6C59,0x6C72,0x6C90,0x6CB4,0x6CDF,0x6D11,0x6D4D, +0x6D94,0x6DE9,0x6E4D,0x6EC5,0x6F53,0x6FFC,0x70C5,0x71B3, +0x72CF,0x7420,0x75B1,0x778D,0x79C3,0x7C63,0x7F82,0x8338, +0x87A1,0x8CDF,0x9319,0x9A81,0xA34D,0xADC2,0xBA30,0xC8F6, +/* A:0e B:1e */ +0x7F75,0x7F88,0x7F9F,0x7FBA,0x7FDA,0x8000,0x802D,0x8063, +0x80A3,0x80EF,0x8149,0x81B4,0x8234,0x82CB,0x837F,0x8455, +0x8554,0x8682,0x87E9,0x8994,0x8B8F,0x8DEA,0x90B7,0x940B, +0x97FF,0x9CB2,0xA248,0xA8EC,0xB0D0,0xBA30,0xC555,0xD294, +/* A:0e B:1f */ +0x9645,0x9656,0x9669,0x9680,0x969C,0x96BD,0x96E4,0x9712, +0x9749,0x978B,0x97D9,0x9835,0x98A3,0x9926,0x99C1,0x9A7A, +0x9B56,0x9C5A,0x9D90,0x9F01,0xA0B7,0xA2BF,0xA52A,0xA809, +0xAB73,0xAF81,0xB453,0xBA0E,0xC0DE,0xC8F6,0xD294,0xDE03, +/* A: 968D89C0 */ +/* A:0f B:00 */ +0x089A,0x08BA,0x08E1,0x090F,0x0946,0x0987,0x09D5,0x0A31, +0x0A9E,0x0B20,0x0BBB,0x0C73,0x0D4D,0x0E51,0x0F85,0x10F4, +0x12A7,0x14AD,0x1714,0x19F0,0x1D55,0x215E,0x262A,0x2BDD, +0x32A4,0x3AB1,0x4443,0x4FA3,0x5D28,0x6D39,0x8051,0x9703, +/* A:0f B:01 */ +0x08BA,0x08DB,0x0902,0x0930,0x0967,0x09A8,0x09F5,0x0A51, +0x0ABF,0x0B41,0x0BDB,0x0C93,0x0D6D,0x0E71,0x0FA5,0x1113, +0x12C7,0x14CC,0x1734,0x1A0F,0x1D73,0x217C,0x2647,0x2BFA, +0x32C0,0x3ACC,0x445D,0x4FBC,0x5D3F,0x6D4E,0x8064,0x9713, +/* A:0f B:02 */ +0x08E1,0x0902,0x0929,0x0957,0x098E,0x09CF,0x0A1C,0x0A78, +0x0AE5,0x0B67,0x0C02,0x0CB9,0x0D93,0x0E97,0x0FCB,0x1139, +0x12EC,0x14F2,0x1758,0x1A33,0x1D97,0x21A0,0x266A,0x2C1C, +0x32E1,0x3AEC,0x447C,0x4FD9,0x5D5A,0x6D67,0x807A,0x9726, +/* A:0f B:03 */ +0x090F,0x0930,0x0957,0x0985,0x09BC,0x09FD,0x0A4A,0x0AA6, +0x0B13,0x0B95,0x0C2F,0x0CE7,0x0DC1,0x0EC4,0x0FF8,0x1166, +0x1319,0x151E,0x1784,0x1A5E,0x1DC2,0x21CA,0x2694,0x2C45, +0x3308,0x3B12,0x44A0,0x4FFB,0x5D7A,0x6D85,0x8095,0x973D, +/* A:0f B:04 */ +0x0946,0x0967,0x098E,0x09BC,0x09F2,0x0A33,0x0A81,0x0ADD, +0x0B4A,0x0BCB,0x0C66,0x0D1D,0x0DF7,0x0EFA,0x102D,0x119B, +0x134E,0x1552,0x17B8,0x1A92,0x1DF5,0x21FC,0x26C5,0x2C75, +0x3337,0x3B40,0x44CC,0x5025,0x5DA1,0x6DA8,0x80B5,0x9759, +/* A:0f B:05 */ +0x0987,0x09A8,0x09CF,0x09FD,0x0A33,0x0A74,0x0AC2,0x0B1D, +0x0B8A,0x0C0C,0x0CA6,0x0D5D,0x0E37,0x0F3A,0x106D,0x11DA, +0x138D,0x1591,0x17F6,0x1ACF,0x1E32,0x2237,0x26FF,0x2CAE, +0x336F,0x3B75,0x44FF,0x5055,0x5DCF,0x6DD2,0x80DB,0x977A, +/* A:0f B:06 */ +0x09D5,0x09F5,0x0A1C,0x0A4A,0x0A81,0x0AC2,0x0B0F,0x0B6A, +0x0BD7,0x0C59,0x0CF3,0x0DAA,0x0E83,0x0F85,0x10B9,0x1226, +0x13D7,0x15DB,0x1840,0x1B18,0x1E79,0x227E,0x2745,0x2CF2, +0x33B1,0x3BB5,0x453C,0x5090,0x5E05,0x6E05,0x8108,0x97A0, +/* A:0f B:07 */ +0x0A31,0x0A51,0x0A78,0x0AA6,0x0ADD,0x0B1D,0x0B6A,0x0BC6, +0x0C33,0x0CB4,0x0D4E,0x0E05,0x0EDE,0x0FE0,0x1112,0x127F, +0x1430,0x1633,0x1897,0x1B6E,0x1ECF,0x22D2,0x2797,0x2D42, +0x33FF,0x3C01,0x4585,0x50D5,0x5E46,0x6E40,0x813D,0x97CF, +/* A:0f B:08 */ +0x0A9E,0x0ABF,0x0AE5,0x0B13,0x0B4A,0x0B8A,0x0BD7,0x0C33, +0x0C9F,0x0D21,0x0DBA,0x0E70,0x0F49,0x104B,0x117D,0x12E9, +0x149A,0x169C,0x18FF,0x1BD5,0x1F34,0x2336,0x27F9,0x2DA2, +0x345C,0x3C5B,0x45DC,0x5127,0x5E93,0x6E87,0x817D,0x9805, +/* A:0f B:09 */ +0x0B20,0x0B41,0x0B67,0x0B95,0x0BCB,0x0C0C,0x0C59,0x0CB4, +0x0D21,0x0DA1,0x0E3B,0x0EF1,0x0FC9,0x10CA,0x11FC,0x1367, +0x1517,0x1718,0x197A,0x1C4F,0x1FAD,0x23AD,0x286E,0x2E14, +0x34CB,0x3CC7,0x4643,0x5189,0x5EEF,0x6EDB,0x81C8,0x9847, +/* A:0f B:0a */ +0x0BBB,0x0BDB,0x0C02,0x0C2F,0x0C66,0x0CA6,0x0CF3,0x0D4E, +0x0DBA,0x0E3B,0x0ED4,0x0F89,0x1061,0x1162,0x1293,0x13FE, +0x15AC,0x17AD,0x1A0D,0x1CE1,0x203C,0x243A,0x28F8,0x2E9C, +0x354F,0x3D46,0x46BD,0x51FD,0x5F5C,0x6F3F,0x8222,0x9894, +/* A:0f B:0b */ +0x0C73,0x0C93,0x0CB9,0x0CE7,0x0D1D,0x0D5D,0x0DAA,0x0E05, +0x0E70,0x0EF1,0x0F89,0x103F,0x1116,0x1216,0x1346,0x14B0, +0x165E,0x185C,0x1ABC,0x1D8D,0x20E7,0x24E2,0x299D,0x2F3D, +0x35EC,0x3DDD,0x474E,0x5287,0x5FDD,0x6FB6,0x828D,0x98F0, +/* A:0f B:0c */ +0x0D4D,0x0D6D,0x0D93,0x0DC1,0x0DF7,0x0E37,0x0E83,0x0EDE, +0x0F49,0x0FC9,0x1061,0x1116,0x11ED,0x12EC,0x141B,0x1584, +0x1730,0x192E,0x1B8B,0x1E5A,0x21B1,0x25A9,0x2A61,0x2FFC, +0x36A6,0x3E91,0x47FB,0x532B,0x6077,0x7044,0x830B,0x995E, +/* A:0f B:0d */ +0x0E51,0x0E71,0x0E97,0x0EC4,0x0EFA,0x0F3A,0x0F85,0x0FE0, +0x104B,0x10CA,0x1162,0x1216,0x12EC,0x13EA,0x1518,0x1680, +0x182B,0x1A26,0x1C81,0x1F4E,0x22A2,0x2696,0x2B4A,0x30E0, +0x3783,0x3F67,0x48C8,0x53EE,0x612D,0x70EC,0x83A2,0x99E0, +/* A:0f B:0e */ +0x0F85,0x0FA5,0x0FCB,0x0FF8,0x102D,0x106D,0x10B9,0x1112, +0x117D,0x11FC,0x1293,0x1346,0x141B,0x1518,0x1645,0x17AB, +0x1954,0x1B4D,0x1DA6,0x2070,0x23C0,0x27B0,0x2C5E,0x31EE, +0x388A,0x4066,0x49BC,0x54D5,0x6206,0x71B3,0x8455,0x9A7A, +/* A:0f B:0f */ +0x10F4,0x1113,0x1139,0x1166,0x119B,0x11DA,0x1226,0x127F, +0x12E9,0x1367,0x13FE,0x14B0,0x1584,0x1680,0x17AB,0x190F, +0x1AB6,0x1CAD,0x1F02,0x21C8,0x2514,0x28FF,0x2DA7,0x332F, +0x39C3,0x4194,0x4ADE,0x55E9,0x6308,0x72A1,0x852A,0x9B32, +/* A:0f B:10 */ +0x12A7,0x12C7,0x12EC,0x1319,0x134E,0x138D,0x13D7,0x1430, +0x149A,0x1517,0x15AC,0x165E,0x1730,0x182B,0x1954,0x1AB6, +0x1C5A,0x1E4E,0x209F,0x2361,0x26A8,0x2A8D,0x2F2D,0x34AD, +0x3B36,0x42FB,0x4C37,0x5730,0x643B,0x73BB,0x8627,0x9C0C, +/* A:0f B:11 */ +0x14AD,0x14CC,0x14F2,0x151E,0x1552,0x1591,0x15DB,0x1633, +0x169C,0x1718,0x17AD,0x185C,0x192E,0x1A26,0x1B4D,0x1CAD, +0x1E4E,0x203E,0x228B,0x2547,0x2888,0x2C65,0x30FD,0x3673, +0x3CF0,0x44A6,0x4DD0,0x58B5,0x65A7,0x750A,0x8754,0x9D10, +/* A:0f B:12 */ +0x1714,0x1734,0x1758,0x1784,0x17B8,0x17F6,0x1840,0x1897, +0x18FF,0x197A,0x1A0D,0x1ABC,0x1B8B,0x1C81,0x1DA6,0x1F02, +0x209F,0x228B,0x24D3,0x278A,0x2AC3,0x2E97,0x3325,0x388E, +0x3EFD,0x46A2,0x4FB7,0x5A83,0x6758,0x7699,0x88B9,0x9E44, +/* A:0f B:13 */ +0x19F0,0x1A0F,0x1A33,0x1A5E,0x1A92,0x1ACF,0x1B18,0x1B6E, +0x1BD5,0x1C4F,0x1CE1,0x1D8D,0x1E5A,0x1F4E,0x2070,0x21C8, +0x2361,0x2547,0x278A,0x2A38,0x2D69,0x3133,0x35B5,0x3B0F, +0x416C,0x48FD,0x51FA,0x5CA9,0x695B,0x7872,0x8A62,0x9FB2, +/* A:0f B:14 */ +0x1D55,0x1D73,0x1D97,0x1DC2,0x1DF5,0x1E32,0x1E79,0x1ECF, +0x1F34,0x1FAD,0x203C,0x20E7,0x21B1,0x22A2,0x23C0,0x2514, +0x26A8,0x2888,0x2AC3,0x2D69,0x308F,0x344D,0x38C0,0x3E09, +0x4452,0x4BC9,0x54A9,0x5F36,0x6BBF,0x7AA5,0x8C5A,0xA166, +/* A:0f B:15 */ +0x215E,0x217C,0x21A0,0x21CA,0x21FC,0x2237,0x227E,0x22D2, +0x2336,0x23AD,0x243A,0x24E2,0x25A9,0x2696,0x27B0,0x28FF, +0x2A8D,0x2C65,0x2E97,0x3133,0x344D,0x37FD,0x3C5E,0x4193, +0x47C3,0x4F1D,0x57DA,0x623E,0x6E96,0x7D42,0x8EB2,0xA36C, +/* A:0f B:16 */ +0x262A,0x2647,0x266A,0x2694,0x26C5,0x26FF,0x2745,0x2797, +0x27F9,0x286E,0x28F8,0x299D,0x2A61,0x2B4A,0x2C5E,0x2DA7, +0x2F2D,0x30FD,0x3325,0x35B5,0x38C0,0x3C5E,0x40AB,0x45C7, +0x4BDA,0x5312,0x5BA6,0x65D8,0x71F6,0x805D,0x917B,0xA5D3, +/* A:0f B:17 */ +0x2BDD,0x2BFA,0x2C1C,0x2C45,0x2C75,0x2CAE,0x2CF2,0x2D42, +0x2DA2,0x2E14,0x2E9C,0x2F3D,0x2FFC,0x30E0,0x31EE,0x332F, +0x34AD,0x3673,0x388E,0x3B0F,0x3E09,0x4193,0x45C7,0x4AC6, +0x50B6,0x57C5,0x6028,0x6A20,0x75F9,0x840E,0x94CA,0xA8AE, +/* A:0f B:18 */ +0x32A4,0x32C0,0x32E1,0x3308,0x3337,0x336F,0x33B1,0x33FF, +0x345C,0x34CB,0x354F,0x35EC,0x36A6,0x3783,0x388A,0x39C3, +0x3B36,0x3CF0,0x3EFD,0x416C,0x4452,0x47C3,0x4BDA,0x50B6, +0x567D,0x5D5B,0x6584,0x6F37,0x7ABE,0x8871,0x98B9,0xAC13, +/* A:0f B:19 */ +0x3AB1,0x3ACC,0x3AEC,0x3B12,0x3B40,0x3B75,0x3BB5,0x3C01, +0x3C5B,0x3CC7,0x3D46,0x3DDD,0x3E91,0x3F67,0x4066,0x4194, +0x42FB,0x44A6,0x46A2,0x48FD,0x4BC9,0x4F1D,0x5312,0x57C5, +0x5D5B,0x63FE,0x6BE2,0x7543,0x8069,0x8DA8,0x9D66,0xB01C, +/* A:0f B:1a */ +0x4443,0x445D,0x447C,0x44A0,0x44CC,0x44FF,0x453C,0x4585, +0x45DC,0x4643,0x46BD,0x474E,0x47FB,0x48C8,0x49BC,0x4ADE, +0x4C37,0x4DD0,0x4FB7,0x51FA,0x54A9,0x57DA,0x5BA6,0x6028, +0x6584,0x6BE2,0x7374,0x7C73,0x8725,0x93DA,0xA2F5,0xB4E8, +/* A:0f B:1b */ +0x4FA3,0x4FBC,0x4FD9,0x4FFB,0x5025,0x5055,0x5090,0x50D5, +0x5127,0x5189,0x51FD,0x5287,0x532B,0x53EE,0x54D5,0x55E9, +0x5730,0x58B5,0x5A83,0x5CA9,0x5F36,0x623E,0x65D8,0x6A20, +0x6F37,0x7543,0x7C73,0x84FF,0x8F26,0x9B37,0xA98F,0xBA9B, +/* A:0f B:1c */ +0x5D28,0x5D3F,0x5D5A,0x5D7A,0x5DA1,0x5DCF,0x5E05,0x5E46, +0x5E93,0x5EEF,0x5F5C,0x5FDD,0x6077,0x612D,0x6206,0x6308, +0x643B,0x65A7,0x6758,0x695B,0x6BBF,0x6E96,0x71F6,0x75F9, +0x7ABE,0x8069,0x8725,0x8F26,0x98AA,0xA3F8,0xB168,0xC161, +/* A:0f B:1d */ +0x6D39,0x6D4E,0x6D67,0x6D85,0x6DA8,0x6DD2,0x6E05,0x6E40, +0x6E87,0x6EDB,0x6F3F,0x6FB6,0x7044,0x70EC,0x71B3,0x72A1, +0x73BB,0x750A,0x7699,0x7872,0x7AA5,0x7D42,0x805D,0x840E, +0x8871,0x8DA8,0x93DA,0x9B37,0xA3F8,0xAE5F,0xBABC,0xC96E, +/* A:0f B:1e */ +0x8051,0x8064,0x807A,0x8095,0x80B5,0x80DB,0x8108,0x813D, +0x817D,0x81C8,0x8222,0x828D,0x830B,0x83A2,0x8455,0x852A, +0x8627,0x8754,0x88B9,0x8A62,0x8C5A,0x8EB2,0x917B,0x94CA, +0x98B9,0x9D66,0xA2F5,0xA98F,0xB168,0xBABC,0xC5D3,0xD300, +/* A:0f B:1f */ +0x9703,0x9713,0x9726,0x973D,0x9759,0x977A,0x97A0,0x97CF, +0x9805,0x9847,0x9894,0x98F0,0x995E,0x99E0,0x9A7A,0x9B32, +0x9C0C,0x9D10,0x9E44,0x9FB2,0xA166,0xA36C,0xA5D3,0xA8AE, +0xAC13,0xB01C,0xB4E8,0xBA9B,0xC161,0xC96E,0xD300,0xDE5F, +/* A: 968D89C0 */ +/* A:10 B:00 */ +0x0A5B,0x0A7B,0x0AA2,0x0ACF,0x0B06,0x0B47,0x0B94,0x0BEF, +0x0C5C,0x0CDD,0x0D77,0x0E2E,0x0F07,0x1008,0x113B,0x12A7, +0x1458,0x165B,0x18BF,0x1B95,0x1EF5,0x22F8,0x27BD,0x2D67, +0x3423,0x3C23,0x45A6,0x50F4,0x5E64,0x6E5B,0x8156,0x97E4, +/* A:10 B:01 */ +0x0A7B,0x0A9B,0x0AC2,0x0AF0,0x0B26,0x0B67,0x0BB4,0x0C10, +0x0C7C,0x0CFD,0x0D97,0x0E4E,0x0F26,0x1028,0x115B,0x12C7, +0x1478,0x167A,0x18DD,0x1BB4,0x1F13,0x2316,0x27DA,0x2D83, +0x343E,0x3C3E,0x45C0,0x510D,0x5E7A,0x6E70,0x8168,0x97F4, +/* A:10 B:02 */ +0x0AA2,0x0AC2,0x0AE9,0x0B16,0x0B4D,0x0B8E,0x0BDB,0x0C36, +0x0CA3,0x0D24,0x0DBD,0x0E74,0x0F4C,0x104E,0x1180,0x12EC, +0x149D,0x169F,0x1902,0x1BD8,0x1F37,0x2339,0x27FC,0x2DA5, +0x345F,0x3C5E,0x45DE,0x512A,0x5E96,0x6E89,0x817F,0x9807, +/* A:10 B:03 */ +0x0ACF,0x0AF0,0x0B16,0x0B44,0x0B7B,0x0BBB,0x0C08,0x0C64, +0x0CD0,0x0D51,0x0DEB,0x0EA1,0x0F7A,0x107B,0x11AD,0x1319, +0x14C9,0x16CB,0x192E,0x1C03,0x1F62,0x2363,0x2825,0x2DCD, +0x3486,0x3C84,0x4603,0x514C,0x5EB6,0x6EA7,0x8199,0x981E, +/* A:10 B:04 */ +0x0B06,0x0B26,0x0B4D,0x0B7B,0x0BB1,0x0BF2,0x0C3E,0x0C9A, +0x0D06,0x0D87,0x0E20,0x0ED7,0x0FAF,0x10B0,0x11E2,0x134E, +0x14FE,0x16FF,0x1961,0x1C36,0x1F94,0x2395,0x2856,0x2DFD, +0x34B5,0x3CB1,0x462E,0x5175,0x5EDC,0x6ECA,0x81B9,0x983A, +/* A:10 B:05 */ +0x0B47,0x0B67,0x0B8E,0x0BBB,0x0BF2,0x0C32,0x0C7F,0x0CDA, +0x0D47,0x0DC7,0x0E61,0x0F17,0x0FEF,0x10F0,0x1221,0x138D, +0x153C,0x173D,0x199F,0x1C73,0x1FD0,0x23D0,0x2890,0x2E36, +0x34EC,0x3CE6,0x4661,0x51A6,0x5F0A,0x6EF4,0x81DF,0x985A, +/* A:10 B:06 */ +0x0B94,0x0BB4,0x0BDB,0x0C08,0x0C3E,0x0C7F,0x0CCC,0x0D27, +0x0D93,0x0E14,0x0EAD,0x0F63,0x103B,0x113B,0x126D,0x13D7, +0x1586,0x1787,0x19E8,0x1CBC,0x2018,0x2416,0x28D5,0x2E79, +0x352E,0x3D26,0x469E,0x51DF,0x5F40,0x6F26,0x820B,0x9881, +/* A:10 B:07 */ +0x0BEF,0x0C10,0x0C36,0x0C64,0x0C9A,0x0CDA,0x0D27,0x0D82, +0x0DEE,0x0E6E,0x0F07,0x0FBD,0x1095,0x1195,0x12C6,0x1430, +0x15DF,0x17DF,0x1A3F,0x1D12,0x206D,0x246A,0x2927,0x2ECA, +0x357C,0x3D71,0x46E6,0x5224,0x5F80,0x6F61,0x8241,0x98AE, +/* A:10 B:08 */ +0x0C5C,0x0C7C,0x0CA3,0x0CD0,0x0D06,0x0D47,0x0D93,0x0DEE, +0x0E5A,0x0EDA,0x0F73,0x1028,0x1100,0x1200,0x1330,0x149A, +0x1648,0x1847,0x1AA6,0x1D78,0x20D2,0x24CD,0x2989,0x2F29, +0x35D9,0x3DCB,0x473C,0x5276,0x5FCD,0x6FA8,0x8280,0x98E5, +/* A:10 B:09 */ +0x0CDD,0x0CFD,0x0D24,0x0D51,0x0D87,0x0DC7,0x0E14,0x0E6E, +0x0EDA,0x0F5A,0x0FF3,0x10A8,0x117F,0x127E,0x13AE,0x1517, +0x16C4,0x18C2,0x1B21,0x1DF1,0x2149,0x2543,0x29FD,0x2F9A, +0x3647,0x3E35,0x47A3,0x52D7,0x6028,0x6FFB,0x82CB,0x9926, +/* A:10 B:0a */ +0x0D77,0x0D97,0x0DBD,0x0DEB,0x0E20,0x0E61,0x0EAD,0x0F07, +0x0F73,0x0FF3,0x108B,0x113F,0x1216,0x1315,0x1444,0x15AC, +0x1759,0x1956,0x1BB3,0x1E81,0x21D8,0x25CF,0x2A86,0x3021, +0x36CA,0x3EB4,0x481C,0x534A,0x6094,0x705F,0x8324,0x9973, +/* A:10 B:0b */ +0x0E2E,0x0E4E,0x0E74,0x0EA1,0x0ED7,0x0F17,0x0F63,0x0FBD, +0x1028,0x10A8,0x113F,0x11F3,0x12C9,0x13C8,0x14F6,0x165E, +0x1809,0x1A04,0x1C60,0x1F2D,0x2281,0x2676,0x2B2A,0x30C1, +0x3765,0x3F4B,0x48AD,0x53D3,0x6114,0x70D5,0x838E,0x99CE, +/* A:10 B:0c */ +0x0F07,0x0F26,0x0F4C,0x0F7A,0x0FAF,0x0FEF,0x103B,0x1095, +0x1100,0x117F,0x1216,0x12C9,0x139F,0x149C,0x15CA,0x1730, +0x18DA,0x1AD4,0x1D2E,0x1FF9,0x234A,0x273C,0x2BED,0x317F, +0x381E,0x3FFD,0x4958,0x5476,0x61AD,0x7162,0x840C,0x9A3B, +/* A:10 B:0d */ +0x1008,0x1028,0x104E,0x107B,0x10B0,0x10F0,0x113B,0x1195, +0x1200,0x127E,0x1315,0x13C8,0x149C,0x1599,0x16C6,0x182B, +0x19D3,0x1BCB,0x1E23,0x20EB,0x243A,0x2828,0x2CD4,0x3261, +0x38FA,0x40D2,0x4A24,0x5538,0x6263,0x7209,0x84A2,0x9ABC, +/* A:10 B:0e */ +0x113B,0x115B,0x1180,0x11AD,0x11E2,0x1221,0x126D,0x12C6, +0x1330,0x13AE,0x1444,0x14F6,0x15CA,0x16C6,0x17F1,0x1954, +0x1AFB,0x1CF1,0x1F46,0x220B,0x2556,0x2940,0x2DE7,0x336E, +0x3A00,0x41CF,0x4B17,0x561E,0x633A,0x72CF,0x8554,0x9B56, +/* A:10 B:0f */ +0x12A7,0x12C7,0x12EC,0x1319,0x134E,0x138D,0x13D7,0x1430, +0x149A,0x1517,0x15AC,0x165E,0x1730,0x182B,0x1954,0x1AB6, +0x1C5A,0x1E4E,0x209F,0x2361,0x26A8,0x2A8D,0x2F2D,0x34AD, +0x3B36,0x42FB,0x4C37,0x5730,0x643B,0x73BB,0x8627,0x9C0C, +/* A:10 B:10 */ +0x1458,0x1478,0x149D,0x14C9,0x14FE,0x153C,0x1586,0x15DF, +0x1648,0x16C4,0x1759,0x1809,0x18DA,0x19D3,0x1AFB,0x1C5A, +0x1DFC,0x1FEC,0x223B,0x24F8,0x2839,0x2C18,0x30B1,0x3629, +0x3CA8,0x4460,0x4D8D,0x5875,0x656C,0x74D3,0x8722,0x9CE5, +/* A:10 B:11 */ +0x165B,0x167A,0x169F,0x16CB,0x16FF,0x173D,0x1787,0x17DF, +0x1847,0x18C2,0x1956,0x1A04,0x1AD4,0x1BCB,0x1CF1,0x1E4E, +0x1FEC,0x21D9,0x2423,0x26DB,0x2A17,0x2DEE,0x327F,0x37EC, +0x3E5E,0x4608,0x4F24,0x59F8,0x66D6,0x7620,0x884D,0x9DE7, +/* A:10 B:12 */ +0x18BF,0x18DD,0x1902,0x192E,0x1961,0x199F,0x19E8,0x1A3F, +0x1AA6,0x1B21,0x1BB3,0x1C60,0x1D2E,0x1E23,0x1F46,0x209F, +0x223B,0x2423,0x2668,0x291A,0x2C4E,0x301C,0x34A3,0x3A04, +0x4068,0x4801,0x5108,0x5BC3,0x6884,0x77AC,0x89B0,0x9F19, +/* A:10 B:13 */ +0x1B95,0x1BB4,0x1BD8,0x1C03,0x1C36,0x1C73,0x1CBC,0x1D12, +0x1D78,0x1DF1,0x1E81,0x1F2D,0x1FF9,0x20EB,0x220B,0x2361, +0x24F8,0x26DB,0x291A,0x2BC4,0x2EF0,0x32B4,0x372E,0x3C81, +0x42D4,0x4A58,0x5347,0x5DE5,0x6A84,0x7983,0x8B56,0xA085, +/* A:10 B:14 */ +0x1EF5,0x1F13,0x1F37,0x1F62,0x1F94,0x1FD0,0x2018,0x206D, +0x20D2,0x2149,0x21D8,0x2281,0x234A,0x243A,0x2556,0x26A8, +0x2839,0x2A17,0x2C4E,0x2EF0,0x3211,0x35C9,0x3A35,0x3F76, +0x45B4,0x4D20,0x55F2,0x606E,0x6CE4,0x7BB2,0x8D4C,0xA236, +/* A:10 B:15 */ +0x22F8,0x2316,0x2339,0x2363,0x2395,0x23D0,0x2416,0x246A, +0x24CD,0x2543,0x25CF,0x2676,0x273C,0x2828,0x2940,0x2A8D, +0x2C18,0x2DEE,0x301C,0x32B4,0x35C9,0x3973,0x3DCD,0x42FA, +0x4920,0x506F,0x591F,0x6371,0x6FB6,0x7E4B,0x8FA0,0xA439, +/* A:10 B:16 */ +0x27BD,0x27DA,0x27FC,0x2825,0x2856,0x2890,0x28D5,0x2927, +0x2989,0x29FD,0x2A86,0x2B2A,0x2BED,0x2CD4,0x2DE7,0x2F2D, +0x30B1,0x327F,0x34A3,0x372E,0x3A35,0x3DCD,0x4213,0x4727, +0x4D31,0x545D,0x5CE4,0x6706,0x7311,0x8161,0x9264,0xA69C, +/* A:10 B:17 */ +0x2D67,0x2D83,0x2DA5,0x2DCD,0x2DFD,0x2E36,0x2E79,0x2ECA, +0x2F29,0x2F9A,0x3021,0x30C1,0x317F,0x3261,0x336E,0x34AD, +0x3629,0x37EC,0x3A04,0x3C81,0x3F76,0x42FA,0x4727,0x4C1F, +0x5205,0x5909,0x615F,0x6B47,0x770E,0x850C,0x95AE,0xA973, +/* A:10 B:18 */ +0x3423,0x343E,0x345F,0x3486,0x34B5,0x34EC,0x352E,0x357C, +0x35D9,0x3647,0x36CA,0x3765,0x381E,0x38FA,0x3A00,0x3B36, +0x3CA8,0x3E5E,0x4068,0x42D4,0x45B4,0x4920,0x4D31,0x5205, +0x57C3,0x5E96,0x66B2,0x7056,0x7BCB,0x8968,0x9997,0xACD2, +/* A:10 B:19 */ +0x3C23,0x3C3E,0x3C5E,0x3C84,0x3CB1,0x3CE6,0x3D26,0x3D71, +0x3DCB,0x3E35,0x3EB4,0x3F4B,0x3FFD,0x40D2,0x41CF,0x42FB, +0x4460,0x4608,0x4801,0x4A58,0x4D20,0x506F,0x545D,0x5909, +0x5E96,0x652F,0x6D07,0x7659,0x816C,0x8E97,0x9E3C,0xB0D5, +/* A:10 B:1a */ +0x45A6,0x45C0,0x45DE,0x4603,0x462E,0x4661,0x469E,0x46E6, +0x473C,0x47A3,0x481C,0x48AD,0x4958,0x4A24,0x4B17,0x4C37, +0x4D8D,0x4F24,0x5108,0x5347,0x55F2,0x591F,0x5CE4,0x615F, +0x66B2,0x6D07,0x748D,0x7D7E,0x881E,0x94BF,0xA3C2,0xB599, +/* A:10 B:1b */ +0x50F4,0x510D,0x512A,0x514C,0x5175,0x51A6,0x51DF,0x5224, +0x5276,0x52D7,0x534A,0x53D3,0x5476,0x5538,0x561E,0x5730, +0x5875,0x59F8,0x5BC3,0x5DE5,0x606E,0x6371,0x6706,0x6B47, +0x7056,0x7659,0x7D7E,0x85FB,0x9012,0x9C11,0xAA52,0xBB42, +/* A:10 B:1c */ +0x5E64,0x5E7A,0x5E96,0x5EB6,0x5EDC,0x5F0A,0x5F40,0x5F80, +0x5FCD,0x6028,0x6094,0x6114,0x61AD,0x6263,0x633A,0x643B, +0x656C,0x66D6,0x6884,0x6A84,0x6CE4,0x6FB6,0x7311,0x770E, +0x7BCB,0x816C,0x881E,0x9012,0x9987,0xA4C3,0xB21E,0xC1FE, +/* A:10 B:1d */ +0x6E5B,0x6E70,0x6E89,0x6EA7,0x6ECA,0x6EF4,0x6F26,0x6F61, +0x6FA8,0x6FFB,0x705F,0x70D5,0x7162,0x7209,0x72CF,0x73BB, +0x74D3,0x7620,0x77AC,0x7983,0x7BB2,0x7E4B,0x8161,0x850C, +0x8968,0x8E97,0x94BF,0x9C11,0xA4C3,0xAF1A,0xBB63,0xC9FE, +/* A:10 B:1e */ +0x8156,0x8168,0x817F,0x8199,0x81B9,0x81DF,0x820B,0x8241, +0x8280,0x82CB,0x8324,0x838E,0x840C,0x84A2,0x8554,0x8627, +0x8722,0x884D,0x89B0,0x8B56,0x8D4C,0x8FA0,0x9264,0x95AE, +0x9997,0x9E3C,0xA3C2,0xAA52,0xB21E,0xBB63,0xC668,0xD37F, +/* A:10 B:1f */ +0x97E4,0x97F4,0x9807,0x981E,0x983A,0x985A,0x9881,0x98AE, +0x98E5,0x9926,0x9973,0x99CE,0x9A3B,0x9ABC,0x9B56,0x9C0C, +0x9CE5,0x9DE7,0x9F19,0xA085,0xA236,0xA439,0xA69C,0xA973, +0xACD2,0xB0D5,0xB599,0xBB42,0xC1FE,0xC9FE,0xD37F,0xDECC, +/* A: 968D89C0 */ +/* A:11 B:00 */ +0x0C70,0x0C90,0x0CB6,0x0CE4,0x0D1A,0x0D5A,0x0DA7,0x0E02, +0x0E6E,0x0EEE,0x0F86,0x103C,0x1113,0x1213,0x1343,0x14AD, +0x165B,0x185A,0x1AB9,0x1D8A,0x20E4,0x24DF,0x299B,0x2F3A, +0x35EA,0x3DDB,0x474C,0x5285,0x5FDB,0x6FB5,0x828B,0x98EF, +/* A:11 B:01 */ +0x0C90,0x0CB0,0x0CD7,0x0D04,0x0D3A,0x0D7B,0x0DC7,0x0E22, +0x0E8E,0x0F0E,0x0FA6,0x105C,0x1133,0x1233,0x1363,0x14CC, +0x167A,0x1879,0x1AD7,0x1DA9,0x2102,0x24FD,0x29B8,0x2F57, +0x3605,0x3DF6,0x4766,0x529D,0x5FF2,0x6FCA,0x829E,0x98FF, +/* A:11 B:02 */ +0x0CB6,0x0CD7,0x0CFD,0x0D2A,0x0D60,0x0DA1,0x0DED,0x0E48, +0x0EB4,0x0F34,0x0FCC,0x1081,0x1159,0x1258,0x1388,0x14F2, +0x169F,0x189D,0x1AFC,0x1DCD,0x2125,0x2520,0x29DA,0x2F78, +0x3626,0x3E15,0x4784,0x52BA,0x600D,0x6FE2,0x82B4,0x9912, +/* A:11 B:03 */ +0x0CE4,0x0D04,0x0D2A,0x0D58,0x0D8E,0x0DCE,0x0E1A,0x0E75, +0x0EE1,0x0F61,0x0FF9,0x10AE,0x1185,0x1285,0x13B5,0x151E, +0x16CB,0x18C9,0x1B27,0x1DF7,0x2150,0x2549,0x2A03,0x2FA0, +0x364D,0x3E3B,0x47A8,0x52DC,0x602D,0x7000,0x82CF,0x9929, +/* A:11 B:04 */ +0x0D1A,0x0D3A,0x0D60,0x0D8E,0x0DC4,0x0E04,0x0E50,0x0EAB, +0x0F17,0x0F97,0x102F,0x10E4,0x11BB,0x12BA,0x13EA,0x1552, +0x16FF,0x18FD,0x1B5A,0x1E2A,0x2182,0x257B,0x2A33,0x2FD0, +0x367B,0x3E68,0x47D3,0x5305,0x6053,0x7023,0x82EE,0x9944, +/* A:11 B:05 */ +0x0D5A,0x0D7B,0x0DA1,0x0DCE,0x0E04,0x0E44,0x0E90,0x0EEB, +0x0F56,0x0FD6,0x106E,0x1123,0x11FA,0x12F9,0x1428,0x1591, +0x173D,0x193A,0x1B97,0x1E67,0x21BE,0x25B5,0x2A6D,0x3008, +0x36B2,0x3E9D,0x4806,0x5335,0x6080,0x704D,0x8314,0x9965, +/* A:11 B:06 */ +0x0DA7,0x0DC7,0x0DED,0x0E1A,0x0E50,0x0E90,0x0EDC,0x0F37, +0x0FA2,0x1022,0x10BA,0x116E,0x1245,0x1344,0x1473,0x15DB, +0x1787,0x1984,0x1BE0,0x1EAE,0x2204,0x25FB,0x2AB1,0x304B, +0x36F3,0x3EDC,0x4842,0x536E,0x60B6,0x707E,0x8340,0x998B, +/* A:11 B:07 */ +0x0E02,0x0E22,0x0E48,0x0E75,0x0EAB,0x0EEB,0x0F37,0x0F91, +0x0FFD,0x107C,0x1114,0x11C8,0x129E,0x139D,0x14CB,0x1633, +0x17DF,0x19DB,0x1C36,0x1F04,0x2259,0x264E,0x2B03,0x309B, +0x3740,0x3F26,0x488A,0x53B3,0x60F6,0x70B9,0x8375,0x99B8, +/* A:11 B:08 */ +0x0E6E,0x0E8E,0x0EB4,0x0EE1,0x0F17,0x0F56,0x0FA2,0x0FFD, +0x1068,0x10E7,0x117F,0x1233,0x1308,0x1407,0x1535,0x169C, +0x1847,0x1A42,0x1C9D,0x1F69,0x22BD,0x26B1,0x2B64,0x30F9, +0x379C,0x3F7F,0x48DF,0x5404,0x6142,0x70FF,0x83B3,0x99EE, +/* A:11 B:09 */ +0x0EEE,0x0F0E,0x0F34,0x0F61,0x0F97,0x0FD6,0x1022,0x107C, +0x10E7,0x1166,0x11FE,0x12B1,0x1387,0x1484,0x15B2,0x1718, +0x18C2,0x1ABD,0x1D17,0x1FE2,0x2334,0x2726,0x2BD7,0x316A, +0x380A,0x3FE9,0x4945,0x5464,0x619C,0x7152,0x83FE,0x9A2F, +/* A:11 B:0a */ +0x0F86,0x0FA6,0x0FCC,0x0FF9,0x102F,0x106E,0x10BA,0x1114, +0x117F,0x11FE,0x1294,0x1348,0x141D,0x151A,0x1647,0x17AD, +0x1956,0x1B4F,0x1DA7,0x2071,0x23C1,0x27B1,0x2C5F,0x31EF, +0x388C,0x4067,0x49BE,0x54D7,0x6207,0x71B5,0x8456,0x9A7B, +/* A:11 B:0b */ +0x103C,0x105C,0x1081,0x10AE,0x10E4,0x1123,0x116E,0x11C8, +0x1233,0x12B1,0x1348,0x13FA,0x14CF,0x15CC,0x16F8,0x185C, +0x1A04,0x1BFC,0x1E53,0x211B,0x2469,0x2857,0x2D02,0x328E, +0x3926,0x40FC,0x4A4D,0x555F,0x6287,0x722A,0x84C0,0x9AD6, +/* A:11 B:0c */ +0x1113,0x1133,0x1159,0x1185,0x11BB,0x11FA,0x1245,0x129E, +0x1308,0x1387,0x141D,0x14CF,0x15A3,0x169F,0x17CA,0x192E, +0x1AD4,0x1CCB,0x1F20,0x21E6,0x2531,0x291B,0x2DC3,0x334B, +0x39DE,0x41AE,0x4AF7,0x5601,0x631E,0x72B5,0x853D,0x9B42, +/* A:11 B:0d */ +0x1213,0x1233,0x1258,0x1285,0x12BA,0x12F9,0x1344,0x139D, +0x1407,0x1484,0x151A,0x15CC,0x169F,0x179A,0x18C4,0x1A26, +0x1BCB,0x1DC0,0x2013,0x22D6,0x261E,0x2A05,0x2EA8,0x342B, +0x3AB8,0x4281,0x4BC2,0x56C1,0x63D3,0x735B,0x85D1,0x9BC2, +/* A:11 B:0e */ +0x1343,0x1363,0x1388,0x13B5,0x13EA,0x1428,0x1473,0x14CB, +0x1535,0x15B2,0x1647,0x16F8,0x17CA,0x18C4,0x19ED,0x1B4D, +0x1CF1,0x1EE3,0x2134,0x23F4,0x2739,0x2B1B,0x2FB9,0x3536, +0x3BBC,0x437C,0x4CB2,0x57A5,0x64A9,0x7420,0x8682,0x9C5A, +/* A:11 B:0f */ +0x14AD,0x14CC,0x14F2,0x151E,0x1552,0x1591,0x15DB,0x1633, +0x169C,0x1718,0x17AD,0x185C,0x192E,0x1A26,0x1B4D,0x1CAD, +0x1E4E,0x203E,0x228B,0x2547,0x2888,0x2C65,0x30FD,0x3673, +0x3CF0,0x44A6,0x4DD0,0x58B5,0x65A7,0x750A,0x8754,0x9D10, +/* A:11 B:10 */ +0x165B,0x167A,0x169F,0x16CB,0x16FF,0x173D,0x1787,0x17DF, +0x1847,0x18C2,0x1956,0x1A04,0x1AD4,0x1BCB,0x1CF1,0x1E4E, +0x1FEC,0x21D9,0x2423,0x26DB,0x2A17,0x2DEE,0x327F,0x37EC, +0x3E5E,0x4608,0x4F24,0x59F8,0x66D6,0x7620,0x884D,0x9DE7, +/* A:11 B:11 */ +0x185A,0x1879,0x189D,0x18C9,0x18FD,0x193A,0x1984,0x19DB, +0x1A42,0x1ABD,0x1B4F,0x1BFC,0x1CCB,0x1DC0,0x1EE3,0x203E, +0x21D9,0x23C3,0x2608,0x28BB,0x2BF0,0x2FC0,0x3449,0x39AB, +0x4012,0x47AE,0x50B8,0x5B77,0x683D,0x776B,0x8976,0x9EE7, +/* A:11 B:12 */ +0x1AB9,0x1AD7,0x1AFC,0x1B27,0x1B5A,0x1B97,0x1BE0,0x1C36, +0x1C9D,0x1D17,0x1DA7,0x1E53,0x1F20,0x2013,0x2134,0x228B, +0x2423,0x2608,0x2848,0x2AF5,0x2E23,0x31EB,0x3669,0x3BBF, +0x4218,0x49A2,0x5299,0x5D3F,0x69E8,0x78F4,0x8AD6,0xA017, +/* A:11 B:13 */ +0x1D8A,0x1DA9,0x1DCD,0x1DF7,0x1E2A,0x1E67,0x1EAE,0x1F04, +0x1F69,0x1FE2,0x2071,0x211B,0x21E6,0x22D6,0x23F4,0x2547, +0x26DB,0x28BB,0x2AF5,0x2D9B,0x30C0,0x347E,0x38F0,0x3E38, +0x447F,0x4BF5,0x54D3,0x5F5D,0x6BE4,0x7AC7,0x8C79,0xA180, +/* A:11 B:14 */ +0x20E4,0x2102,0x2125,0x2150,0x2182,0x21BE,0x2204,0x2259, +0x22BD,0x2334,0x23C1,0x2469,0x2531,0x261E,0x2739,0x2888, +0x2A17,0x2BF0,0x2E23,0x30C0,0x33DC,0x378D,0x3BF0,0x4127, +0x475A,0x4EB8,0x577A,0x61E1,0x6E40,0x7CF2,0x8E6B,0xA32E, +/* A:11 B:15 */ +0x24DF,0x24FD,0x2520,0x2549,0x257B,0x25B5,0x25FB,0x264E, +0x26B1,0x2726,0x27B1,0x2857,0x291B,0x2A05,0x2B1B,0x2C65, +0x2DEE,0x2FC0,0x31EB,0x347E,0x378D,0x3B30,0x3F82,0x44A5, +0x4ABF,0x5200,0x5AA0,0x64DF,0x710D,0x7F86,0x90BA,0xA52C, +/* A:11 B:16 */ +0x299B,0x29B8,0x29DA,0x2A03,0x2A33,0x2A6D,0x2AB1,0x2B03, +0x2B64,0x2BD7,0x2C5F,0x2D02,0x2DC3,0x2EA8,0x2FB9,0x30FD, +0x327F,0x3449,0x3669,0x38F0,0x3BF0,0x3F82,0x43C0,0x48CA, +0x4EC8,0x55E7,0x5E5E,0x686D,0x7461,0x8296,0x9379,0xA78B, +/* A:11 B:17 */ +0x2F3A,0x2F57,0x2F78,0x2FA0,0x2FD0,0x3008,0x304B,0x309B, +0x30F9,0x316A,0x31EF,0x328E,0x334B,0x342B,0x3536,0x3673, +0x37EC,0x39AB,0x3BBF,0x3E38,0x4127,0x44A5,0x48CA,0x4DB8, +0x5394,0x5A8A,0x62D0,0x6CA6,0x7856,0x863A,0x96BD,0xAA5C, +/* A:11 B:18 */ +0x35EA,0x3605,0x3626,0x364D,0x367B,0x36B2,0x36F3,0x3740, +0x379C,0x380A,0x388C,0x3926,0x39DE,0x3AB8,0x3BBC,0x3CF0, +0x3E5E,0x4012,0x4218,0x447F,0x475A,0x4ABF,0x4EC8,0x5394, +0x5947,0x600D,0x681A,0x71AB,0x7D0A,0x8A8E,0x9A9E,0xADB5, +/* A:11 B:19 */ +0x3DDB,0x3DF6,0x3E15,0x3E3B,0x3E68,0x3E9D,0x3EDC,0x3F26, +0x3F7F,0x3FE9,0x4067,0x40FC,0x41AE,0x4281,0x437C,0x44A6, +0x4608,0x47AE,0x49A2,0x4BF5,0x4EB8,0x5200,0x55E7,0x5A8A, +0x600D,0x6699,0x6E62,0x77A2,0x82A1,0x8FB3,0x9F3A,0xB1B0, +/* A:11 B:1a */ +0x474C,0x4766,0x4784,0x47A8,0x47D3,0x4806,0x4842,0x488A, +0x48DF,0x4945,0x49BE,0x4A4D,0x4AF7,0x4BC2,0x4CB2,0x4DD0, +0x4F24,0x50B8,0x5299,0x54D3,0x577A,0x5AA0,0x5E5E,0x62D0, +0x681A,0x6E62,0x75DA,0x7EBA,0x8946,0x95CF,0xA4B5,0xB66A, +/* A:11 B:1b */ +0x5285,0x529D,0x52BA,0x52DC,0x5305,0x5335,0x536E,0x53B3, +0x5404,0x5464,0x54D7,0x555F,0x5601,0x56C1,0x57A5,0x58B5, +0x59F8,0x5B77,0x5D3F,0x5F5D,0x61E1,0x64DF,0x686D,0x6CA6, +0x71AB,0x77A2,0x7EBA,0x8727,0x912B,0x9D13,0xAB39,0xBC09, +/* A:11 B:1c */ +0x5FDB,0x5FF2,0x600D,0x602D,0x6053,0x6080,0x60B6,0x60F6, +0x6142,0x619C,0x6207,0x6287,0x631E,0x63D3,0x64A9,0x65A7, +0x66D6,0x683D,0x69E8,0x6BE4,0x6E40,0x710D,0x7461,0x7856, +0x7D0A,0x82A1,0x8946,0x912B,0x9A8E,0xA5B5,0xB2F6,0xC2B7, +/* A:11 B:1d */ +0x6FB5,0x6FCA,0x6FE2,0x7000,0x7023,0x704D,0x707E,0x70B9, +0x70FF,0x7152,0x71B5,0x722A,0x72B5,0x735B,0x7420,0x750A, +0x7620,0x776B,0x78F4,0x7AC7,0x7CF2,0x7F86,0x8296,0x863A, +0x8A8E,0x8FB3,0x95CF,0x9D13,0xA5B5,0xAFF8,0xBC29,0xCAA8, +/* A:11 B:1e */ +0x828B,0x829E,0x82B4,0x82CF,0x82EE,0x8314,0x8340,0x8375, +0x83B3,0x83FE,0x8456,0x84C0,0x853D,0x85D1,0x8682,0x8754, +0x884D,0x8976,0x8AD6,0x8C79,0x8E6B,0x90BA,0x9379,0x96BD, +0x9A9E,0x9F3A,0xA4B5,0xAB39,0xB2F6,0xBC29,0xC719,0xD417, +/* A:11 B:1f */ +0x98EF,0x98FF,0x9912,0x9929,0x9944,0x9965,0x998B,0x99B8, +0x99EE,0x9A2F,0x9A7B,0x9AD6,0x9B42,0x9BC2,0x9C5A,0x9D10, +0x9DE7,0x9EE7,0xA017,0xA180,0xA32E,0xA52C,0xA78B,0xAA5C, +0xADB5,0xB1B0,0xB66A,0xBC09,0xC2B7,0xCAA8,0xD417,0xDF4E, +/* A: 968D89C0 */ +/* A:12 B:00 */ +0x0EEA,0x0F0A,0x0F30,0x0F5D,0x0F93,0x0FD2,0x101E,0x1078, +0x10E3,0x1162,0x11F9,0x12AD,0x1383,0x1480,0x15AE,0x1714, +0x18BF,0x1AB9,0x1D13,0x1FDE,0x2330,0x2722,0x2BD3,0x3166, +0x3806,0x3FE6,0x4942,0x5461,0x6199,0x7150,0x83FC,0x9A2D, +/* A:12 B:01 */ +0x0F0A,0x0F2A,0x0F50,0x0F7D,0x0FB2,0x0FF2,0x103E,0x1098, +0x1103,0x1182,0x1219,0x12CD,0x13A2,0x14A0,0x15CD,0x1734, +0x18DD,0x1AD7,0x1D31,0x1FFC,0x234E,0x273F,0x2BF0,0x3182, +0x3821,0x4000,0x495B,0x5479,0x61B0,0x7164,0x840E,0x9A3D, +/* A:12 B:02 */ +0x0F30,0x0F50,0x0F76,0x0FA3,0x0FD8,0x1018,0x1064,0x10BE, +0x1129,0x11A8,0x123F,0x12F2,0x13C7,0x14C5,0x15F2,0x1758, +0x1902,0x1AFC,0x1D55,0x2020,0x2371,0x2762,0x2C12,0x31A3, +0x3842,0x4020,0x4979,0x5496,0x61CB,0x717D,0x8424,0x9A50, +/* A:12 B:03 */ +0x0F5D,0x0F7D,0x0FA3,0x0FD0,0x1005,0x1045,0x1091,0x10EA, +0x1155,0x11D4,0x126B,0x131F,0x13F4,0x14F1,0x161E,0x1784, +0x192E,0x1B27,0x1D80,0x204A,0x239B,0x278B,0x2C3A,0x31CB, +0x3868,0x4045,0x499D,0x54B8,0x61EA,0x719A,0x843F,0x9A67, +/* A:12 B:04 */ +0x0F93,0x0FB2,0x0FD8,0x1005,0x103B,0x107A,0x10C6,0x1120, +0x118B,0x1209,0x12A0,0x1354,0x1429,0x1526,0x1653,0x17B8, +0x1961,0x1B5A,0x1DB3,0x207C,0x23CC,0x27BC,0x2C6A,0x31FA, +0x3896,0x4071,0x49C7,0x54E0,0x6210,0x71BD,0x845E,0x9A82, +/* A:12 B:05 */ +0x0FD2,0x0FF2,0x1018,0x1045,0x107A,0x10BA,0x1105,0x115F, +0x11CA,0x1249,0x12DF,0x1392,0x1467,0x1564,0x1691,0x17F6, +0x199F,0x1B97,0x1DEF,0x20B8,0x2408,0x27F7,0x2CA3,0x3232, +0x38CC,0x40A6,0x49FA,0x5510,0x623D,0x71E6,0x8483,0x9AA2, +/* A:12 B:06 */ +0x101E,0x103E,0x1064,0x1091,0x10C6,0x1105,0x1151,0x11AB, +0x1215,0x1294,0x132A,0x13DD,0x14B2,0x15AE,0x16DB,0x1840, +0x19E8,0x1BE0,0x1E37,0x20FF,0x244E,0x283C,0x2CE7,0x3274, +0x390D,0x40E4,0x4A36,0x5549,0x6272,0x7217,0x84AF,0x9AC7, +/* A:12 B:07 */ +0x1078,0x1098,0x10BE,0x10EA,0x1120,0x115F,0x11AB,0x1204, +0x126F,0x12ED,0x1383,0x1436,0x150A,0x1607,0x1733,0x1897, +0x1A3F,0x1C36,0x1E8D,0x2154,0x24A1,0x288E,0x2D38,0x32C3, +0x395A,0x412E,0x4A7D,0x558C,0x62B2,0x7251,0x84E3,0x9AF5, +/* A:12 B:08 */ +0x10E3,0x1103,0x1129,0x1155,0x118B,0x11CA,0x1215,0x126F, +0x12D9,0x1357,0x13ED,0x14A0,0x1574,0x1670,0x179B,0x18FF, +0x1AA6,0x1C9D,0x1EF2,0x21B8,0x2505,0x28F0,0x2D98,0x3321, +0x39B5,0x4187,0x4AD1,0x55DD,0x62FD,0x7297,0x8521,0x9B2A, +/* A:12 B:09 */ +0x1162,0x1182,0x11A8,0x11D4,0x1209,0x1249,0x1294,0x12ED, +0x1357,0x13D5,0x146B,0x151D,0x15F1,0x16EC,0x1817,0x197A, +0x1B21,0x1D17,0x1F6B,0x2230,0x257A,0x2964,0x2E0A,0x3390, +0x3A21,0x41EF,0x4B36,0x563C,0x6356,0x72E9,0x856B,0x9B6A, +/* A:12 B:0a */ +0x11F9,0x1219,0x123F,0x126B,0x12A0,0x12DF,0x132A,0x1383, +0x13ED,0x146B,0x1500,0x15B2,0x1685,0x1780,0x18AB,0x1A0D, +0x1BB3,0x1DA7,0x1FFB,0x22BE,0x2607,0x29EE,0x2E91,0x3415, +0x3AA2,0x426C,0x4BAE,0x56AE,0x63C1,0x734B,0x85C2,0x9BB5, +/* A:12 B:0b */ +0x12AD,0x12CD,0x12F2,0x131F,0x1354,0x1392,0x13DD,0x1436, +0x14A0,0x151D,0x15B2,0x1663,0x1736,0x1830,0x195A,0x1ABC, +0x1C60,0x1E53,0x20A5,0x2367,0x26AD,0x2A92,0x2F32,0x34B2, +0x3B3C,0x4300,0x4C3C,0x5735,0x643F,0x73BF,0x862B,0x9C0F, +/* A:12 B:0c */ +0x1383,0x13A2,0x13C7,0x13F4,0x1429,0x1467,0x14B2,0x150A, +0x1574,0x15F1,0x1685,0x1736,0x1808,0x1902,0x1A2A,0x1B8B, +0x1D2E,0x1F20,0x2170,0x242F,0x2773,0x2B55,0x2FF2,0x356D, +0x3BF2,0x43B0,0x4CE4,0x57D5,0x64D5,0x7449,0x86A7,0x9C7A, +/* A:12 B:0d */ +0x1480,0x14A0,0x14C5,0x14F1,0x1526,0x1564,0x15AE,0x1607, +0x1670,0x16EC,0x1780,0x1830,0x1902,0x19FA,0x1B22,0x1C81, +0x1E23,0x2013,0x2261,0x251E,0x285F,0x2C3D,0x30D5,0x364C, +0x3CCA,0x4481,0x4DAD,0x5894,0x6588,0x74ED,0x873A,0x9CF9, +/* A:12 B:0e */ +0x15AE,0x15CD,0x15F2,0x161E,0x1653,0x1691,0x16DB,0x1733, +0x179B,0x1817,0x18AB,0x195A,0x1A2A,0x1B22,0x1C48,0x1DA6, +0x1F46,0x2134,0x237F,0x2639,0x2976,0x2D50,0x31E4,0x3754, +0x3DCB,0x457A,0x4E9C,0x5976,0x665C,0x75B1,0x87E9,0x9D90, +/* A:12 B:0f */ +0x1714,0x1734,0x1758,0x1784,0x17B8,0x17F6,0x1840,0x1897, +0x18FF,0x197A,0x1A0D,0x1ABC,0x1B8B,0x1C81,0x1DA6,0x1F02, +0x209F,0x228B,0x24D3,0x278A,0x2AC3,0x2E97,0x3325,0x388E, +0x3EFD,0x46A2,0x4FB7,0x5A83,0x6758,0x7699,0x88B9,0x9E44, +/* A:12 B:10 */ +0x18BF,0x18DD,0x1902,0x192E,0x1961,0x199F,0x19E8,0x1A3F, +0x1AA6,0x1B21,0x1BB3,0x1C60,0x1D2E,0x1E23,0x1F46,0x209F, +0x223B,0x2423,0x2668,0x291A,0x2C4E,0x301C,0x34A3,0x3A04, +0x4068,0x4801,0x5108,0x5BC3,0x6884,0x77AC,0x89B0,0x9F19, +/* A:12 B:11 */ +0x1AB9,0x1AD7,0x1AFC,0x1B27,0x1B5A,0x1B97,0x1BE0,0x1C36, +0x1C9D,0x1D17,0x1DA7,0x1E53,0x1F20,0x2013,0x2134,0x228B, +0x2423,0x2608,0x2848,0x2AF5,0x2E23,0x31EB,0x3669,0x3BBF, +0x4218,0x49A2,0x5299,0x5D3F,0x69E8,0x78F4,0x8AD6,0xA017, +/* A:12 B:12 */ +0x1D13,0x1D31,0x1D55,0x1D80,0x1DB3,0x1DEF,0x1E37,0x1E8D, +0x1EF2,0x1F6B,0x1FFB,0x20A5,0x2170,0x2261,0x237F,0x24D3, +0x2668,0x2848,0x2A84,0x2D2A,0x3051,0x3410,0x3884,0x3DCF, +0x4419,0x4B92,0x5474,0x5F03,0x6B90,0x7A7A,0x8C33,0xA144, +/* A:12 B:13 */ +0x1FDE,0x1FFC,0x2020,0x204A,0x207C,0x20B8,0x20FF,0x2154, +0x21B8,0x2230,0x22BE,0x2367,0x242F,0x251E,0x2639,0x278A, +0x291A,0x2AF5,0x2D2A,0x2FCA,0x32E9,0x369E,0x3B05,0x4042, +0x467B,0x4DE0,0x56AA,0x611C,0x6D87,0x7C49,0x8DD2,0xA2AA, +/* A:12 B:14 */ +0x2330,0x234E,0x2371,0x239B,0x23CC,0x2408,0x244E,0x24A1, +0x2505,0x257A,0x2607,0x26AD,0x2773,0x285F,0x2976,0x2AC3, +0x2C4E,0x2E23,0x3051,0x32E9,0x35FD,0x39A6,0x3DFF,0x432B, +0x494F,0x509D,0x594A,0x639B,0x6FDD,0x7E6F,0x8FC0,0xA454, +/* A:12 B:15 */ +0x2722,0x273F,0x2762,0x278B,0x27BC,0x27F7,0x283C,0x288E, +0x28F0,0x2964,0x29EE,0x2A92,0x2B55,0x2C3D,0x2D50,0x2E97, +0x301C,0x31EB,0x3410,0x369E,0x39A6,0x3D40,0x4189,0x46A0, +0x4CAD,0x53DE,0x5C69,0x6692,0x72A4,0x80FD,0x920A,0xA64E, +/* A:12 B:16 */ +0x2BD3,0x2BF0,0x2C12,0x2C3A,0x2C6A,0x2CA3,0x2CE7,0x2D38, +0x2D98,0x2E0A,0x2E91,0x2F32,0x2FF2,0x30D5,0x31E4,0x3325, +0x34A3,0x3669,0x3884,0x3B05,0x3DFF,0x4189,0x45BD,0x4ABC, +0x50AD,0x57BB,0x601F,0x6A17,0x75F1,0x8406,0x94C3,0xA8A7, +/* A:12 B:17 */ +0x3166,0x3182,0x31A3,0x31CB,0x31FA,0x3232,0x3274,0x32C3, +0x3321,0x3390,0x3415,0x34B2,0x356D,0x364C,0x3754,0x388E, +0x3A04,0x3BBF,0x3DCF,0x4042,0x432B,0x46A0,0x4ABC,0x4F9F, +0x556D,0x5C54,0x6488,0x6E47,0x79DD,0x87A1,0x97FF,0xAB72, +/* A:12 B:18 */ +0x3806,0x3821,0x3842,0x3868,0x3896,0x38CC,0x390D,0x395A, +0x39B5,0x3A21,0x3AA2,0x3B3C,0x3BF2,0x3CCA,0x3DCB,0x3EFD, +0x4068,0x4218,0x4419,0x467B,0x494F,0x4CAD,0x50AD,0x556D, +0x5B13,0x61CA,0x69C5,0x7341,0x7E86,0x8BEB,0x9BD7,0xAEC3, +/* A:12 B:19 */ +0x3FE6,0x4000,0x4020,0x4045,0x4071,0x40A6,0x40E4,0x412E, +0x4187,0x41EF,0x426C,0x4300,0x43B0,0x4481,0x457A,0x46A2, +0x4801,0x49A2,0x4B92,0x4DE0,0x509D,0x53DE,0x57BB,0x5C54, +0x61CA,0x6848,0x6FFF,0x792A,0x8410,0x9104,0xA069,0xB2B4, +/* A:12 B:1a */ +0x4942,0x495B,0x4979,0x499D,0x49C7,0x49FA,0x4A36,0x4A7D, +0x4AD1,0x4B36,0x4BAE,0x4C3C,0x4CE4,0x4DAD,0x4E9C,0x4FB7, +0x5108,0x5299,0x5474,0x56AA,0x594A,0x5C69,0x601F,0x6488, +0x69C5,0x6FFF,0x7766,0x8031,0x8AA6,0x9713,0xA5D7,0xB764, +/* A:12 B:1b */ +0x5461,0x5479,0x5496,0x54B8,0x54E0,0x5510,0x5549,0x558C, +0x55DD,0x563C,0x56AE,0x5735,0x57D5,0x5894,0x5976,0x5A83, +0x5BC3,0x5D3F,0x5F03,0x611C,0x639B,0x6692,0x6A17,0x6E47, +0x7341,0x792A,0x8031,0x888C,0x9279,0x9E46,0xAC4B,0xBCF6, +/* A:12 B:1c */ +0x6199,0x61B0,0x61CB,0x61EA,0x6210,0x623D,0x6272,0x62B2, +0x62FD,0x6356,0x63C1,0x643F,0x64D5,0x6588,0x665C,0x6758, +0x6884,0x69E8,0x6B90,0x6D87,0x6FDD,0x72A4,0x75F1,0x79DD, +0x7E86,0x8410,0x8AA6,0x9279,0x9BC6,0xA6D4,0xB3F7,0xC394, +/* A:12 B:1d */ +0x7150,0x7164,0x717D,0x719A,0x71BD,0x71E6,0x7217,0x7251, +0x7297,0x72E9,0x734B,0x73BF,0x7449,0x74ED,0x75B1,0x7699, +0x77AC,0x78F4,0x7A7A,0x7C49,0x7E6F,0x80FD,0x8406,0x87A1, +0x8BEB,0x9104,0x9713,0x9E46,0xA6D4,0xB0FF,0xBD15,0xCB72, +/* A:12 B:1e */ +0x83FC,0x840E,0x8424,0x843F,0x845E,0x8483,0x84AF,0x84E3, +0x8521,0x856B,0x85C2,0x862B,0x86A7,0x873A,0x87E9,0x88B9, +0x89B0,0x8AD6,0x8C33,0x8DD2,0x8FC0,0x920A,0x94C3,0x97FF, +0x9BD7,0xA069,0xA5D7,0xAC4B,0xB3F7,0xBD15,0xC7EB,0xD4CC, +/* A:12 B:1f */ +0x9A2D,0x9A3D,0x9A50,0x9A67,0x9A82,0x9AA2,0x9AC7,0x9AF5, +0x9B2A,0x9B6A,0x9BB5,0x9C0F,0x9C7A,0x9CF9,0x9D90,0x9E44, +0x9F19,0xA017,0xA144,0xA2AA,0xA454,0xA64E,0xA8A7,0xAB72, +0xAEC3,0xB2B4,0xB764,0xBCF6,0xC394,0xCB72,0xD4CC,0xDFE8, +/* A: 968D89C0 */ +/* A:13 B:00 */ +0x11DB,0x11FB,0x1220,0x124D,0x1282,0x12C1,0x130C,0x1365, +0x13CF,0x144D,0x14E3,0x1594,0x1668,0x1763,0x188D,0x19F0, +0x1B95,0x1D8A,0x1FDE,0x22A2,0x25EB,0x29D2,0x2E76,0x33FB, +0x3A89,0x4253,0x4B96,0x5697,0x63AC,0x7338,0x85B2,0x9BA7, +/* A:13 B:01 */ +0x11FB,0x121A,0x1240,0x126D,0x12A2,0x12E1,0x132C,0x1385, +0x13EF,0x146C,0x1502,0x15B4,0x1687,0x1782,0x18AC,0x1A0F, +0x1BB4,0x1DA9,0x1FFC,0x22BF,0x2608,0x29EF,0x2E93,0x3416, +0x3AA4,0x426D,0x4BAF,0x56AF,0x63C2,0x734C,0x85C4,0x9BB7, +/* A:13 B:02 */ +0x1220,0x1240,0x1266,0x1292,0x12C7,0x1306,0x1351,0x13AA, +0x1414,0x1492,0x1527,0x15D9,0x16AC,0x17A7,0x18D1,0x1A33, +0x1BD8,0x1DCD,0x2020,0x22E3,0x262B,0x2A12,0x2EB5,0x3437, +0x3AC4,0x428C,0x4BCD,0x56CB,0x63DD,0x7364,0x85DA,0x9BCA, +/* A:13 B:03 */ +0x124D,0x126D,0x1292,0x12BF,0x12F4,0x1333,0x137E,0x13D7, +0x1440,0x14BE,0x1553,0x1605,0x16D8,0x17D2,0x18FC,0x1A5E, +0x1C03,0x1DF7,0x204A,0x230D,0x2654,0x2A3A,0x2EDD,0x345E, +0x3AEA,0x42B1,0x4BF0,0x56ED,0x63FC,0x7381,0x85F4,0x9BE0, +/* A:13 B:04 */ +0x1282,0x12A2,0x12C7,0x12F4,0x1329,0x1368,0x13B2,0x140B, +0x1475,0x14F2,0x1588,0x1639,0x170C,0x1806,0x1930,0x1A92, +0x1C36,0x1E2A,0x207C,0x233E,0x2686,0x2A6B,0x2F0C,0x348D, +0x3B17,0x42DD,0x4C1A,0x5715,0x6421,0x73A4,0x8612,0x9BFB, +/* A:13 B:05 */ +0x12C1,0x12E1,0x1306,0x1333,0x1368,0x13A6,0x13F1,0x144A, +0x14B4,0x1531,0x15C6,0x1677,0x174A,0x1844,0x196E,0x1ACF, +0x1C73,0x1E67,0x20B8,0x237A,0x26C0,0x2AA4,0x2F45,0x34C4, +0x3B4D,0x4311,0x4C4C,0x5744,0x644E,0x73CC,0x8637,0x9C1A, +/* A:13 B:06 */ +0x130C,0x132C,0x1351,0x137E,0x13B2,0x13F1,0x143C,0x1495, +0x14FE,0x157B,0x1610,0x16C1,0x1794,0x188E,0x19B7,0x1B18, +0x1CBC,0x1EAE,0x20FF,0x23C0,0x2706,0x2AE9,0x2F88,0x3506, +0x3B8D,0x434F,0x4C87,0x577C,0x6482,0x73FD,0x8662,0x9C40, +/* A:13 B:07 */ +0x1365,0x1385,0x13AA,0x13D7,0x140B,0x144A,0x1495,0x14ED, +0x1556,0x15D4,0x1668,0x1719,0x17EB,0x18E5,0x1A0E,0x1B6E, +0x1D12,0x1F04,0x2154,0x2414,0x2758,0x2B3A,0x2FD8,0x3554, +0x3BD9,0x4398,0x4CCE,0x57BF,0x64C1,0x7437,0x8696,0x9C6C, +/* A:13 B:08 */ +0x13CF,0x13EF,0x1414,0x1440,0x1475,0x14B4,0x14FE,0x1556, +0x15C0,0x163D,0x16D1,0x1782,0x1853,0x194D,0x1A75,0x1BD5, +0x1D78,0x1F69,0x21B8,0x2477,0x27BA,0x2B9B,0x3037,0x35B1, +0x3C33,0x43EF,0x4D21,0x580F,0x650C,0x747B,0x86D4,0x9CA1, +/* A:13 B:09 */ +0x144D,0x146C,0x1492,0x14BE,0x14F2,0x1531,0x157B,0x15D4, +0x163D,0x16B9,0x174E,0x17FE,0x18CF,0x19C8,0x1AF0,0x1C4F, +0x1DF1,0x1FE2,0x2230,0x24ED,0x282F,0x2C0E,0x30A7,0x361F, +0x3C9E,0x4457,0x4D85,0x586D,0x6564,0x74CD,0x871D,0x9CE0, +/* A:13 B:0a */ +0x14E3,0x1502,0x1527,0x1553,0x1588,0x15C6,0x1610,0x1668, +0x16D1,0x174E,0x17E1,0x1891,0x1962,0x1A5B,0x1B82,0x1CE1, +0x1E81,0x2071,0x22BE,0x257A,0x28BA,0x2C96,0x312D,0x36A2, +0x3D1E,0x44D3,0x4DFB,0x58DE,0x65CD,0x752D,0x8773,0x9D2B, +/* A:13 B:0b */ +0x1594,0x15B4,0x15D9,0x1605,0x1639,0x1677,0x16C1,0x1719, +0x1782,0x17FE,0x1891,0x1941,0x1A11,0x1B09,0x1C2F,0x1D8D, +0x1F2D,0x211B,0x2367,0x2621,0x295F,0x2D39,0x31CD,0x373E, +0x3DB5,0x4565,0x4E88,0x5963,0x664A,0x75A0,0x87DA,0x9D84, +/* A:13 B:0c */ +0x1668,0x1687,0x16AC,0x16D8,0x170C,0x174A,0x1794,0x17EB, +0x1853,0x18CF,0x1962,0x1A11,0x1AE1,0x1BD8,0x1CFD,0x1E5A, +0x1FF9,0x21E6,0x242F,0x26E7,0x2A22,0x2DFA,0x328A,0x37F7, +0x3E6A,0x4613,0x4F2F,0x5A02,0x66DF,0x7629,0x8855,0x9DEE, +/* A:13 B:0d */ +0x1763,0x1782,0x17A7,0x17D2,0x1806,0x1844,0x188E,0x18E5, +0x194D,0x19C8,0x1A5B,0x1B09,0x1BD8,0x1CCE,0x1DF2,0x1F4E, +0x20EB,0x22D6,0x251E,0x27D3,0x2B0B,0x2EDF,0x336B,0x38D3, +0x3F40,0x46E2,0x4FF5,0x5ABE,0x6790,0x76CC,0x88E7,0x9E6C, +/* A:13 B:0e */ +0x188D,0x18AC,0x18D1,0x18FC,0x1930,0x196E,0x19B7,0x1A0E, +0x1A75,0x1AF0,0x1B82,0x1C2F,0x1CFD,0x1DF2,0x1F16,0x2070, +0x220B,0x23F4,0x2639,0x28EB,0x2C20,0x2FEF,0x3477,0x39D9, +0x403E,0x47D8,0x50E1,0x5B9E,0x6862,0x778D,0x8994,0x9F01, +/* A:13 B:0f */ +0x19F0,0x1A0F,0x1A33,0x1A5E,0x1A92,0x1ACF,0x1B18,0x1B6E, +0x1BD5,0x1C4F,0x1CE1,0x1D8D,0x1E5A,0x1F4E,0x2070,0x21C8, +0x2361,0x2547,0x278A,0x2A38,0x2D69,0x3133,0x35B5,0x3B0F, +0x416C,0x48FD,0x51FA,0x5CA9,0x695B,0x7872,0x8A62,0x9FB2, +/* A:13 B:10 */ +0x1B95,0x1BB4,0x1BD8,0x1C03,0x1C36,0x1C73,0x1CBC,0x1D12, +0x1D78,0x1DF1,0x1E81,0x1F2D,0x1FF9,0x20EB,0x220B,0x2361, +0x24F8,0x26DB,0x291A,0x2BC4,0x2EF0,0x32B4,0x372E,0x3C81, +0x42D4,0x4A58,0x5347,0x5DE5,0x6A84,0x7983,0x8B56,0xA085, +/* A:13 B:11 */ +0x1D8A,0x1DA9,0x1DCD,0x1DF7,0x1E2A,0x1E67,0x1EAE,0x1F04, +0x1F69,0x1FE2,0x2071,0x211B,0x21E6,0x22D6,0x23F4,0x2547, +0x26DB,0x28BB,0x2AF5,0x2D9B,0x30C0,0x347E,0x38F0,0x3E38, +0x447F,0x4BF5,0x54D3,0x5F5D,0x6BE4,0x7AC7,0x8C79,0xA180, +/* A:13 B:12 */ +0x1FDE,0x1FFC,0x2020,0x204A,0x207C,0x20B8,0x20FF,0x2154, +0x21B8,0x2230,0x22BE,0x2367,0x242F,0x251E,0x2639,0x278A, +0x291A,0x2AF5,0x2D2A,0x2FCA,0x32E9,0x369E,0x3B05,0x4042, +0x467B,0x4DE0,0x56AA,0x611C,0x6D87,0x7C49,0x8DD2,0xA2AA, +/* A:13 B:13 */ +0x22A2,0x22BF,0x22E3,0x230D,0x233E,0x237A,0x23C0,0x2414, +0x2477,0x24ED,0x257A,0x2621,0x26E7,0x27D3,0x28EB,0x2A38, +0x2BC4,0x2D9B,0x2FCA,0x3263,0x3579,0x3924,0x3D80,0x42AE, +0x48D6,0x5027,0x58DA,0x6330,0x6F79,0x7E13,0x8F6D,0xA40D, +/* A:13 B:14 */ +0x25EB,0x2608,0x262B,0x2654,0x2686,0x26C0,0x2706,0x2758, +0x27BA,0x282F,0x28BA,0x295F,0x2A22,0x2B0B,0x2C20,0x2D69, +0x2EF0,0x30C0,0x32E9,0x3579,0x3885,0x3C24,0x4071,0x458F, +0x4BA3,0x52DD,0x5B73,0x65A7,0x71C8,0x8033,0x9155,0xA5B2, +/* A:13 B:15 */ +0x29D2,0x29EF,0x2A12,0x2A3A,0x2A6B,0x2AA4,0x2AE9,0x2B3A, +0x2B9B,0x2C0E,0x2C96,0x2D39,0x2DFA,0x2EDF,0x2FEF,0x3133, +0x32B4,0x347E,0x369E,0x3924,0x3C24,0x3FB5,0x43F1,0x48FB, +0x4EF7,0x5615,0x5E89,0x6896,0x7488,0x82BA,0x9399,0xA7A6, +/* A:13 B:16 */ +0x2E76,0x2E93,0x2EB5,0x2EDD,0x2F0C,0x2F45,0x2F88,0x2FD8, +0x3037,0x30A7,0x312D,0x31CD,0x328A,0x336B,0x3477,0x35B5, +0x372E,0x38F0,0x3B05,0x3D80,0x4071,0x43F1,0x481A,0x4D0C, +0x52EC,0x59E8,0x6235,0x6C12,0x77CB,0x85BB,0x964A,0xA9F9, +/* A:13 B:17 */ +0x33FB,0x3416,0x3437,0x345E,0x348D,0x34C4,0x3506,0x3554, +0x35B1,0x361F,0x36A2,0x373E,0x37F7,0x38D3,0x39D9,0x3B0F, +0x3C81,0x3E38,0x4042,0x42AE,0x458F,0x48FB,0x4D0C,0x51E1, +0x57A0,0x5E74,0x6691,0x7036,0x7BAD,0x894C,0x997D,0xACBB, +/* A:13 B:18 */ +0x3A89,0x3AA4,0x3AC4,0x3AEA,0x3B17,0x3B4D,0x3B8D,0x3BD9, +0x3C33,0x3C9E,0x3D1E,0x3DB5,0x3E6A,0x3F40,0x403E,0x416C, +0x42D4,0x447F,0x467B,0x48D6,0x4BA3,0x4EF7,0x52EC,0x57A0, +0x5D37,0x63DB,0x6BC0,0x7522,0x8049,0x8D8A,0x9D4B,0xB003, +/* A:13 B:19 */ +0x4253,0x426D,0x428C,0x42B1,0x42DD,0x4311,0x434F,0x4398, +0x43EF,0x4457,0x44D3,0x4565,0x4613,0x46E2,0x47D8,0x48FD, +0x4A58,0x4BF5,0x4DE0,0x5027,0x52DD,0x5615,0x59E8,0x5E74, +0x63DB,0x6A48,0x71EA,0x7AFC,0x85C4,0x9295,0xA1D0,0xB3EA, +/* A:13 B:1a */ +0x4B96,0x4BAF,0x4BCD,0x4BF0,0x4C1A,0x4C4C,0x4C87,0x4CCE, +0x4D21,0x4D85,0x4DFB,0x4E88,0x4F2F,0x4FF5,0x50E1,0x51FA, +0x5347,0x54D3,0x56AA,0x58DA,0x5B73,0x5E89,0x6235,0x6691, +0x6BC0,0x71EA,0x793C,0x81F0,0x8C48,0x9893,0xA72F,0xB88C, +/* A:13 B:1b */ +0x5697,0x56AF,0x56CB,0x56ED,0x5715,0x5744,0x577C,0x57BF, +0x580F,0x586D,0x58DE,0x5963,0x5A02,0x5ABE,0x5B9E,0x5CA9, +0x5DE5,0x5F5D,0x611C,0x6330,0x65A7,0x6896,0x6C12,0x7036, +0x7522,0x7AFC,0x81F0,0x8A34,0x9406,0x9FB2,0xAD92,0xBE0F, +/* A:13 B:1c */ +0x63AC,0x63C2,0x63DD,0x63FC,0x6421,0x644E,0x6482,0x64C1, +0x650C,0x6564,0x65CD,0x664A,0x66DF,0x6790,0x6862,0x695B, +0x6A84,0x6BE4,0x6D87,0x6F79,0x71C8,0x7488,0x77CB,0x7BAD, +0x8049,0x85C4,0x8C48,0x9406,0x9D39,0xA829,0xB528,0xC49B, +/* A:13 B:1d */ +0x7338,0x734C,0x7364,0x7381,0x73A4,0x73CC,0x73FD,0x7437, +0x747B,0x74CD,0x752D,0x75A0,0x7629,0x76CC,0x778D,0x7872, +0x7983,0x7AC7,0x7C49,0x7E13,0x8033,0x82BA,0x85BB,0x894C, +0x8D8A,0x9295,0x9893,0x9FB2,0xA829,0xB238,0xBE2D,0xCC63, +/* A:13 B:1e */ +0x85B2,0x85C4,0x85DA,0x85F4,0x8612,0x8637,0x8662,0x8696, +0x86D4,0x871D,0x8773,0x87DA,0x8855,0x88E7,0x8994,0x8A62, +0x8B56,0x8C79,0x8DD2,0x8F6D,0x9155,0x9399,0x964A,0x997D, +0x9D4B,0xA1D0,0xA72F,0xAD92,0xB528,0xBE2D,0xC8E5,0xD5A2, +/* A:13 B:1f */ +0x9BA7,0x9BB7,0x9BCA,0x9BE0,0x9BFB,0x9C1A,0x9C40,0x9C6C, +0x9CA1,0x9CE0,0x9D2B,0x9D84,0x9DEE,0x9E6C,0x9F01,0x9FB2, +0xA085,0xA180,0xA2AA,0xA40D,0xA5B2,0xA7A6,0xA9F9,0xACBB, +0xB003,0xB3EA,0xB88C,0xBE0F,0xC49B,0xCC63,0xD5A2,0xE0A0, +/* A: 968D89C0 */ +/* A:14 B:00 */ +0x155B,0x157A,0x159F,0x15CB,0x15FF,0x163E,0x1688,0x16E0, +0x1748,0x17C5,0x1858,0x1908,0x19D8,0x1AD0,0x1BF7,0x1D55, +0x1EF5,0x20E4,0x2330,0x25EB,0x2929,0x2D04,0x3199,0x370B, +0x3D84,0x4536,0x4E5A,0x5938,0x6622,0x757C,0x87BA,0x9D68, +/* A:14 B:01 */ +0x157A,0x1599,0x15BE,0x15EA,0x161F,0x165D,0x16A7,0x16FF, +0x1767,0x17E3,0x1877,0x1927,0x19F7,0x1AEF,0x1C15,0x1D73, +0x1F13,0x2102,0x234E,0x2608,0x2946,0x2D21,0x31B5,0x3727, +0x3D9F,0x4550,0x4E73,0x5950,0x6638,0x7590,0x87CC,0x9D78, +/* A:14 B:02 */ +0x159F,0x15BE,0x15E3,0x160F,0x1644,0x1682,0x16CC,0x1724, +0x178C,0x1808,0x189C,0x194B,0x1A1C,0x1B13,0x1C3A,0x1D97, +0x1F37,0x2125,0x2371,0x262B,0x2969,0x2D43,0x31D7,0x3747, +0x3DBF,0x456E,0x4E90,0x596B,0x6652,0x75A8,0x87E1,0x9D8A, +/* A:14 B:03 */ +0x15CB,0x15EA,0x160F,0x163B,0x1670,0x16AE,0x16F8,0x1750, +0x17B8,0x1834,0x18C7,0x1977,0x1A47,0x1B3E,0x1C65,0x1DC2, +0x1F62,0x2150,0x239B,0x2654,0x2991,0x2D6B,0x31FE,0x376E, +0x3DE4,0x4592,0x4EB3,0x598D,0x6671,0x75C4,0x87FB,0x9DA0, +/* A:14 B:04 */ +0x15FF,0x161F,0x1644,0x1670,0x16A4,0x16E2,0x172C,0x1784, +0x17EC,0x1868,0x18FB,0x19AA,0x1A7A,0x1B72,0x1C98,0x1DF5, +0x1F94,0x2182,0x23CC,0x2686,0x29C2,0x2D9B,0x322D,0x379C, +0x3E11,0x45BE,0x4EDD,0x59B4,0x6696,0x75E6,0x8819,0x9DBB, +/* A:14 B:05 */ +0x163E,0x165D,0x1682,0x16AE,0x16E2,0x1720,0x176A,0x17C2, +0x182A,0x18A6,0x1939,0x19E8,0x1AB8,0x1BAF,0x1CD5,0x1E32, +0x1FD0,0x21BE,0x2408,0x26C0,0x29FC,0x2DD4,0x3265,0x37D2, +0x3E46,0x45F1,0x4F0E,0x59E3,0x66C2,0x760F,0x883D,0x9DDA, +/* A:14 B:06 */ +0x1688,0x16A7,0x16CC,0x16F8,0x172C,0x176A,0x17B4,0x180B, +0x1873,0x18EF,0x1982,0x1A31,0x1B00,0x1BF7,0x1D1D,0x1E79, +0x2018,0x2204,0x244E,0x2706,0x2A40,0x2E17,0x32A7,0x3813, +0x3E85,0x462E,0x4F48,0x5A1A,0x66F6,0x763F,0x8868,0x9DFF, +/* A:14 B:07 */ +0x16E0,0x16FF,0x1724,0x1750,0x1784,0x17C2,0x180B,0x1863, +0x18CB,0x1946,0x19D9,0x1A88,0x1B57,0x1C4E,0x1D73,0x1ECF, +0x206D,0x2259,0x24A1,0x2758,0x2A92,0x2E67,0x32F6,0x3860, +0x3ED0,0x4677,0x4F8E,0x5A5C,0x6734,0x7677,0x889B,0x9E2B, +/* A:14 B:08 */ +0x1748,0x1767,0x178C,0x17B8,0x17EC,0x182A,0x1873,0x18CB, +0x1932,0x19AE,0x1A40,0x1AEF,0x1BBE,0x1CB4,0x1DD9,0x1F34, +0x20D2,0x22BD,0x2505,0x27BA,0x2AF3,0x2EC7,0x3354,0x38BC, +0x3F29,0x46CD,0x4FE1,0x5AAB,0x677E,0x76BB,0x88D8,0x9E5F, +/* A:14 B:09 */ +0x17C5,0x17E3,0x1808,0x1834,0x1868,0x18A6,0x18EF,0x1946, +0x19AE,0x1A29,0x1ABB,0x1B69,0x1C38,0x1D2E,0x1E52,0x1FAD, +0x2149,0x2334,0x257A,0x282F,0x2B66,0x2F38,0x33C3,0x3929, +0x3F93,0x4733,0x5043,0x5B08,0x67D5,0x770B,0x8920,0x9E9D, +/* A:14 B:0a */ +0x1858,0x1877,0x189C,0x18C7,0x18FB,0x1939,0x1982,0x19D9, +0x1A40,0x1ABB,0x1B4D,0x1BFB,0x1CC9,0x1DBE,0x1EE2,0x203C, +0x21D8,0x23C1,0x2607,0x28BA,0x2BEF,0x2FBF,0x3447,0x39AA, +0x4011,0x47AD,0x50B8,0x5B77,0x683D,0x776B,0x8976,0x9EE7, +/* A:14 B:0b */ +0x1908,0x1927,0x194B,0x1977,0x19AA,0x19E8,0x1A31,0x1A88, +0x1AEF,0x1B69,0x1BFB,0x1CA8,0x1D76,0x1E6A,0x1F8D,0x20E7, +0x2281,0x2469,0x26AD,0x295F,0x2C92,0x305F,0x34E5,0x3A44, +0x40A7,0x483D,0x5142,0x5BFB,0x68B8,0x77DD,0x89DC,0x9F3F, +/* A:14 B:0c */ +0x19D8,0x19F7,0x1A1C,0x1A47,0x1A7A,0x1AB8,0x1B00,0x1B57, +0x1BBE,0x1C38,0x1CC9,0x1D76,0x1E43,0x1F37,0x2059,0x21B1, +0x234A,0x2531,0x2773,0x2A22,0x2D53,0x311E,0x35A0,0x3AFB, +0x4159,0x48E9,0x51E7,0x5C97,0x694B,0x7863,0x8A55,0x9FA7, +/* A:14 B:0d */ +0x1AD0,0x1AEF,0x1B13,0x1B3E,0x1B72,0x1BAF,0x1BF7,0x1C4E, +0x1CB4,0x1D2E,0x1DBE,0x1E6A,0x1F37,0x202A,0x214B,0x22A2, +0x243A,0x261E,0x285F,0x2B0B,0x2E39,0x3200,0x367E,0x3BD4, +0x422C,0x49B6,0x52AB,0x5D51,0x69F9,0x7904,0x8AE4,0xA023, +/* A:14 B:0e */ +0x1BF7,0x1C15,0x1C3A,0x1C65,0x1C98,0x1CD5,0x1D1D,0x1D73, +0x1DD9,0x1E52,0x1EE2,0x1F8D,0x2059,0x214B,0x226A,0x23C0, +0x2556,0x2739,0x2976,0x2C20,0x2F4A,0x330D,0x3786,0x3CD6, +0x4327,0x4AA9,0x5394,0x5E2F,0x6AC9,0x79C3,0x8B8F,0xA0B7, +/* A:14 B:0f */ +0x1D55,0x1D73,0x1D97,0x1DC2,0x1DF5,0x1E32,0x1E79,0x1ECF, +0x1F34,0x1FAD,0x203C,0x20E7,0x21B1,0x22A2,0x23C0,0x2514, +0x26A8,0x2888,0x2AC3,0x2D69,0x308F,0x344D,0x38C0,0x3E09, +0x4452,0x4BC9,0x54A9,0x5F36,0x6BBF,0x7AA5,0x8C5A,0xA166, +/* A:14 B:10 */ +0x1EF5,0x1F13,0x1F37,0x1F62,0x1F94,0x1FD0,0x2018,0x206D, +0x20D2,0x2149,0x21D8,0x2281,0x234A,0x243A,0x2556,0x26A8, +0x2839,0x2A17,0x2C4E,0x2EF0,0x3211,0x35C9,0x3A35,0x3F76, +0x45B4,0x4D20,0x55F2,0x606E,0x6CE4,0x7BB2,0x8D4C,0xA236, +/* A:14 B:11 */ +0x20E4,0x2102,0x2125,0x2150,0x2182,0x21BE,0x2204,0x2259, +0x22BD,0x2334,0x23C1,0x2469,0x2531,0x261E,0x2739,0x2888, +0x2A17,0x2BF0,0x2E23,0x30C0,0x33DC,0x378D,0x3BF0,0x4127, +0x475A,0x4EB8,0x577A,0x61E1,0x6E40,0x7CF2,0x8E6B,0xA32E, +/* A:14 B:12 */ +0x2330,0x234E,0x2371,0x239B,0x23CC,0x2408,0x244E,0x24A1, +0x2505,0x257A,0x2607,0x26AD,0x2773,0x285F,0x2976,0x2AC3, +0x2C4E,0x2E23,0x3051,0x32E9,0x35FD,0x39A6,0x3DFF,0x432B, +0x494F,0x509D,0x594A,0x639B,0x6FDD,0x7E6F,0x8FC0,0xA454, +/* A:14 B:13 */ +0x25EB,0x2608,0x262B,0x2654,0x2686,0x26C0,0x2706,0x2758, +0x27BA,0x282F,0x28BA,0x295F,0x2A22,0x2B0B,0x2C20,0x2D69, +0x2EF0,0x30C0,0x32E9,0x3579,0x3885,0x3C24,0x4071,0x458F, +0x4BA3,0x52DD,0x5B73,0x65A7,0x71C8,0x8033,0x9155,0xA5B2, +/* A:14 B:14 */ +0x2929,0x2946,0x2969,0x2991,0x29C2,0x29FC,0x2A40,0x2A92, +0x2AF3,0x2B66,0x2BEF,0x2C92,0x2D53,0x2E39,0x2F4A,0x308F, +0x3211,0x33DC,0x35FD,0x3885,0x3B87,0x3F1A,0x435A,0x4867, +0x4E67,0x5589,0x5E03,0x6817,0x7411,0x824C,0x9336,0xA751, +/* A:14 B:15 */ +0x2D04,0x2D21,0x2D43,0x2D6B,0x2D9B,0x2DD4,0x2E17,0x2E67, +0x2EC7,0x2F38,0x2FBF,0x305F,0x311E,0x3200,0x330D,0x344D, +0x35C9,0x378D,0x39A6,0x3C24,0x3F1A,0x429F,0x46CE,0x4BC7, +0x51B0,0x58B7,0x6110,0x6AFC,0x76C7,0x84CB,0x9573,0xA93F, +/* A:14 B:16 */ +0x3199,0x31B5,0x31D7,0x31FE,0x322D,0x3265,0x32A7,0x32F6, +0x3354,0x33C3,0x3447,0x34E5,0x35A0,0x367E,0x3786,0x38C0, +0x3A35,0x3BF0,0x3DFF,0x4071,0x435A,0x46CE,0x4AEA,0x4FCB, +0x5599,0x5C7E,0x64AF,0x6E6D,0x7A00,0x87C2,0x981B,0xAB8A, +/* A:14 B:17 */ +0x370B,0x3727,0x3747,0x376E,0x379C,0x37D2,0x3813,0x3860, +0x38BC,0x3929,0x39AA,0x3A44,0x3AFB,0x3BD4,0x3CD6,0x3E09, +0x3F76,0x4127,0x432B,0x458F,0x4867,0x4BC7,0x4FCB,0x5491, +0x5A3D,0x60FB,0x68FE,0x7283,0x7DD4,0x8B47,0x9B44,0xAE43, +/* A:14 B:18 */ +0x3D84,0x3D9F,0x3DBF,0x3DE4,0x3E11,0x3E46,0x3E85,0x3ED0, +0x3F29,0x3F93,0x4011,0x40A7,0x4159,0x422C,0x4327,0x4452, +0x45B4,0x475A,0x494F,0x4BA3,0x4E67,0x51B0,0x5599,0x5A3D, +0x5FC2,0x6650,0x6E1C,0x775F,0x8262,0x8F77,0x9F05,0xB180, +/* A:14 B:19 */ +0x4536,0x4550,0x456E,0x4592,0x45BE,0x45F1,0x462E,0x4677, +0x46CD,0x4733,0x47AD,0x483D,0x48E9,0x49B6,0x4AA9,0x4BC9, +0x4D20,0x4EB8,0x509D,0x52DD,0x5589,0x58B7,0x5C7E,0x60FB, +0x6650,0x6CA8,0x7431,0x7D26,0x87CB,0x9472,0xA37B,0xB55A, +/* A:14 B:1a */ +0x4E5A,0x4E73,0x4E90,0x4EB3,0x4EDD,0x4F0E,0x4F48,0x4F8E, +0x4FE1,0x5043,0x50B8,0x5142,0x51E7,0x52AB,0x5394,0x54A9, +0x55F2,0x577A,0x594A,0x5B73,0x5E03,0x6110,0x64AF,0x68FE, +0x6E1C,0x7431,0x7B6B,0x8403,0x8E39,0x9A5C,0xA8C8,0xB9ED, +/* A:14 B:1b */ +0x5938,0x5950,0x596B,0x598D,0x59B4,0x59E3,0x5A1A,0x5A5C, +0x5AAB,0x5B08,0x5B77,0x5BFB,0x5C97,0x5D51,0x5E2F,0x5F36, +0x606E,0x61E1,0x639B,0x65A7,0x6817,0x6AFC,0x6E6D,0x7283, +0x775F,0x7D26,0x8403,0x8C2B,0x95DD,0xA163,0xAF15,0xBF5C, +/* A:14 B:1c */ +0x6622,0x6638,0x6652,0x6671,0x6696,0x66C2,0x66F6,0x6734, +0x677E,0x67D5,0x683D,0x68B8,0x694B,0x69F9,0x6AC9,0x6BBF, +0x6CE4,0x6E40,0x6FDD,0x71C8,0x7411,0x76C7,0x7A00,0x7DD4, +0x8262,0x87CB,0x8E39,0x95DD,0x9EF3,0xA9BE,0xB693,0xC5D3, +/* A:14 B:1d */ +0x757C,0x7590,0x75A8,0x75C4,0x75E6,0x760F,0x763F,0x7677, +0x76BB,0x770B,0x776B,0x77DD,0x7863,0x7904,0x79C3,0x7AA5, +0x7BB2,0x7CF2,0x7E6F,0x8033,0x824C,0x84CB,0x87C2,0x8B47, +0x8F77,0x9472,0x9A5C,0xA163,0xA9BE,0xB3AC,0xBF7A,0xCD80, +/* A:14 B:1e */ +0x87BA,0x87CC,0x87E1,0x87FB,0x8819,0x883D,0x8868,0x889B, +0x88D8,0x8920,0x8976,0x89DC,0x8A55,0x8AE4,0x8B8F,0x8C5A, +0x8D4C,0x8E6B,0x8FC0,0x9155,0x9336,0x9573,0x981B,0x9B44, +0x9F05,0xA37B,0xA8C8,0xAF15,0xB693,0xBF7A,0xCA0E,0xD6A1, +/* A:14 B:1f */ +0x9D68,0x9D78,0x9D8A,0x9DA0,0x9DBB,0x9DDA,0x9DFF,0x9E2B, +0x9E5F,0x9E9D,0x9EE7,0x9F3F,0x9FA7,0xA023,0xA0B7,0xA166, +0xA236,0xA32E,0xA454,0xA5B2,0xA751,0xA93F,0xAB8A,0xAE43, +0xB180,0xB55A,0xB9ED,0xBF5C,0xC5D3,0xCD80,0xD6A1,0xE17A, +/* A: 968D89C0 */ +/* A:15 B:00 */ +0x1983,0x19A2,0x19C6,0x19F2,0x1A25,0x1A63,0x1AAB,0x1B02, +0x1B69,0x1BE3,0x1C75,0x1D22,0x1DEF,0x1EE3,0x2005,0x215E, +0x22F8,0x24DF,0x2722,0x29D2,0x2D04,0x30D0,0x3553,0x3AB0, +0x4110,0x48A3,0x51A4,0x5C58,0x6910,0x782D,0x8A24,0x9F7E, +/* A:15 B:01 */ +0x19A2,0x19C0,0x19E5,0x1A10,0x1A44,0x1A81,0x1ACA,0x1B21, +0x1B88,0x1C02,0x1C93,0x1D40,0x1E0D,0x1F01,0x2023,0x217C, +0x2316,0x24FD,0x273F,0x29EF,0x2D21,0x30EC,0x356F,0x3ACB, +0x412A,0x48BD,0x51BD,0x5C6F,0x6925,0x7841,0x8A36,0x9F8D, +/* A:15 B:02 */ +0x19C6,0x19E5,0x1A09,0x1A35,0x1A68,0x1AA6,0x1AEE,0x1B45, +0x1BAC,0x1C26,0x1CB7,0x1D64,0x1E31,0x1F25,0x2047,0x21A0, +0x2339,0x2520,0x2762,0x2A12,0x2D43,0x310E,0x3590,0x3AEB, +0x4149,0x48DB,0x51DA,0x5C8A,0x693F,0x7859,0x8A4B,0x9FA0, +/* A:15 B:03 */ +0x19F2,0x1A10,0x1A35,0x1A60,0x1A94,0x1AD1,0x1B1A,0x1B70, +0x1BD7,0x1C51,0x1CE2,0x1D8F,0x1E5C,0x1F50,0x2071,0x21CA, +0x2363,0x2549,0x278B,0x2A3A,0x2D6B,0x3135,0x35B7,0x3B11, +0x416E,0x48FF,0x51FC,0x5CAB,0x695D,0x7875,0x8A64,0x9FB5, +/* A:15 B:04 */ +0x1A25,0x1A44,0x1A68,0x1A94,0x1AC7,0x1B04,0x1B4D,0x1BA3, +0x1C0A,0x1C84,0x1D15,0x1DC2,0x1E8F,0x1F82,0x20A4,0x21FC, +0x2395,0x257B,0x27BC,0x2A6B,0x2D9B,0x3164,0x35E5,0x3B3F, +0x419A,0x4929,0x5225,0x5CD2,0x6982,0x7896,0x8A82,0x9FCF, +/* A:15 B:05 */ +0x1A63,0x1A81,0x1AA6,0x1AD1,0x1B04,0x1B41,0x1B8A,0x1BE0, +0x1C47,0x1CC1,0x1D52,0x1DFE,0x1ECB,0x1FBE,0x20E0,0x2237, +0x23D0,0x25B5,0x27F7,0x2AA4,0x2DD4,0x319C,0x361C,0x3B74, +0x41CF,0x495C,0x5255,0x5D00,0x69AD,0x78BE,0x8AA6,0x9FEE, +/* A:15 B:06 */ +0x1AAB,0x1ACA,0x1AEE,0x1B1A,0x1B4D,0x1B8A,0x1BD3,0x1C29, +0x1C8F,0x1D09,0x1D9A,0x1E46,0x1F13,0x2006,0x2127,0x227E, +0x2416,0x25FB,0x283C,0x2AE9,0x2E17,0x31DF,0x365D,0x3BB4, +0x420D,0x4998,0x528F,0x5D36,0x69E0,0x78ED,0x8AD0,0xA012, +/* A:15 B:07 */ +0x1B02,0x1B21,0x1B45,0x1B70,0x1BA3,0x1BE0,0x1C29,0x1C7F, +0x1CE5,0x1D5F,0x1DF0,0x1E9C,0x1F68,0x205B,0x217B,0x22D2, +0x246A,0x264E,0x288E,0x2B3A,0x2E67,0x322E,0x36AB,0x3C00, +0x4257,0x49DF,0x52D3,0x5D77,0x6A1D,0x7925,0x8B02,0xA03E, +/* A:15 B:08 */ +0x1B69,0x1B88,0x1BAC,0x1BD7,0x1C0A,0x1C47,0x1C8F,0x1CE5, +0x1D4C,0x1DC5,0x1E56,0x1F01,0x1FCD,0x20C0,0x21E0,0x2336, +0x24CD,0x26B1,0x28F0,0x2B9B,0x2EC7,0x328C,0x3707,0x3C5A, +0x42AE,0x4A34,0x5325,0x5DC5,0x6A65,0x7968,0x8B3E,0xA071, +/* A:15 B:09 */ +0x1BE3,0x1C02,0x1C26,0x1C51,0x1C84,0x1CC1,0x1D09,0x1D5F, +0x1DC5,0x1E3E,0x1ECF,0x1F7A,0x2046,0x2137,0x2257,0x23AD, +0x2543,0x2726,0x2964,0x2C0E,0x2F38,0x32FC,0x3775,0x3CC5, +0x4317,0x4A99,0x5385,0x5E21,0x6ABB,0x79B7,0x8B85,0xA0AE, +/* A:15 B:0a */ +0x1C75,0x1C93,0x1CB7,0x1CE2,0x1D15,0x1D52,0x1D9A,0x1DF0, +0x1E56,0x1ECF,0x1F5E,0x2009,0x20D5,0x21C6,0x22E5,0x243A, +0x25CF,0x27B1,0x29EE,0x2C96,0x2FBF,0x3381,0x37F7,0x3D45, +0x4393,0x4B11,0x53F8,0x5E8E,0x6B22,0x7A15,0x8BD9,0xA0F7, +/* A:15 B:0b */ +0x1D22,0x1D40,0x1D64,0x1D8F,0x1DC2,0x1DFE,0x1E46,0x1E9C, +0x1F01,0x1F7A,0x2009,0x20B4,0x217F,0x226F,0x238E,0x24E2, +0x2676,0x2857,0x2A92,0x2D39,0x305F,0x341E,0x3892,0x3DDC, +0x4426,0x4B9F,0x5481,0x5F0F,0x6B9B,0x7A85,0x8C3D,0xA14D, +/* A:15 B:0c */ +0x1DEF,0x1E0D,0x1E31,0x1E5C,0x1E8F,0x1ECB,0x1F13,0x1F68, +0x1FCD,0x2046,0x20D5,0x217F,0x2249,0x2339,0x2456,0x25A9, +0x273C,0x291B,0x2B55,0x2DFA,0x311E,0x34DA,0x394A,0x3E90, +0x44D5,0x4C49,0x5523,0x5FAA,0x6C2C,0x7B09,0x8CB4,0xA1B4, +/* A:15 B:0d */ +0x1EE3,0x1F01,0x1F25,0x1F50,0x1F82,0x1FBE,0x2006,0x205B, +0x20C0,0x2137,0x21C6,0x226F,0x2339,0x2428,0x2544,0x2696, +0x2828,0x2A05,0x2C3D,0x2EDF,0x3200,0x35B9,0x3A25,0x3F66, +0x45A5,0x4D12,0x55E4,0x6061,0x6CD7,0x7BA7,0x8D42,0xA22E, +/* A:15 B:0e */ +0x2005,0x2023,0x2047,0x2071,0x20A4,0x20E0,0x2127,0x217B, +0x21E0,0x2257,0x22E5,0x238E,0x2456,0x2544,0x265F,0x27B0, +0x2940,0x2B1B,0x2D50,0x2FEF,0x330D,0x36C2,0x3B29,0x4065, +0x469D,0x4E01,0x56CA,0x613B,0x6DA3,0x7C63,0x8DEA,0xA2BF, +/* A:15 B:0f */ +0x215E,0x217C,0x21A0,0x21CA,0x21FC,0x2237,0x227E,0x22D2, +0x2336,0x23AD,0x243A,0x24E2,0x25A9,0x2696,0x27B0,0x28FF, +0x2A8D,0x2C65,0x2E97,0x3133,0x344D,0x37FD,0x3C5E,0x4193, +0x47C3,0x4F1D,0x57DA,0x623E,0x6E96,0x7D42,0x8EB2,0xA36C, +/* A:15 B:10 */ +0x22F8,0x2316,0x2339,0x2363,0x2395,0x23D0,0x2416,0x246A, +0x24CD,0x2543,0x25CF,0x2676,0x273C,0x2828,0x2940,0x2A8D, +0x2C18,0x2DEE,0x301C,0x32B4,0x35C9,0x3973,0x3DCD,0x42FA, +0x4920,0x506F,0x591F,0x6371,0x6FB6,0x7E4B,0x8FA0,0xA439, +/* A:15 B:11 */ +0x24DF,0x24FD,0x2520,0x2549,0x257B,0x25B5,0x25FB,0x264E, +0x26B1,0x2726,0x27B1,0x2857,0x291B,0x2A05,0x2B1B,0x2C65, +0x2DEE,0x2FC0,0x31EB,0x347E,0x378D,0x3B30,0x3F82,0x44A5, +0x4ABF,0x5200,0x5AA0,0x64DF,0x710D,0x7F86,0x90BA,0xA52C, +/* A:15 B:12 */ +0x2722,0x273F,0x2762,0x278B,0x27BC,0x27F7,0x283C,0x288E, +0x28F0,0x2964,0x29EE,0x2A92,0x2B55,0x2C3D,0x2D50,0x2E97, +0x301C,0x31EB,0x3410,0x369E,0x39A6,0x3D40,0x4189,0x46A0, +0x4CAD,0x53DE,0x5C69,0x6692,0x72A4,0x80FD,0x920A,0xA64E, +/* A:15 B:13 */ +0x29D2,0x29EF,0x2A12,0x2A3A,0x2A6B,0x2AA4,0x2AE9,0x2B3A, +0x2B9B,0x2C0E,0x2C96,0x2D39,0x2DFA,0x2EDF,0x2FEF,0x3133, +0x32B4,0x347E,0x369E,0x3924,0x3C24,0x3FB5,0x43F1,0x48FB, +0x4EF7,0x5615,0x5E89,0x6896,0x7488,0x82BA,0x9399,0xA7A6, +/* A:15 B:14 */ +0x2D04,0x2D21,0x2D43,0x2D6B,0x2D9B,0x2DD4,0x2E17,0x2E67, +0x2EC7,0x2F38,0x2FBF,0x305F,0x311E,0x3200,0x330D,0x344D, +0x35C9,0x378D,0x39A6,0x3C24,0x3F1A,0x429F,0x46CE,0x4BC7, +0x51B0,0x58B7,0x6110,0x6AFC,0x76C7,0x84CB,0x9573,0xA93F, +/* A:15 B:15 */ +0x30D0,0x30EC,0x310E,0x3135,0x3164,0x319C,0x31DF,0x322E, +0x328C,0x32FC,0x3381,0x341E,0x34DA,0x35B9,0x36C2,0x37FD, +0x3973,0x3B30,0x3D40,0x3FB5,0x429F,0x4617,0x4A36,0x4F1B, +0x54ED,0x5BD8,0x6410,0x6DD5,0x7972,0x873F,0x97A6,0xAB25, +/* A:15 B:16 */ +0x3553,0x356F,0x3590,0x35B7,0x35E5,0x361C,0x365D,0x36AB, +0x3707,0x3775,0x37F7,0x3892,0x394A,0x3A25,0x3B29,0x3C5E, +0x3DCD,0x3F82,0x4189,0x43F1,0x46CE,0x4A36,0x4E41,0x530F, +0x58C6,0x5F90,0x67A1,0x7139,0x7C9E,0x8A2A,0x9A44,0xAD67, +/* A:15 B:17 */ +0x3AB0,0x3ACB,0x3AEB,0x3B11,0x3B3F,0x3B74,0x3BB4,0x3C00, +0x3C5A,0x3CC5,0x3D45,0x3DDC,0x3E90,0x3F66,0x4065,0x4193, +0x42FA,0x44A5,0x46A0,0x48FB,0x4BC7,0x4F1B,0x530F,0x57C2, +0x5D58,0x63FB,0x6BDF,0x753F,0x8064,0x8DA2,0x9D60,0xB015, +/* A:15 B:18 */ +0x4110,0x412A,0x4149,0x416E,0x419A,0x41CF,0x420D,0x4257, +0x42AE,0x4317,0x4393,0x4426,0x44D5,0x45A5,0x469D,0x47C3, +0x4920,0x4ABF,0x4CAD,0x4EF7,0x51B0,0x54ED,0x58C6,0x5D58, +0x62C7,0x693C,0x70E9,0x7A08,0x84DF,0x91C2,0xA112,0xB345, +/* A:15 B:19 */ +0x48A3,0x48BD,0x48DB,0x48FF,0x4929,0x495C,0x4998,0x49DF, +0x4A34,0x4A99,0x4B11,0x4B9F,0x4C49,0x4D12,0x4E01,0x4F1D, +0x506F,0x5200,0x53DE,0x5615,0x58B7,0x5BD8,0x5F90,0x63FB, +0x693C,0x6F7A,0x76E6,0x7FB8,0x8A33,0x96A8,0xA576,0xB70F, +/* A:15 B:1a */ +0x51A4,0x51BD,0x51DA,0x51FC,0x5225,0x5255,0x528F,0x52D3, +0x5325,0x5385,0x53F8,0x5481,0x5523,0x55E4,0x56CA,0x57DA, +0x591F,0x5AA0,0x5C69,0x5E89,0x6110,0x6410,0x67A1,0x6BDF, +0x70E9,0x76E6,0x7E04,0x867A,0x9088,0x9C7B,0xAAAE,0xBB8F, +/* A:15 B:1b */ +0x5C58,0x5C6F,0x5C8A,0x5CAB,0x5CD2,0x5D00,0x5D36,0x5D77, +0x5DC5,0x5E21,0x5E8E,0x5F0F,0x5FAA,0x6061,0x613B,0x623E, +0x6371,0x64DF,0x6692,0x6896,0x6AFC,0x6DD5,0x7139,0x753F, +0x7A08,0x7FB8,0x867A,0x8E82,0x980E,0xA366,0xB0E2,0xC0E9, +/* A:15 B:1c */ +0x6910,0x6925,0x693F,0x695D,0x6982,0x69AD,0x69E0,0x6A1D, +0x6A65,0x6ABB,0x6B22,0x6B9B,0x6C2C,0x6CD7,0x6DA3,0x6E96, +0x6FB6,0x710D,0x72A4,0x7488,0x76C7,0x7972,0x7C9E,0x8064, +0x84DF,0x8A33,0x9088,0x980E,0xA0FF,0xABA0,0xB842,0xC745, +/* A:15 B:1d */ +0x782D,0x7841,0x7859,0x7875,0x7896,0x78BE,0x78ED,0x7925, +0x7968,0x79B7,0x7A15,0x7A85,0x7B09,0x7BA7,0x7C63,0x7D42, +0x7E4B,0x7F86,0x80FD,0x82BA,0x84CB,0x873F,0x8A2A,0x8DA2, +0x91C2,0x96A8,0x9C7B,0xA366,0xABA0,0xB567,0xC105,0xCED4, +/* A:15 B:1e */ +0x8A24,0x8A36,0x8A4B,0x8A64,0x8A82,0x8AA6,0x8AD0,0x8B02, +0x8B3E,0x8B85,0x8BD9,0x8C3D,0x8CB4,0x8D42,0x8DEA,0x8EB2, +0x8FA0,0x90BA,0x920A,0x9399,0x9573,0x97A6,0x9A44,0x9D60, +0xA112,0xA576,0xAAAE,0xB0E2,0xB842,0xC105,0xCB6F,0xD7D0, +/* A:15 B:1f */ +0x9F7E,0x9F8D,0x9FA0,0x9FB5,0x9FCF,0x9FEE,0xA012,0xA03E, +0xA071,0xA0AE,0xA0F7,0xA14D,0xA1B4,0xA22E,0xA2BF,0xA36C, +0xA439,0xA52C,0xA64E,0xA7A6,0xA93F,0xAB25,0xAD67,0xB015, +0xB345,0xB70F,0xBB8F,0xC0E9,0xC745,0xCED4,0xD7D0,0xE27D, +/* A: 968D89C0 */ +/* A:16 B:00 */ +0x1E74,0x1E92,0x1EB6,0x1EE0,0x1F13,0x1F4F,0x1F97,0x1FEC, +0x2051,0x20C9,0x2158,0x2201,0x22CB,0x23BB,0x24D8,0x262A, +0x27BD,0x299B,0x2BD3,0x2E76,0x3199,0x3553,0x39C1,0x3F05, +0x4547,0x4CB7,0x558D,0x600E,0x6C8A,0x7B61,0x8D03,0xA1F8, +/* A:16 B:01 */ +0x1E92,0x1EB0,0x1ED4,0x1EFF,0x1F31,0x1F6D,0x1FB5,0x200A, +0x206F,0x20E7,0x2176,0x221F,0x22E9,0x23D8,0x24F5,0x2647, +0x27DA,0x29B8,0x2BF0,0x2E93,0x31B5,0x356F,0x39DC,0x3F20, +0x4561,0x4CCF,0x55A5,0x6025,0x6C9F,0x7B74,0x8D15,0xA207, +/* A:16 B:02 */ +0x1EB6,0x1ED4,0x1EF8,0x1F22,0x1F55,0x1F91,0x1FD9,0x202E, +0x2092,0x210A,0x2199,0x2243,0x230C,0x23FB,0x2518,0x266A, +0x27FC,0x29DA,0x2C12,0x2EB5,0x31D7,0x3590,0x39FD,0x3F3F, +0x457F,0x4CED,0x55C1,0x6040,0x6CB9,0x7B8B,0x8D29,0xA219, +/* A:16 B:03 */ +0x1EE0,0x1EFF,0x1F22,0x1F4D,0x1F7F,0x1FBC,0x2003,0x2058, +0x20BD,0x2135,0x21C3,0x226D,0x2336,0x2425,0x2542,0x2694, +0x2825,0x2A03,0x2C3A,0x2EDD,0x31FE,0x35B7,0x3A23,0x3F64, +0x45A3,0x4D10,0x55E3,0x6060,0x6CD7,0x7BA7,0x8D42,0xA22F, +/* A:16 B:04 */ +0x1F13,0x1F31,0x1F55,0x1F7F,0x1FB2,0x1FEE,0x2035,0x208A, +0x20EF,0x2167,0x21F5,0x229F,0x2368,0x2457,0x2573,0x26C5, +0x2856,0x2A33,0x2C6A,0x2F0C,0x322D,0x35E5,0x3A50,0x3F91, +0x45CF,0x4D3A,0x560B,0x6086,0x6CFA,0x7BC8,0x8D5F,0xA248, +/* A:16 B:05 */ +0x1F4F,0x1F6D,0x1F91,0x1FBC,0x1FEE,0x202A,0x2071,0x20C6, +0x212B,0x21A3,0x2231,0x22DA,0x23A3,0x2492,0x25AE,0x26FF, +0x2890,0x2A6D,0x2CA3,0x2F45,0x3265,0x361C,0x3A86,0x3FC5, +0x4602,0x4D6B,0x563B,0x60B3,0x6D24,0x7BEF,0x8D82,0xA266, +/* A:16 B:06 */ +0x1F97,0x1FB5,0x1FD9,0x2003,0x2035,0x2071,0x20B9,0x210D, +0x2172,0x21EA,0x2278,0x2321,0x23E9,0x24D8,0x25F4,0x2745, +0x28D5,0x2AB1,0x2CE7,0x2F88,0x32A7,0x365D,0x3AC6,0x4004, +0x463F,0x4DA6,0x5673,0x60E9,0x6D57,0x7C1D,0x8DAC,0xA28A, +/* A:16 B:07 */ +0x1FEC,0x200A,0x202E,0x2058,0x208A,0x20C6,0x210D,0x2162, +0x21C6,0x223E,0x22CC,0x2374,0x243D,0x252B,0x2647,0x2797, +0x2927,0x2B03,0x2D38,0x2FD8,0x32F6,0x36AB,0x3B12,0x404F, +0x4687,0x4DED,0x56B6,0x6128,0x6D93,0x7C54,0x8DDD,0xA2B4, +/* A:16 B:08 */ +0x2051,0x206F,0x2092,0x20BD,0x20EF,0x212B,0x2172,0x21C6, +0x222B,0x22A2,0x2330,0x23D8,0x24A0,0x258E,0x26A9,0x27F9, +0x2989,0x2B64,0x2D98,0x3037,0x3354,0x3707,0x3B6D,0x40A7, +0x46DE,0x4E40,0x5706,0x6174,0x6DDA,0x7C95,0x8E18,0xA2E7, +/* A:16 B:09 */ +0x20C9,0x20E7,0x210A,0x2135,0x2167,0x21A3,0x21EA,0x223E, +0x22A2,0x2319,0x23A7,0x244F,0x2517,0x2604,0x271E,0x286E, +0x29FD,0x2BD7,0x2E0A,0x30A7,0x33C3,0x3775,0x3BD9,0x4110, +0x4744,0x4EA3,0x5765,0x61CE,0x6E2E,0x7CE3,0x8E5D,0xA323, +/* A:16 B:0a */ +0x2158,0x2176,0x2199,0x21C3,0x21F5,0x2231,0x2278,0x22CC, +0x2330,0x23A7,0x2434,0x24DB,0x25A3,0x2690,0x27AA,0x28F8, +0x2A86,0x2C5F,0x2E91,0x312D,0x3447,0x37F7,0x3C59,0x418D, +0x47BE,0x4F18,0x57D6,0x623A,0x6E92,0x7D3F,0x8EB0,0xA36A, +/* A:16 B:0b */ +0x2201,0x221F,0x2243,0x226D,0x229F,0x22DA,0x2321,0x2374, +0x23D8,0x244F,0x24DB,0x2583,0x264A,0x2736,0x284F,0x299D, +0x2B2A,0x2D02,0x2F32,0x31CD,0x34E5,0x3892,0x3CF1,0x4222, +0x484E,0x4FA4,0x585C,0x62B9,0x6F0A,0x7DAD,0x8F12,0xA3BF, +/* A:16 B:0c */ +0x22CB,0x22E9,0x230C,0x2336,0x2368,0x23A3,0x23E9,0x243D, +0x24A0,0x2517,0x25A3,0x264A,0x2710,0x27FC,0x2914,0x2A61, +0x2BED,0x2DC3,0x2FF2,0x328A,0x35A0,0x394A,0x3DA5,0x42D3, +0x48FA,0x504A,0x58FC,0x6350,0x6F97,0x7E2F,0x8F87,0xA424, +/* A:16 B:0d */ +0x23BB,0x23D8,0x23FB,0x2425,0x2457,0x2492,0x24D8,0x252B, +0x258E,0x2604,0x2690,0x2736,0x27FC,0x28E7,0x29FE,0x2B4A, +0x2CD4,0x2EA8,0x30D5,0x336B,0x367E,0x3A25,0x3E7C,0x43A5, +0x49C6,0x5110,0x59B9,0x6404,0x7040,0x7ECA,0x9012,0xA49C, +/* A:16 B:0e */ +0x24D8,0x24F5,0x2518,0x2542,0x2573,0x25AE,0x25F4,0x2647, +0x26A9,0x271E,0x27AA,0x284F,0x2914,0x29FE,0x2B14,0x2C5E, +0x2DE7,0x2FB9,0x31E4,0x3477,0x3786,0x3B29,0x3F7B,0x449E, +0x4AB9,0x51FB,0x5A9A,0x64DA,0x7108,0x7F82,0x90B7,0xA52A, +/* A:16 B:0f */ +0x262A,0x2647,0x266A,0x2694,0x26C5,0x26FF,0x2745,0x2797, +0x27F9,0x286E,0x28F8,0x299D,0x2A61,0x2B4A,0x2C5E,0x2DA7, +0x2F2D,0x30FD,0x3325,0x35B5,0x38C0,0x3C5E,0x40AB,0x45C7, +0x4BDA,0x5312,0x5BA6,0x65D8,0x71F6,0x805D,0x917B,0xA5D3, +/* A:16 B:10 */ +0x27BD,0x27DA,0x27FC,0x2825,0x2856,0x2890,0x28D5,0x2927, +0x2989,0x29FD,0x2A86,0x2B2A,0x2BED,0x2CD4,0x2DE7,0x2F2D, +0x30B1,0x327F,0x34A3,0x372E,0x3A35,0x3DCD,0x4213,0x4727, +0x4D31,0x545D,0x5CE4,0x6706,0x7311,0x8161,0x9264,0xA69C, +/* A:16 B:11 */ +0x299B,0x29B8,0x29DA,0x2A03,0x2A33,0x2A6D,0x2AB1,0x2B03, +0x2B64,0x2BD7,0x2C5F,0x2D02,0x2DC3,0x2EA8,0x2FB9,0x30FD, +0x327F,0x3449,0x3669,0x38F0,0x3BF0,0x3F82,0x43C0,0x48CA, +0x4EC8,0x55E7,0x5E5E,0x686D,0x7461,0x8296,0x9379,0xA78B, +/* A:16 B:12 */ +0x2BD3,0x2BF0,0x2C12,0x2C3A,0x2C6A,0x2CA3,0x2CE7,0x2D38, +0x2D98,0x2E0A,0x2E91,0x2F32,0x2FF2,0x30D5,0x31E4,0x3325, +0x34A3,0x3669,0x3884,0x3B05,0x3DFF,0x4189,0x45BD,0x4ABC, +0x50AD,0x57BB,0x601F,0x6A17,0x75F1,0x8406,0x94C3,0xA8A7, +/* A:16 B:13 */ +0x2E76,0x2E93,0x2EB5,0x2EDD,0x2F0C,0x2F45,0x2F88,0x2FD8, +0x3037,0x30A7,0x312D,0x31CD,0x328A,0x336B,0x3477,0x35B5, +0x372E,0x38F0,0x3B05,0x3D80,0x4071,0x43F1,0x481A,0x4D0C, +0x52EC,0x59E8,0x6235,0x6C12,0x77CB,0x85BB,0x964A,0xA9F9, +/* A:16 B:14 */ +0x3199,0x31B5,0x31D7,0x31FE,0x322D,0x3265,0x32A7,0x32F6, +0x3354,0x33C3,0x3447,0x34E5,0x35A0,0x367E,0x3786,0x38C0, +0x3A35,0x3BF0,0x3DFF,0x4071,0x435A,0x46CE,0x4AEA,0x4FCB, +0x5599,0x5C7E,0x64AF,0x6E6D,0x7A00,0x87C2,0x981B,0xAB8A, +/* A:16 B:15 */ +0x3553,0x356F,0x3590,0x35B7,0x35E5,0x361C,0x365D,0x36AB, +0x3707,0x3775,0x37F7,0x3892,0x394A,0x3A25,0x3B29,0x3C5E, +0x3DCD,0x3F82,0x4189,0x43F1,0x46CE,0x4A36,0x4E41,0x530F, +0x58C6,0x5F90,0x67A1,0x7139,0x7C9E,0x8A2A,0x9A44,0xAD67, +/* A:16 B:16 */ +0x39C1,0x39DC,0x39FD,0x3A23,0x3A50,0x3A86,0x3AC6,0x3B12, +0x3B6D,0x3BD9,0x3C59,0x3CF1,0x3DA5,0x3E7C,0x3F7B,0x40AB, +0x4213,0x43C0,0x45BD,0x481A,0x4AEA,0x4E41,0x5239,0x56F1, +0x5C8C,0x6336,0x6B22,0x748C,0x7FBC,0x8D08,0x9CD5,0xAF9D, +/* A:16 B:17 */ +0x3F05,0x3F20,0x3F3F,0x3F64,0x3F91,0x3FC5,0x4004,0x404F, +0x40A7,0x4110,0x418D,0x4222,0x42D3,0x43A5,0x449E,0x45C7, +0x4727,0x48CA,0x4ABC,0x4D0C,0x4FCB,0x530F,0x56F1,0x5B8E, +0x6109,0x678D,0x6F4B,0x787F,0x836F,0x906F,0x9FE2,0xB23F, +/* A:16 B:18 */ +0x4547,0x4561,0x457F,0x45A3,0x45CF,0x4602,0x463F,0x4687, +0x46DE,0x4744,0x47BE,0x484E,0x48FA,0x49C6,0x4AB9,0x4BDA, +0x4D31,0x4EC8,0x50AD,0x52EC,0x5599,0x58C6,0x5C8C,0x6109, +0x665E,0x6CB5,0x743D,0x7D31,0x87D5,0x947A,0xA382,0xB55F, +/* A:16 B:19 */ +0x4CB7,0x4CCF,0x4CED,0x4D10,0x4D3A,0x4D6B,0x4DA6,0x4DED, +0x4E40,0x4EA3,0x4F18,0x4FA4,0x504A,0x5110,0x51FB,0x5312, +0x545D,0x55E7,0x57BB,0x59E8,0x5C7E,0x5F90,0x6336,0x678D, +0x6CB5,0x72D5,0x7A1E,0x82C6,0x8D0F,0x9949,0xA7D1,0xB916, +/* A:16 B:1a */ +0x558D,0x55A5,0x55C1,0x55E3,0x560B,0x563B,0x5673,0x56B6, +0x5706,0x5765,0x57D6,0x585C,0x58FC,0x59B9,0x5A9A,0x5BA6, +0x5CE4,0x5E5E,0x601F,0x6235,0x64AF,0x67A1,0x6B22,0x6F4B, +0x743D,0x7A1E,0x811A,0x8968,0x9346,0x9F00,0xACF0,0xBD81, +/* A:16 B:1b */ +0x600E,0x6025,0x6040,0x6060,0x6086,0x60B3,0x60E9,0x6128, +0x6174,0x61CE,0x623A,0x62B9,0x6350,0x6404,0x64DA,0x65D8, +0x6706,0x686D,0x6A17,0x6C12,0x6E6D,0x7139,0x748C,0x787F, +0x7D31,0x82C6,0x8968,0x914A,0x9AA8,0xA5CB,0xB306,0xC2C1, +/* A:16 B:1c */ +0x6C8A,0x6C9F,0x6CB9,0x6CD7,0x6CFA,0x6D24,0x6D57,0x6D93, +0x6DDA,0x6E2E,0x6E92,0x6F0A,0x6F97,0x7040,0x7108,0x71F6, +0x7311,0x7461,0x75F1,0x77CB,0x7A00,0x7C9E,0x7FBC,0x836F, +0x87D5,0x8D0F,0x9346,0x9AA8,0xA36F,0xADDD,0xBA42,0xC8FE, +/* A:16 B:1d */ +0x7B61,0x7B74,0x7B8B,0x7BA7,0x7BC8,0x7BEF,0x7C1D,0x7C54, +0x7C95,0x7CE3,0x7D3F,0x7DAD,0x7E2F,0x7ECA,0x7F82,0x805D, +0x8161,0x8296,0x8406,0x85BB,0x87C2,0x8A2A,0x8D08,0x906F, +0x947A,0x9949,0x9F00,0xA5CB,0xADDD,0xB775,0xC2DB,0xD068, +/* A:16 B:1e */ +0x8D03,0x8D15,0x8D29,0x8D42,0x8D5F,0x8D82,0x8DAC,0x8DDD, +0x8E18,0x8E5D,0x8EB0,0x8F12,0x8F87,0x9012,0x90B7,0x917B, +0x9264,0x9379,0x94C3,0x964A,0x981B,0x9A44,0x9CD5,0x9FE2, +0xA382,0xA7D1,0xACF0,0xB306,0xBA42,0xC2DB,0xCD13,0xD938, +/* A:16 B:1f */ +0xA1F8,0xA207,0xA219,0xA22F,0xA248,0xA266,0xA28A,0xA2B4, +0xA2E7,0xA323,0xA36A,0xA3BF,0xA424,0xA49C,0xA52A,0xA5D3, +0xA69C,0xA78B,0xA8A7,0xA9F9,0xAB8A,0xAD67,0xAF9D,0xB23F, +0xB55F,0xB916,0xBD81,0xC2C1,0xC8FE,0xD068,0xD938,0xE3B1, +/* A: 968D89C0 */ +/* A:17 B:00 */ +0x2453,0x2471,0x2494,0x24BD,0x24EF,0x252A,0x2570,0x25C3, +0x2626,0x269B,0x2727,0x27CC,0x2892,0x297C,0x2A92,0x2BDD, +0x2D67,0x2F3A,0x3166,0x33FB,0x370B,0x3AB0,0x3F05,0x442B, +0x4A49,0x518E,0x5A33,0x6478,0x70AD,0x7F2E,0x906C,0xA4EA, +/* A:17 B:01 */ +0x2471,0x248E,0x24B1,0x24DB,0x250C,0x2547,0x258D,0x25E0, +0x2643,0x26B8,0x2744,0x27EA,0x28AF,0x2999,0x2AAF,0x2BFA, +0x2D83,0x2F57,0x3182,0x3416,0x3727,0x3ACB,0x3F20,0x4445, +0x4A62,0x51A7,0x5A4A,0x648E,0x70C1,0x7F42,0x907E,0xA4F9, +/* A:17 B:02 */ +0x2494,0x24B1,0x24D4,0x24FE,0x252F,0x256A,0x25B0,0x2603, +0x2666,0x26DB,0x2766,0x280C,0x28D1,0x29BB,0x2AD1,0x2C1C, +0x2DA5,0x2F78,0x31A3,0x3437,0x3747,0x3AEB,0x3F3F,0x4463, +0x4A80,0x51C4,0x5A66,0x64A8,0x70DA,0x7F58,0x9092,0xA50B, +/* A:17 B:03 */ +0x24BD,0x24DB,0x24FE,0x2527,0x2559,0x2594,0x25D9,0x262C, +0x268F,0x2704,0x2790,0x2835,0x28FA,0x29E4,0x2AFA,0x2C45, +0x2DCD,0x2FA0,0x31CB,0x345E,0x376E,0x3B11,0x3F64,0x4488, +0x4AA3,0x51E6,0x5A86,0x64C7,0x70F7,0x7F73,0x90AA,0xA51F, +/* A:17 B:04 */ +0x24EF,0x250C,0x252F,0x2559,0x258A,0x25C5,0x260B,0x265E, +0x26C0,0x2735,0x27C1,0x2866,0x292B,0x2A15,0x2B2A,0x2C75, +0x2DFD,0x2FD0,0x31FA,0x348D,0x379C,0x3B3F,0x3F91,0x44B3, +0x4ACE,0x520F,0x5AAE,0x64ED,0x711A,0x7F93,0x90C7,0xA538, +/* A:17 B:05 */ +0x252A,0x2547,0x256A,0x2594,0x25C5,0x2600,0x2645,0x2698, +0x26FB,0x2770,0x27FB,0x28A0,0x2965,0x2A4E,0x2B64,0x2CAE, +0x2E36,0x3008,0x3232,0x34C4,0x37D2,0x3B74,0x3FC5,0x44E7, +0x4B00,0x523F,0x5ADC,0x6519,0x7143,0x7FB9,0x90E9,0xA556, +/* A:17 B:06 */ +0x2570,0x258D,0x25B0,0x25D9,0x260B,0x2645,0x268B,0x26DE, +0x2740,0x27B5,0x2840,0x28E5,0x29AA,0x2A93,0x2BA8,0x2CF2, +0x2E79,0x304B,0x3274,0x3506,0x3813,0x3BB4,0x4004,0x4524, +0x4B3B,0x5279,0x5B13,0x654D,0x7175,0x7FE6,0x9111,0xA579, +/* A:17 B:07 */ +0x25C3,0x25E0,0x2603,0x262C,0x265E,0x2698,0x26DE,0x2730, +0x2793,0x2807,0x2892,0x2937,0x29FB,0x2AE4,0x2BF9,0x2D42, +0x2ECA,0x309B,0x32C3,0x3554,0x3860,0x3C00,0x404F,0x456D, +0x4B82,0x52BD,0x5B55,0x658C,0x71AF,0x801C,0x9141,0xA5A2, +/* A:17 B:08 */ +0x2626,0x2643,0x2666,0x268F,0x26C0,0x26FB,0x2740,0x2793, +0x27F5,0x2869,0x28F4,0x2999,0x2A5C,0x2B45,0x2C5A,0x2DA2, +0x2F29,0x30F9,0x3321,0x35B1,0x38BC,0x3C5A,0x40A7,0x45C4, +0x4BD7,0x530F,0x5BA3,0x65D6,0x71F4,0x805C,0x917B,0xA5D3, +/* A:17 B:09 */ +0x269B,0x26B8,0x26DB,0x2704,0x2735,0x2770,0x27B5,0x2807, +0x2869,0x28DE,0x2968,0x2A0D,0x2AD0,0x2BB8,0x2CCC,0x2E14, +0x2F9A,0x316A,0x3390,0x361F,0x3929,0x3CC5,0x4110,0x462A, +0x4C3B,0x536F,0x5C00,0x662E,0x7247,0x80A8,0x91BF,0xA60E, +/* A:17 B:0a */ +0x2727,0x2744,0x2766,0x2790,0x27C1,0x27FB,0x2840,0x2892, +0x28F4,0x2968,0x29F2,0x2A96,0x2B59,0x2C41,0x2D54,0x2E9C, +0x3021,0x31EF,0x3415,0x36A2,0x39AA,0x3D45,0x418D,0x46A5, +0x4CB2,0x53E2,0x5C6E,0x6697,0x72A9,0x8102,0x920F,0xA654, +/* A:17 B:0b */ +0x27CC,0x27EA,0x280C,0x2835,0x2866,0x28A0,0x28E5,0x2937, +0x2999,0x2A0D,0x2A96,0x2B3A,0x2BFC,0x2CE4,0x2DF6,0x2F3D, +0x30C1,0x328E,0x34B2,0x373E,0x3A44,0x3DDC,0x4222,0x4736, +0x4D3F,0x546B,0x5CF1,0x6713,0x731E,0x816D,0x9270,0xA6A7, +/* A:17 B:0c */ +0x2892,0x28AF,0x28D1,0x28FA,0x292B,0x2965,0x29AA,0x29FB, +0x2A5C,0x2AD0,0x2B59,0x2BFC,0x2CBE,0x2DA5,0x2EB7,0x2FFC, +0x317F,0x334B,0x356D,0x37F7,0x3AFB,0x3E90,0x42D3,0x47E3, +0x4DE7,0x550E,0x5D8D,0x67A7,0x73A8,0x81ED,0x92E2,0xA709, +/* A:17 B:0d */ +0x297C,0x2999,0x29BB,0x29E4,0x2A15,0x2A4E,0x2A93,0x2AE4, +0x2B45,0x2BB8,0x2C41,0x2CE4,0x2DA5,0x2E8A,0x2F9B,0x30E0, +0x3261,0x342B,0x364C,0x38D3,0x3BD4,0x3F66,0x43A5,0x48B0, +0x4EAF,0x55CF,0x5E46,0x6857,0x744D,0x8284,0x9369,0xA77E, +/* A:17 B:0e */ +0x2A92,0x2AAF,0x2AD1,0x2AFA,0x2B2A,0x2B64,0x2BA8,0x2BF9, +0x2C5A,0x2CCC,0x2D54,0x2DF6,0x2EB7,0x2F9B,0x30AB,0x31EE, +0x336E,0x3536,0x3754,0x39D9,0x3CD6,0x4065,0x449E,0x49A4, +0x4F9C,0x56B4,0x5F22,0x6928,0x7511,0x8338,0x940B,0xA809, +/* A:17 B:0f */ +0x2BDD,0x2BFA,0x2C1C,0x2C45,0x2C75,0x2CAE,0x2CF2,0x2D42, +0x2DA2,0x2E14,0x2E9C,0x2F3D,0x2FFC,0x30E0,0x31EE,0x332F, +0x34AD,0x3673,0x388E,0x3B0F,0x3E09,0x4193,0x45C7,0x4AC6, +0x50B6,0x57C5,0x6028,0x6A20,0x75F9,0x840E,0x94CA,0xA8AE, +/* A:17 B:10 */ +0x2D67,0x2D83,0x2DA5,0x2DCD,0x2DFD,0x2E36,0x2E79,0x2ECA, +0x2F29,0x2F9A,0x3021,0x30C1,0x317F,0x3261,0x336E,0x34AD, +0x3629,0x37EC,0x3A04,0x3C81,0x3F76,0x42FA,0x4727,0x4C1F, +0x5205,0x5909,0x615F,0x6B47,0x770E,0x850C,0x95AE,0xA973, +/* A:17 B:11 */ +0x2F3A,0x2F57,0x2F78,0x2FA0,0x2FD0,0x3008,0x304B,0x309B, +0x30F9,0x316A,0x31EF,0x328E,0x334B,0x342B,0x3536,0x3673, +0x37EC,0x39AB,0x3BBF,0x3E38,0x4127,0x44A5,0x48CA,0x4DB8, +0x5394,0x5A8A,0x62D0,0x6CA6,0x7856,0x863A,0x96BD,0xAA5C, +/* A:17 B:12 */ +0x3166,0x3182,0x31A3,0x31CB,0x31FA,0x3232,0x3274,0x32C3, +0x3321,0x3390,0x3415,0x34B2,0x356D,0x364C,0x3754,0x388E, +0x3A04,0x3BBF,0x3DCF,0x4042,0x432B,0x46A0,0x4ABC,0x4F9F, +0x556D,0x5C54,0x6488,0x6E47,0x79DD,0x87A1,0x97FF,0xAB72, +/* A:17 B:13 */ +0x33FB,0x3416,0x3437,0x345E,0x348D,0x34C4,0x3506,0x3554, +0x35B1,0x361F,0x36A2,0x373E,0x37F7,0x38D3,0x39D9,0x3B0F, +0x3C81,0x3E38,0x4042,0x42AE,0x458F,0x48FB,0x4D0C,0x51E1, +0x57A0,0x5E74,0x6691,0x7036,0x7BAD,0x894C,0x997D,0xACBB, +/* A:17 B:14 */ +0x370B,0x3727,0x3747,0x376E,0x379C,0x37D2,0x3813,0x3860, +0x38BC,0x3929,0x39AA,0x3A44,0x3AFB,0x3BD4,0x3CD6,0x3E09, +0x3F76,0x4127,0x432B,0x458F,0x4867,0x4BC7,0x4FCB,0x5491, +0x5A3D,0x60FB,0x68FE,0x7283,0x7DD4,0x8B47,0x9B44,0xAE43, +/* A:17 B:15 */ +0x3AB0,0x3ACB,0x3AEB,0x3B11,0x3B3F,0x3B74,0x3BB4,0x3C00, +0x3C5A,0x3CC5,0x3D45,0x3DDC,0x3E90,0x3F66,0x4065,0x4193, +0x42FA,0x44A5,0x46A0,0x48FB,0x4BC7,0x4F1B,0x530F,0x57C2, +0x5D58,0x63FB,0x6BDF,0x753F,0x8064,0x8DA2,0x9D60,0xB015, +/* A:17 B:16 */ +0x3F05,0x3F20,0x3F3F,0x3F64,0x3F91,0x3FC5,0x4004,0x404F, +0x40A7,0x4110,0x418D,0x4222,0x42D3,0x43A5,0x449E,0x45C7, +0x4727,0x48CA,0x4ABC,0x4D0C,0x4FCB,0x530F,0x56F1,0x5B8E, +0x6109,0x678D,0x6F4B,0x787F,0x836F,0x906F,0x9FE2,0xB23F, +/* A:17 B:17 */ +0x442B,0x4445,0x4463,0x4488,0x44B3,0x44E7,0x4524,0x456D, +0x45C4,0x462A,0x46A5,0x4736,0x47E3,0x48B0,0x49A4,0x4AC6, +0x4C1F,0x4DB8,0x4F9F,0x51E1,0x5491,0x57C2,0x5B8E,0x6010, +0x656C,0x6BCA,0x735C,0x7C5C,0x870D,0x93C2,0xA2DD,0xB4D1, +/* A:17 B:18 */ +0x4A49,0x4A62,0x4A80,0x4AA3,0x4ACE,0x4B00,0x4B3B,0x4B82, +0x4BD7,0x4C3B,0x4CB2,0x4D3F,0x4DE7,0x4EAF,0x4F9C,0x50B6, +0x5205,0x5394,0x556D,0x57A0,0x5A3D,0x5D58,0x6109,0x656C, +0x6AA2,0x70D5,0x7832,0x80F3,0x8B5A,0x97B6,0xA668,0xB7DF, +/* A:17 B:19 */ +0x518E,0x51A7,0x51C4,0x51E6,0x520F,0x523F,0x5279,0x52BD, +0x530F,0x536F,0x53E2,0x546B,0x550E,0x55CF,0x56B4,0x57C5, +0x5909,0x5A8A,0x5C54,0x5E74,0x60FB,0x63FB,0x678D,0x6BCA, +0x70D5,0x76D2,0x7DF1,0x8667,0x9076,0x9C69,0xAA9E,0xBB80, +/* A:17 B:1a */ +0x5A33,0x5A4A,0x5A66,0x5A86,0x5AAE,0x5ADC,0x5B13,0x5B55, +0x5BA3,0x5C00,0x5C6E,0x5CF1,0x5D8D,0x5E46,0x5F22,0x6028, +0x615F,0x62D0,0x6488,0x6691,0x68FE,0x6BDF,0x6F4B,0x735C, +0x7832,0x7DF1,0x84C5,0x8CE3,0x9688,0xA1FF,0xAF9F,0xBFD1, +/* A:17 B:1b */ +0x6478,0x648E,0x64A8,0x64C7,0x64ED,0x6519,0x654D,0x658C, +0x65D6,0x662E,0x6697,0x6713,0x67A7,0x6857,0x6928,0x6A20, +0x6B47,0x6CA6,0x6E47,0x7036,0x7283,0x753F,0x787F,0x7C5C, +0x80F3,0x8667,0x8CE3,0x9497,0x9DC0,0xA8A2,0xB592,0xC4F1, +/* A:17 B:1c */ +0x70AD,0x70C1,0x70DA,0x70F7,0x711A,0x7143,0x7175,0x71AF, +0x71F4,0x7247,0x72A9,0x731E,0x73A8,0x744D,0x7511,0x75F9, +0x770E,0x7856,0x79DD,0x7BAD,0x7DD4,0x8064,0x836F,0x870D, +0x8B5A,0x9076,0x9688,0x9DC0,0xA654,0xB085,0xBCA3,0xCB0A, +/* A:17 B:1d */ +0x7F2E,0x7F42,0x7F58,0x7F73,0x7F93,0x7FB9,0x7FE6,0x801C, +0x805C,0x80A8,0x8102,0x816D,0x81ED,0x8284,0x8338,0x840E, +0x850C,0x863A,0x87A1,0x894C,0x8B47,0x8DA2,0x906F,0x93C2, +0x97B6,0x9C69,0xA1FF,0xA8A2,0xB085,0xB9E5,0xC50A,0xD248, +/* A:17 B:1e */ +0x906C,0x907E,0x9092,0x90AA,0x90C7,0x90E9,0x9111,0x9141, +0x917B,0x91BF,0x920F,0x9270,0x92E2,0x9369,0x940B,0x94CA, +0x95AE,0x96BD,0x97FF,0x997D,0x9B44,0x9D60,0x9FE2,0xA2DD, +0xA668,0xAA9E,0xAF9F,0xB592,0xBCA3,0xC50A,0xCF06,0xDAE4, +/* A:17 B:1f */ +0xA4EA,0xA4F9,0xA50B,0xA51F,0xA538,0xA556,0xA579,0xA5A2, +0xA5D3,0xA60E,0xA654,0xA6A7,0xA709,0xA77E,0xA809,0xA8AE, +0xA973,0xAA5C,0xAB72,0xACBB,0xAE43,0xB015,0xB23F,0xB4D1, +0xB7DF,0xBB80,0xBFD1,0xC4F1,0xCB0A,0xD248,0xDAE4,0xE51F, +/* A: 968D89C0 */ +/* A:18 B:00 */ +0x2B4E,0x2B6A,0x2B8D,0x2BB5,0x2BE5,0x2C1E,0x2C63,0x2CB3, +0x2D14,0x2D86,0x2E0E,0x2EAF,0x2F6F,0x3053,0x3162,0x32A4, +0x3423,0x35EA,0x3806,0x3A89,0x3D84,0x4110,0x4547,0x4A49, +0x503D,0x5750,0x5FB8,0x69B6,0x7597,0x83B4,0x947B,0xA86B, +/* A:18 B:01 */ +0x2B6A,0x2B87,0x2BA9,0x2BD2,0x2C02,0x2C3B,0x2C7F,0x2CD0, +0x2D30,0x2DA2,0x2E2A,0x2ECB,0x2F8B,0x306F,0x317E,0x32C0, +0x343E,0x3605,0x3821,0x3AA4,0x3D9F,0x412A,0x4561,0x4A62, +0x5055,0x5767,0x5FCF,0x69CC,0x75AB,0x83C6,0x948B,0xA879, +/* A:18 B:02 */ +0x2B8D,0x2BA9,0x2BCB,0x2BF4,0x2C24,0x2C5D,0x2CA1,0x2CF2, +0x2D52,0x2DC4,0x2E4C,0x2EED,0x2FAD,0x3090,0x319F,0x32E1, +0x345F,0x3626,0x3842,0x3AC4,0x3DBF,0x4149,0x457F,0x4A80, +0x5072,0x5783,0x5FEA,0x69E5,0x75C3,0x83DD,0x949F,0xA88A, +/* A:18 B:03 */ +0x2BB5,0x2BD2,0x2BF4,0x2C1C,0x2C4C,0x2C86,0x2CC9,0x2D1A, +0x2D7A,0x2DEC,0x2E74,0x2F15,0x2FD5,0x30B8,0x31C7,0x3308, +0x3486,0x364D,0x3868,0x3AEA,0x3DE4,0x416E,0x45A3,0x4AA3, +0x5095,0x57A5,0x600A,0x6A04,0x75DF,0x83F7,0x94B6,0xA89E, +/* A:18 B:04 */ +0x2BE5,0x2C02,0x2C24,0x2C4C,0x2C7C,0x2CB6,0x2CF9,0x2D4A, +0x2DAA,0x2E1C,0x2EA4,0x2F45,0x3004,0x30E7,0x31F6,0x3337, +0x34B5,0x367B,0x3896,0x3B17,0x3E11,0x419A,0x45CF,0x4ACE, +0x50BE,0x57CD,0x6030,0x6A28,0x7601,0x8416,0x94D2,0xA8B6, +/* A:18 B:05 */ +0x2C1E,0x2C3B,0x2C5D,0x2C86,0x2CB6,0x2CEF,0x2D32,0x2D83, +0x2DE3,0x2E55,0x2EDC,0x2F7D,0x303C,0x3120,0x322E,0x336F, +0x34EC,0x36B2,0x38CC,0x3B4D,0x3E46,0x41CF,0x4602,0x4B00, +0x50EF,0x57FC,0x605D,0x6A53,0x7629,0x843B,0x94F3,0xA8D3, +/* A:18 B:06 */ +0x2C63,0x2C7F,0x2CA1,0x2CC9,0x2CF9,0x2D32,0x2D76,0x2DC7, +0x2E27,0x2E98,0x2F20,0x2FC0,0x307F,0x3162,0x3270,0x33B1, +0x352E,0x36F3,0x390D,0x3B8D,0x3E85,0x420D,0x463F,0x4B3B, +0x5129,0x5834,0x6093,0x6A86,0x7659,0x8467,0x951B,0xA8F5, +/* A:18 B:07 */ +0x2CB3,0x2CD0,0x2CF2,0x2D1A,0x2D4A,0x2D83,0x2DC7,0x2E17, +0x2E77,0x2EE8,0x2F70,0x3010,0x30CF,0x31B1,0x32BF,0x33FF, +0x357C,0x3740,0x395A,0x3BD9,0x3ED0,0x4257,0x4687,0x4B82, +0x516E,0x5876,0x60D3,0x6AC3,0x7692,0x849B,0x954A,0xA91D, +/* A:18 B:08 */ +0x2D14,0x2D30,0x2D52,0x2D7A,0x2DAA,0x2DE3,0x2E27,0x2E77, +0x2ED6,0x2F48,0x2FCF,0x306F,0x312D,0x3210,0x331D,0x345C, +0x35D9,0x379C,0x39B5,0x3C33,0x3F29,0x42AE,0x46DE,0x4BD7, +0x51BF,0x58C6,0x611F,0x6B0B,0x76D5,0x84D9,0x9581,0xA94D, +/* A:18 B:09 */ +0x2D86,0x2DA2,0x2DC4,0x2DEC,0x2E1C,0x2E55,0x2E98,0x2EE8, +0x2F48,0x2FB9,0x3040,0x30E0,0x319E,0x3280,0x338C,0x34CB, +0x3647,0x380A,0x3A21,0x3C9E,0x3F93,0x4317,0x4744,0x4C3B, +0x5221,0x5924,0x6179,0x6B60,0x7726,0x8523,0x95C3,0xA986, +/* A:18 B:0a */ +0x2E0E,0x2E2A,0x2E4C,0x2E74,0x2EA4,0x2EDC,0x2F20,0x2F70, +0x2FCF,0x3040,0x30C6,0x3166,0x3223,0x3305,0x3411,0x354F, +0x36CA,0x388C,0x3AA2,0x3D1E,0x4011,0x4393,0x47BE,0x4CB2, +0x5295,0x5994,0x61E4,0x6BC6,0x7785,0x857B,0x9612,0xA9CA, +/* A:18 B:0b */ +0x2EAF,0x2ECB,0x2EED,0x2F15,0x2F45,0x2F7D,0x2FC0,0x3010, +0x306F,0x30E0,0x3166,0x3205,0x32C2,0x33A3,0x34AE,0x35EC, +0x3765,0x3926,0x3B3C,0x3DB5,0x40A7,0x4426,0x484E,0x4D3F, +0x531E,0x5A19,0x6264,0x6C3F,0x77F6,0x85E3,0x966F,0xAA1A, +/* A:18 B:0c */ +0x2F6F,0x2F8B,0x2FAD,0x2FD5,0x3004,0x303C,0x307F,0x30CF, +0x312D,0x319E,0x3223,0x32C2,0x337F,0x345F,0x3569,0x36A6, +0x381E,0x39DE,0x3BF2,0x3E6A,0x4159,0x44D5,0x48FA,0x4DE7, +0x53C2,0x5AB7,0x62FB,0x6CCF,0x787D,0x865F,0x96DE,0xAA7A, +/* A:18 B:0d */ +0x3053,0x306F,0x3090,0x30B8,0x30E7,0x3120,0x3162,0x31B1, +0x3210,0x3280,0x3305,0x33A3,0x345F,0x353E,0x3648,0x3783, +0x38FA,0x3AB8,0x3CCA,0x3F40,0x422C,0x45A5,0x49C6,0x4EAF, +0x5484,0x5B72,0x63AF,0x6D7A,0x791D,0x86F2,0x9762,0xAAEC, +/* A:18 B:0e */ +0x3162,0x317E,0x319F,0x31C7,0x31F6,0x322E,0x3270,0x32BF, +0x331D,0x338C,0x3411,0x34AE,0x3569,0x3648,0x3750,0x388A, +0x3A00,0x3BBC,0x3DCB,0x403E,0x4327,0x469D,0x4AB9,0x4F9C, +0x556B,0x5C52,0x6486,0x6E45,0x79DC,0x87A1,0x97FF,0xAB73, +/* A:18 B:0f */ +0x32A4,0x32C0,0x32E1,0x3308,0x3337,0x336F,0x33B1,0x33FF, +0x345C,0x34CB,0x354F,0x35EC,0x36A6,0x3783,0x388A,0x39C3, +0x3B36,0x3CF0,0x3EFD,0x416C,0x4452,0x47C3,0x4BDA,0x50B6, +0x567D,0x5D5B,0x6584,0x6F37,0x7ABE,0x8871,0x98B9,0xAC13, +/* A:18 B:10 */ +0x3423,0x343E,0x345F,0x3486,0x34B5,0x34EC,0x352E,0x357C, +0x35D9,0x3647,0x36CA,0x3765,0x381E,0x38FA,0x3A00,0x3B36, +0x3CA8,0x3E5E,0x4068,0x42D4,0x45B4,0x4920,0x4D31,0x5205, +0x57C3,0x5E96,0x66B2,0x7056,0x7BCB,0x8968,0x9997,0xACD2, +/* A:18 B:11 */ +0x35EA,0x3605,0x3626,0x364D,0x367B,0x36B2,0x36F3,0x3740, +0x379C,0x380A,0x388C,0x3926,0x39DE,0x3AB8,0x3BBC,0x3CF0, +0x3E5E,0x4012,0x4218,0x447F,0x475A,0x4ABF,0x4EC8,0x5394, +0x5947,0x600D,0x681A,0x71AB,0x7D0A,0x8A8E,0x9A9E,0xADB5, +/* A:18 B:12 */ +0x3806,0x3821,0x3842,0x3868,0x3896,0x38CC,0x390D,0x395A, +0x39B5,0x3A21,0x3AA2,0x3B3C,0x3BF2,0x3CCA,0x3DCB,0x3EFD, +0x4068,0x4218,0x4419,0x467B,0x494F,0x4CAD,0x50AD,0x556D, +0x5B13,0x61CA,0x69C5,0x7341,0x7E86,0x8BEB,0x9BD7,0xAEC3, +/* A:18 B:13 */ +0x3A89,0x3AA4,0x3AC4,0x3AEA,0x3B17,0x3B4D,0x3B8D,0x3BD9, +0x3C33,0x3C9E,0x3D1E,0x3DB5,0x3E6A,0x3F40,0x403E,0x416C, +0x42D4,0x447F,0x467B,0x48D6,0x4BA3,0x4EF7,0x52EC,0x57A0, +0x5D37,0x63DB,0x6BC0,0x7522,0x8049,0x8D8A,0x9D4B,0xB003, +/* A:18 B:14 */ +0x3D84,0x3D9F,0x3DBF,0x3DE4,0x3E11,0x3E46,0x3E85,0x3ED0, +0x3F29,0x3F93,0x4011,0x40A7,0x4159,0x422C,0x4327,0x4452, +0x45B4,0x475A,0x494F,0x4BA3,0x4E67,0x51B0,0x5599,0x5A3D, +0x5FC2,0x6650,0x6E1C,0x775F,0x8262,0x8F77,0x9F05,0xB180, +/* A:18 B:15 */ +0x4110,0x412A,0x4149,0x416E,0x419A,0x41CF,0x420D,0x4257, +0x42AE,0x4317,0x4393,0x4426,0x44D5,0x45A5,0x469D,0x47C3, +0x4920,0x4ABF,0x4CAD,0x4EF7,0x51B0,0x54ED,0x58C6,0x5D58, +0x62C7,0x693C,0x70E9,0x7A08,0x84DF,0x91C2,0xA112,0xB345, +/* A:18 B:16 */ +0x4547,0x4561,0x457F,0x45A3,0x45CF,0x4602,0x463F,0x4687, +0x46DE,0x4744,0x47BE,0x484E,0x48FA,0x49C6,0x4AB9,0x4BDA, +0x4D31,0x4EC8,0x50AD,0x52EC,0x5599,0x58C6,0x5C8C,0x6109, +0x665E,0x6CB5,0x743D,0x7D31,0x87D5,0x947A,0xA382,0xB55F, +/* A:18 B:17 */ +0x4A49,0x4A62,0x4A80,0x4AA3,0x4ACE,0x4B00,0x4B3B,0x4B82, +0x4BD7,0x4C3B,0x4CB2,0x4D3F,0x4DE7,0x4EAF,0x4F9C,0x50B6, +0x5205,0x5394,0x556D,0x57A0,0x5A3D,0x5D58,0x6109,0x656C, +0x6AA2,0x70D5,0x7832,0x80F3,0x8B5A,0x97B6,0xA668,0xB7DF, +/* A:18 B:18 */ +0x503D,0x5055,0x5072,0x5095,0x50BE,0x50EF,0x5129,0x516E, +0x51BF,0x5221,0x5295,0x531E,0x53C2,0x5484,0x556B,0x567D, +0x57C3,0x5947,0x5B13,0x5D37,0x5FC2,0x62C7,0x665E,0x6AA2, +0x6FB5,0x75BC,0x7CE6,0x8569,0x8F88,0x9B8F,0xA9DA,0xBAD7, +/* A:18 B:19 */ +0x5750,0x5767,0x5783,0x57A5,0x57CD,0x57FC,0x5834,0x5876, +0x58C6,0x5924,0x5994,0x5A19,0x5AB7,0x5B72,0x5C52,0x5D5B, +0x5E96,0x600D,0x61CA,0x63DB,0x6650,0x693C,0x6CB5,0x70D5, +0x75BC,0x7B90,0x827C,0x8AB8,0x9480,0xA020,0xADF2,0xBE5E, +/* A:18 B:1a */ +0x5FB8,0x5FCF,0x5FEA,0x600A,0x6030,0x605D,0x6093,0x60D3, +0x611F,0x6179,0x61E4,0x6264,0x62FB,0x63AF,0x6486,0x6584, +0x66B2,0x681A,0x69C5,0x6BC0,0x6E1C,0x70E9,0x743D,0x7832, +0x7CE6,0x827C,0x8921,0x9106,0x9A68,0xA58E,0xB2CF,0xC28F, +/* A:18 B:1b */ +0x69B6,0x69CC,0x69E5,0x6A04,0x6A28,0x6A53,0x6A86,0x6AC3, +0x6B0B,0x6B60,0x6BC6,0x6C3F,0x6CCF,0x6D7A,0x6E45,0x6F37, +0x7056,0x71AB,0x7341,0x7522,0x775F,0x7A08,0x7D31,0x80F3, +0x8569,0x8AB8,0x9106,0x9884,0xA16D,0xAC03,0xB897,0xC78B, +/* A:18 B:1c */ +0x7597,0x75AB,0x75C3,0x75DF,0x7601,0x7629,0x7659,0x7692, +0x76D5,0x7726,0x7785,0x77F6,0x787D,0x791D,0x79DC,0x7ABE, +0x7BCB,0x7D0A,0x7E86,0x8049,0x8262,0x84DF,0x87D5,0x8B5A, +0x8F88,0x9480,0x9A68,0xA16D,0xA9C4,0xB3AE,0xBF77,0xCD78, +/* A:18 B:1d */ +0x83B4,0x83C6,0x83DD,0x83F7,0x8416,0x843B,0x8467,0x849B, +0x84D9,0x8523,0x857B,0x85E3,0x865F,0x86F2,0x87A1,0x8871, +0x8968,0x8A8E,0x8BEB,0x8D8A,0x8F77,0x91C2,0x947A,0x97B6, +0x9B8F,0xA020,0xA58E,0xAC03,0xB3AE,0xBCCC,0xC7A2,0xD482, +/* A:18 B:1e */ +0x947B,0x948B,0x949F,0x94B6,0x94D2,0x94F3,0x951B,0x954A, +0x9581,0x95C3,0x9612,0x966F,0x96DE,0x9762,0x97FF,0x98B9, +0x9997,0x9A9E,0x9BD7,0x9D4B,0x9F05,0xA112,0xA382,0xA668, +0xA9DA,0xADF2,0xB2CF,0xB897,0xBF77,0xC7A2,0xD157,0xDCE0, +/* A:18 B:1f */ +0xA86B,0xA879,0xA88A,0xA89E,0xA8B6,0xA8D3,0xA8F5,0xA91D, +0xA94D,0xA986,0xA9CA,0xAA1A,0xAA7A,0xAAEC,0xAB73,0xAC13, +0xACD2,0xADB5,0xAEC3,0xB003,0xB180,0xB345,0xB55F,0xB7DF, +0xBAD7,0xBE5E,0xC28F,0xC78B,0xCD78,0xD482,0xDCE0,0xE6D2, +/* A: 968D89C0 */ +/* A:19 B:00 */ +0x3399,0x33B5,0x33D6,0x33FD,0x342C,0x3463,0x34A5,0x34F3, +0x3550,0x35BF,0x3642,0x36DE,0x3797,0x3874,0x397A,0x3AB1, +0x3C23,0x3DDB,0x3FE6,0x4253,0x4536,0x48A3,0x4CB7,0x518E, +0x5750,0x5E27,0x6648,0x6FF2,0x7B6E,0x8914,0x994C,0xAC94, +/* A:19 B:01 */ +0x33B5,0x33D1,0x33F2,0x3419,0x3447,0x347F,0x34C0,0x350F, +0x356C,0x35DA,0x365D,0x36F9,0x37B3,0x388F,0x3995,0x3ACC, +0x3C3E,0x3DF6,0x4000,0x426D,0x4550,0x48BD,0x4CCF,0x51A7, +0x5767,0x5E3E,0x665E,0x7007,0x7B81,0x8926,0x995C,0xACA2, +/* A:19 B:02 */ +0x33D6,0x33F2,0x3413,0x343A,0x3468,0x34A0,0x34E1,0x352F, +0x358C,0x35FB,0x367E,0x371A,0x37D3,0x38AF,0x39B5,0x3AEC, +0x3C5E,0x3E15,0x4020,0x428C,0x456E,0x48DB,0x4CED,0x51C4, +0x5783,0x5E59,0x6678,0x701F,0x7B98,0x893B,0x996F,0xACB2, +/* A:19 B:03 */ +0x33FD,0x3419,0x343A,0x3461,0x348F,0x34C7,0x3508,0x3556, +0x35B3,0x3622,0x36A5,0x3740,0x37FA,0x38D6,0x39DB,0x3B12, +0x3C84,0x3E3B,0x4045,0x42B1,0x4592,0x48FF,0x4D10,0x51E6, +0x57A5,0x5E79,0x6697,0x703D,0x7BB4,0x8954,0x9986,0xACC5, +/* A:19 B:04 */ +0x342C,0x3447,0x3468,0x348F,0x34BE,0x34F5,0x3537,0x3585, +0x35E2,0x3650,0x36D3,0x376E,0x3828,0x3903,0x3A09,0x3B40, +0x3CB1,0x3E68,0x4071,0x42DD,0x45BE,0x4929,0x4D3A,0x520F, +0x57CD,0x5EA0,0x66BC,0x7060,0x7BD4,0x8972,0x99A1,0xACDD, +/* A:19 B:05 */ +0x3463,0x347F,0x34A0,0x34C7,0x34F5,0x352C,0x356E,0x35BC, +0x3619,0x3687,0x370A,0x37A5,0x385E,0x393A,0x3A3F,0x3B75, +0x3CE6,0x3E9D,0x40A6,0x4311,0x45F1,0x495C,0x4D6B,0x523F, +0x57FC,0x5ECD,0x66E8,0x7089,0x7BFB,0x8996,0x99C1,0xACF8, +/* A:19 B:06 */ +0x34A5,0x34C0,0x34E1,0x3508,0x3537,0x356E,0x35AF,0x35FD, +0x365A,0x36C8,0x374B,0x37E6,0x389F,0x397A,0x3A7F,0x3BB5, +0x3D26,0x3EDC,0x40E4,0x434F,0x462E,0x4998,0x4DA6,0x5279, +0x5834,0x5F03,0x671C,0x70BA,0x7C2A,0x89C0,0x99E7,0xAD19, +/* A:19 B:07 */ +0x34F3,0x350F,0x352F,0x3556,0x3585,0x35BC,0x35FD,0x364B, +0x36A8,0x3715,0x3798,0x3833,0x38EC,0x39C7,0x3ACB,0x3C01, +0x3D71,0x3F26,0x412E,0x4398,0x4677,0x49DF,0x4DED,0x52BD, +0x5876,0x5F44,0x6759,0x70F5,0x7C60,0x89F3,0x9A14,0xAD40, +/* A:19 B:08 */ +0x3550,0x356C,0x358C,0x35B3,0x35E2,0x3619,0x365A,0x36A8, +0x3704,0x3772,0x37F4,0x388F,0x3947,0x3A22,0x3B26,0x3C5B, +0x3DCB,0x3F7F,0x4187,0x43EF,0x46CD,0x4A34,0x4E40,0x530F, +0x58C6,0x5F90,0x67A3,0x713B,0x7CA2,0x8A2F,0x9A4A,0xAD6E, +/* A:19 B:09 */ +0x35BF,0x35DA,0x35FB,0x3622,0x3650,0x3687,0x36C8,0x3715, +0x3772,0x37DF,0x3861,0x38FC,0x39B4,0x3A8E,0x3B92,0x3CC7, +0x3E35,0x3FE9,0x41EF,0x4457,0x4733,0x4A99,0x4EA3,0x536F, +0x5924,0x5FEB,0x67FA,0x718E,0x7CEF,0x8A76,0x9A8A,0xADA5, +/* A:19 B:0a */ +0x3642,0x365D,0x367E,0x36A5,0x36D3,0x370A,0x374B,0x3798, +0x37F4,0x3861,0x38E3,0x397D,0x3A35,0x3B0F,0x3C12,0x3D46, +0x3EB4,0x4067,0x426C,0x44D3,0x47AD,0x4B11,0x4F18,0x53E2, +0x5994,0x6057,0x6862,0x71F0,0x7D4B,0x8ACB,0x9AD6,0xADE7, +/* A:19 B:0b */ +0x36DE,0x36F9,0x371A,0x3740,0x376E,0x37A5,0x37E6,0x3833, +0x388F,0x38FC,0x397D,0x3A17,0x3ACE,0x3BA8,0x3CAA,0x3DDD, +0x3F4B,0x40FC,0x4300,0x4565,0x483D,0x4B9F,0x4FA4,0x546B, +0x5A19,0x60D8,0x68DD,0x7265,0x7DB9,0x8B30,0x9B30,0xAE35, +/* A:19 B:0c */ +0x3797,0x37B3,0x37D3,0x37FA,0x3828,0x385E,0x389F,0x38EC, +0x3947,0x39B4,0x3A35,0x3ACE,0x3B85,0x3C5E,0x3D5F,0x3E91, +0x3FFD,0x41AE,0x43B0,0x4613,0x48E9,0x4C49,0x504A,0x550E, +0x5AB7,0x6171,0x696F,0x72F0,0x7E3B,0x8BA7,0x9B9B,0xAE91, +/* A:19 B:0d */ +0x3874,0x388F,0x38AF,0x38D6,0x3903,0x393A,0x397A,0x39C7, +0x3A22,0x3A8E,0x3B0F,0x3BA8,0x3C5E,0x3D36,0x3E36,0x3F67, +0x40D2,0x4281,0x4481,0x46E2,0x49B6,0x4D12,0x5110,0x55CF, +0x5B72,0x6226,0x6A1E,0x7395,0x7ED6,0x8C36,0x9C1B,0xAEFF, +/* A:19 B:0e */ +0x397A,0x3995,0x39B5,0x39DB,0x3A09,0x3A3F,0x3A7F,0x3ACB, +0x3B26,0x3B92,0x3C12,0x3CAA,0x3D5F,0x3E36,0x3F36,0x4066, +0x41CF,0x437C,0x457A,0x47D8,0x4AA9,0x4E01,0x51FB,0x56B4, +0x5C52,0x62FE,0x6AED,0x745A,0x7F8E,0x8CDF,0x9CB2,0xAF81, +/* A:19 B:0f */ +0x3AB1,0x3ACC,0x3AEC,0x3B12,0x3B40,0x3B75,0x3BB5,0x3C01, +0x3C5B,0x3CC7,0x3D46,0x3DDD,0x3E91,0x3F67,0x4066,0x4194, +0x42FB,0x44A6,0x46A2,0x48FD,0x4BC9,0x4F1D,0x5312,0x57C5, +0x5D5B,0x63FE,0x6BE2,0x7543,0x8069,0x8DA8,0x9D66,0xB01C, +/* A:19 B:10 */ +0x3C23,0x3C3E,0x3C5E,0x3C84,0x3CB1,0x3CE6,0x3D26,0x3D71, +0x3DCB,0x3E35,0x3EB4,0x3F4B,0x3FFD,0x40D2,0x41CF,0x42FB, +0x4460,0x4608,0x4801,0x4A58,0x4D20,0x506F,0x545D,0x5909, +0x5E96,0x652F,0x6D07,0x7659,0x816C,0x8E97,0x9E3C,0xB0D5, +/* A:19 B:11 */ +0x3DDB,0x3DF6,0x3E15,0x3E3B,0x3E68,0x3E9D,0x3EDC,0x3F26, +0x3F7F,0x3FE9,0x4067,0x40FC,0x41AE,0x4281,0x437C,0x44A6, +0x4608,0x47AE,0x49A2,0x4BF5,0x4EB8,0x5200,0x55E7,0x5A8A, +0x600D,0x6699,0x6E62,0x77A2,0x82A1,0x8FB3,0x9F3A,0xB1B0, +/* A:19 B:12 */ +0x3FE6,0x4000,0x4020,0x4045,0x4071,0x40A6,0x40E4,0x412E, +0x4187,0x41EF,0x426C,0x4300,0x43B0,0x4481,0x457A,0x46A2, +0x4801,0x49A2,0x4B92,0x4DE0,0x509D,0x53DE,0x57BB,0x5C54, +0x61CA,0x6848,0x6FFF,0x792A,0x8410,0x9104,0xA069,0xB2B4, +/* A:19 B:13 */ +0x4253,0x426D,0x428C,0x42B1,0x42DD,0x4311,0x434F,0x4398, +0x43EF,0x4457,0x44D3,0x4565,0x4613,0x46E2,0x47D8,0x48FD, +0x4A58,0x4BF5,0x4DE0,0x5027,0x52DD,0x5615,0x59E8,0x5E74, +0x63DB,0x6A48,0x71EA,0x7AFC,0x85C4,0x9295,0xA1D0,0xB3EA, +/* A:19 B:14 */ +0x4536,0x4550,0x456E,0x4592,0x45BE,0x45F1,0x462E,0x4677, +0x46CD,0x4733,0x47AD,0x483D,0x48E9,0x49B6,0x4AA9,0x4BC9, +0x4D20,0x4EB8,0x509D,0x52DD,0x5589,0x58B7,0x5C7E,0x60FB, +0x6650,0x6CA8,0x7431,0x7D26,0x87CB,0x9472,0xA37B,0xB55A, +/* A:19 B:15 */ +0x48A3,0x48BD,0x48DB,0x48FF,0x4929,0x495C,0x4998,0x49DF, +0x4A34,0x4A99,0x4B11,0x4B9F,0x4C49,0x4D12,0x4E01,0x4F1D, +0x506F,0x5200,0x53DE,0x5615,0x58B7,0x5BD8,0x5F90,0x63FB, +0x693C,0x6F7A,0x76E6,0x7FB8,0x8A33,0x96A8,0xA576,0xB70F, +/* A:19 B:16 */ +0x4CB7,0x4CCF,0x4CED,0x4D10,0x4D3A,0x4D6B,0x4DA6,0x4DED, +0x4E40,0x4EA3,0x4F18,0x4FA4,0x504A,0x5110,0x51FB,0x5312, +0x545D,0x55E7,0x57BB,0x59E8,0x5C7E,0x5F90,0x6336,0x678D, +0x6CB5,0x72D5,0x7A1E,0x82C6,0x8D0F,0x9949,0xA7D1,0xB916, +/* A:19 B:17 */ +0x518E,0x51A7,0x51C4,0x51E6,0x520F,0x523F,0x5279,0x52BD, +0x530F,0x536F,0x53E2,0x546B,0x550E,0x55CF,0x56B4,0x57C5, +0x5909,0x5A8A,0x5C54,0x5E74,0x60FB,0x63FB,0x678D,0x6BCA, +0x70D5,0x76D2,0x7DF1,0x8667,0x9076,0x9C69,0xAA9E,0xBB80, +/* A:19 B:18 */ +0x5750,0x5767,0x5783,0x57A5,0x57CD,0x57FC,0x5834,0x5876, +0x58C6,0x5924,0x5994,0x5A19,0x5AB7,0x5B72,0x5C52,0x5D5B, +0x5E96,0x600D,0x61CA,0x63DB,0x6650,0x693C,0x6CB5,0x70D5, +0x75BC,0x7B90,0x827C,0x8AB8,0x9480,0xA020,0xADF2,0xBE5E, +/* A:19 B:19 */ +0x5E27,0x5E3E,0x5E59,0x5E79,0x5EA0,0x5ECD,0x5F03,0x5F44, +0x5F90,0x5FEB,0x6057,0x60D8,0x6171,0x6226,0x62FE,0x63FE, +0x652F,0x6699,0x6848,0x6A48,0x6CA8,0x6F7A,0x72D5,0x76D2, +0x7B90,0x8132,0x87E3,0x8FD8,0x994D,0xA48A,0xB1E6,0xC1C6, +/* A:19 B:1a */ +0x6648,0x665E,0x6678,0x6697,0x66BC,0x66E8,0x671C,0x6759, +0x67A3,0x67FA,0x6862,0x68DD,0x696F,0x6A1E,0x6AED,0x6BE2, +0x6D07,0x6E62,0x6FFF,0x71EA,0x7431,0x76E6,0x7A1E,0x7DF1, +0x827C,0x87E3,0x8E4F,0x95F1,0x9F02,0xA9CA,0xB699,0xC5D3, +/* A:19 B:1b */ +0x6FF2,0x7007,0x701F,0x703D,0x7060,0x7089,0x70BA,0x70F5, +0x713B,0x718E,0x71F0,0x7265,0x72F0,0x7395,0x745A,0x7543, +0x7659,0x77A2,0x792A,0x7AFC,0x7D26,0x7FB8,0x82C6,0x8667, +0x8AB8,0x8FD8,0x95F1,0x9D2F,0xA5CB,0xB006,0xBC2F,0xCAA3, +/* A:19 B:1c */ +0x7B6E,0x7B81,0x7B98,0x7BB4,0x7BD4,0x7BFB,0x7C2A,0x7C60, +0x7CA2,0x7CEF,0x7D4B,0x7DB9,0x7E3B,0x7ED6,0x7F8E,0x8069, +0x816C,0x82A1,0x8410,0x85C4,0x87CB,0x8A33,0x8D0F,0x9076, +0x9480,0x994D,0x9F02,0xA5CB,0xADDB,0xB770,0xC2D3,0xD05C, +/* A:19 B:1d */ +0x8914,0x8926,0x893B,0x8954,0x8972,0x8996,0x89C0,0x89F3, +0x8A2F,0x8A76,0x8ACB,0x8B30,0x8BA7,0x8C36,0x8CDF,0x8DA8, +0x8E97,0x8FB3,0x9104,0x9295,0x9472,0x96A8,0x9949,0x9C69, +0xA020,0xA48A,0xA9CA,0xB006,0xB770,0xC03F,0xCAB7,0xD728, +/* A:19 B:1e */ +0x994C,0x995C,0x996F,0x9986,0x99A1,0x99C1,0x99E7,0x9A14, +0x9A4A,0x9A8A,0x9AD6,0x9B30,0x9B9B,0x9C1B,0x9CB2,0x9D66, +0x9E3C,0x9F3A,0xA069,0xA1D0,0xA37B,0xA576,0xA7D1,0xAA9E, +0xADF2,0xB1E6,0xB699,0xBC2F,0xC2D3,0xCAB7,0xD417,0xDF3D, +/* A:19 B:1f */ +0xAC94,0xACA2,0xACB2,0xACC5,0xACDD,0xACF8,0xAD19,0xAD40, +0xAD6E,0xADA5,0xADE7,0xAE35,0xAE91,0xAEFF,0xAF81,0xB01C, +0xB0D5,0xB1B0,0xB2B4,0xB3EA,0xB55A,0xB70F,0xB916,0xBB80, +0xBE5E,0xC1C6,0xC5D3,0xCAA3,0xD05C,0xD728,0xDF3D,0xE8D7, +/* A: 968D89C0 */ +/* A:1a B:00 */ +0x3D75,0x3D8F,0x3DAF,0x3DD5,0x3E01,0x3E37,0x3E76,0x3EC1, +0x3F1A,0x3F84,0x4002,0x4098,0x414A,0x421D,0x4318,0x4443, +0x45A6,0x474C,0x4942,0x4B96,0x4E5A,0x51A4,0x558D,0x5A33, +0x5FB8,0x6648,0x6E15,0x775A,0x825E,0x8F77,0x9F07,0xB186, +/* A:1a B:01 */ +0x3D8F,0x3DAA,0x3DCA,0x3DEF,0x3E1C,0x3E51,0x3E90,0x3EDB, +0x3F34,0x3F9E,0x401C,0x40B2,0x4164,0x4237,0x4332,0x445D, +0x45C0,0x4766,0x495B,0x4BAF,0x4E73,0x51BD,0x55A5,0x5A4A, +0x5FCF,0x665E,0x6E2A,0x776E,0x8271,0x8F88,0x9F16,0xB193, +/* A:1a B:02 */ +0x3DAF,0x3DCA,0x3DE9,0x3E0F,0x3E3C,0x3E71,0x3EB0,0x3EFB, +0x3F54,0x3FBE,0x403C,0x40D1,0x4183,0x4256,0x4351,0x447C, +0x45DE,0x4784,0x4979,0x4BCD,0x4E90,0x51DA,0x55C1,0x5A66, +0x5FEA,0x6678,0x6E43,0x7786,0x8287,0x8F9C,0x9F28,0xB1A3, +/* A:1a B:03 */ +0x3DD5,0x3DEF,0x3E0F,0x3E34,0x3E61,0x3E96,0x3ED5,0x3F20, +0x3F79,0x3FE3,0x4061,0x40F6,0x41A8,0x427B,0x4376,0x44A0, +0x4603,0x47A8,0x499D,0x4BF0,0x4EB3,0x51FC,0x55E3,0x5A86, +0x600A,0x6697,0x6E61,0x77A2,0x82A2,0x8FB4,0x9F3E,0xB1B5, +/* A:1a B:04 */ +0x3E01,0x3E1C,0x3E3C,0x3E61,0x3E8E,0x3EC3,0x3F02,0x3F4D, +0x3FA5,0x400F,0x408D,0x4122,0x41D4,0x42A7,0x43A2,0x44CC, +0x462E,0x47D3,0x49C7,0x4C1A,0x4EDD,0x5225,0x560B,0x5AAE, +0x6030,0x66BC,0x6E84,0x77C3,0x82C1,0x8FD1,0x9F58,0xB1CB, +/* A:1a B:05 */ +0x3E37,0x3E51,0x3E71,0x3E96,0x3EC3,0x3EF8,0x3F37,0x3F81, +0x3FDA,0x4044,0x40C1,0x4157,0x4208,0x42DB,0x43D5,0x44FF, +0x4661,0x4806,0x49FA,0x4C4C,0x4F0E,0x5255,0x563B,0x5ADC, +0x605D,0x66E8,0x6EAE,0x77EB,0x82E6,0x8FF3,0x9F76,0xB1E6, +/* A:1a B:06 */ +0x3E76,0x3E90,0x3EB0,0x3ED5,0x3F02,0x3F37,0x3F75,0x3FC0, +0x4019,0x4082,0x4100,0x4195,0x4246,0x4319,0x4413,0x453C, +0x469E,0x4842,0x4A36,0x4C87,0x4F48,0x528F,0x5673,0x5B13, +0x6093,0x671C,0x6EE0,0x781A,0x8313,0x901C,0x9F9B,0xB205, +/* A:1a B:07 */ +0x3EC1,0x3EDB,0x3EFB,0x3F20,0x3F4D,0x3F81,0x3FC0,0x400B, +0x4063,0x40CD,0x414A,0x41DF,0x4290,0x4362,0x445C,0x4585, +0x46E6,0x488A,0x4A7D,0x4CCE,0x4F8E,0x52D3,0x56B6,0x5B55, +0x60D3,0x6759,0x6F1B,0x7853,0x8347,0x904D,0x9FC6,0xB22B, +/* A:1a B:08 */ +0x3F1A,0x3F34,0x3F54,0x3F79,0x3FA5,0x3FDA,0x4019,0x4063, +0x40BC,0x4125,0x41A2,0x4237,0x42E8,0x43BA,0x44B3,0x45DC, +0x473C,0x48DF,0x4AD1,0x4D21,0x4FE1,0x5325,0x5706,0x5BA3, +0x611F,0x67A3,0x6F61,0x7895,0x8386,0x9086,0x9FFA,0xB257, +/* A:1a B:09 */ +0x3F84,0x3F9E,0x3FBE,0x3FE3,0x400F,0x4044,0x4082,0x40CD, +0x4125,0x418E,0x420B,0x42A0,0x4350,0x4422,0x451B,0x4643, +0x47A3,0x4945,0x4B36,0x4D85,0x5043,0x5385,0x5765,0x5C00, +0x6179,0x67FA,0x6FB5,0x78E5,0x83D0,0x90CA,0xA037,0xB28C, +/* A:1a B:0a */ +0x4002,0x401C,0x403C,0x4061,0x408D,0x40C1,0x4100,0x414A, +0x41A2,0x420B,0x4288,0x431C,0x43CC,0x449D,0x4596,0x46BD, +0x481C,0x49BE,0x4BAE,0x4DFB,0x50B8,0x53F8,0x57D6,0x5C6E, +0x61E4,0x6862,0x7018,0x7943,0x8429,0x911C,0xA080,0xB2CA, +/* A:1a B:0b */ +0x4098,0x40B2,0x40D1,0x40F6,0x4122,0x4157,0x4195,0x41DF, +0x4237,0x42A0,0x431C,0x43B0,0x445F,0x4530,0x4628,0x474E, +0x48AD,0x4A4D,0x4C3C,0x4E88,0x5142,0x5481,0x585C,0x5CF1, +0x6264,0x68DD,0x708F,0x79B4,0x8492,0x917C,0xA0D6,0xB315, +/* A:1a B:0c */ +0x414A,0x4164,0x4183,0x41A8,0x41D4,0x4208,0x4246,0x4290, +0x42E8,0x4350,0x43CC,0x445F,0x450E,0x45DE,0x46D5,0x47FB, +0x4958,0x4AF7,0x4CE4,0x4F2F,0x51E7,0x5523,0x58FC,0x5D8D, +0x62FB,0x696F,0x711B,0x7A39,0x850E,0x91EF,0xA13D,0xB36D, +/* A:1a B:0d */ +0x421D,0x4237,0x4256,0x427B,0x42A7,0x42DB,0x4319,0x4362, +0x43BA,0x4422,0x449D,0x4530,0x45DE,0x46AD,0x47A4,0x48C8, +0x4A24,0x4BC2,0x4DAD,0x4FF5,0x52AB,0x55E4,0x59B9,0x5E46, +0x63AF,0x6A1E,0x71C2,0x7AD7,0x85A3,0x9277,0xA1B7,0xB3D6, +/* A:1a B:0e */ +0x4318,0x4332,0x4351,0x4376,0x43A2,0x43D5,0x4413,0x445C, +0x44B3,0x451B,0x4596,0x4628,0x46D5,0x47A4,0x4899,0x49BC, +0x4B17,0x4CB2,0x4E9C,0x50E1,0x5394,0x56CA,0x5A9A,0x5F22, +0x6486,0x6AED,0x7288,0x7B94,0x8653,0x9319,0xA248,0xB453, +/* A:1a B:0f */ +0x4443,0x445D,0x447C,0x44A0,0x44CC,0x44FF,0x453C,0x4585, +0x45DC,0x4643,0x46BD,0x474E,0x47FB,0x48C8,0x49BC,0x4ADE, +0x4C37,0x4DD0,0x4FB7,0x51FA,0x54A9,0x57DA,0x5BA6,0x6028, +0x6584,0x6BE2,0x7374,0x7C73,0x8725,0x93DA,0xA2F5,0xB4E8, +/* A:1a B:10 */ +0x45A6,0x45C0,0x45DE,0x4603,0x462E,0x4661,0x469E,0x46E6, +0x473C,0x47A3,0x481C,0x48AD,0x4958,0x4A24,0x4B17,0x4C37, +0x4D8D,0x4F24,0x5108,0x5347,0x55F2,0x591F,0x5CE4,0x615F, +0x66B2,0x6D07,0x748D,0x7D7E,0x881E,0x94BF,0xA3C2,0xB599, +/* A:1a B:11 */ +0x474C,0x4766,0x4784,0x47A8,0x47D3,0x4806,0x4842,0x488A, +0x48DF,0x4945,0x49BE,0x4A4D,0x4AF7,0x4BC2,0x4CB2,0x4DD0, +0x4F24,0x50B8,0x5299,0x54D3,0x577A,0x5AA0,0x5E5E,0x62D0, +0x681A,0x6E62,0x75DA,0x7EBA,0x8946,0x95CF,0xA4B5,0xB66A, +/* A:1a B:12 */ +0x4942,0x495B,0x4979,0x499D,0x49C7,0x49FA,0x4A36,0x4A7D, +0x4AD1,0x4B36,0x4BAE,0x4C3C,0x4CE4,0x4DAD,0x4E9C,0x4FB7, +0x5108,0x5299,0x5474,0x56AA,0x594A,0x5C69,0x601F,0x6488, +0x69C5,0x6FFF,0x7766,0x8031,0x8AA6,0x9713,0xA5D7,0xB764, +/* A:1a B:13 */ +0x4B96,0x4BAF,0x4BCD,0x4BF0,0x4C1A,0x4C4C,0x4C87,0x4CCE, +0x4D21,0x4D85,0x4DFB,0x4E88,0x4F2F,0x4FF5,0x50E1,0x51FA, +0x5347,0x54D3,0x56AA,0x58DA,0x5B73,0x5E89,0x6235,0x6691, +0x6BC0,0x71EA,0x793C,0x81F0,0x8C48,0x9893,0xA72F,0xB88C, +/* A:1a B:14 */ +0x4E5A,0x4E73,0x4E90,0x4EB3,0x4EDD,0x4F0E,0x4F48,0x4F8E, +0x4FE1,0x5043,0x50B8,0x5142,0x51E7,0x52AB,0x5394,0x54A9, +0x55F2,0x577A,0x594A,0x5B73,0x5E03,0x6110,0x64AF,0x68FE, +0x6E1C,0x7431,0x7B6B,0x8403,0x8E39,0x9A5C,0xA8C8,0xB9ED, +/* A:1a B:15 */ +0x51A4,0x51BD,0x51DA,0x51FC,0x5225,0x5255,0x528F,0x52D3, +0x5325,0x5385,0x53F8,0x5481,0x5523,0x55E4,0x56CA,0x57DA, +0x591F,0x5AA0,0x5C69,0x5E89,0x6110,0x6410,0x67A1,0x6BDF, +0x70E9,0x76E6,0x7E04,0x867A,0x9088,0x9C7B,0xAAAE,0xBB8F, +/* A:1a B:16 */ +0x558D,0x55A5,0x55C1,0x55E3,0x560B,0x563B,0x5673,0x56B6, +0x5706,0x5765,0x57D6,0x585C,0x58FC,0x59B9,0x5A9A,0x5BA6, +0x5CE4,0x5E5E,0x601F,0x6235,0x64AF,0x67A1,0x6B22,0x6F4B, +0x743D,0x7A1E,0x811A,0x8968,0x9346,0x9F00,0xACF0,0xBD81, +/* A:1a B:17 */ +0x5A33,0x5A4A,0x5A66,0x5A86,0x5AAE,0x5ADC,0x5B13,0x5B55, +0x5BA3,0x5C00,0x5C6E,0x5CF1,0x5D8D,0x5E46,0x5F22,0x6028, +0x615F,0x62D0,0x6488,0x6691,0x68FE,0x6BDF,0x6F4B,0x735C, +0x7832,0x7DF1,0x84C5,0x8CE3,0x9688,0xA1FF,0xAF9F,0xBFD1, +/* A:1a B:18 */ +0x5FB8,0x5FCF,0x5FEA,0x600A,0x6030,0x605D,0x6093,0x60D3, +0x611F,0x6179,0x61E4,0x6264,0x62FB,0x63AF,0x6486,0x6584, +0x66B2,0x681A,0x69C5,0x6BC0,0x6E1C,0x70E9,0x743D,0x7832, +0x7CE6,0x827C,0x8921,0x9106,0x9A68,0xA58E,0xB2CF,0xC28F, +/* A:1a B:19 */ +0x6648,0x665E,0x6678,0x6697,0x66BC,0x66E8,0x671C,0x6759, +0x67A3,0x67FA,0x6862,0x68DD,0x696F,0x6A1E,0x6AED,0x6BE2, +0x6D07,0x6E62,0x6FFF,0x71EA,0x7431,0x76E6,0x7A1E,0x7DF1, +0x827C,0x87E3,0x8E4F,0x95F1,0x9F02,0xA9CA,0xB699,0xC5D3, +/* A:1a B:1a */ +0x6E15,0x6E2A,0x6E43,0x6E61,0x6E84,0x6EAE,0x6EE0,0x6F1B, +0x6F61,0x6FB5,0x7018,0x708F,0x711B,0x71C2,0x7288,0x7374, +0x748D,0x75DA,0x7766,0x793C,0x7B6B,0x7E04,0x811A,0x84C5, +0x8921,0x8E4F,0x9477,0x9BC9,0xA47B,0xAED1,0xBB1A,0xC9B4, +/* A:1a B:1b */ +0x775A,0x776E,0x7786,0x77A2,0x77C3,0x77EB,0x781A,0x7853, +0x7895,0x78E5,0x7943,0x79B4,0x7A39,0x7AD7,0x7B94,0x7C73, +0x7D7E,0x7EBA,0x8031,0x81F0,0x8403,0x867A,0x8968,0x8CE3, +0x9106,0x95F1,0x9BC9,0xA2BB,0xAAFC,0xB4CB,0xC074,0xCE50, +/* A:1a B:1c */ +0x825E,0x8271,0x8287,0x82A2,0x82C1,0x82E6,0x8313,0x8347, +0x8386,0x83D0,0x8429,0x8492,0x850E,0x85A3,0x8653,0x8725, +0x881E,0x8946,0x8AA6,0x8C48,0x8E39,0x9088,0x9346,0x9688, +0x9A68,0x9F02,0xA47B,0xAAFC,0xB2B6,0xBBE6,0xC6D1,0xD3CB, +/* A:1a B:1d */ +0x8F77,0x8F88,0x8F9C,0x8FB4,0x8FD1,0x8FF3,0x901C,0x904D, +0x9086,0x90CA,0x911C,0x917C,0x91EF,0x9277,0x9319,0x93DA, +0x94BF,0x95CF,0x9713,0x9893,0x9A5C,0x9C7B,0x9F00,0xA1FF, +0xA58E,0xA9CA,0xAED1,0xB4CB,0xBBE6,0xC458,0xCE60,0xDA4E, +/* A:1a B:1e */ +0x9F07,0x9F16,0x9F28,0x9F3E,0x9F58,0x9F76,0x9F9B,0x9FC6, +0x9FFA,0xA037,0xA080,0xA0D6,0xA13D,0xA1B7,0xA248,0xA2F5, +0xA3C2,0xA4B5,0xA5D7,0xA72F,0xA8C8,0xAAAE,0xACF0,0xAF9F, +0xB2CF,0xB699,0xBB1A,0xC074,0xC6D1,0xCE60,0xD75D,0xE20B, +/* A:1a B:1f */ +0xB186,0xB193,0xB1A3,0xB1B5,0xB1CB,0xB1E6,0xB205,0xB22B, +0xB257,0xB28C,0xB2CA,0xB315,0xB36D,0xB3D6,0xB453,0xB4E8, +0xB599,0xB66A,0xB764,0xB88C,0xB9ED,0xBB8F,0xBD81,0xBFD1, +0xC28F,0xC5D3,0xC9B4,0xCE50,0xD3CB,0xDA4E,0xE20B,0xEB3E, +/* A: 968D89C0 */ +/* A:1b B:00 */ +0x492C,0x4946,0x4964,0x4987,0x49B2,0x49E4,0x4A20,0x4A67, +0x4ABC,0x4B21,0x4B98,0x4C27,0x4CD0,0x4D99,0x4E87,0x4FA3, +0x50F4,0x5285,0x5461,0x5697,0x5938,0x5C58,0x600E,0x6478, +0x69B6,0x6FF2,0x775A,0x8028,0x8A9E,0x970E,0xA5D5,0xB766, +/* A:1b B:01 */ +0x4946,0x495F,0x497D,0x49A1,0x49CB,0x49FD,0x4A39,0x4A81, +0x4AD5,0x4B3A,0x4BB1,0x4C40,0x4CE9,0x4DB1,0x4EA0,0x4FBC, +0x510D,0x529D,0x5479,0x56AF,0x5950,0x5C6F,0x6025,0x648E, +0x69CC,0x7007,0x776E,0x803B,0x8AB0,0x971E,0xA5E4,0xB773, +/* A:1b B:02 */ +0x4964,0x497D,0x499B,0x49BF,0x49E9,0x4A1B,0x4A57,0x4A9E, +0x4AF3,0x4B58,0x4BCF,0x4C5D,0x4D06,0x4DCF,0x4EBD,0x4FD9, +0x512A,0x52BA,0x5496,0x56CB,0x596B,0x5C8A,0x6040,0x64A8, +0x69E5,0x701F,0x7786,0x8051,0x8AC5,0x9731,0xA5F5,0xB782, +/* A:1b B:03 */ +0x4987,0x49A1,0x49BF,0x49E2,0x4A0D,0x4A3F,0x4A7B,0x4AC2, +0x4B17,0x4B7B,0x4BF2,0x4C80,0x4D29,0x4DF2,0x4EE0,0x4FFB, +0x514C,0x52DC,0x54B8,0x56ED,0x598D,0x5CAB,0x6060,0x64C7, +0x6A04,0x703D,0x77A2,0x806C,0x8ADE,0x9748,0xA60A,0xB793, +/* A:1b B:04 */ +0x49B2,0x49CB,0x49E9,0x4A0D,0x4A37,0x4A69,0x4AA5,0x4AEC, +0x4B41,0x4BA5,0x4C1C,0x4CAA,0x4D53,0x4E1B,0x4F09,0x5025, +0x5175,0x5305,0x54E0,0x5715,0x59B4,0x5CD2,0x6086,0x64ED, +0x6A28,0x7060,0x77C3,0x808C,0x8AFC,0x9764,0xA622,0xB7A8, +/* A:1b B:05 */ +0x49E4,0x49FD,0x4A1B,0x4A3F,0x4A69,0x4A9C,0x4AD7,0x4B1E, +0x4B73,0x4BD7,0x4C4E,0x4CDC,0x4D85,0x4E4D,0x4F3B,0x5055, +0x51A6,0x5335,0x5510,0x5744,0x59E3,0x5D00,0x60B3,0x6519, +0x6A53,0x7089,0x77EB,0x80B1,0x8B1F,0x9784,0xA63F,0xB7C1, +/* A:1b B:06 */ +0x4A20,0x4A39,0x4A57,0x4A7B,0x4AA5,0x4AD7,0x4B13,0x4B5A, +0x4BAE,0x4C13,0x4C8A,0x4D17,0x4DC0,0x4E88,0x4F75,0x5090, +0x51DF,0x536E,0x5549,0x577C,0x5A1A,0x5D36,0x60E9,0x654D, +0x6A86,0x70BA,0x781A,0x80DE,0x8B49,0x97AB,0xA662,0xB7DF, +/* A:1b B:07 */ +0x4A67,0x4A81,0x4A9E,0x4AC2,0x4AEC,0x4B1E,0x4B5A,0x4BA1, +0x4BF5,0x4C59,0x4CD0,0x4D5E,0x4E06,0x4ECD,0x4FBB,0x50D5, +0x5224,0x53B3,0x558C,0x57BF,0x5A5C,0x5D77,0x6128,0x658C, +0x6AC3,0x70F5,0x7853,0x8114,0x8B7B,0x97D9,0xA68B,0xB802, +/* A:1b B:08 */ +0x4ABC,0x4AD5,0x4AF3,0x4B17,0x4B41,0x4B73,0x4BAE,0x4BF5, +0x4C49,0x4CAD,0x4D24,0x4DB1,0x4E59,0x4F20,0x500D,0x5127, +0x5276,0x5404,0x55DD,0x580F,0x5AAB,0x5DC5,0x6174,0x65D6, +0x6B0B,0x713B,0x7895,0x8153,0x8BB7,0x980F,0xA6BC,0xB82C, +/* A:1b B:09 */ +0x4B21,0x4B3A,0x4B58,0x4B7B,0x4BA5,0x4BD7,0x4C13,0x4C59, +0x4CAD,0x4D11,0x4D87,0x4E14,0x4EBC,0x4F83,0x5070,0x5189, +0x52D7,0x5464,0x563C,0x586D,0x5B08,0x5E21,0x61CE,0x662E, +0x6B60,0x718E,0x78E5,0x819E,0x8BFD,0x9850,0xA6F6,0xB85E, +/* A:1b B:0a */ +0x4B98,0x4BB1,0x4BCF,0x4BF2,0x4C1C,0x4C4E,0x4C8A,0x4CD0, +0x4D24,0x4D87,0x4DFE,0x4E8A,0x4F32,0x4FF8,0x50E4,0x51FD, +0x534A,0x54D7,0x56AE,0x58DE,0x5B77,0x5E8E,0x623A,0x6697, +0x6BC6,0x71F0,0x7943,0x81F8,0x8C51,0x989D,0xA73B,0xB89A, +/* A:1b B:0b */ +0x4C27,0x4C40,0x4C5D,0x4C80,0x4CAA,0x4CDC,0x4D17,0x4D5E, +0x4DB1,0x4E14,0x4E8A,0x4F17,0x4FBD,0x5084,0x516F,0x5287, +0x53D3,0x555F,0x5735,0x5963,0x5BFB,0x5F0F,0x62B9,0x6713, +0x6C3F,0x7265,0x79B4,0x8263,0x8CB5,0x98F9,0xA78D,0xB8E0, +/* A:1b B:0c */ +0x4CD0,0x4CE9,0x4D06,0x4D29,0x4D53,0x4D85,0x4DC0,0x4E06, +0x4E59,0x4EBC,0x4F32,0x4FBD,0x5064,0x5129,0x5214,0x532B, +0x5476,0x5601,0x57D5,0x5A02,0x5C97,0x5FAA,0x6350,0x67A7, +0x6CCF,0x72F0,0x7A39,0x82E1,0x8D2B,0x9966,0xA7EE,0xB934, +/* A:1b B:0d */ +0x4D99,0x4DB1,0x4DCF,0x4DF2,0x4E1B,0x4E4D,0x4E88,0x4ECD, +0x4F20,0x4F83,0x4FF8,0x5084,0x5129,0x51EE,0x52D8,0x53EE, +0x5538,0x56C1,0x5894,0x5ABE,0x5D51,0x6061,0x6404,0x6857, +0x6D7A,0x7395,0x7AD7,0x8377,0x8DB8,0x99E7,0xA862,0xB998, +/* A:1b B:0e */ +0x4E87,0x4EA0,0x4EBD,0x4EE0,0x4F09,0x4F3B,0x4F75,0x4FBB, +0x500D,0x5070,0x50E4,0x516F,0x5214,0x52D8,0x53C1,0x54D5, +0x561E,0x57A5,0x5976,0x5B9E,0x5E2F,0x613B,0x64DA,0x6928, +0x6E45,0x745A,0x7B94,0x842A,0x8E5F,0x9A81,0xA8EC,0xBA0E, +/* A:1b B:0f */ +0x4FA3,0x4FBC,0x4FD9,0x4FFB,0x5025,0x5055,0x5090,0x50D5, +0x5127,0x5189,0x51FD,0x5287,0x532B,0x53EE,0x54D5,0x55E9, +0x5730,0x58B5,0x5A83,0x5CA9,0x5F36,0x623E,0x65D8,0x6A20, +0x6F37,0x7543,0x7C73,0x84FF,0x8F26,0x9B37,0xA98F,0xBA9B, +/* A:1b B:10 */ +0x50F4,0x510D,0x512A,0x514C,0x5175,0x51A6,0x51DF,0x5224, +0x5276,0x52D7,0x534A,0x53D3,0x5476,0x5538,0x561E,0x5730, +0x5875,0x59F8,0x5BC3,0x5DE5,0x606E,0x6371,0x6706,0x6B47, +0x7056,0x7659,0x7D7E,0x85FB,0x9012,0x9C11,0xAA52,0xBB42, +/* A:1b B:11 */ +0x5285,0x529D,0x52BA,0x52DC,0x5305,0x5335,0x536E,0x53B3, +0x5404,0x5464,0x54D7,0x555F,0x5601,0x56C1,0x57A5,0x58B5, +0x59F8,0x5B77,0x5D3F,0x5F5D,0x61E1,0x64DF,0x686D,0x6CA6, +0x71AB,0x77A2,0x7EBA,0x8727,0x912B,0x9D13,0xAB39,0xBC09, +/* A:1b B:12 */ +0x5461,0x5479,0x5496,0x54B8,0x54E0,0x5510,0x5549,0x558C, +0x55DD,0x563C,0x56AE,0x5735,0x57D5,0x5894,0x5976,0x5A83, +0x5BC3,0x5D3F,0x5F03,0x611C,0x639B,0x6692,0x6A17,0x6E47, +0x7341,0x792A,0x8031,0x888C,0x9279,0x9E46,0xAC4B,0xBCF6, +/* A:1b B:13 */ +0x5697,0x56AF,0x56CB,0x56ED,0x5715,0x5744,0x577C,0x57BF, +0x580F,0x586D,0x58DE,0x5963,0x5A02,0x5ABE,0x5B9E,0x5CA9, +0x5DE5,0x5F5D,0x611C,0x6330,0x65A7,0x6896,0x6C12,0x7036, +0x7522,0x7AFC,0x81F0,0x8A34,0x9406,0x9FB2,0xAD92,0xBE0F, +/* A:1b B:14 */ +0x5938,0x5950,0x596B,0x598D,0x59B4,0x59E3,0x5A1A,0x5A5C, +0x5AAB,0x5B08,0x5B77,0x5BFB,0x5C97,0x5D51,0x5E2F,0x5F36, +0x606E,0x61E1,0x639B,0x65A7,0x6817,0x6AFC,0x6E6D,0x7283, +0x775F,0x7D26,0x8403,0x8C2B,0x95DD,0xA163,0xAF15,0xBF5C, +/* A:1b B:15 */ +0x5C58,0x5C6F,0x5C8A,0x5CAB,0x5CD2,0x5D00,0x5D36,0x5D77, +0x5DC5,0x5E21,0x5E8E,0x5F0F,0x5FAA,0x6061,0x613B,0x623E, +0x6371,0x64DF,0x6692,0x6896,0x6AFC,0x6DD5,0x7139,0x753F, +0x7A08,0x7FB8,0x867A,0x8E82,0x980E,0xA366,0xB0E2,0xC0E9, +/* A:1b B:16 */ +0x600E,0x6025,0x6040,0x6060,0x6086,0x60B3,0x60E9,0x6128, +0x6174,0x61CE,0x623A,0x62B9,0x6350,0x6404,0x64DA,0x65D8, +0x6706,0x686D,0x6A17,0x6C12,0x6E6D,0x7139,0x748C,0x787F, +0x7D31,0x82C6,0x8968,0x914A,0x9AA8,0xA5CB,0xB306,0xC2C1, +/* A:1b B:17 */ +0x6478,0x648E,0x64A8,0x64C7,0x64ED,0x6519,0x654D,0x658C, +0x65D6,0x662E,0x6697,0x6713,0x67A7,0x6857,0x6928,0x6A20, +0x6B47,0x6CA6,0x6E47,0x7036,0x7283,0x753F,0x787F,0x7C5C, +0x80F3,0x8667,0x8CE3,0x9497,0x9DC0,0xA8A2,0xB592,0xC4F1, +/* A:1b B:18 */ +0x69B6,0x69CC,0x69E5,0x6A04,0x6A28,0x6A53,0x6A86,0x6AC3, +0x6B0B,0x6B60,0x6BC6,0x6C3F,0x6CCF,0x6D7A,0x6E45,0x6F37, +0x7056,0x71AB,0x7341,0x7522,0x775F,0x7A08,0x7D31,0x80F3, +0x8569,0x8AB8,0x9106,0x9884,0xA16D,0xAC03,0xB897,0xC78B, +/* A:1b B:19 */ +0x6FF2,0x7007,0x701F,0x703D,0x7060,0x7089,0x70BA,0x70F5, +0x713B,0x718E,0x71F0,0x7265,0x72F0,0x7395,0x745A,0x7543, +0x7659,0x77A2,0x792A,0x7AFC,0x7D26,0x7FB8,0x82C6,0x8667, +0x8AB8,0x8FD8,0x95F1,0x9D2F,0xA5CB,0xB006,0xBC2F,0xCAA3, +/* A:1b B:1a */ +0x775A,0x776E,0x7786,0x77A2,0x77C3,0x77EB,0x781A,0x7853, +0x7895,0x78E5,0x7943,0x79B4,0x7A39,0x7AD7,0x7B94,0x7C73, +0x7D7E,0x7EBA,0x8031,0x81F0,0x8403,0x867A,0x8968,0x8CE3, +0x9106,0x95F1,0x9BC9,0xA2BB,0xAAFC,0xB4CB,0xC074,0xCE50, +/* A:1b B:1b */ +0x8028,0x803B,0x8051,0x806C,0x808C,0x80B1,0x80DE,0x8114, +0x8153,0x819E,0x81F8,0x8263,0x82E1,0x8377,0x842A,0x84FF, +0x85FB,0x8727,0x888C,0x8A34,0x8C2B,0x8E82,0x914A,0x9497, +0x9884,0x9D2F,0xA2BB,0xA952,0xB127,0xBA77,0xC588,0xD2AE, +/* A:1b B:1c */ +0x8A9E,0x8AB0,0x8AC5,0x8ADE,0x8AFC,0x8B1F,0x8B49,0x8B7B, +0x8BB7,0x8BFD,0x8C51,0x8CB5,0x8D2B,0x8DB8,0x8E5F,0x8F26, +0x9012,0x912B,0x9279,0x9406,0x95DD,0x980E,0x9AA8,0x9DC0, +0xA16D,0xA5CB,0xAAFC,0xB127,0xB87D,0xC134,0xCB90,0xD7DF, +/* A:1b B:1d */ +0x970E,0x971E,0x9731,0x9748,0x9764,0x9784,0x97AB,0x97D9, +0x980F,0x9850,0x989D,0x98F9,0x9966,0x99E7,0x9A81,0x9B37, +0x9C11,0x9D13,0x9E46,0x9FB2,0xA163,0xA366,0xA5CB,0xA8A2, +0xAC03,0xB006,0xB4CB,0xBA77,0xC134,0xC936,0xD2BB,0xDE0B, +/* A:1b B:1e */ +0xA5D5,0xA5E4,0xA5F5,0xA60A,0xA622,0xA63F,0xA662,0xA68B, +0xA6BC,0xA6F6,0xA73B,0xA78D,0xA7EE,0xA862,0xA8EC,0xA98F, +0xAA52,0xAB39,0xAC4B,0xAD92,0xAF15,0xB0E2,0xB306,0xB592, +0xB897,0xBC2F,0xC074,0xC588,0xCB90,0xD2BB,0xDB40,0xE561, +/* A:1b B:1f */ +0xB766,0xB773,0xB782,0xB793,0xB7A8,0xB7C1,0xB7DF,0xB802, +0xB82C,0xB85E,0xB89A,0xB8E0,0xB934,0xB998,0xBA0E,0xBA9B, +0xBB42,0xBC09,0xBCF6,0xBE0F,0xBF5C,0xC0E9,0xC2C1,0xC4F1, +0xC78B,0xCAA3,0xCE50,0xD2AE,0xD7DF,0xDE0B,0xE561,0xEE18, +/* A: 968D89C0 */ +/* A:1c B:00 */ +0x5719,0x5731,0x574D,0x576E,0x5796,0x57C5,0x57FE,0x5840, +0x5890,0x58EE,0x595E,0x59E3,0x5A82,0x5B3E,0x5C1E,0x5D28, +0x5E64,0x5FDB,0x6199,0x63AC,0x6622,0x6910,0x6C8A,0x70AD, +0x7597,0x7B6E,0x825E,0x8A9E,0x946C,0xA013,0xADEC,0xBE62, +/* A:1c B:01 */ +0x5731,0x5748,0x5765,0x5786,0x57AE,0x57DD,0x5815,0x5858, +0x58A7,0x5906,0x5976,0x59FB,0x5A99,0x5B55,0x5C35,0x5D3F, +0x5E7A,0x5FF2,0x61B0,0x63C2,0x6638,0x6925,0x6C9F,0x70C1, +0x75AB,0x7B81,0x8271,0x8AB0,0x947D,0xA022,0xADFA,0xBE6E, +/* A:1c B:02 */ +0x574D,0x5765,0x5781,0x57A2,0x57CA,0x57F9,0x5831,0x5874, +0x58C3,0x5921,0x5991,0x5A17,0x5AB5,0x5B71,0x5C50,0x5D5A, +0x5E96,0x600D,0x61CB,0x63DD,0x6652,0x693F,0x6CB9,0x70DA, +0x75C3,0x7B98,0x8287,0x8AC5,0x9490,0xA035,0xAE0A,0xBE7C, +/* A:1c B:03 */ +0x576E,0x5786,0x57A2,0x57C4,0x57EB,0x581A,0x5853,0x5895, +0x58E4,0x5943,0x59B3,0x5A38,0x5AD6,0x5B92,0x5C71,0x5D7A, +0x5EB6,0x602D,0x61EA,0x63FC,0x6671,0x695D,0x6CD7,0x70F7, +0x75DF,0x7BB4,0x82A2,0x8ADE,0x94A8,0xA04A,0xAE1E,0xBE8C, +/* A:1c B:04 */ +0x5796,0x57AE,0x57CA,0x57EB,0x5813,0x5842,0x587A,0x58BD, +0x590C,0x596A,0x59DA,0x5A5F,0x5AFD,0x5BB9,0x5C98,0x5DA1, +0x5EDC,0x6053,0x6210,0x6421,0x6696,0x6982,0x6CFA,0x711A, +0x7601,0x7BD4,0x82C1,0x8AFC,0x94C4,0xA064,0xAE34,0xBEA0, +/* A:1c B:05 */ +0x57C5,0x57DD,0x57F9,0x581A,0x5842,0x5871,0x58A9,0x58EC, +0x593B,0x5999,0x5A09,0x5A8D,0x5B2B,0x5BE7,0x5CC6,0x5DCF, +0x5F0A,0x6080,0x623D,0x644E,0x66C2,0x69AD,0x6D24,0x7143, +0x7629,0x7BFB,0x82E6,0x8B1F,0x94E5,0xA082,0xAE50,0xBEB7, +/* A:1c B:06 */ +0x57FE,0x5815,0x5831,0x5853,0x587A,0x58A9,0x58E1,0x5924, +0x5973,0x59D1,0x5A40,0x5AC5,0x5B63,0x5C1E,0x5CFD,0x5E05, +0x5F40,0x60B6,0x6272,0x6482,0x66F6,0x69E0,0x6D57,0x7175, +0x7659,0x7C2A,0x8313,0x8B49,0x950C,0xA0A6,0xAE70,0xBED3, +/* A:1c B:07 */ +0x5840,0x5858,0x5874,0x5895,0x58BD,0x58EC,0x5924,0x5966, +0x59B5,0x5A13,0x5A82,0x5B07,0x5BA4,0x5C5F,0x5D3E,0x5E46, +0x5F80,0x60F6,0x62B2,0x64C1,0x6734,0x6A1D,0x6D93,0x71AF, +0x7692,0x7C60,0x8347,0x8B7B,0x953B,0xA0D1,0xAE96,0xBEF4, +/* A:1c B:08 */ +0x5890,0x58A7,0x58C3,0x58E4,0x590C,0x593B,0x5973,0x59B5, +0x5A04,0x5A61,0x5AD1,0x5B55,0x5BF2,0x5CAD,0x5D8B,0x5E93, +0x5FCD,0x6142,0x62FD,0x650C,0x677E,0x6A65,0x6DDA,0x71F4, +0x76D5,0x7CA2,0x8386,0x8BB7,0x9572,0xA104,0xAEC4,0xBF1C, +/* A:1c B:09 */ +0x58EE,0x5906,0x5921,0x5943,0x596A,0x5999,0x59D1,0x5A13, +0x5A61,0x5ABF,0x5B2E,0x5BB2,0x5C4F,0x5D0A,0x5DE7,0x5EEF, +0x6028,0x619C,0x6356,0x6564,0x67D5,0x6ABB,0x6E2E,0x7247, +0x7726,0x7CEF,0x83D0,0x8BFD,0x95B5,0xA141,0xAEFA,0xBF4A, +/* A:1c B:0a */ +0x595E,0x5976,0x5991,0x59B3,0x59DA,0x5A09,0x5A40,0x5A82, +0x5AD1,0x5B2E,0x5B9D,0x5C21,0x5CBD,0x5D77,0x5E55,0x5F5C, +0x6094,0x6207,0x63C1,0x65CD,0x683D,0x6B22,0x6E92,0x72A9, +0x7785,0x7D4B,0x8429,0x8C51,0x9603,0xA189,0xAF3B,0xBF82, +/* A:1c B:0b */ +0x59E3,0x59FB,0x5A17,0x5A38,0x5A5F,0x5A8D,0x5AC5,0x5B07, +0x5B55,0x5BB2,0x5C21,0x5CA4,0x5D40,0x5DFA,0x5ED7,0x5FDD, +0x6114,0x6287,0x643F,0x664A,0x68B8,0x6B9B,0x6F0A,0x731E, +0x77F6,0x7DB9,0x8492,0x8CB5,0x9660,0xA1DF,0xAF87,0xBFC4, +/* A:1c B:0c */ +0x5A82,0x5A99,0x5AB5,0x5AD6,0x5AFD,0x5B2B,0x5B63,0x5BA4, +0x5BF2,0x5C4F,0x5CBD,0x5D40,0x5DDC,0x5E95,0x5F71,0x6077, +0x61AD,0x631E,0x64D5,0x66DF,0x694B,0x6C2C,0x6F97,0x73A8, +0x787D,0x7E3B,0x850E,0x8D2B,0x96CF,0xA244,0xAFE3,0xC012, +/* A:1c B:0d */ +0x5B3E,0x5B55,0x5B71,0x5B92,0x5BB9,0x5BE7,0x5C1E,0x5C5F, +0x5CAD,0x5D0A,0x5D77,0x5DFA,0x5E95,0x5F4E,0x6029,0x612D, +0x6263,0x63D3,0x6588,0x6790,0x69F9,0x6CD7,0x7040,0x744D, +0x791D,0x7ED6,0x85A3,0x8DB8,0x9753,0xA2BD,0xB04F,0xC06F, +/* A:1c B:0e */ +0x5C1E,0x5C35,0x5C50,0x5C71,0x5C98,0x5CC6,0x5CFD,0x5D3E, +0x5D8B,0x5DE7,0x5E55,0x5ED7,0x5F71,0x6029,0x6103,0x6206, +0x633A,0x64A9,0x665C,0x6862,0x6AC9,0x6DA3,0x7108,0x7511, +0x79DC,0x7F8E,0x8653,0x8E5F,0x97EF,0xA34D,0xB0D0,0xC0DE, +/* A:1c B:0f */ +0x5D28,0x5D3F,0x5D5A,0x5D7A,0x5DA1,0x5DCF,0x5E05,0x5E46, +0x5E93,0x5EEF,0x5F5C,0x5FDD,0x6077,0x612D,0x6206,0x6308, +0x643B,0x65A7,0x6758,0x695B,0x6BBF,0x6E96,0x71F6,0x75F9, +0x7ABE,0x8069,0x8725,0x8F26,0x98AA,0xA3F8,0xB168,0xC161, +/* A:1c B:10 */ +0x5E64,0x5E7A,0x5E96,0x5EB6,0x5EDC,0x5F0A,0x5F40,0x5F80, +0x5FCD,0x6028,0x6094,0x6114,0x61AD,0x6263,0x633A,0x643B, +0x656C,0x66D6,0x6884,0x6A84,0x6CE4,0x6FB6,0x7311,0x770E, +0x7BCB,0x816C,0x881E,0x9012,0x9987,0xA4C3,0xB21E,0xC1FE, +/* A:1c B:11 */ +0x5FDB,0x5FF2,0x600D,0x602D,0x6053,0x6080,0x60B6,0x60F6, +0x6142,0x619C,0x6207,0x6287,0x631E,0x63D3,0x64A9,0x65A7, +0x66D6,0x683D,0x69E8,0x6BE4,0x6E40,0x710D,0x7461,0x7856, +0x7D0A,0x82A1,0x8946,0x912B,0x9A8E,0xA5B5,0xB2F6,0xC2B7, +/* A:1c B:12 */ +0x6199,0x61B0,0x61CB,0x61EA,0x6210,0x623D,0x6272,0x62B2, +0x62FD,0x6356,0x63C1,0x643F,0x64D5,0x6588,0x665C,0x6758, +0x6884,0x69E8,0x6B90,0x6D87,0x6FDD,0x72A4,0x75F1,0x79DD, +0x7E86,0x8410,0x8AA6,0x9279,0x9BC6,0xA6D4,0xB3F7,0xC394, +/* A:1c B:13 */ +0x63AC,0x63C2,0x63DD,0x63FC,0x6421,0x644E,0x6482,0x64C1, +0x650C,0x6564,0x65CD,0x664A,0x66DF,0x6790,0x6862,0x695B, +0x6A84,0x6BE4,0x6D87,0x6F79,0x71C8,0x7488,0x77CB,0x7BAD, +0x8049,0x85C4,0x8C48,0x9406,0x9D39,0xA829,0xB528,0xC49B, +/* A:1c B:14 */ +0x6622,0x6638,0x6652,0x6671,0x6696,0x66C2,0x66F6,0x6734, +0x677E,0x67D5,0x683D,0x68B8,0x694B,0x69F9,0x6AC9,0x6BBF, +0x6CE4,0x6E40,0x6FDD,0x71C8,0x7411,0x76C7,0x7A00,0x7DD4, +0x8262,0x87CB,0x8E39,0x95DD,0x9EF3,0xA9BE,0xB693,0xC5D3, +/* A:1c B:15 */ +0x6910,0x6925,0x693F,0x695D,0x6982,0x69AD,0x69E0,0x6A1D, +0x6A65,0x6ABB,0x6B22,0x6B9B,0x6C2C,0x6CD7,0x6DA3,0x6E96, +0x6FB6,0x710D,0x72A4,0x7488,0x76C7,0x7972,0x7C9E,0x8064, +0x84DF,0x8A33,0x9088,0x980E,0xA0FF,0xABA0,0xB842,0xC745, +/* A:1c B:16 */ +0x6C8A,0x6C9F,0x6CB9,0x6CD7,0x6CFA,0x6D24,0x6D57,0x6D93, +0x6DDA,0x6E2E,0x6E92,0x6F0A,0x6F97,0x7040,0x7108,0x71F6, +0x7311,0x7461,0x75F1,0x77CB,0x7A00,0x7C9E,0x7FBC,0x836F, +0x87D5,0x8D0F,0x9346,0x9AA8,0xA36F,0xADDD,0xBA42,0xC8FE, +/* A:1c B:17 */ +0x70AD,0x70C1,0x70DA,0x70F7,0x711A,0x7143,0x7175,0x71AF, +0x71F4,0x7247,0x72A9,0x731E,0x73A8,0x744D,0x7511,0x75F9, +0x770E,0x7856,0x79DD,0x7BAD,0x7DD4,0x8064,0x836F,0x870D, +0x8B5A,0x9076,0x9688,0x9DC0,0xA654,0xB085,0xBCA3,0xCB0A, +/* A:1c B:18 */ +0x7597,0x75AB,0x75C3,0x75DF,0x7601,0x7629,0x7659,0x7692, +0x76D5,0x7726,0x7785,0x77F6,0x787D,0x791D,0x79DC,0x7ABE, +0x7BCB,0x7D0A,0x7E86,0x8049,0x8262,0x84DF,0x87D5,0x8B5A, +0x8F88,0x9480,0x9A68,0xA16D,0xA9C4,0xB3AE,0xBF77,0xCD78, +/* A:1c B:19 */ +0x7B6E,0x7B81,0x7B98,0x7BB4,0x7BD4,0x7BFB,0x7C2A,0x7C60, +0x7CA2,0x7CEF,0x7D4B,0x7DB9,0x7E3B,0x7ED6,0x7F8E,0x8069, +0x816C,0x82A1,0x8410,0x85C4,0x87CB,0x8A33,0x8D0F,0x9076, +0x9480,0x994D,0x9F02,0xA5CB,0xADDB,0xB770,0xC2D3,0xD05C, +/* A:1c B:1a */ +0x825E,0x8271,0x8287,0x82A2,0x82C1,0x82E6,0x8313,0x8347, +0x8386,0x83D0,0x8429,0x8492,0x850E,0x85A3,0x8653,0x8725, +0x881E,0x8946,0x8AA6,0x8C48,0x8E39,0x9088,0x9346,0x9688, +0x9A68,0x9F02,0xA47B,0xAAFC,0xB2B6,0xBBE6,0xC6D1,0xD3CB, +/* A:1c B:1b */ +0x8A9E,0x8AB0,0x8AC5,0x8ADE,0x8AFC,0x8B1F,0x8B49,0x8B7B, +0x8BB7,0x8BFD,0x8C51,0x8CB5,0x8D2B,0x8DB8,0x8E5F,0x8F26, +0x9012,0x912B,0x9279,0x9406,0x95DD,0x980E,0x9AA8,0x9DC0, +0xA16D,0xA5CB,0xAAFC,0xB127,0xB87D,0xC134,0xCB90,0xD7DF, +/* A:1c B:1c */ +0x946C,0x947D,0x9490,0x94A8,0x94C4,0x94E5,0x950C,0x953B, +0x9572,0x95B5,0x9603,0x9660,0x96CF,0x9753,0x97EF,0x98AA, +0x9987,0x9A8E,0x9BC6,0x9D39,0x9EF3,0xA0FF,0xA36F,0xA654, +0xA9C4,0xADDB,0xB2B6,0xB87D,0xBF5A,0xC782,0xD134,0xDCB9, +/* A:1c B:1d */ +0xA013,0xA022,0xA035,0xA04A,0xA064,0xA082,0xA0A6,0xA0D1, +0xA104,0xA141,0xA189,0xA1DF,0xA244,0xA2BD,0xA34D,0xA3F8, +0xA4C3,0xA5B5,0xA6D4,0xA829,0xA9BE,0xABA0,0xADDD,0xB085, +0xB3AE,0xB770,0xBBE6,0xC134,0xC782,0xCF00,0xD7E8,0xE27D, +/* A:1c B:1e */ +0xADEC,0xADFA,0xAE0A,0xAE1E,0xAE34,0xAE50,0xAE70,0xAE96, +0xAEC4,0xAEFA,0xAF3B,0xAF87,0xAFE3,0xB04F,0xB0D0,0xB168, +0xB21E,0xB2F6,0xB3F7,0xB528,0xB693,0xB842,0xBA42,0xBCA3, +0xBF77,0xC2D3,0xC6D1,0xCB90,0xD134,0xD7E8,0xDFDF,0xE957, +/* A:1c B:1f */ +0xBE62,0xBE6E,0xBE7C,0xBE8C,0xBEA0,0xBEB7,0xBED3,0xBEF4, +0xBF1C,0xBF4A,0xBF82,0xBFC4,0xC012,0xC06F,0xC0DE,0xC161, +0xC1FE,0xC2B7,0xC394,0xC49B,0xC5D3,0xC745,0xC8FE,0xCB0A, +0xCD78,0xD05C,0xD3CB,0xD7DF,0xDCB9,0xE27D,0xE957,0xF17C, +/* A: 968D89C0 */ +/* A:1d B:00 */ +0x67A6,0x67BC,0x67D6,0x67F4,0x6819,0x6844,0x6878,0x68B6, +0x68FF,0x6955,0x69BD,0x6A37,0x6AC9,0x6B76,0x6C44,0x6D39, +0x6E5B,0x6FB5,0x7150,0x7338,0x757C,0x782D,0x7B61,0x7F2E, +0x83B4,0x8914,0x8F77,0x970E,0xA013,0xAACC,0xB78A,0xC6AF, +/* A:1d B:01 */ +0x67BC,0x67D1,0x67EB,0x680A,0x682F,0x685A,0x688E,0x68CB, +0x6914,0x696B,0x69D2,0x6A4D,0x6ADE,0x6B8B,0x6C59,0x6D4E, +0x6E70,0x6FCA,0x7164,0x734C,0x7590,0x7841,0x7B74,0x7F42, +0x83C6,0x8926,0x8F88,0x971E,0xA022,0xAADA,0xB797,0xC6BA, +/* A:1d B:02 */ +0x67D6,0x67EB,0x6805,0x6824,0x6849,0x6874,0x68A8,0x68E5, +0x692E,0x6985,0x69EC,0x6A66,0x6AF8,0x6BA5,0x6C72,0x6D67, +0x6E89,0x6FE2,0x717D,0x7364,0x75A8,0x7859,0x7B8B,0x7F58, +0x83DD,0x893B,0x8F9C,0x9731,0xA035,0xAAEB,0xB7A6,0xC6C7, +/* A:1d B:03 */ +0x67F4,0x680A,0x6824,0x6843,0x6867,0x6893,0x68C6,0x6904, +0x694D,0x69A3,0x6A0A,0x6A85,0x6B16,0x6BC3,0x6C90,0x6D85, +0x6EA7,0x7000,0x719A,0x7381,0x75C4,0x7875,0x7BA7,0x7F73, +0x83F7,0x8954,0x8FB4,0x9748,0xA04A,0xAAFE,0xB7B7,0xC6D6, +/* A:1d B:04 */ +0x6819,0x682F,0x6849,0x6867,0x688C,0x68B7,0x68EB,0x6928, +0x6971,0x69C7,0x6A2E,0x6AA9,0x6B3A,0x6BE7,0x6CB4,0x6DA8, +0x6ECA,0x7023,0x71BD,0x73A4,0x75E6,0x7896,0x7BC8,0x7F93, +0x8416,0x8972,0x8FD1,0x9764,0xA064,0xAB16,0xB7CC,0xC6E8, +/* A:1d B:05 */ +0x6844,0x685A,0x6874,0x6893,0x68B7,0x68E3,0x6916,0x6953, +0x699C,0x69F3,0x6A59,0x6AD4,0x6B65,0x6C11,0x6CDF,0x6DD2, +0x6EF4,0x704D,0x71E6,0x73CC,0x760F,0x78BE,0x7BEF,0x7FB9, +0x843B,0x8996,0x8FF3,0x9784,0xA082,0xAB32,0xB7E5,0xC6FD, +/* A:1d B:06 */ +0x6878,0x688E,0x68A8,0x68C6,0x68EB,0x6916,0x694A,0x6987, +0x69CF,0x6A26,0x6A8D,0x6B07,0x6B98,0x6C44,0x6D11,0x6E05, +0x6F26,0x707E,0x7217,0x73FD,0x763F,0x78ED,0x7C1D,0x7FE6, +0x8467,0x89C0,0x901C,0x97AB,0xA0A6,0xAB53,0xB803,0xC717, +/* A:1d B:07 */ +0x68B6,0x68CB,0x68E5,0x6904,0x6928,0x6953,0x6987,0x69C4, +0x6A0C,0x6A63,0x6AC9,0x6B43,0x6BD4,0x6C80,0x6D4D,0x6E40, +0x6F61,0x70B9,0x7251,0x7437,0x7677,0x7925,0x7C54,0x801C, +0x849B,0x89F3,0x904D,0x97D9,0xA0D1,0xAB7A,0xB826,0xC735, +/* A:1d B:08 */ +0x68FF,0x6914,0x692E,0x694D,0x6971,0x699C,0x69CF,0x6A0C, +0x6A55,0x6AAB,0x6B12,0x6B8B,0x6C1C,0x6CC8,0x6D94,0x6E87, +0x6FA8,0x70FF,0x7297,0x747B,0x76BB,0x7968,0x7C95,0x805C, +0x84D9,0x8A2F,0x9086,0x980F,0xA104,0xABA9,0xB850,0xC759, +/* A:1d B:09 */ +0x6955,0x696B,0x6985,0x69A3,0x69C7,0x69F3,0x6A26,0x6A63, +0x6AAB,0x6B01,0x6B67,0x6BE1,0x6C71,0x6D1D,0x6DE9,0x6EDB, +0x6FFB,0x7152,0x72E9,0x74CD,0x770B,0x79B7,0x7CE3,0x80A8, +0x8523,0x8A76,0x90CA,0x9850,0xA141,0xABE1,0xB882,0xC784, +/* A:1d B:0a */ +0x69BD,0x69D2,0x69EC,0x6A0A,0x6A2E,0x6A59,0x6A8D,0x6AC9, +0x6B12,0x6B67,0x6BCD,0x6C47,0x6CD7,0x6D82,0x6E4D,0x6F3F, +0x705F,0x71B5,0x734B,0x752D,0x776B,0x7A15,0x7D3F,0x8102, +0x857B,0x8ACB,0x911C,0x989D,0xA189,0xAC23,0xB8BD,0xC7B7, +/* A:1d B:0b */ +0x6A37,0x6A4D,0x6A66,0x6A85,0x6AA9,0x6AD4,0x6B07,0x6B43, +0x6B8B,0x6BE1,0x6C47,0x6CC0,0x6D4F,0x6DFA,0x6EC5,0x6FB6, +0x70D5,0x722A,0x73BF,0x75A0,0x77DD,0x7A85,0x7DAD,0x816D, +0x85E3,0x8B30,0x917C,0x98F9,0xA1DF,0xAC72,0xB903,0xC7F3, +/* A:1d B:0c */ +0x6AC9,0x6ADE,0x6AF8,0x6B16,0x6B3A,0x6B65,0x6B98,0x6BD4, +0x6C1C,0x6C71,0x6CD7,0x6D4F,0x6DDF,0x6E89,0x6F53,0x7044, +0x7162,0x72B5,0x7449,0x7629,0x7863,0x7B09,0x7E2F,0x81ED, +0x865F,0x8BA7,0x91EF,0x9966,0xA244,0xACCF,0xB957,0xC83B, +/* A:1d B:0d */ +0x6B76,0x6B8B,0x6BA5,0x6BC3,0x6BE7,0x6C11,0x6C44,0x6C80, +0x6CC8,0x6D1D,0x6D82,0x6DFA,0x6E89,0x6F32,0x6FFC,0x70EC, +0x7209,0x735B,0x74ED,0x76CC,0x7904,0x7BA7,0x7ECA,0x8284, +0x86F2,0x8C36,0x9277,0x99E7,0xA2BD,0xAD3E,0xB9BA,0xC890, +/* A:1d B:0e */ +0x6C44,0x6C59,0x6C72,0x6C90,0x6CB4,0x6CDF,0x6D11,0x6D4D, +0x6D94,0x6DE9,0x6E4D,0x6EC5,0x6F53,0x6FFC,0x70C5,0x71B3, +0x72CF,0x7420,0x75B1,0x778D,0x79C3,0x7C63,0x7F82,0x8338, +0x87A1,0x8CDF,0x9319,0x9A81,0xA34D,0xADC2,0xBA30,0xC8F6, +/* A:1d B:0f */ +0x6D39,0x6D4E,0x6D67,0x6D85,0x6DA8,0x6DD2,0x6E05,0x6E40, +0x6E87,0x6EDB,0x6F3F,0x6FB6,0x7044,0x70EC,0x71B3,0x72A1, +0x73BB,0x750A,0x7699,0x7872,0x7AA5,0x7D42,0x805D,0x840E, +0x8871,0x8DA8,0x93DA,0x9B37,0xA3F8,0xAE5F,0xBABC,0xC96E, +/* A:1d B:10 */ +0x6E5B,0x6E70,0x6E89,0x6EA7,0x6ECA,0x6EF4,0x6F26,0x6F61, +0x6FA8,0x6FFB,0x705F,0x70D5,0x7162,0x7209,0x72CF,0x73BB, +0x74D3,0x7620,0x77AC,0x7983,0x7BB2,0x7E4B,0x8161,0x850C, +0x8968,0x8E97,0x94BF,0x9C11,0xA4C3,0xAF1A,0xBB63,0xC9FE, +/* A:1d B:11 */ +0x6FB5,0x6FCA,0x6FE2,0x7000,0x7023,0x704D,0x707E,0x70B9, +0x70FF,0x7152,0x71B5,0x722A,0x72B5,0x735B,0x7420,0x750A, +0x7620,0x776B,0x78F4,0x7AC7,0x7CF2,0x7F86,0x8296,0x863A, +0x8A8E,0x8FB3,0x95CF,0x9D13,0xA5B5,0xAFF8,0xBC29,0xCAA8, +/* A:1d B:12 */ +0x7150,0x7164,0x717D,0x719A,0x71BD,0x71E6,0x7217,0x7251, +0x7297,0x72E9,0x734B,0x73BF,0x7449,0x74ED,0x75B1,0x7699, +0x77AC,0x78F4,0x7A7A,0x7C49,0x7E6F,0x80FD,0x8406,0x87A1, +0x8BEB,0x9104,0x9713,0x9E46,0xA6D4,0xB0FF,0xBD15,0xCB72, +/* A:1d B:13 */ +0x7338,0x734C,0x7364,0x7381,0x73A4,0x73CC,0x73FD,0x7437, +0x747B,0x74CD,0x752D,0x75A0,0x7629,0x76CC,0x778D,0x7872, +0x7983,0x7AC7,0x7C49,0x7E13,0x8033,0x82BA,0x85BB,0x894C, +0x8D8A,0x9295,0x9893,0x9FB2,0xA829,0xB238,0xBE2D,0xCC63, +/* A:1d B:14 */ +0x757C,0x7590,0x75A8,0x75C4,0x75E6,0x760F,0x763F,0x7677, +0x76BB,0x770B,0x776B,0x77DD,0x7863,0x7904,0x79C3,0x7AA5, +0x7BB2,0x7CF2,0x7E6F,0x8033,0x824C,0x84CB,0x87C2,0x8B47, +0x8F77,0x9472,0x9A5C,0xA163,0xA9BE,0xB3AC,0xBF7A,0xCD80, +/* A:1d B:15 */ +0x782D,0x7841,0x7859,0x7875,0x7896,0x78BE,0x78ED,0x7925, +0x7968,0x79B7,0x7A15,0x7A85,0x7B09,0x7BA7,0x7C63,0x7D42, +0x7E4B,0x7F86,0x80FD,0x82BA,0x84CB,0x873F,0x8A2A,0x8DA2, +0x91C2,0x96A8,0x9C7B,0xA366,0xABA0,0xB567,0xC105,0xCED4, +/* A:1d B:16 */ +0x7B61,0x7B74,0x7B8B,0x7BA7,0x7BC8,0x7BEF,0x7C1D,0x7C54, +0x7C95,0x7CE3,0x7D3F,0x7DAD,0x7E2F,0x7ECA,0x7F82,0x805D, +0x8161,0x8296,0x8406,0x85BB,0x87C2,0x8A2A,0x8D08,0x906F, +0x947A,0x9949,0x9F00,0xA5CB,0xADDD,0xB775,0xC2DB,0xD068, +/* A:1d B:17 */ +0x7F2E,0x7F42,0x7F58,0x7F73,0x7F93,0x7FB9,0x7FE6,0x801C, +0x805C,0x80A8,0x8102,0x816D,0x81ED,0x8284,0x8338,0x840E, +0x850C,0x863A,0x87A1,0x894C,0x8B47,0x8DA2,0x906F,0x93C2, +0x97B6,0x9C69,0xA1FF,0xA8A2,0xB085,0xB9E5,0xC50A,0xD248, +/* A:1d B:18 */ +0x83B4,0x83C6,0x83DD,0x83F7,0x8416,0x843B,0x8467,0x849B, +0x84D9,0x8523,0x857B,0x85E3,0x865F,0x86F2,0x87A1,0x8871, +0x8968,0x8A8E,0x8BEB,0x8D8A,0x8F77,0x91C2,0x947A,0x97B6, +0x9B8F,0xA020,0xA58E,0xAC03,0xB3AE,0xBCCC,0xC7A2,0xD482, +/* A:1d B:19 */ +0x8914,0x8926,0x893B,0x8954,0x8972,0x8996,0x89C0,0x89F3, +0x8A2F,0x8A76,0x8ACB,0x8B30,0x8BA7,0x8C36,0x8CDF,0x8DA8, +0x8E97,0x8FB3,0x9104,0x9295,0x9472,0x96A8,0x9949,0x9C69, +0xA020,0xA48A,0xA9CA,0xB006,0xB770,0xC03F,0xCAB7,0xD728, +/* A:1d B:1a */ +0x8F77,0x8F88,0x8F9C,0x8FB4,0x8FD1,0x8FF3,0x901C,0x904D, +0x9086,0x90CA,0x911C,0x917C,0x91EF,0x9277,0x9319,0x93DA, +0x94BF,0x95CF,0x9713,0x9893,0x9A5C,0x9C7B,0x9F00,0xA1FF, +0xA58E,0xA9CA,0xAED1,0xB4CB,0xBBE6,0xC458,0xCE60,0xDA4E, +/* A:1d B:1b */ +0x970E,0x971E,0x9731,0x9748,0x9764,0x9784,0x97AB,0x97D9, +0x980F,0x9850,0x989D,0x98F9,0x9966,0x99E7,0x9A81,0x9B37, +0x9C11,0x9D13,0x9E46,0x9FB2,0xA163,0xA366,0xA5CB,0xA8A2, +0xAC03,0xB006,0xB4CB,0xBA77,0xC134,0xC936,0xD2BB,0xDE0B, +/* A:1d B:1c */ +0xA013,0xA022,0xA035,0xA04A,0xA064,0xA082,0xA0A6,0xA0D1, +0xA104,0xA141,0xA189,0xA1DF,0xA244,0xA2BD,0xA34D,0xA3F8, +0xA4C3,0xA5B5,0xA6D4,0xA829,0xA9BE,0xABA0,0xADDD,0xB085, +0xB3AE,0xB770,0xBBE6,0xC134,0xC782,0xCF00,0xD7E8,0xE27D, +/* A:1d B:1d */ +0xAACC,0xAADA,0xAAEB,0xAAFE,0xAB16,0xAB32,0xAB53,0xAB7A, +0xABA9,0xABE1,0xAC23,0xAC72,0xACCF,0xAD3E,0xADC2,0xAE5F, +0xAF1A,0xAFF8,0xB0FF,0xB238,0xB3AC,0xB567,0xB775,0xB9E5, +0xBCCC,0xC03F,0xC458,0xC936,0xCF00,0xD5E1,0xDE0E,0xE7C6, +/* A:1d B:1e */ +0xB78A,0xB797,0xB7A6,0xB7B7,0xB7CC,0xB7E5,0xB803,0xB826, +0xB850,0xB882,0xB8BD,0xB903,0xB957,0xB9BA,0xBA30,0xBABC, +0xBB63,0xBC29,0xBD15,0xBE2D,0xBF7A,0xC105,0xC2DB,0xC50A, +0xC7A2,0xCAB7,0xCE60,0xD2BB,0xD7E8,0xDE0E,0xE55D,0xEE0D, +/* A:1d B:1f */ +0xC6AF,0xC6BA,0xC6C7,0xC6D6,0xC6E8,0xC6FD,0xC717,0xC735, +0xC759,0xC784,0xC7B7,0xC7F3,0xC83B,0xC890,0xC8F6,0xC96E, +0xC9FE,0xCAA8,0xCB72,0xCC63,0xCD80,0xCED4,0xD068,0xD248, +0xD482,0xD728,0xDA4E,0xDE0B,0xE27D,0xE7C6,0xEE0D,0xF583, +/* A: 968D89C0 */ +/* A:1e B:00 */ +0x7B51,0x7B65,0x7B7C,0x7B98,0x7BB8,0x7BE0,0x7C0E,0x7C45, +0x7C86,0x7CD4,0x7D31,0x7D9F,0x7E21,0x7EBD,0x7F75,0x8051, +0x8156,0x828B,0x83FC,0x85B2,0x87BA,0x8A24,0x8D03,0x906C, +0x947B,0x994C,0x9F07,0xA5D5,0xADEC,0xB78A,0xC2F8,0xD08D, +/* A:1e B:01 */ +0x7B65,0x7B78,0x7B90,0x7BAB,0x7BCC,0x7BF3,0x7C21,0x7C58, +0x7C9A,0x7CE8,0x7D44,0x7DB2,0x7E35,0x7ED0,0x7F88,0x8064, +0x8168,0x829E,0x840E,0x85C4,0x87CC,0x8A36,0x8D15,0x907E, +0x948B,0x995C,0x9F16,0xA5E4,0xADFA,0xB797,0xC303,0xD097, +/* A:1e B:02 */ +0x7B7C,0x7B90,0x7BA7,0x7BC2,0x7BE3,0x7C0A,0x7C38,0x7C70, +0x7CB1,0x7CFF,0x7D5B,0x7DC9,0x7E4C,0x7EE7,0x7F9F,0x807A, +0x817F,0x82B4,0x8424,0x85DA,0x87E1,0x8A4B,0x8D29,0x9092, +0x949F,0x996F,0x9F28,0xA5F5,0xAE0A,0xB7A6,0xC310,0xD0A2, +/* A:1e B:03 */ +0x7B98,0x7BAB,0x7BC2,0x7BDE,0x7BFF,0x7C26,0x7C54,0x7C8B, +0x7CCC,0x7D1A,0x7D76,0x7DE4,0x7E67,0x7F02,0x7FBA,0x8095, +0x8199,0x82CF,0x843F,0x85F4,0x87FB,0x8A64,0x8D42,0x90AA, +0x94B6,0x9986,0x9F3E,0xA60A,0xAE1E,0xB7B7,0xC320,0xD0AF, +/* A:1e B:04 */ +0x7BB8,0x7BCC,0x7BE3,0x7BFF,0x7C1F,0x7C46,0x7C75,0x7CAC, +0x7CED,0x7D3B,0x7D97,0x7E05,0x7E87,0x7F22,0x7FDA,0x80B5, +0x81B9,0x82EE,0x845E,0x8612,0x8819,0x8A82,0x8D5F,0x90C7, +0x94D2,0x99A1,0x9F58,0xA622,0xAE34,0xB7CC,0xC333,0xD0C0, +/* A:1e B:05 */ +0x7BE0,0x7BF3,0x7C0A,0x7C26,0x7C46,0x7C6D,0x7C9C,0x7CD2, +0x7D14,0x7D61,0x7DBE,0x7E2B,0x7EAD,0x7F48,0x8000,0x80DB, +0x81DF,0x8314,0x8483,0x8637,0x883D,0x8AA6,0x8D82,0x90E9, +0x94F3,0x99C1,0x9F76,0xA63F,0xAE50,0xB7E5,0xC349,0xD0D3, +/* A:1e B:06 */ +0x7C0E,0x7C21,0x7C38,0x7C54,0x7C75,0x7C9C,0x7CCA,0x7D01, +0x7D42,0x7D8F,0x7DEB,0x7E59,0x7EDB,0x7F76,0x802D,0x8108, +0x820B,0x8340,0x84AF,0x8662,0x8868,0x8AD0,0x8DAC,0x9111, +0x951B,0x99E7,0x9F9B,0xA662,0xAE70,0xB803,0xC364,0xD0E9, +/* A:1e B:07 */ +0x7C45,0x7C58,0x7C70,0x7C8B,0x7CAC,0x7CD2,0x7D01,0x7D37, +0x7D78,0x7DC6,0x7E22,0x7E8F,0x7F11,0x7FAC,0x8063,0x813D, +0x8241,0x8375,0x84E3,0x8696,0x889B,0x8B02,0x8DDD,0x9141, +0x954A,0x9A14,0x9FC6,0xA68B,0xAE96,0xB826,0xC383,0xD104, +/* A:1e B:08 */ +0x7C86,0x7C9A,0x7CB1,0x7CCC,0x7CED,0x7D14,0x7D42,0x7D78, +0x7DB9,0x7E07,0x7E63,0x7ED0,0x7F52,0x7FEC,0x80A3,0x817D, +0x8280,0x83B3,0x8521,0x86D4,0x88D8,0x8B3E,0x8E18,0x917B, +0x9581,0x9A4A,0x9FFA,0xA6BC,0xAEC4,0xB850,0xC3A8,0xD124, +/* A:1e B:09 */ +0x7CD4,0x7CE8,0x7CFF,0x7D1A,0x7D3B,0x7D61,0x7D8F,0x7DC6, +0x7E07,0x7E54,0x7EB0,0x7F1D,0x7F9E,0x8038,0x80EF,0x81C8, +0x82CB,0x83FE,0x856B,0x871D,0x8920,0x8B85,0x8E5D,0x91BF, +0x95C3,0x9A8A,0xA037,0xA6F6,0xAEFA,0xB882,0xC3D5,0xD14B, +/* A:1e B:0a */ +0x7D31,0x7D44,0x7D5B,0x7D76,0x7D97,0x7DBE,0x7DEB,0x7E22, +0x7E63,0x7EB0,0x7F0B,0x7F78,0x7FF9,0x8093,0x8149,0x8222, +0x8324,0x8456,0x85C2,0x8773,0x8976,0x8BD9,0x8EB0,0x920F, +0x9612,0x9AD6,0xA080,0xA73B,0xAF3B,0xB8BD,0xC40A,0xD178, +/* A:1e B:0b */ +0x7D9F,0x7DB2,0x7DC9,0x7DE4,0x7E05,0x7E2B,0x7E59,0x7E8F, +0x7ED0,0x7F1D,0x7F78,0x7FE4,0x8065,0x80FE,0x81B4,0x828D, +0x838E,0x84C0,0x862B,0x87DA,0x89DC,0x8C3D,0x8F12,0x9270, +0x966F,0x9B30,0xA0D6,0xA78D,0xAF87,0xB903,0xC449,0xD1AE, +/* A:1e B:0c */ +0x7E21,0x7E35,0x7E4C,0x7E67,0x7E87,0x7EAD,0x7EDB,0x7F11, +0x7F52,0x7F9E,0x7FF9,0x8065,0x80E6,0x817E,0x8234,0x830B, +0x840C,0x853D,0x86A7,0x8855,0x8A55,0x8CB4,0x8F87,0x92E2, +0x96DE,0x9B9B,0xA13D,0xA7EE,0xAFE3,0xB957,0xC493,0xD1EE, +/* A:1e B:0d */ +0x7EBD,0x7ED0,0x7EE7,0x7F02,0x7F22,0x7F48,0x7F76,0x7FAC, +0x7FEC,0x8038,0x8093,0x80FE,0x817E,0x8216,0x82CB,0x83A2, +0x84A2,0x85D1,0x873A,0x88E7,0x8AE4,0x8D42,0x9012,0x9369, +0x9762,0x9C1B,0xA1B7,0xA862,0xB04F,0xB9BA,0xC4EC,0xD23A, +/* A:1e B:0e */ +0x7F75,0x7F88,0x7F9F,0x7FBA,0x7FDA,0x8000,0x802D,0x8063, +0x80A3,0x80EF,0x8149,0x81B4,0x8234,0x82CB,0x837F,0x8455, +0x8554,0x8682,0x87E9,0x8994,0x8B8F,0x8DEA,0x90B7,0x940B, +0x97FF,0x9CB2,0xA248,0xA8EC,0xB0D0,0xBA30,0xC555,0xD294, +/* A:1e B:0f */ +0x8051,0x8064,0x807A,0x8095,0x80B5,0x80DB,0x8108,0x813D, +0x817D,0x81C8,0x8222,0x828D,0x830B,0x83A2,0x8455,0x852A, +0x8627,0x8754,0x88B9,0x8A62,0x8C5A,0x8EB2,0x917B,0x94CA, +0x98B9,0x9D66,0xA2F5,0xA98F,0xB168,0xBABC,0xC5D3,0xD300, +/* A:1e B:10 */ +0x8156,0x8168,0x817F,0x8199,0x81B9,0x81DF,0x820B,0x8241, +0x8280,0x82CB,0x8324,0x838E,0x840C,0x84A2,0x8554,0x8627, +0x8722,0x884D,0x89B0,0x8B56,0x8D4C,0x8FA0,0x9264,0x95AE, +0x9997,0x9E3C,0xA3C2,0xAA52,0xB21E,0xBB63,0xC668,0xD37F, +/* A:1e B:11 */ +0x828B,0x829E,0x82B4,0x82CF,0x82EE,0x8314,0x8340,0x8375, +0x83B3,0x83FE,0x8456,0x84C0,0x853D,0x85D1,0x8682,0x8754, +0x884D,0x8976,0x8AD6,0x8C79,0x8E6B,0x90BA,0x9379,0x96BD, +0x9A9E,0x9F3A,0xA4B5,0xAB39,0xB2F6,0xBC29,0xC719,0xD417, +/* A:1e B:12 */ +0x83FC,0x840E,0x8424,0x843F,0x845E,0x8483,0x84AF,0x84E3, +0x8521,0x856B,0x85C2,0x862B,0x86A7,0x873A,0x87E9,0x88B9, +0x89B0,0x8AD6,0x8C33,0x8DD2,0x8FC0,0x920A,0x94C3,0x97FF, +0x9BD7,0xA069,0xA5D7,0xAC4B,0xB3F7,0xBD15,0xC7EB,0xD4CC, +/* A:1e B:13 */ +0x85B2,0x85C4,0x85DA,0x85F4,0x8612,0x8637,0x8662,0x8696, +0x86D4,0x871D,0x8773,0x87DA,0x8855,0x88E7,0x8994,0x8A62, +0x8B56,0x8C79,0x8DD2,0x8F6D,0x9155,0x9399,0x964A,0x997D, +0x9D4B,0xA1D0,0xA72F,0xAD92,0xB528,0xBE2D,0xC8E5,0xD5A2, +/* A:1e B:14 */ +0x87BA,0x87CC,0x87E1,0x87FB,0x8819,0x883D,0x8868,0x889B, +0x88D8,0x8920,0x8976,0x89DC,0x8A55,0x8AE4,0x8B8F,0x8C5A, +0x8D4C,0x8E6B,0x8FC0,0x9155,0x9336,0x9573,0x981B,0x9B44, +0x9F05,0xA37B,0xA8C8,0xAF15,0xB693,0xBF7A,0xCA0E,0xD6A1, +/* A:1e B:15 */ +0x8A24,0x8A36,0x8A4B,0x8A64,0x8A82,0x8AA6,0x8AD0,0x8B02, +0x8B3E,0x8B85,0x8BD9,0x8C3D,0x8CB4,0x8D42,0x8DEA,0x8EB2, +0x8FA0,0x90BA,0x920A,0x9399,0x9573,0x97A6,0x9A44,0x9D60, +0xA112,0xA576,0xAAAE,0xB0E2,0xB842,0xC105,0xCB6F,0xD7D0, +/* A:1e B:16 */ +0x8D03,0x8D15,0x8D29,0x8D42,0x8D5F,0x8D82,0x8DAC,0x8DDD, +0x8E18,0x8E5D,0x8EB0,0x8F12,0x8F87,0x9012,0x90B7,0x917B, +0x9264,0x9379,0x94C3,0x964A,0x981B,0x9A44,0x9CD5,0x9FE2, +0xA382,0xA7D1,0xACF0,0xB306,0xBA42,0xC2DB,0xCD13,0xD938, +/* A:1e B:17 */ +0x906C,0x907E,0x9092,0x90AA,0x90C7,0x90E9,0x9111,0x9141, +0x917B,0x91BF,0x920F,0x9270,0x92E2,0x9369,0x940B,0x94CA, +0x95AE,0x96BD,0x97FF,0x997D,0x9B44,0x9D60,0x9FE2,0xA2DD, +0xA668,0xAA9E,0xAF9F,0xB592,0xBCA3,0xC50A,0xCF06,0xDAE4, +/* A:1e B:18 */ +0x947B,0x948B,0x949F,0x94B6,0x94D2,0x94F3,0x951B,0x954A, +0x9581,0x95C3,0x9612,0x966F,0x96DE,0x9762,0x97FF,0x98B9, +0x9997,0x9A9E,0x9BD7,0x9D4B,0x9F05,0xA112,0xA382,0xA668, +0xA9DA,0xADF2,0xB2CF,0xB897,0xBF77,0xC7A2,0xD157,0xDCE0, +/* A:1e B:19 */ +0x994C,0x995C,0x996F,0x9986,0x99A1,0x99C1,0x99E7,0x9A14, +0x9A4A,0x9A8A,0x9AD6,0x9B30,0x9B9B,0x9C1B,0x9CB2,0x9D66, +0x9E3C,0x9F3A,0xA069,0xA1D0,0xA37B,0xA576,0xA7D1,0xAA9E, +0xADF2,0xB1E6,0xB699,0xBC2F,0xC2D3,0xCAB7,0xD417,0xDF3D, +/* A:1e B:1a */ +0x9F07,0x9F16,0x9F28,0x9F3E,0x9F58,0x9F76,0x9F9B,0x9FC6, +0x9FFA,0xA037,0xA080,0xA0D6,0xA13D,0xA1B7,0xA248,0xA2F5, +0xA3C2,0xA4B5,0xA5D7,0xA72F,0xA8C8,0xAAAE,0xACF0,0xAF9F, +0xB2CF,0xB699,0xBB1A,0xC074,0xC6D1,0xCE60,0xD75D,0xE20B, +/* A:1e B:1b */ +0xA5D5,0xA5E4,0xA5F5,0xA60A,0xA622,0xA63F,0xA662,0xA68B, +0xA6BC,0xA6F6,0xA73B,0xA78D,0xA7EE,0xA862,0xA8EC,0xA98F, +0xAA52,0xAB39,0xAC4B,0xAD92,0xAF15,0xB0E2,0xB306,0xB592, +0xB897,0xBC2F,0xC074,0xC588,0xCB90,0xD2BB,0xDB40,0xE561, +/* A:1e B:1c */ +0xADEC,0xADFA,0xAE0A,0xAE1E,0xAE34,0xAE50,0xAE70,0xAE96, +0xAEC4,0xAEFA,0xAF3B,0xAF87,0xAFE3,0xB04F,0xB0D0,0xB168, +0xB21E,0xB2F6,0xB3F7,0xB528,0xB693,0xB842,0xBA42,0xBCA3, +0xBF77,0xC2D3,0xC6D1,0xCB90,0xD134,0xD7E8,0xDFDF,0xE957, +/* A:1e B:1d */ +0xB78A,0xB797,0xB7A6,0xB7B7,0xB7CC,0xB7E5,0xB803,0xB826, +0xB850,0xB882,0xB8BD,0xB903,0xB957,0xB9BA,0xBA30,0xBABC, +0xBB63,0xBC29,0xBD15,0xBE2D,0xBF7A,0xC105,0xC2DB,0xC50A, +0xC7A2,0xCAB7,0xCE60,0xD2BB,0xD7E8,0xDE0E,0xE55D,0xEE0D, +/* A:1e B:1e */ +0xC2F8,0xC303,0xC310,0xC320,0xC333,0xC349,0xC364,0xC383, +0xC3A8,0xC3D5,0xC40A,0xC449,0xC493,0xC4EC,0xC555,0xC5D3, +0xC668,0xC719,0xC7EB,0xC8E5,0xCA0E,0xCB6F,0xCD13,0xCF06, +0xD157,0xD417,0xD75D,0xDB40,0xDFDF,0xE55D,0xEBE4,0xF3A6, +/* A:1e B:1f */ +0xD08D,0xD097,0xD0A2,0xD0AF,0xD0C0,0xD0D3,0xD0E9,0xD104, +0xD124,0xD14B,0xD178,0xD1AE,0xD1EE,0xD23A,0xD294,0xD300, +0xD37F,0xD417,0xD4CC,0xD5A2,0xD6A1,0xD7D0,0xD938,0xDAE4, +0xDCE0,0xDF3D,0xE20B,0xE561,0xE957,0xEE0D,0xF3A6,0xFA4D, +/* A: 968D89C0 */ +/* A:1f B:00 */ +0x92B2,0x92C3,0x92D7,0x92EF,0x930B,0x932D,0x9355,0x9384, +0x93BD,0x9400,0x9450,0x94AF,0x9520,0x95A6,0x9645,0x9703, +0x97E4,0x98EF,0x9A2D,0x9BA7,0x9D68,0x9F7E,0xA1F8,0xA4EA, +0xA86B,0xAC94,0xB186,0xB766,0xBE62,0xC6AF,0xD08D,0xDC47, +/* A:1f B:01 */ +0x92C3,0x92D4,0x92E8,0x9300,0x931C,0x933E,0x9366,0x9395, +0x93CE,0x9411,0x9461,0x94BF,0x9530,0x95B6,0x9656,0x9713, +0x97F4,0x98FF,0x9A3D,0x9BB7,0x9D78,0x9F8D,0xA207,0xA4F9, +0xA879,0xACA2,0xB193,0xB773,0xBE6E,0xC6BA,0xD097,0xDC4F, +/* A:1f B:02 */ +0x92D7,0x92E8,0x92FC,0x9314,0x9330,0x9352,0x937A,0x93A9, +0x93E2,0x9425,0x9474,0x94D3,0x9544,0x95CA,0x9669,0x9726, +0x9807,0x9912,0x9A50,0x9BCA,0x9D8A,0x9FA0,0xA219,0xA50B, +0xA88A,0xACB2,0xB1A3,0xB782,0xBE7C,0xC6C7,0xD0A2,0xDC59, +/* A:1f B:03 */ +0x92EF,0x9300,0x9314,0x932B,0x9348,0x9369,0x9391,0x93C1, +0x93F9,0x943C,0x948C,0x94EB,0x955B,0x95E1,0x9680,0x973D, +0x981E,0x9929,0x9A67,0x9BE0,0x9DA0,0x9FB5,0xA22F,0xA51F, +0xA89E,0xACC5,0xB1B5,0xB793,0xBE8C,0xC6D6,0xD0AF,0xDC64, +/* A:1f B:04 */ +0x930B,0x931C,0x9330,0x9348,0x9364,0x9386,0x93AD,0x93DD, +0x9415,0x9458,0x94A8,0x9507,0x9577,0x95FD,0x969C,0x9759, +0x983A,0x9944,0x9A82,0x9BFB,0x9DBB,0x9FCF,0xA248,0xA538, +0xA8B6,0xACDD,0xB1CB,0xB7A8,0xBEA0,0xC6E8,0xD0C0,0xDC72, +/* A:1f B:05 */ +0x932D,0x933E,0x9352,0x9369,0x9386,0x93A7,0x93CF,0x93FE, +0x9437,0x947A,0x94C9,0x9528,0x9598,0x961E,0x96BD,0x977A, +0x985A,0x9965,0x9AA2,0x9C1A,0x9DDA,0x9FEE,0xA266,0xA556, +0xA8D3,0xACF8,0xB1E6,0xB7C1,0xBEB7,0xC6FD,0xD0D3,0xDC82, +/* A:1f B:06 */ +0x9355,0x9366,0x937A,0x9391,0x93AD,0x93CF,0x93F7,0x9426, +0x945E,0x94A1,0x94F1,0x954F,0x95C0,0x9645,0x96E4,0x97A0, +0x9881,0x998B,0x9AC7,0x9C40,0x9DFF,0xA012,0xA28A,0xA579, +0xA8F5,0xAD19,0xB205,0xB7DF,0xBED3,0xC717,0xD0E9,0xDC96, +/* A:1f B:07 */ +0x9384,0x9395,0x93A9,0x93C1,0x93DD,0x93FE,0x9426,0x9456, +0x948E,0x94D1,0x9520,0x957E,0x95EE,0x9674,0x9712,0x97CF, +0x98AE,0x99B8,0x9AF5,0x9C6C,0x9E2B,0xA03E,0xA2B4,0xA5A2, +0xA91D,0xAD40,0xB22B,0xB802,0xBEF4,0xC735,0xD104,0xDCAD, +/* A:1f B:08 */ +0x93BD,0x93CE,0x93E2,0x93F9,0x9415,0x9437,0x945E,0x948E, +0x94C6,0x9509,0x9558,0x95B6,0x9626,0x96AB,0x9749,0x9805, +0x98E5,0x99EE,0x9B2A,0x9CA1,0x9E5F,0xA071,0xA2E7,0xA5D3, +0xA94D,0xAD6E,0xB257,0xB82C,0xBF1C,0xC759,0xD124,0xDCC8, +/* A:1f B:09 */ +0x9400,0x9411,0x9425,0x943C,0x9458,0x947A,0x94A1,0x94D1, +0x9509,0x954B,0x959A,0x95F8,0x9668,0x96ED,0x978B,0x9847, +0x9926,0x9A2F,0x9B6A,0x9CE0,0x9E9D,0xA0AE,0xA323,0xA60E, +0xA986,0xADA5,0xB28C,0xB85E,0xBF4A,0xC784,0xD14B,0xDCE9, +/* A:1f B:0a */ +0x9450,0x9461,0x9474,0x948C,0x94A8,0x94C9,0x94F1,0x9520, +0x9558,0x959A,0x95E9,0x9647,0x96B7,0x973B,0x97D9,0x9894, +0x9973,0x9A7B,0x9BB5,0x9D2B,0x9EE7,0xA0F7,0xA36A,0xA654, +0xA9CA,0xADE7,0xB2CA,0xB89A,0xBF82,0xC7B7,0xD178,0xDD10, +/* A:1f B:0b */ +0x94AF,0x94BF,0x94D3,0x94EB,0x9507,0x9528,0x954F,0x957E, +0x95B6,0x95F8,0x9647,0x96A5,0x9714,0x9798,0x9835,0x98F0, +0x99CE,0x9AD6,0x9C0F,0x9D84,0x9F3F,0xA14D,0xA3BF,0xA6A7, +0xAA1A,0xAE35,0xB315,0xB8E0,0xBFC4,0xC7F3,0xD1AE,0xDD3E, +/* A:1f B:0c */ +0x9520,0x9530,0x9544,0x955B,0x9577,0x9598,0x95C0,0x95EE, +0x9626,0x9668,0x96B7,0x9714,0x9783,0x9807,0x98A3,0x995E, +0x9A3B,0x9B42,0x9C7A,0x9DEE,0x9FA7,0xA1B4,0xA424,0xA709, +0xAA7A,0xAE91,0xB36D,0xB934,0xC012,0xC83B,0xD1EE,0xDD75, +/* A:1f B:0d */ +0x95A6,0x95B6,0x95CA,0x95E1,0x95FD,0x961E,0x9645,0x9674, +0x96AB,0x96ED,0x973B,0x9798,0x9807,0x988A,0x9926,0x99E0, +0x9ABC,0x9BC2,0x9CF9,0x9E6C,0xA023,0xA22E,0xA49C,0xA77E, +0xAAEC,0xAEFF,0xB3D6,0xB998,0xC06F,0xC890,0xD23A,0xDDB6, +/* A:1f B:0e */ +0x9645,0x9656,0x9669,0x9680,0x969C,0x96BD,0x96E4,0x9712, +0x9749,0x978B,0x97D9,0x9835,0x98A3,0x9926,0x99C1,0x9A7A, +0x9B56,0x9C5A,0x9D90,0x9F01,0xA0B7,0xA2BF,0xA52A,0xA809, +0xAB73,0xAF81,0xB453,0xBA0E,0xC0DE,0xC8F6,0xD294,0xDE03, +/* A:1f B:0f */ +0x9703,0x9713,0x9726,0x973D,0x9759,0x977A,0x97A0,0x97CF, +0x9805,0x9847,0x9894,0x98F0,0x995E,0x99E0,0x9A7A,0x9B32, +0x9C0C,0x9D10,0x9E44,0x9FB2,0xA166,0xA36C,0xA5D3,0xA8AE, +0xAC13,0xB01C,0xB4E8,0xBA9B,0xC161,0xC96E,0xD300,0xDE5F, +/* A:1f B:10 */ +0x97E4,0x97F4,0x9807,0x981E,0x983A,0x985A,0x9881,0x98AE, +0x98E5,0x9926,0x9973,0x99CE,0x9A3B,0x9ABC,0x9B56,0x9C0C, +0x9CE5,0x9DE7,0x9F19,0xA085,0xA236,0xA439,0xA69C,0xA973, +0xACD2,0xB0D5,0xB599,0xBB42,0xC1FE,0xC9FE,0xD37F,0xDECC, +/* A:1f B:11 */ +0x98EF,0x98FF,0x9912,0x9929,0x9944,0x9965,0x998B,0x99B8, +0x99EE,0x9A2F,0x9A7B,0x9AD6,0x9B42,0x9BC2,0x9C5A,0x9D10, +0x9DE7,0x9EE7,0xA017,0xA180,0xA32E,0xA52C,0xA78B,0xAA5C, +0xADB5,0xB1B0,0xB66A,0xBC09,0xC2B7,0xCAA8,0xD417,0xDF4E, +/* A:1f B:12 */ +0x9A2D,0x9A3D,0x9A50,0x9A67,0x9A82,0x9AA2,0x9AC7,0x9AF5, +0x9B2A,0x9B6A,0x9BB5,0x9C0F,0x9C7A,0x9CF9,0x9D90,0x9E44, +0x9F19,0xA017,0xA144,0xA2AA,0xA454,0xA64E,0xA8A7,0xAB72, +0xAEC3,0xB2B4,0xB764,0xBCF6,0xC394,0xCB72,0xD4CC,0xDFE8, +/* A:1f B:13 */ +0x9BA7,0x9BB7,0x9BCA,0x9BE0,0x9BFB,0x9C1A,0x9C40,0x9C6C, +0x9CA1,0x9CE0,0x9D2B,0x9D84,0x9DEE,0x9E6C,0x9F01,0x9FB2, +0xA085,0xA180,0xA2AA,0xA40D,0xA5B2,0xA7A6,0xA9F9,0xACBB, +0xB003,0xB3EA,0xB88C,0xBE0F,0xC49B,0xCC63,0xD5A2,0xE0A0, +/* A:1f B:14 */ +0x9D68,0x9D78,0x9D8A,0x9DA0,0x9DBB,0x9DDA,0x9DFF,0x9E2B, +0x9E5F,0x9E9D,0x9EE7,0x9F3F,0x9FA7,0xA023,0xA0B7,0xA166, +0xA236,0xA32E,0xA454,0xA5B2,0xA751,0xA93F,0xAB8A,0xAE43, +0xB180,0xB55A,0xB9ED,0xBF5C,0xC5D3,0xCD80,0xD6A1,0xE17A, +/* A:1f B:15 */ +0x9F7E,0x9F8D,0x9FA0,0x9FB5,0x9FCF,0x9FEE,0xA012,0xA03E, +0xA071,0xA0AE,0xA0F7,0xA14D,0xA1B4,0xA22E,0xA2BF,0xA36C, +0xA439,0xA52C,0xA64E,0xA7A6,0xA93F,0xAB25,0xAD67,0xB015, +0xB345,0xB70F,0xBB8F,0xC0E9,0xC745,0xCED4,0xD7D0,0xE27D, +/* A:1f B:16 */ +0xA1F8,0xA207,0xA219,0xA22F,0xA248,0xA266,0xA28A,0xA2B4, +0xA2E7,0xA323,0xA36A,0xA3BF,0xA424,0xA49C,0xA52A,0xA5D3, +0xA69C,0xA78B,0xA8A7,0xA9F9,0xAB8A,0xAD67,0xAF9D,0xB23F, +0xB55F,0xB916,0xBD81,0xC2C1,0xC8FE,0xD068,0xD938,0xE3B1, +/* A:1f B:17 */ +0xA4EA,0xA4F9,0xA50B,0xA51F,0xA538,0xA556,0xA579,0xA5A2, +0xA5D3,0xA60E,0xA654,0xA6A7,0xA709,0xA77E,0xA809,0xA8AE, +0xA973,0xAA5C,0xAB72,0xACBB,0xAE43,0xB015,0xB23F,0xB4D1, +0xB7DF,0xBB80,0xBFD1,0xC4F1,0xCB0A,0xD248,0xDAE4,0xE51F, +/* A:1f B:18 */ +0xA86B,0xA879,0xA88A,0xA89E,0xA8B6,0xA8D3,0xA8F5,0xA91D, +0xA94D,0xA986,0xA9CA,0xAA1A,0xAA7A,0xAAEC,0xAB73,0xAC13, +0xACD2,0xADB5,0xAEC3,0xB003,0xB180,0xB345,0xB55F,0xB7DF, +0xBAD7,0xBE5E,0xC28F,0xC78B,0xCD78,0xD482,0xDCE0,0xE6D2, +/* A:1f B:19 */ +0xAC94,0xACA2,0xACB2,0xACC5,0xACDD,0xACF8,0xAD19,0xAD40, +0xAD6E,0xADA5,0xADE7,0xAE35,0xAE91,0xAEFF,0xAF81,0xB01C, +0xB0D5,0xB1B0,0xB2B4,0xB3EA,0xB55A,0xB70F,0xB916,0xBB80, +0xBE5E,0xC1C6,0xC5D3,0xCAA3,0xD05C,0xD728,0xDF3D,0xE8D7, +/* A:1f B:1a */ +0xB186,0xB193,0xB1A3,0xB1B5,0xB1CB,0xB1E6,0xB205,0xB22B, +0xB257,0xB28C,0xB2CA,0xB315,0xB36D,0xB3D6,0xB453,0xB4E8, +0xB599,0xB66A,0xB764,0xB88C,0xB9ED,0xBB8F,0xBD81,0xBFD1, +0xC28F,0xC5D3,0xC9B4,0xCE50,0xD3CB,0xDA4E,0xE20B,0xEB3E, +/* A:1f B:1b */ +0xB766,0xB773,0xB782,0xB793,0xB7A8,0xB7C1,0xB7DF,0xB802, +0xB82C,0xB85E,0xB89A,0xB8E0,0xB934,0xB998,0xBA0E,0xBA9B, +0xBB42,0xBC09,0xBCF6,0xBE0F,0xBF5C,0xC0E9,0xC2C1,0xC4F1, +0xC78B,0xCAA3,0xCE50,0xD2AE,0xD7DF,0xDE0B,0xE561,0xEE18, +/* A:1f B:1c */ +0xBE62,0xBE6E,0xBE7C,0xBE8C,0xBEA0,0xBEB7,0xBED3,0xBEF4, +0xBF1C,0xBF4A,0xBF82,0xBFC4,0xC012,0xC06F,0xC0DE,0xC161, +0xC1FE,0xC2B7,0xC394,0xC49B,0xC5D3,0xC745,0xC8FE,0xCB0A, +0xCD78,0xD05C,0xD3CB,0xD7DF,0xDCB9,0xE27D,0xE957,0xF17C, +/* A:1f B:1d */ +0xC6AF,0xC6BA,0xC6C7,0xC6D6,0xC6E8,0xC6FD,0xC717,0xC735, +0xC759,0xC784,0xC7B7,0xC7F3,0xC83B,0xC890,0xC8F6,0xC96E, +0xC9FE,0xCAA8,0xCB72,0xCC63,0xCD80,0xCED4,0xD068,0xD248, +0xD482,0xD728,0xDA4E,0xDE0B,0xE27D,0xE7C6,0xEE0D,0xF583, +/* A:1f B:1e */ +0xD08D,0xD097,0xD0A2,0xD0AF,0xD0C0,0xD0D3,0xD0E9,0xD104, +0xD124,0xD14B,0xD178,0xD1AE,0xD1EE,0xD23A,0xD294,0xD300, +0xD37F,0xD417,0xD4CC,0xD5A2,0xD6A1,0xD7D0,0xD938,0xDAE4, +0xDCE0,0xDF3D,0xE20B,0xE561,0xE957,0xEE0D,0xF3A6,0xFA4D, +/* A:1f B:1f */ +0xDC47,0xDC4F,0xDC59,0xDC64,0xDC72,0xDC82,0xDC96,0xDCAD, +0xDCC8,0xDCE9,0xDD10,0xDD3E,0xDD75,0xDDB6,0xDE03,0xDE5F, +0xDECC,0xDF4E,0xDFE8,0xE0A0,0xE17A,0xE27D,0xE3B1,0xE51F, +0xE6D2,0xE8D7,0xEB3E,0xEE18,0xF17C,0xF583,0xFA4D,0xFFFF, +} Index: apps/codecs/libsc68/io68/ymemul.c =================================================================== --- apps/codecs/libsc68/io68/ymemul.c (revision 0) +++ apps/codecs/libsc68/io68/ymemul.c (revision 0) @@ -0,0 +1,681 @@ +/* + * sc68 - YM-2149 emulator + * Copyright (C) 2001-2009 Ben(jamin) Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef HAVE_CONFIG_OPTION68_H +# include +#else +# include "default_option68.h" +#endif + +#include "ymemul.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/assert68.h" + +#include "file68/msg68.h" +#include "file68/option68.h" +#endif + +#include + +#ifndef BREAKPOINT68 +# define BREAKPOINT68 assert(!"breakpoint") +#endif + +#ifndef DEBUG_YM_O +# define DEBUG_YM_O 0 +#endif +int ym_cat = msg68_DEFAULT; + +int ym_default_chans = 7; + +#include "ym_linear_table.c" +#include "ym_atarist_table.c" + + +/** 3 channels output table. + * Using a table for non linear mixing. + */ +static s16 ymout5[32*32*32]; +static inline +void access_list_reset(ym_waccess_list_t * const access_list, + const char * name, + const cycle68_t ymcycle) +{ + if (!name) name = "und"; + access_list->name[0] = name[0]; + access_list->name[1] = name[1]; + access_list->name[2] = name[2]; + access_list->name[3] = 0; + access_list->head = access_list->tail = 0; +} + +static void access_list_add(ym_t * const ym, + ym_waccess_list_t * const access_list, + const int reg, const int val, + const cycle68_t ymcycle) +{ + ym_waccess_t * free_access = ym->waccess_nxt; + + if (free_access >= ym->waccess+ym->waccess_max) { + /* No more free entries. */ + /* $$$ TODO: realloc buffer, reloc all lists ... */ + TRACE68(msg68_CRITICAL, + "ym-2148: access list *%s* -- *OVERFLOW*", access_list->name); + return; + } + ym->waccess_nxt = free_access+1; + + free_access->ymcycle = ymcycle; + free_access->reg = reg; + free_access->val = val; + free_access->link = 0; + + if (access_list->tail) { + access_list->tail->link = free_access; + } else { + access_list->head = free_access; + } + access_list->tail = free_access; +} + +static void access_adjust_cycle(ym_waccess_list_t * const access_list, + const cycle68_t ymcycles) +{ + ym_waccess_t * access; + /* access_list->last_cycle -= ymcycles; */ + for (access = access_list->head; access; access = access->link) { + access->ymcycle -= ymcycles; + } +} + + +/****************************************************** + * Yamaha reset * + ******************************************************/ + +int ym_reset(ym_t * const ym, const cycle68_t ymcycle) +{ + int ret = -1; + + if (ym) { + unsigned i; + + /* Run emulator specific reset callback. */ + if (ym->cb_reset) { + ym->cb_reset(ym,ymcycle); + } + + /* Clear internal registers. */ + for (i=0; ireg.index)/sizeof(*ym->reg.index); ++i) { + ym->reg.index[i] = 0; + } + + /* Reset control register */ + ym->ctrl = 0; + + /* Reset mixer: tone & noise off for all channels */ + ym->reg.name.ctl_mixer = 077; + + /* Reset envelop generator */ + ym->reg.name.env_shape = 0x0A; + + /* Reset access lists */ + access_list_reset(&ym->ton_regs, "Ton", ymcycle); + access_list_reset(&ym->noi_regs, "Noi", ymcycle); + access_list_reset(&ym->env_regs, "Env", ymcycle); + + /* Copy registers to shadow */ + for (i=0; ireg.index)/sizeof(*ym->reg.index); ++i) { + ym->shadow.index[i] = ym->reg.index[i]; + } + + ret = 0; + } + + return ret; +} + +/****************************************************** + * Yamaha init * + ******************************************************/ + +/* -DYM_ENGINE=YM_ENGINE_BLEP choose BLEP as default engine */ +#ifndef YM_ENGINE +# define YM_ENGINE YM_ENGINE_PULS +#endif + +/* -DYM_VOL_TABLE=YM_VOL_LINEAR choose linear volume table */ +#ifndef YM_VOL_TABLE +# define YM_VOL_TABLE YM_VOL_ATARIST +#endif + +/* Default parameters */ +static ym_parms_t default_parms; + +/* Max output level for volume tables. */ +static const int output_level = 0xDEAD; + +/* Command line options */ +static const char prefix[] = "sc68-"; +static const char engcat[] = "ym-2149"; +static option68_t opts[] = { + { option68_STR, prefix, "ym-engine", engcat, + "set ym-2149 engine [pulse|blep|dump]", + {0},0,0,0 }, + { option68_STR, prefix, "ym-volmodel", engcat, + "set ym-2149 volume model [atari|linear|atari4]", + {0},0,0,0 }, + { option68_INT, prefix, "ym-chans", engcat, + "set ym-2149 active channel [bit-0:A ... bit-2:C]", + {0},0,0,0 } +}; + + +int ym_init(int * argc, char ** argv) +{ + option68_t * opt; + + /* Debug */ + ym_cat = msg68_cat("ym","ym-2149 emulator",DEBUG_YM_O); + + /* Setup default */ + default_parms.engine = YM_ENGINE; + default_parms.volmodel = YM_VOL_TABLE; + default_parms.clock = YM_CLOCK_ATARIST; + default_parms.hz = SAMPLING_RATE_DEF; + + /* Set default parameters. */ +/* if (parms) { */ +/* if (parms->emul) default_parms.emul = parms->emul; */ +/* if (parms->volmodel) default_parms.volmodel = parms->volmodel; */ +/* if (parms->hz) default_parms.hz = parms->hz; */ +/* if (parms->clock) default_parms.clock = parms->clock; */ +/* if (parms->outlevel) default_parms.outlevel = parms->outlevel; */ +/* if (parms->argc) { */ +/* argc = *parms->argc; */ +/* argv = parms->argv; */ +/* } */ +/* } */ + + /* ym- Options */ + option68_append(opts,sizeof(opts)/sizeof(*opts)); + *argc = option68_parse(*argc,argv,0); + + /* --sc68-ym-engine */ + opt = option68_get("ym-engine",1); + if (opt) { + int k; + if (!strcmp(opt->val.str,"pulse")) { + k = YM_ENGINE_PULS; + } else if (!strcmp(opt->val.str,"blep")) { + k = YM_ENGINE_BLEP; + } else if (!strcmp(opt->val.str,"dump")) { + k = YM_ENGINE_DUMP; + } else { + k = YM_ENGINE_DEFAULT; + } + ym_engine(0, k); + } + + /* --sc68-ym-volmodel */ + opt = option68_get("ym-volmodel",1); + if (opt) { + if (!strcmp(opt->val.str,"linear")) { + default_parms.volmodel = YM_VOL_LINEAR; + } else if (!strcmp(opt->val.str,"atari")) { + default_parms.volmodel = YM_VOL_ATARIST; + } else if (!strcmp(opt->val.str,"atari4")) { + default_parms.volmodel = YM_VOL_ATARIST_4BIT; + } + } + + /* --sc68-ym-chans */ + opt = option68_get("ym-chans",1); + if (opt) { + ym_default_chans = opt->val.num & 7; + } + + /* Set volume table (unique for all instance) */ + switch (default_parms.volmodel) { + case YM_VOL_LINEAR: + ym_create_5bit_linear_table(ymout5, output_level); + break; + case YM_VOL_ATARIST_4BIT: + ym_create_4bit_atarist_table(ymout5, output_level); + break; + case YM_VOL_DEFAULT: + case YM_VOL_ATARIST: + default: + ym_create_5bit_atarist_table(ymout5, output_level); + } + + /* Process ym-puls options */ + *argc = ym_puls_options(*argc, argv); + + return 0; +} + +void ym_shutdown(void) +{ +} + + +/* ,-----------------------------------------------------------------. + * | Run emulation | + * `-----------------------------------------------------------------' + */ +int ym_run(ym_t * const ym, s32 * output, const cycle68_t ymcycles) +{ + if (!ymcycles) { + return 0; + } + + /* + * Currently ymcycles must be multiple of 32. + * 32 cycles will generate 4 samples @ 250000hz. It helps to + * simplify the first filter code (half-level buzz trick). + */ + if ( (ymcycles&31) || !output) { + return -1; + } + + return ym->cb_run(ym,output,ymcycles); +} + + + +/* ,-----------------------------------------------------------------. + * | Write YM register | + * `-----------------------------------------------------------------' + */ + +void ym_writereg(ym_t * const ym, + const int val, const cycle68_t ymcycle) +{ + const int reg = ym->ctrl; + + if (reg >= 0 && reg < 16) { + + /*TRACE68(ym_cat,"write #%X = %02X (%u)\n",reg,(int)(u8)val,ymcycle); */ + + ym->shadow.index[reg] = val; + + switch(reg) { + /* Tone generator related registers. */ + case YM_PERL(0): case YM_PERH(0): + case YM_PERL(1): case YM_PERH(1): + case YM_PERL(2): case YM_PERH(2): + case YM_VOL(0): case YM_VOL(1): case YM_VOL(2): + access_list_add(ym, &ym->ton_regs, reg, val, ymcycle); + break; + + /* Envelop generator related registers. */ + case YM_ENVL: case YM_ENVH: case YM_ENVTYPE: + access_list_add(ym, &ym->env_regs, reg, val, ymcycle); + break; + + /* Reg 7 modifies both noise &ym-> tone generators */ + case YM_MIXER: + access_list_add(ym, &ym->ton_regs, reg, val, ymcycle); + /* Noise generator related registers. */ + case YM_NOISE: + access_list_add(ym, &ym->noi_regs, reg, val, ymcycle); + break; + + default: + break; + } + } +} + +/* ,-----------------------------------------------------------------. + * | Adjust YM-2149 cycle counters | + * `-----------------------------------------------------------------' + */ +void ym_adjust_cycle(ym_t * const ym, const cycle68_t ymcycles) +{ + if (ym) { + access_adjust_cycle(&ym->ton_regs, ymcycles); + access_adjust_cycle(&ym->noi_regs, ymcycles); + access_adjust_cycle(&ym->env_regs, ymcycles); + } +} + +/* ,-----------------------------------------------------------------. + * | Yamaha get activated voices | + * `-----------------------------------------------------------------' + */ + +extern const int ym_smsk_table[]; /* declared in ym_puls.c */ +int ym_active_channels(ym_t * const ym, const int clr, const int set) +{ + int v = 0; + if (ym) { + const int voice_mute = ym->voice_mute; + v = ( voice_mute & 1 ) | ( (voice_mute>>5) & 2 ) | ( (voice_mute>>10) & 4); + v = ( (v & ~clr ) | set ) & 7; + ym->voice_mute = ym_smsk_table[v]; + msg68_info("ym-2149: active channels -- *%c%c%c*\n", + (v&1)?'A':'.', (v&2)?'B':'.', (v&4)?'C':'.'); + } + return v; +} + +/* ,-----------------------------------------------------------------. + * | Engine selection | + * `-----------------------------------------------------------------' + */ + +static +const char * ym_engine_name(int emul) +{ + switch (emul) { + case YM_ENGINE_PULS: return "PULSE"; + case YM_ENGINE_BLEP: return "BLEP"; + case YM_ENGINE_DUMP: return "DUMP"; + } + return 0; +} + +int ym_engine(ym_t * const ym, int engine) +{ + switch (engine) { + + case YM_ENGINE_QUERY: + /* Get current value. */ + engine = ym ? ym->engine : default_parms.engine; + break; + + default: + /* Invalid values */ + msg68_warning("ym-2149: unknown ym-engine -- *%d*\n", engine); + case YM_ENGINE_DEFAULT: + /* Default values */ + engine = default_parms.engine; + case YM_ENGINE_PULS: + case YM_ENGINE_BLEP: + case YM_ENGINE_DUMP: + /* Valid values */ + if (!ym) { + default_parms.engine = engine; + msg68_info("ym-2149: default engine -- *%s*\n", + ym_engine_name(engine)); + } else { + engine = ym->engine; + } + break; + } + return engine; +} + + +/* ,-----------------------------------------------------------------. + * | Master clock | + * `-----------------------------------------------------------------' + */ + +int ym_clock(ym_t * const ym, int clock) +{ + switch (clock) { + + case YM_CLOCK_QUERY: + clock = ym ? (int) ym->clock : default_parms.clock; + break; + + case YM_CLOCK_DEFAULT: + clock = default_parms.clock; + + default: + if (clock != YM_CLOCK_ATARIST) { + msg68_warning("ym-2149: unsupported clock -- %u\n", + (unsigned int)clock); + } + clock = YM_CLOCK_ATARIST; + if (!ym) { + default_parms.clock = clock; + msg68_info("ym-2149: default clock -- *ATARI-ST*\n", + (unsigned int)clock); + } else { + clock = ym->clock; + } + break; + } + return clock; +} + +/* ,-----------------------------------------------------------------. + * | Volume model | + * `-----------------------------------------------------------------' + */ + +static +const char * ym_volmodel_name(int model) +{ + switch (model) { + case YM_VOL_LINEAR: return "LINEAR"; + case YM_VOL_ATARIST: return "ATARI-ST"; + } + return 0; +} + +int ym_volume_model(ym_t * const ym, int model) +{ + /* Set volume table (unique for all instance) */ + switch (model) { + + case YM_VOL_QUERY: + model = default_parms.volmodel; + break; + + default: + msg68_warning("ym-2149: unknown volume model -- %d\n", model); + case YM_VOL_DEFAULT: + model = default_parms.volmodel; + case YM_VOL_LINEAR: + case YM_VOL_ATARIST: + if (ym) { + model = ym->volmodel; + } else { + ym->volmodel = model; + assert(model == YM_VOL_LINEAR || model == YM_VOL_ATARIST); + if ( model == YM_VOL_LINEAR ) { + ym_create_5bit_linear_table(ymout5, output_level); + } else { + ym_create_5bit_atarist_table(ymout5, output_level); + } + msg68_info("ym-2149: default volume model -- *%s*\n", + ym_volmodel_name(model)); + } + break; + } + return model; +} + + +/* ,-----------------------------------------------------------------. + * | Output sampling rate | + * `-----------------------------------------------------------------' + */ + +int ym_sampling_rate(ym_t * const ym, int hz) +{ + switch (hz) { + + case YM_VOL_QUERY: + hz = ym ? (int) ym->hz : default_parms.hz; + break; + + case YM_VOL_DEFAULT: + hz = default_parms.hz; + + default: + if (hz < SAMPLING_RATE_MIN) hz = SAMPLING_RATE_MIN; + if (hz > SAMPLING_RATE_MAX) hz = SAMPLING_RATE_MAX; + if (ym->cb_sampling_rate) { + /* engine sampling rate callback */ + hz = ym->cb_sampling_rate(ym,hz); + } + if (ym) { + ym->hz = hz; + } else { + default_parms.hz = hz; + } + msg68_info("ym-2149: %ssampling rate -- *%dhz*\n", + ym ? "" : "default ", hz); + } + return hz; +} + + +/* ,-----------------------------------------------------------------. + * | Configure default or emulator instance | + * `-----------------------------------------------------------------' + */ + +int ym_configure(ym_t * const ym, ym_parms_t * const parms) +{ + if (!parms) { + msg68_error("ym-2149: nothing to configure\n"); + return -1; + } + parms->engine = ym_engine(ym, parms->engine); + parms->volmodel = ym_volume_model(ym, parms->volmodel); + parms->clock = ym_clock(ym, parms->clock); + parms->hz = ym_sampling_rate(ym, parms->hz); + return 0; +} + + +/* ,-----------------------------------------------------------------. + * | Setup / Cleanup emulator instance | + * `-----------------------------------------------------------------' + */ + +int ym_setup(ym_t * const ym, ym_parms_t * const parms) +{ + ym_parms_t * const p = parms ? parms : &default_parms; + int err = -1; + + /* engine */ + if (p->engine == YM_ENGINE_DEFAULT) { + p->engine = default_parms.engine; + } + + /* sampling rate */ + if (p->hz == 0) { + p->hz = default_parms.hz; + } + + /* clock */ + switch (p->clock) { + case YM_CLOCK_ATARIST: + break; + case YM_CLOCK_DEFAULT: + default: + p->clock = default_parms.clock; + } + + /* output level */ +/* if (p->outlevel == 0) { */ +/* p->outlevel = default_parms.outlevel; */ +/* } */ +/* if (p->outlevel <= 0) { */ +/* p->outlevel = 0; */ +/* } else if (p->outlevel >= 0x100) { */ +/* p->outlevel = 0x100; */ +/* } */ + + TRACE68(ym_cat,"ym-2149: setup -- engine:%d rate:%d clock:%d level:%d\n", + p->engine,p->hz,p->clock,256); + + if (ym) { + ym->ymout5 = ymout5; + ym->waccess_max = sizeof(ym->static_waccess)/sizeof(*ym->static_waccess); + ym->waccess = ym->static_waccess; + ym->waccess_nxt = ym->waccess; + ym->clock = p->clock; +/* ym->outlevel = p->outlevel >> 2; */ + ym->voice_mute = ym_smsk_table[7 & ym_default_chans]; + /* clearing sampling rate callback ensure requested rate to be in + valid range. */ + ym->cb_sampling_rate = 0; + ym_sampling_rate(ym, p->hz); + ym->engine = p->engine; + + TRACE68(ym_cat,"ym-2149: engine -- *%d*\n", p->engine); + + switch (p->engine) { + case YM_ENGINE_PULS: + err = ym_puls_setup(ym); + break; + + case YM_ENGINE_BLEP: + err = ym_blep_setup(ym); + break; + + case YM_ENGINE_DUMP: + err = ym_dump_setup(ym); + break; + + default: + msg68_critical("ym-2149: engine %d -- *invalid*\n", p->engine); + err = -1; + } + if (!err) + msg68_info("ym-2149: engine -- *%s*\n", ym_engine_name(ym->engine)); + + + /* at this point specific sampling rate callback can be call */ + ym_sampling_rate(ym, ym->hz); + } + + /* Just for info print */ + ym_active_channels(ym,0,0); + + msg68(ym_cat,"ym-2149: trace level -- *active*\n"); + + return err ? err : ym_reset(ym, 0); +} + + +/** Destroy an Yamaha-2149 emulator instance. + */ +void ym_cleanup(ym_t * const ym) +{ + TRACE68(ym_cat,"ym-2149: cleanup\n"); + if (ym && ym->cb_cleanup) { + ym->cb_cleanup(ym); + } +} + +/** Get required output buffer size. + */ +uint68_t ym_buffersize(const ym_t const * ym, const cycle68_t ymcycles) +{ + return ym->cb_buffersize(ym,ymcycles); +} Index: apps/codecs/libsc68/io68/mfp_io.c =================================================================== --- apps/codecs/libsc68/io68/mfp_io.c (revision 0) +++ apps/codecs/libsc68/io68/mfp_io.c (revision 0) @@ -0,0 +1,458 @@ +/* + * sc68 - MFP-68901 emulator + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "mfp_io.h" +#include "mfpemul.h" + +typedef struct { + io68_t io; + mfp_t mfp; +} mfp_io68_t; + +/* $$$ Currently hardcoded for 8Mhz cpu */ +#define cpu2bogo(mfpio,cycle) ((bogoc68_t)((cycle)*192u)) +#define bogo2cpu(mfpio,bogoc) ((cycle68_t)((bogoc)/* +191u */)/192u) + +/* 0 GPIP General purpose I/O */ +static int68_t mfpr_01(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x01]; +} +/* 1 AER Active edge register */ +static int68_t mfpr_03(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x03]; +} +/* 2 DDR Data direction register */ +static int68_t mfpr_05(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x05]; +} +/* 3 IERA Interrupt enable register A */ +static int68_t mfpr_07(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x07]; +} +/* 4 IERB Interrupt enable register B */ +static int68_t mfpr_09(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x09]; +} +/* 5 IPRA Interrupt pending register A */ +static int68_t mfpr_0B(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x0B]; +} +/* 6 IPRB Interrupt pending register B */ +static int68_t mfpr_0D(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x0D]; +} +/* 7 ISRA Interrupt in-service register A */ +static int68_t mfpr_0F(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x0F]; +} +/* 8 ISRB Interrupt in-service register B */ +static int68_t mfpr_11(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x11]; +} +/* 9 IMRA Interrupt mask register A */ +static int68_t mfpr_13(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x13]; +} +/* A IMRB Interrupt mask register B */ +static int68_t mfpr_15(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x15]; +} +/* B VR Vector register */ +static int68_t mfpr_17(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x17]; +} +/* C TACR Timer A control register */ +static int68_t mfpr_19(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x19]; +} +/* D TBCR Timer B control register */ +static int68_t mfpr_1B(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x1B]; +} +/* E TCDCR Timers C and D control registers */ +static int68_t mfpr_1D(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x1D]; +} +/* F TADR Timer A data register */ +static int68_t mfpr_1F(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp_get_tdr(mfp, TIMER_A, bogoc); +} +/* 10 TBDR Timer B data register */ +static int68_t mfpr_21(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp_get_tdr(mfp, TIMER_B, bogoc); +} +/* 11 TCDR Timer C data register */ +static int68_t mfpr_23(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp_get_tdr(mfp, TIMER_C, bogoc); +} +/* 12 TDDR Timer D data register */ +static int68_t mfpr_25(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp_get_tdr(mfp, TIMER_D, bogoc); +} +/* 13 SCR Sync character register */ +static int68_t mfpr_27(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x27]; +} +/* 14 UCR USART control register */ +static int68_t mfpr_29(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x29]; +} +/* 15 RSR Receiver status register */ +static int68_t mfpr_2B(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x2B]; +} +/* 16 TSR Transmitter status register */ +static int68_t mfpr_2D(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x2D]; +} +/* 17 UDR USART data register */ +static int68_t mfpr_2F(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x2F]; +} +static int68_t mfpr_31(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x31]; +} +static int68_t mfpr_33(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x33]; +} +static int68_t mfpr_35(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x35]; +} +static int68_t mfpr_37(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x37]; +} +static int68_t mfpr_39(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x39]; +} +static int68_t mfpr_3B(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x3B]; +} +static int68_t mfpr_3D(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x3D]; +} +static int68_t mfpr_3F(mfp_t * const mfp, const bogoc68_t bogoc) { + return mfp->map[0x3F]; +} + + +static void mfpw_01(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x01]=v; } +static void mfpw_03(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x03]=v; } +static void mfpw_05(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x05]=v; } +static void mfpw_07(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x07]=v; } +static void mfpw_09(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x09]=v; } +static void mfpw_0B(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x0B]=v; } +static void mfpw_0D(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x0D]=v; } +static void mfpw_0F(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x0F]=v; } +static void mfpw_11(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x11]=v; } +static void mfpw_13(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x13]=v; } +static void mfpw_15(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x15]=v; } +static void mfpw_17(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x17]=v; } +static void mfpw_19(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tcr(mfp, TIMER_A, v, bogoc); } +static void mfpw_1B(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tcr(mfp, TIMER_B, v, bogoc); } +static void mfpw_1D(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tcr(mfp, TIMER_C, v, bogoc); } +static void mfpw_1F(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tdr(mfp, TIMER_A, v, bogoc); } +static void mfpw_21(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tdr(mfp, TIMER_B, v, bogoc); } +static void mfpw_23(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tdr(mfp, TIMER_C, v, bogoc); } +static void mfpw_25(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp_put_tdr(mfp, TIMER_D, v, bogoc); } +static void mfpw_27(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x27]=v; } +static void mfpw_29(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x29]=v; } +static void mfpw_2B(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x2B]=v; } +static void mfpw_2D(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x2D]=v; } +static void mfpw_2F(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x2F]=v; } +static void mfpw_31(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x31]=v; } +static void mfpw_33(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x33]=v; } +static void mfpw_35(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x35]=v; } +static void mfpw_37(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x37]=v; } +static void mfpw_39(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x39]=v; } +static void mfpw_3B(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x3B]=v; } +static void mfpw_3D(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x3D]=v; } +static void mfpw_3F(mfp_t * const mfp, const int68_t v, const bogoc68_t bogoc) +{ mfp->map[0x3F]=v; } + +/* MFP read jump table */ +static int68_t (* const mfpr_func[32]) +(mfp_t * const, const bogoc68_t) = +{ + mfpr_01,mfpr_03,mfpr_05,mfpr_07, + mfpr_09,mfpr_0B,mfpr_0D,mfpr_0F, + mfpr_11,mfpr_13,mfpr_15,mfpr_17, + mfpr_19,mfpr_1B,mfpr_1D,mfpr_1F, + mfpr_21,mfpr_23,mfpr_25,mfpr_27, + mfpr_29,mfpr_2B,mfpr_2D,mfpr_2F, + mfpr_31,mfpr_33,mfpr_35,mfpr_37, + mfpr_39,mfpr_3B,mfpr_3D,mfpr_3F, +}; + +/* MFP write jump table */ +static void (* const mfpw_func[32]) +(mfp_t * const, const int68_t, const bogoc68_t) = +{ + mfpw_01,mfpw_03,mfpw_05,mfpw_07, + mfpw_09,mfpw_0B,mfpw_0D,mfpw_0F, + mfpw_11,mfpw_13,mfpw_15,mfpw_17, + mfpw_19,mfpw_1B,mfpw_1D,mfpw_1F, + mfpw_21,mfpw_23,mfpw_25,mfpw_27, + mfpw_29,mfpw_2B,mfpw_2D,mfpw_2F, + mfpw_31,mfpw_33,mfpw_35,mfpw_37, + mfpw_39,mfpw_3B,mfpw_3D,mfpw_3F, +}; + +static int68_t _mfp_readB(mfp_io68_t * const mfpio, const int addr, + const bogoc68_t bogoc) +{ + return !(addr&1) + ? 0 + : mfpr_func[(addr>>1)&0x1f](&mfpio->mfp, bogoc) + ; +} + +static void mfpio_readB(io68_t * const io) +{ + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + io->emu68->bus_data = + _mfp_readB((mfp_io68_t *)io, + io->emu68->bus_addr, bogoc); +} + +static void mfpio_readW(io68_t * const io) +{ + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + /* Expected EVEN addr for 16 bit access */ + io->emu68->bus_data = + _mfp_readB((mfp_io68_t *)io, + io->emu68->bus_addr+1, bogoc); +} + +static void mfpio_readL(io68_t * const io) +{ + /* Expected EVEN addr for 16 bit access */ + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + const int addr = io->emu68->bus_addr; + + io->emu68->bus_data = + (_mfp_readB((mfp_io68_t *)io, addr+1, bogoc)<<16) + |_mfp_readB((mfp_io68_t *)io, addr+3, bogoc); +} + +static inline void _mfp_writeB(mfp_io68_t * const mfpio, const int addr, + const int68_t v, const bogoc68_t bogoc) +{ + if (!(addr&1)) return; + mfpw_func[(addr>>1)&0x1f](&mfpio->mfp, (u8)v, bogoc); +} + +static void mfpio_writeB(io68_t * const io) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + _mfp_writeB(mfpio, io->emu68->bus_addr, io->emu68->bus_data, bogoc); +} + +/* Expected EVEN addr for 16 bit access */ +static void mfpio_writeW(io68_t * const io) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + _mfp_writeB(mfpio, io->emu68->bus_addr+1, io->emu68->bus_data, bogoc); +} + +/* Expected EVEN addr for 32 bit access */ +static void mfpio_writeL(io68_t * const io) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + _mfp_writeB(mfpio, + io->emu68->bus_addr+1, io->emu68->bus_data>>16, bogoc); + _mfp_writeB((mfp_io68_t *)io, + io->emu68->bus_addr+3, io->emu68->bus_data ,bogoc); +} + +static int mfpio_reset(io68_t * const io) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + const bogoc68_t bogoc = cpu2bogo(io,io->emu68->cycle); + mfp_reset(&mfpio->mfp,bogoc); + return 0; +} + +static interrupt68_t * mfpio_interrupt(io68_t * const io, + const cycle68_t cycle) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + const bogoc68_t bogoc = cpu2bogo(io,cycle); + interrupt68_t * const inter = + mfp_interrupt(&mfpio->mfp, bogoc); + if (inter) { +#ifdef DEBUG + if (inter->cycle >= bogoc) { + *(int *)0 = 0xDEADBEEF; + } +#endif + + inter->cycle = bogo2cpu(io,inter->cycle); + +#ifdef DEBUG + if (inter->cycle >= cycle) { + *(int *)0 = 0xDEADBEEF; + } + + /* Happen in 'Wave is my Passion.sc68' with the version +191u + + Register dump: + CS:0073 SS:007b DS:007b ES:007b FS:0033 GS:003b + EIP:0040b38c ESP:008dfd70 EBP:008dfd88 EFLAGS:00010246(- 00 -RIZP1) + EAX:deadbeef EBX:01d58000 ECX:00164c88 EDX:00027200 + ESI:00027200 EDI:0007fff0 + + Stack dump: + 0x008dfd70: 00164bec 01d58000 00000005 004071a1 + 0x008dfd80: 00164c54 00166618 008dfda8 004078f5 + 0x008dfd90: 00164b90 00027200 00008008 00164408 + 0x008dfda0: 00164408 00000000 008dfe08 004042cb + 0x008dfdb0: 00166618 00027200 00000095 64703380 + 0x008dfdc0: 00008000 001fcec8 00000020 00000001 + + Backtrace: + =>1 0x0040b38c mfpio_interrupt+0x4c(io=0x164b90, cycle=0x27200) + [./libsc68/io68/mfp_io.c:348] + in sc68 (0x008dfd88) + + 2 0x004078f5 emu68_level_and_interrupt+0x165(emu68=0x166618, + cycleperpass=0x27200) + [./libsc68/emu68/emu68.c:341] + in sc68 (0x008dfda8) + + 0x0040b38c mfpio_interrupt+0x4c [./libsc68/io68/mfp_io.c:348] + in sc68: movl %eax,0x00000000 348 *(int *)0 = 0xDEADBEEF; + Modules: + */ + +#endif + + } + return inter; +} + +/* static cycle68_t mfpio_nextinterrupt(io68_t * const io, */ +/* const cycle68_t cycle) */ +/* { */ +/* mfp_io68_t * const mfpio = (mfp_io68_t * const)io; */ +/* cycle68_t const ret = mfp_nextinterrupt(&mfpio->mfp); */ +/* return ret == IO68_NO_INT */ +/* ? IO68_NO_INT */ +/* : bogo2cpu(io,ret); */ +/* } */ + +static void mfpio_adjust_cycle(io68_t * const io, + const cycle68_t cycle) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + const bogoc68_t bogoc = cpu2bogo(io, cycle); + mfp_adjust_bogoc(&mfpio->mfp, bogoc); +} + +void mfpio_destroy(io68_t * const io) +{ + mfp_io68_t * const mfpio = (mfp_io68_t * const)io; + if (io) { + mfp_cleanup(&mfpio->mfp); + emu68_free(io); + } +} + +static io68_t mfp_io = +{ + 0, + "MFP-68901", + 0xFFFFFA00, 0xFFFFFA2F, + mfpio_readB,mfpio_readW,mfpio_readL, + mfpio_writeB,mfpio_writeW,mfpio_writeL, + mfpio_interrupt,/* mfpio_nextinterrupt */0, + mfpio_adjust_cycle, + mfpio_reset, + mfpio_destroy, + 0 +}; + +int mfpio_init(int * argc, char ** argv) +{ + argc = argc; + argv = argv; + return mfp_init(); +} + +void mfpio_shutdown(void) +{ + mfp_shutdown(); +} + +io68_t * mfpio_create(emu68_t * const emu68) +{ + mfp_io68_t * mfpio = 0; + + if (emu68) { + mfpio = emu68_alloc(sizeof(*mfpio)); + if (mfpio) { + mfpio->io = mfp_io; + mfp_setup(&mfpio->mfp); + } + } + return &mfpio->io; +} Index: apps/codecs/libsc68/io68/ym_dump.c =================================================================== --- apps/codecs/libsc68/io68/ym_dump.c (revision 0) +++ apps/codecs/libsc68/io68/ym_dump.c (revision 0) @@ -0,0 +1,185 @@ +/* + * sc68 - YM-2149 dump engine + * Copyright (C) 2001-2009 Ben(jamin) Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id: ym_puls.c 102 2009-03-14 17:21:58Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#ifdef HAVE_CONFIG_OPTION68_H +# include +#else +# include "default_option68.h" +#endif + + +#include "ymemul.h" + +#if defined(INCLUDE_SHARED68) +#include "file68/msg68.h" +#include "file68/string68.h" +#include "file68/option68.h" +#endif + +static int reset(ym_t * const ym, const cycle68_t ymcycle) +{ + ym_dump_t * const dump = &ym->emu.dump; + dump->base_cycle = 0; + dump->pass = 0; + return 0; +} + +static ym_waccess_t * advance_list( ym_waccess_t * regs[] ) +{ + int j, i; + ym_waccess_t * w = 0; + + for ( i = 0, j = -1; i < 3; ++i ) { + if ( ! regs[i] ) continue; + if ( j < 0 || regs[i]->ymcycle < regs[j]->ymcycle ) { + j = i; + } + } + + if ( j >= 0 ) { + w = regs[j]; + regs[j] = w->link; + } + + return w; +} + +static +int buffersize(const ym_t const * ym, const cycle68_t ymcycles) +{ + return ymcycles * ym->hz / ym->clock; +} + +#define CYCLE_DIGITS 10 +#define PASS_DIGITS 6 + +static +int run(ym_t * const ym, s32 * output, const cycle68_t ymcycles) +{ + static const char hex[16] = { + '0','1','2','3','4','5','6','7', + '8','9','A','B','C','D','E','F' + }; + + ym_dump_t * const dump = &ym->emu.dump; + cycle68_t curcycle; + u64 longcycle; + int i, len, ymreg[16]; + + char tmp [128], * buf; + ym_waccess_t * ptr, * regs[3]; + + regs[0] = ym->ton_regs.head; + regs[1] = ym->noi_regs.head; + regs[2] = ym->env_regs.head; + + for ( i = 0; i < 16; ++i ) ymreg[i] = -1; + + ptr = advance_list(regs); + while (ptr) { + curcycle = ptr->ymcycle; + longcycle = dump->base_cycle + (u64) curcycle; + + /* Get all entry at this cycle */ + while (ptr && ptr->ymcycle == curcycle) { + ymreg[ ptr->reg & 15 ] = ptr->val & 255; + ptr = advance_list(regs); + } + + buf = tmp; + + /* dump pass number */ + for ( i = (PASS_DIGITS-1)*4; i >= 0; i -= 4) { + *buf++ = hex [ 15 & (int)(dump->pass >> i) ]; + } + *buf++ = ' '; + + /* dump cycle number */ + for ( i = (CYCLE_DIGITS-1)*4; i >= 0; i -= 4) { + *buf++ = hex [ 15 & (int)(longcycle >> i) ]; + } + /* dump register list */ + for ( i = 0; i < 14; ++i ) { + *buf++ = (!i) ? ' ' : '-'; + if (ymreg[i] < 0){ + *buf++ = '.'; + *buf++ = '.'; + } else { + *buf++ = hex[ ymreg[i] >> 4 ]; + *buf++ = hex[ ymreg[i] & 15 ]; + } + ymreg[i] = -1; + } + *buf++ = 0; +#if !defined(ROCKBOX) + puts(tmp); +#endif + } + + /* Reset write lists */ + ym->ton_regs.head = ym->ton_regs.tail = 0; + ym->noi_regs.head = ym->noi_regs.tail = 0; + ym->env_regs.head = ym->env_regs.tail = 0; + ym->waccess_nxt = ym->waccess; + + /* null terminated string and align to 32-bit */ + dump->base_cycle += (uint64_t) ymcycles; + dump->pass++; + + len = buffersize(ym, ymcycles); + + for (i=0; iemu.dump; + int err = 0; + + /* fill callback functions */ + ym->cb_cleanup = cleanup; + ym->cb_reset = reset; + ym->cb_run = run; + ym->cb_buffersize = buffersize; + ym->cb_sampling_rate = (void*)0; + dump->base_cycle = 0; + + return err; +} Index: apps/codecs/libsc68/io68/mfpemul.h =================================================================== --- apps/codecs/libsc68/io68/mfpemul.h (revision 0) +++ apps/codecs/libsc68/io68/mfpemul.h (revision 0) @@ -0,0 +1,368 @@ +/** + * @ingroup io68_mfp_devel + * @file io68/mfpemul.h + * @author Benjamin Gerard + * @date 1999/03/20 + * @brief MFP-68901 emulator header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_MFPEMUL_H_ +#define _IO68_MFPEMUL_H + +#include "io68_api.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/struct68.h" +#endif + +/** @defgroup io68_mfp_devel MFP-68901 emulator + * @ingroup io68_devel + * @brief MFP-68901 (Atari-ST timers) emulator. + * + * Motorola Multi Function Peripheral is a multi purpose IO chip: + * - 8 bit parallele port. + * - Each bit has indepedant direction + * - Each bit can be a interruption source + * - 16 interruption sources + * - 4 universal timers (most part of this emulator) + * - Integrated serial interface. + * - 24 registers + * + * @p Registers + * + * - 00 @b GPIP (General Purpose I/O Interrupt port): + * + * Data Register for the 8 bit port for reading or writing. + * - bit#0 : Centronics (parrallele port) + * - bit#1 : Rs232 carrier detection + * - bit#1 : Rs232 CTS (clear to send) + * - bit#3 : Blitter + * - bit#4 : MIDI/Keyboard irq + * - bit#5 : FDC/DMA interrupt + * - bit#6 : Rs232 ring + * - bit#7 : Monochorm monitor detect + * + * - 01 @b AER (Active Edge Register): + * + * If port's bit are an interruption source this register + * selects interruption direction (0:descending 1:ascending). + * + * - 02 @b DDR (Data Direction Register): + * + * Port's bit direction select. 0 => input / 1 => output. + * + * - 03 @b IERA (Interrupt Enable Register A) + * - 04 @b IERB (Interrupt Enable Register B) + * + * Control the 16 interrupt source. 0 => Disable / 1 => Enable. + * - iera bit#7 : bit 7 of I/O port (highest priority) + * - iera bit#6 : bit 6 of I/O port + * - iera bit#5 : Timer A + * - iera bit#4 : Receive Buffer Full + * - iera bit#3 : Receive Error + * - iera bit#2 : Send Buffer Empty + * - iera bit#1 : Send Error + * - iera bit#0 : Timer B + * - ierb bit#7 : bit 5 of I/O port + * - ierb bit#6 : bit 4 of I/O port + * - ierb bit#5 : Timer C + * - ierb bit#4 : Timer D + * - ierb bit#3 : bit 3 of I/O port + * - ierb bit#2 : bit 2 of I/O port + * - ierb bit#1 : bit 1 of I/O port + * - ierb bit#0 : bit 0 of I/O port (lowest priority) + * + * - 05 @b IPRA (Interrupt Pending Register A) + * - 06 @b IPRB (Interrupt Pending Register B) + * + * Bit is set if an interruption occurs. Interruption have to + * be enable (see IER). If the MFP can produce an interruption + * vector the bit is cleared automatically at this moment. In + * the contrary the bit should be clear by writing this + * register (~1<map[n] << 16 ) + ( mw->map[n+2] << 8 ) + mw->map[n+4] ) + << mw->ct_fix; +} + +static inline +void mw_counter_write(mw_t * const mw, const int n, const mwct_t v) +{ + uint_t vnorm = v >> mw->ct_fix; + mw->map[n+0] = vnorm >> 16; + mw->map[n+2] = vnorm >> 8; + mw->map[n+4] = vnorm; +} + +/** @name Microwire emulator functions + * @{ + */ + +IO68_EXTERN +/** Microwire emulator setup. + * + * The mw_init() function must be call before any other + * function. It mainly setups internal tables. + * + * @return error-code + * @retval 0 on success + * @retval -1 on error (should never happen) + * + * @see mw_shutdown() + */ +int mw_init(int * argc,char ** argv); + +IO68_EXTERN +/** Microwire emulator shutdown. + * + * @see mw_init() + */ +void mw_shutdown(void); + +IO68_EXTERN +/** Setup microwire instance. + * + * @param mw microwire instance + * @param setup setup configuration + * @return error status + * @retval 0 on success + * @retval -1 on error + */ +int mw_setup(mw_t * const mw, mw_setup_t * const setup); + +IO68_EXTERN +/** Cleanup microwire instance. */ +void mw_cleanup(mw_t * const mw); + +IO68_EXTERN +/** Set/Get microwire sampling rate. + * + * The mw_sampling_rate() function set microwire emulator sampling + * rate. + * + * @param mw microwire instance (0 for set or get library default) + * @param hz @ref mw_hz_e "sampling rate" + * @return @ref mw_hz_e "sampling rate" + */ +int mw_sampling_rate(mw_t * const mw, int hz); + +IO68_EXTERN +/** Set/Get microwire emulator engine. + * @param mw microwire instance (0 for set or get library default) + * @param engine @ref mw_engine_e "engine descriptor" + * @return @ref mw_engine_e "engine descriptor" + */ +int mw_engine(mw_t * const mw, int engine); + +IO68_EXTERN +/** Microwire reset. + * + * The mw_reset() reset function restore the chip on to its default + * configuation or what it is believed to be. + * + * @param mw microwire instance + * @return error status (always success) + * @retval 0 on success + * @retval -1 on error + */ +int mw_reset(mw_t * const mw); + +IO68_EXTERN +/** Execute microwire emulation. + * + * The mw_mix() function processes sample mixing with current internal + * parameters for n samples. Mixed samples are stored in a large enough + * (at least n) 32 bit buffer pointed by b. This buffer have to be + * previously filled with the YM-2149 samples. Typically it is the YM-2149 + * emulator output buffer. This allows Microwire emulator to honnor the + * LMC mixer mode.iven LMC mode. This porocess include the mono to stereo + * expansion. The mem68 starting pointer locates the 68K memory buffer + * where samples are stored to allow DMA fetch emulation. + * + * @param out Pointer to YM-2149 source sample directly used for + * Microwire output mixing. + * @param mem68 Pointer to 68K memory buffer start address + * @param n Number of sample to mix in out buffer + * + * @see YM_mix() @see YM_get_buffer() + */ +void mw_mix(mw_t * const mw, s32 * out, int n); + +/** @} */ + + +/** @name Microwire LMC functions + * @{ + */ + + +IO68_EXTERN +/** Set/Get LMC mixer mode. + * + * The mw_lmc_mixer() function selects or retrieves the function + * used by the chip to blend the YM-2149 signal and the digital + * signal produce by microwire chip. + * + * @param mw microwire instance + * @param mode @ref mw_mixer_e "mixer mode" + * @return @ref mw_mixer_e "mixer mode" + */ +int mw_lmc_mixer(mw_t * const mw, int mode); + +IO68_EXTERN +/** Set/Get LMC master volume. + * + * @param mw microwire instance + * @param n @ref mw_lmc_e "volume" in range [0..40] for [-80..0] dB + * @return master @ref mw_lmc_e "volume" + * + * @see mw_lmc_left() + * @see mw_lmc_right() + */ +int mw_lmc_master(mw_t * const mw, int n); + +IO68_EXTERN +/** Set/Get LMC left channel volume. + * + * @param mw microwire instance + * @param n @ref mw_lmc_e "volume" in range [0..20] for [-40..0] dB + * @return left @ref mw_lmc_e "volume" + * + * @see mw_lmc_master() + * @see mw_lmc_right() + */ +int mw_lmc_left(mw_t * const mw, int n); + +IO68_EXTERN +/** Set/Get LMC right channel volume. + * + * @param mw microwire instance + * @param n @ref mw_lmc_e "volume" in range [0..20] for [-40..0] dB + * @return right @ref mw_lmc_e "volume" + * + * @see mw_lmc_master() + * @see mw_lmc_left() + */ +int mw_lmc_right(mw_t * const mw, int n); + +IO68_EXTERN +/** Set/Get high pass filter. + * + * @param mw microwire instance + * @param n @mw_lmc_e "high pass filter" in range [0..12] for [-12..0] dB + * @return @mw_lmc_e "high pass filter" + * + * @see mw_lmc_low() + * @warning Filters are not supported by this microwire emulator. + */ +int mw_lmc_high(mw_t * const mw, int n); + +IO68_EXTERN +/** Set/Get low pass filter. + * + * @param mw microwire instance + * @param n @mw_lmc_e "low pass filter" in range [0..12] for [-12..0] dB + * @return @mw_lmc_e "low pass filter" + * + * @see mw_lmc_high() + * @warning Filters are not supported by this microwire emulator. + */ +int mw_lmc_low(mw_t * const mw,int n); + +IO68_EXTERN +/** Parse and execute a microwire command. + * + * @param mw microwire instance + * @retval 0 on success (a command was found) + * @retval -1 on error + * + */ +int mw_command(mw_t * const mw); + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _MWEMUL_H_*/ Index: apps/codecs/libsc68/io68/ymemul.h =================================================================== --- apps/codecs/libsc68/io68/ymemul.h (revision 0) +++ apps/codecs/libsc68/io68/ymemul.h (revision 0) @@ -0,0 +1,491 @@ +/** + * @ingroup io68_ym_devel + * @file io68/ymemul.h + * @author Benjamin Gerard + * @date 1998/06/24 + * @brief YM-2149 emulator header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_YM_EMUL_H_ +#define _IO68_YM_EMUL_H_ + +#include "io68_api.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/emu68.h" +#endif + +/* Need these defines in ymemul.c and ym_puls.c */ +#define YM_OUT_MSK_A 0x001F +#define YM_OUT_MSK_B 0x03E0 +#define YM_OUT_MSK_C 0x7C00 +#define YM_OUT_MSK_ALL 0x7FFF + +/** @defgroup io68_ym_devel YM-2149 emulator + * @ingroup io68_devel + * + * The YM-2149 (Atari-ST soundchip) emulator. + * + * @{ + */ + + +/** @name YM-2149 registers. + * @{ + */ +#define YM_BASEPERL 0 /**< YM-2149 LSB period base (chan A). */ +#define YM_BASEPERH 1 /**< YM-2149 MSB period base (chan A). */ +#define YM_BASEVOL 8 /**< YM-2149 volume base register (chan A). */ +#define YM_NOISE 6 /**< Noise period. */ +#define YM_MIXER 7 /**< Mixer control. */ +#define YM_ENVL 11 /**< Volume envelop LSB period. */ +#define YM_ENVH 12 /**< Volume envelop MSB period. */ +#define YM_ENVTYPE 13 /**< Volume envelop wave form. */ +#define YM_ENVSHAPE 13 /**< Alias for YM_ENVTYPE. */ +#define YM_PERL(N) (YM_BASEPERL+(N)*2) /**< Canal #N LSB period. */ +#define YM_PERH(N) (YM_BASEPERH+(N)*2) /**< Canal #N MSB period. */ +#define YM_VOL(N) (YM_BASEVOL+(N)) /**< Canal #N volume. */ +/** @} */ + + +/** @name YM-2149 internal register access. + * @{ + */ + +/** YM write access structure. */ +struct ym_waccess_s +{ + struct ym_waccess_s * link; /**< Link to prev or next entry. */ + cycle68_t ymcycle; /**< CPU cycle this access occurs. */ + u8 reg; /**< YM register to write into. */ + u8 val; /**< Value to write. */ +}; + +/** YM write access type. */ +typedef struct ym_waccess_s ym_waccess_t; + +/** Sorted list of YM write access. */ +typedef struct +{ + char name[4]; /**< Name (for debug). */ + ym_waccess_t * head; /**< First access in list. */ + ym_waccess_t * tail; /**< Last acces in list. */ +} ym_waccess_list_t; + +/** @} */ + +/** YM-2149 internal register mapping. */ +struct ym2149_reg_s { + /* 0 */ u8 per_a_lo; + /* 1 */ u8 per_a_hi; + /* 2 */ u8 per_b_lo; + /* 3 */ u8 per_b_hi; + /* 4 */ u8 per_c_lo; + /* 5 */ u8 per_c_hi; + /* 6 */ u8 per_noise; + /* 7 */ u8 ctl_mixer; + /* 8 */ u8 vol_a; + /* 9 */ u8 vol_b; + /* A */ u8 vol_c; + /* B */ u8 per_env_lo; + /* C */ u8 per_env_hi; + /* D */ u8 env_shape; + /* E */ u8 io_a; + /* F */ u8 io_b; +}; + +/** Access YM-2149 internal register by name or by index. */ +typedef union ym_reg_u { + struct ym2149_reg_s name; /* ym registers by name. */ + u8 index[16]; /* ym registers by index. */ +} ym_reg_t; + +/** Toggle table/calculated envelop emulation. */ +#ifndef YM_ENV_TABLE +# define YM_ENV_TABLE 1 +#endif + +/** YM-2149 emulation engines. */ +enum ym_engine_e { + YM_ENGINE_QUERY = -1, /**< Query current or default engine. */ + YM_ENGINE_DEFAULT = 0, /**< Use default mode. */ + YM_ENGINE_PULS, /**< sc68 original (pulse) emulation. */ + YM_ENGINE_BLEP, /**< Antti Lankila's Band Limited Step synthesis. */ + YM_ENGINE_DUMP /**< Dummy register dump. */ +}; + +/** YM-2149 volume models. */ +enum ym_vol_e { + YM_VOL_QUERY = -1, /**< Query current or default volume model. */ + YM_VOL_DEFAULT = 0, /**< Use default volume model. */ + YM_VOL_ATARIST, /**< Atari-ST volume table. */ + YM_VOL_LINEAR, /**< Linear mixing volume table. */ + YM_VOL_ATARIST_4BIT, /**< Atari-ST volume table (4bit). */ +}; + +/** Sampling rate. */ +enum ym_hz_e { + YM_HZ_QUERY = -1, /**< Query current or default sampling rate. */ + YM_HZ_DEFAULT = 0 /**< Default sampling rate. */ +}; + +/** YM master clock frequency. */ +enum ym_clock_e { + /** Query current or default master clock frequency. */ + YM_CLOCK_QUERY = 1, + /** Default master clock frequency. */ + YM_CLOCK_DEFAULT = 0, + /** Atari-ST YM-2149 master clock is about 2Mz. */ + YM_CLOCK_ATARIST = EMU68_ATARIST_CLOCK/4u, +}; + +/* struct ym_s; */ +typedef struct ym_s ym_t; + +#include "ym_puls.h" /* data structure for pulse ym emulator. */ +#include "ym_blep.h" /* data structure for blep ym emulator. */ +#include "ym_dump.h" /* data structure for dump ym emulator. */ + +struct ym_s { + + /** @name Interface + * @{ + */ + void (*cb_cleanup) (ym_t * const); + int (*cb_reset) (ym_t * const, const cycle68_t); + int (*cb_run) (ym_t * const, s32 *, const cycle68_t); + int (*cb_buffersize) (const ym_t const *, const cycle68_t); + int (*cb_sampling_rate) (ym_t * const, const int); + /** @} */ + + /** @name Internal YM registers + * @{ + */ + u8 ctrl; /**< Control (working) register. */ + ym_reg_t reg; /**< YM registers. */ + ym_reg_t shadow; /**< Shadow YM registers (for reading). */ + /** @} */ + + s16 * ymout5; /**< DAC lookup table */ + uint_t voice_mute; /**< Mask muted voices. */ + uint_t hz; /**< Sampling rate. */ + uint68_t clock; /**< Master clock frequency in Hz. */ + + /** @name Write access back storage. + * @{ + */ + ym_waccess_list_t env_regs; /**< envelop generator access list. */ + ym_waccess_list_t noi_regs; /**< noise generator access list. */ + ym_waccess_list_t ton_regs; /**< tone generator access list. */ + int waccess_max; /**< Maximum number of entry in waccess. */ + ym_waccess_t * waccess_nxt; /**< Next available ym_waccess_t. */ + ym_waccess_t * waccess; /**< Static register entry list. */ + /** @} */ + + /* $$$ TEMP: should be allocated... */ + ym_waccess_t static_waccess[2048]; + + /** @name Output + * @{ + */ + s32 * outbuf; /**< output buffer given to ym_run() */ + s32 * outptr; /**< generated sample pointer (into outbuf) */ + /** @} */ + + int engine; /**< @ref ym_engine_e "engine type". */ + int volmodel; /**< @ref ym_vol_e "volume model". */ + + /** Engine private data. */ + union emu_u { + ym_puls_t puls; /**< Original YM emulator data. */ + ym_blep_t blep; /**< BLEP YM emulator data. */ + ym_dump_t dump; /**< DUMP YM emulator data. */ + } emu; +}; + +/** YM-2149 setup structure. + * + * This structure is passed to the ym_init() and ym_setup() + * functions. The caller have to fill it with desired values before + * calling these functions. Each field can be set to a nul value in + * order to use the default value. The function will set the actual + * values before returning. + * + */ +typedef struct +{ + int engine; /**< @ref ym_engine_e "emulator engine". */ + int volmodel; /**< @ref ym_vol_e "volume model". */ + int clock; /**< @see ym_clock_e "master clock frequency". */ + int hz; /**< Sampling rate in Hz. */ +} ym_parms_t; + +/** @name Initialization functions + * @{ + */ + +IO68_EXTERN +/** Create an Yamaha-2149 emulator instance. + * + * @param ym + * @param params + * + * @return error-code + * @retval 0 Success + * @retval -1 Failure + * + * @see ym_destroy() + */ +int ym_setup(ym_t * const ym, ym_parms_t * const parms); + +IO68_EXTERN +/** Destroy an Yamaha-2149 emulator instance. + * + * @param ym ym emulator instance to destroy + */ +void ym_cleanup(ym_t * const ym); + +IO68_EXTERN +/** Perform an Yamaha-2149 hardware reset. + * + * The ym_reset() reset function perform a YM-2149 reset. It + * performs following operations : + * - all register zeroed + * - mixer is set to 077 (no sound and no noise) + * - envelop shape is set to 0xA (/\) + * - control register is set to 0 + * - internal periods counter are zeroed + * + * @param ym YM-2149 emulator instance. + * @param ymcycle ym cycle the reset has occured. + * + * @return error-code (always success) + * @retval 0 Success + * @retval -1 Failure + */ +int ym_reset(ym_t * const ym, const cycle68_t ymcycle); + +IO68_EXTERN +/** Yamaha-2149 first one first initialization. + * + * The ym_init() function must be call before any other ym_ + * function. If params is non nul then all non nul fields will be + * used as the new default value for this field at ym_setup() + * function call. + * + * @param params Default parameters for ym_setup(). + * + * @return error-code (always success) + * @retval 0 Success + * + * @see ym_reset() + */ +int ym_init(int * argc, char ** argv); + +IO68_EXTERN +/** Shutdown the ym-2149 library. + * + * The ym_shutdown() function should be call after all created ym + * emulator instances have been clean up. + * + */ +void ym_shutdown(void); + +/** @} */ + + +/** @name Emulation functions + * @{ + */ + +IO68_EXTERN +/** Execute Yamaha-2149 emulation. + * + * The ym_run() function execute Yamaha-2149 emulation for a given + * number of cycle. The output buffer + * + * @warning The requested output buffer size may seem larger than + * neccessary but it is not. Internally the emulator may need some + * extra place (for oversampling...). Always call ym_buffersize() + * to allocate this buffer large enougth. + * + * @param ym YM-2149 emulator instance. + * @param output Output sample buffer. + * @param ymcycles Number of cycle to mix. + * + * @return Number of sample in output mix-buffer + * @retval -1 Failure + * + * @see ym_buffersize() + */ +int ym_run(ym_t * const ym, s32 * output, const cycle68_t ymcycles); + + +IO68_EXTERN +/** Get required output buffer size. + * + * The ym_buffersize() function returns the minimum size in + * PCM(32bit) of the output buffer for generating ymcycles + * cycles. It should be use to ensure the buffer is large enough + * before calling ym_run() function. + * + * @param ym YM-2149 emulator instance. + * @param ymcycles Number of ym-cycles to generate + * + * @return Minimum size in PCM (32bit) of output buffer to generate + * ymcycles samples. + * + */ +uint68_t ym_buffersize(const ym_t const * ym, const cycle68_t ymcycles); + +IO68_EXTERN +/** Change YM cycle counter base. + * + * The ym_adjest() function allow to corrige the internal cycle + * counter to prevent overflow. Because the number of cycle could + * grow very quickly, it is neccessary to get it down from time to + * time. + * + * @param ym YM-2149 emulator instance. + * @param ymcycles Number of cpu cycle to substract to current the + * cycle counter. + * + */ +void ym_adjust_cycle(ym_t * const ym, const cycle68_t ymcycles); + +/** @} */ + + +/** @name YM-2149 register access functions + * @{ + */ + +IO68_EXTERN +/** Write in YM-2149 register. + * + * The ym_writereg() function performs a write access to an YM-2149 + * internal register. The YM-2149 emulator does not really write + * register but store changes in separate list depending of the + * register nature and dependencies. There are 3 lists of update + * (sound, noise and envelop). This method allow to perform a very + * efficient cycle precise emulation. For this reason the YM-2149 + * registers should be read by ym_readreg() function. + * + * @param ym YM-2149 emulator instance. + * @param val Value to write. + * @param ymcycle YM cycle this access has occurred. + * + * @see ym_readreg(); + */ +void ym_writereg(ym_t * const ym, const int val, const cycle68_t ymcycle); + + +static inline +/** Read a YM-2119 register. + * + * The ym_readreg() function must be call to read an YM-2149 + * register. For the reasons explained in YM_writereg(), register + * must not be read directly. + * + * @param ym YM-2149 emulator instance. + * @param ymcycle CPU cycle number this access has occurred. + * + * @return Register value at given cycle + * + * @see ym_writereg(); + */ +int ym_readreg(ym_t * const ym, const cycle68_t ymcycle) +{ + const int reg = ym->ctrl; + return (reg>=0 && reg<16) + ? ym->shadow.index[reg] + : 0; +} + +/** @} */ + + +/** @name YM-2149 emulator configuration functions. + * @{ + */ + +IO68_EXTERN +/** Get/Set active channels status. + * + * The ym_active_channels() function allows to activate/desactivate + * separarely channels (voices) of the YM-2149. + * + * For both on and off parameters: + * -bit#0: canal A (0:no change 1:change to on or off) + * -bit#1: canal B (0:no change 1:change to on or off) + * -bit#2: canal C (0:no change 1:change to on or off) + * + * How it works: + * + * The ym_active_channels() function performs off parameter before on + * parameter. The formula looks like ``result=(current&^off)|on''. + * + * How to use: + * + * -Get current value : ym_active_channels(ym,0,0); + * -Mute all channels : ym_active_channels(ym,7,0); + * -Active all channels : ym_active_channels(ym,0,7); + * -Active some channel channels : ym_active_channels(ym,0,x); + * + * @param ym YM-2149 emulator instance + * @param off Mute the channels for bit set to 1 + * @param on Active the channels for bit set to 1 + * + * @return new active-voices status + * @retval -1 Failure + * @retval 0 All voice muted + * @retval 1 Only channel A + * @retval 7 all channels active + * + */ +int ym_active_channels(ym_t * const ym, const int off, const int on); + +IO68_EXTERN +/** Set/Get configuration. + */ +int ym_configure(ym_t * const ym, ym_parms_t * const parms); + +IO68_EXTERN +/** Get/Set sampling rate. + * + * @param ym YM-2149 emulator instance + * @param hz frequency in hz or @ref ym_hz_e "special values". + * + * @return Actual sampling rate (may differs from requested). + * @retval -1 on error + */ +int ym_sampling_rate(ym_t * const ym, const int hz); + +IO68_EXTERN +/** Set or get Yamaha-2149 emulator engine. + * + * @param engine @ref ym_engine_e "special values" + * @return @ref ym_engine_e "engine value". + * @retval -1 on error + */ +int ym_engine(ym_t * const ym, int engine); + +IO68_EXTERN +int ym_volume_model(ym_t * const ym, int model); + +IO68_EXTERN +int ym_clock(ym_t * const ym, int clock); + + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _IO68_YM_EMUL_H_ */ Index: apps/codecs/libsc68/io68/mfp_io.h =================================================================== --- apps/codecs/libsc68/io68/mfp_io.h (revision 0) +++ apps/codecs/libsc68/io68/mfp_io.h (revision 0) @@ -0,0 +1,49 @@ +/** + * @ingroup io68_mfp_devel + * @file io68/mfp_io.h + * @author Benjamin Gerard + * @date 1999/03/20 + * @brief MFP-68901 IO plugin header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_MFP_IO_H_ +#define _IO68_MFP_IO_H_ + +#include "io68_api.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/struct68.h" +#endif + +/** @addtogroup io68_mfp_devel + * @{ + */ + +/** @name MFP-68901 (Atari-ST timers) IO plugin + * @{ + */ + +IO68_EXTERN +/** Initialize MFP IO library. */ +int mfpio_init(int * argc, char ** argv); + +IO68_EXTERN +/** Shutdown MFP IO library. */ +void mfpio_shutdown(void); + +IO68_EXTERN +/** MFP-68901 IO plugin instance. */ +io68_t * mfpio_create(emu68_t * const emu68); + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _IO68_MFP_IO_H_ */ Index: apps/codecs/libsc68/io68/ym_dump.h =================================================================== --- apps/codecs/libsc68/io68/ym_dump.h (revision 0) +++ apps/codecs/libsc68/io68/ym_dump.h (revision 0) @@ -0,0 +1,32 @@ +/** + * @ingroup emu68_devel + * @file emu68/ym_dump.h + * @author Benjamin Gerard + * @date 2009/02/10 + * @brief sc68 register dump YM-2149 emulator header. + * + */ + +IO68_EXTERN +/** Setup function for sc68 dump ym engine. + * + * The ym_dump_setup() function sets ym dump engine for this ym + * emulator instance. + * + * @parm ym ym emulator instance to setup + * @retval 0 on success + * @retval -1 on failure + */ +int ym_dump_setup(ym_t * const ym); + +typedef void (*ym_dump_filter_t)(ym_t * const); + +/** YM-2149 internal data structure for original emulator. */ +struct ym2149_dump_s +{ + uint64_t base_cycle; + uint68_t pass; +}; + +/** YM-2149 emulator instance type */ +typedef struct ym2149_dump_s ym_dump_t; Index: apps/codecs/libsc68/io68/ym_atarist_table.c =================================================================== --- apps/codecs/libsc68/io68/ym_atarist_table.c (revision 0) +++ apps/codecs/libsc68/io68/ym_atarist_table.c (revision 0) @@ -0,0 +1,95 @@ +/* + * sc68 - YM-2149 emulator - Atari ST Volume Table + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +/* Table of 4 bit D/A output level for 1 channel.*/ +static const u16 volumetable_original[32 * 32 * 32] = +# include "ymout2k9.h" + ; + +/* Create a non-linear 3 channels 5 bit per channels DAC table. + */ +static void +create_table(s16 * out, uint_t level, const char * name) +{ + int h; + + if (!level) { + for (h=0; h<32*32*32; ++h) { + out[h] = 0; + } + } else { + for (h=0; h<32*32*32; ++h) { + out[h] = volumetable_original[h]; + } + } + + if (level) { + const int min = ((u16*)out)[0x0000]; + const int max = ((u16*)out)[0x7fff]; + const int div = max-min ? max-min : 1; + const int mid = ( level + 1 ) >> 1; + + msg68(ym_cat, + "ym-2149: creating %s -- min:%d max:%d div:%d mid:%d\n", + name, min, max, div, mid); + + assert(level < 65536u); + assert(max > min); + + for (h=0; h<32*32*32; ++h) { + int tmp = ((u16*)out)[h], res; + assert(tmp >= min); + assert(tmp <= max); + + if (tmp < min || tmp > max) { + msg68_critical + ("ym-2149: volume model -- *%s* -- %d out of range [%d..%d]\n", + name, tmp, min, max); + } + + res = (tmp-min) * level / div - mid; + out[h] = res; + + TRACE68(ym_cat, + "ym-2149: -- %s -- %02x %02x %02x -- %d\n", + name, h&31, (h>>5)&31, (h>>10)&31, res); + } + } + msg68_info("ym-2149: volume model -- *%s* -- [%d..%d]\n", + name, out[0], out[0x7FFF]); +} + +/* Create a non-linear 3 channels 5 bit per channels DAC table. + */ +void ym_create_5bit_atarist_table(s16 * out, unsigned int level) +{ + create_table(out, level,"atarist-5bit-2k9"); +} + +/* Create a non-linear 3 channels 4 bit per channels DAC table. + */ +void ym_create_4bit_atarist_table(s16 * out, unsigned int level) +{ + create_table(out, level,"atarist-4bit"); +} + Index: apps/codecs/libsc68/io68/ym_fixed_vol.h =================================================================== --- apps/codecs/libsc68/io68/ym_fixed_vol.h (revision 0) +++ apps/codecs/libsc68/io68/ym_fixed_vol.h (revision 0) @@ -0,0 +1,306 @@ +{ + +/* 000 */ + +/*000*/ 0, 110, 230, 355, 582, 801, 1227, 1701, 2471, 3403, 5071, 6940,10426,14762,23799,36754, +/*010*/ 110, 258, 400, 536, 752, 980, 1397, 1843, 2645, 3574, 5207, 7082,10560,14873,23862,36757, +/*020*/ 230, 400, 528, 667, 880, 1108, 1531, 1977, 2770, 3690, 5327, 7199,10671,14972,23916,36760, +/*030*/ 355, 536, 667, 806, 1002, 1244, 1664, 2105, 2897, 3812, 5446, 7318,10776,15051,23970,36777, +/*040*/ 582, 752, 880, 1002, 1221, 1457, 1866, 2304, 3099, 4011, 5639, 7497,10935,15202,24061,36780, +/*050*/ 801, 980, 1108, 1244, 1457, 1684, 2093, 2539, 3324, 4224, 5849, 7707,11119,15378,24160,36797, +/*060*/ 1227, 1397, 1531, 1664, 1866, 2093, 2505, 2943, 3707, 4616, 6230, 8062,11458,15668,24342,36803, +/*070*/ 1701, 1843, 1977, 2105, 2304, 2539, 2943, 3369, 4133, 5037, 6628, 8452,11824,15992,24589,36828, +/*080*/ 2471, 2645, 2770, 2897, 3099, 3324, 3707, 4133, 4903, 5775, 7344, 9153,12489,16606,25032,36891, +/*090*/ 3403, 3574, 3690, 3812, 4011, 4224, 4616, 5037, 5775, 6639, 8193, 9972,13256,17330,25603,37047, +/*0A0*/ 5071, 5207, 5327, 5446, 5639, 5849, 6230, 6628, 7344, 8193, 9705,11446,14659,18648,26743,37567, +/*0B0*/ 6940, 7082, 7199, 7318, 7497, 7707, 8062, 8452, 9153, 9972,11446,13142,16293,20231,28118,38445, +/*0C0*/ 10426,10560,10671,10776,10935,11119,11458,11824,12489,13256,14659,16293,19381,23208,30893,40473, +/*0D0*/ 14762,14873,14972,15051,15202,15378,15668,15992,16606,17330,18648,20231,23208,26964,34385,43346, +/*0E0*/ 23799,23862,23916,23970,24061,24160,24342,24589,25032,25603,26743,28118,30893,34385,41133,49230, +/*0F0*/ 36754,36757,36760,36777,36780,36797,36803,36828,36891,37047,37567,38445,40473,43346,49230,56457, + +/* 100 */ + +/*100*/ 110, 258, 400, 536, 752, 980, 1397, 1843, 2645, 3574, 5207, 7082,10560,14873,23862,36757, +/*110*/ 258, 414, 551, 681, 894, 1127, 1545, 1991, 2787, 3704, 5341, 7213,10679,14975,23918,36760, +/*120*/ 400, 551, 684, 821, 1034, 1264, 1681, 2125, 2914, 3835, 5466, 7335,10787,15071,23975,36766, +/*130*/ 536, 681, 821, 957, 1161, 1397, 1812, 2255, 3042, 3960, 5588, 7449,10889,15159,24021,36786, +/*140*/ 752, 894, 1034, 1161, 1372, 1608, 2017, 2457, 3244, 4153, 5773, 7628,11057,15307,24109,36789, +/*150*/ 980, 1127, 1264, 1397, 1608, 1838, 2244, 2684, 3466, 4369, 5986, 7835,11244,15475,24214,36800, +/*160*/ 1397, 1545, 1681, 1812, 2017, 2244, 2650, 3085, 3855, 4755, 6361, 8193,11574,15770,24401,36806, +/*170*/ 1843, 1991, 2125, 2255, 2457, 2684, 3085, 3517, 4281, 5173, 6761, 8577,11941,16097,24634,36831, +/*180*/ 2645, 2787, 2914, 3042, 3244, 3466, 3855, 4281, 5037, 5912, 7477, 9276,12594,16696,25080,36896, +/*190*/ 3574, 3704, 3835, 3960, 4153, 4369, 4755, 5173, 5912, 6773, 8318,10088,13361,17415,25637,37056, +/*1A0*/ 5207, 5341, 5466, 5588, 5773, 5986, 6361, 6761, 7477, 8318, 9824,11554,14759,18731,26768,37570, +/*1B0*/ 7082, 7213, 7335, 7449, 7628, 7835, 8193, 8577, 9276,10088,11554,13245,16384,20290,28157,38448, +/*1C0*/ 10560,10679,10787,10889,11057,11244,11574,11941,12594,13361,14759,16384,19447,23254,30899,40476, +/*1D0*/ 14873,14975,15071,15159,15307,15475,15770,16097,16696,17415,18731,20290,23254,26995,34385,43346, +/*1E0*/ 23862,23918,23975,24021,24109,24214,24401,24634,25080,25637,26768,28157,30899,34385,41135,49232, +/*1F0*/ 36757,36760,36766,36786,36789,36800,36806,36831,36896,37056,37570,38448,40476,43346,49232,56460, + +/* 200 */ + +/*200*/ 230, 400, 528, 667, 880, 1108, 1531, 1977, 2770, 3690, 5327, 7199,10671,14972,23916,36760, +/*210*/ 400, 551, 684, 821, 1034, 1264, 1681, 2125, 2914, 3835, 5466, 7335,10787,15071,23975,36766, +/*220*/ 528, 684, 832, 965, 1179, 1412, 1823, 2267, 3054, 3971, 5596, 7463,10901,15171,24026,36780, +/*230*/ 667, 821, 965, 1105, 1312, 1548, 1960, 2403, 3184, 4099, 5721, 7579,11006,15265,24075,36791, +/*240*/ 880, 1034, 1179, 1312, 1519, 1755, 2164, 2602, 3383, 4290, 5906, 7756,11173,15407,24160,36794, +/*250*/ 1108, 1264, 1412, 1548, 1755, 1983, 2392, 2829, 3608, 4508, 6119, 7960,11361,15571,24265,36803, +/*260*/ 1531, 1681, 1823, 1960, 2164, 2392, 2792, 3227, 4000, 4892, 6489, 8318,11688,15870,24455,36808, +/*270*/ 1977, 2125, 2267, 2403, 2602, 2829, 3227, 3659, 4420, 5307, 6892, 8702,12051,16196,24683,36837, +/*280*/ 2770, 2914, 3054, 3184, 3383, 3608, 4000, 4420, 5170, 6045, 7605, 9395,12699,16787,25123,36908, +/*290*/ 3690, 3835, 3971, 4099, 4290, 4508, 4892, 5307, 6045, 6900, 8440,10205,13463,17501,25683,37064, +/*2A0*/ 5327, 5466, 5596, 5721, 5906, 6119, 6489, 6892, 7605, 8440, 9940,11662,14855,18810,26799,37576, +/*2B0*/ 7199, 7335, 7463, 7579, 7756, 7960, 8318, 8702, 9395,10205,11662,13344,16475,20359,28183,38451, +/*2C0*/ 10671,10787,10901,11006,11173,11361,11688,12051,12699,13463,14855,16475,19512,23305,30913,40479, +/*2D0*/ 14972,15071,15171,15265,15407,15571,15870,16196,16787,17501,18810,20359,23305,27018,34391,43349, +/*2E0*/ 23916,23975,24026,24075,24160,24265,24455,24683,25123,25683,26799,28183,30913,34391,41138,49235, +/*2F0*/ 36760,36766,36780,36791,36794,36803,36808,36837,36908,37064,37576,38451,40479,43349,49235,56463, + +/* 300 */ + +/*300*/ 355, 536, 667, 806, 1002, 1244, 1664, 2105, 2897, 3812, 5446, 7318,10776,15051,23970,36777, +/*310*/ 536, 681, 821, 957, 1161, 1397, 1812, 2255, 3042, 3960, 5588, 7449,10889,15159,24021,36786, +/*320*/ 667, 821, 965, 1105, 1312, 1548, 1960, 2403, 3184, 4099, 5721, 7579,11006,15265,24075,36791, +/*330*/ 806, 957, 1105, 1261, 1468, 1701, 2110, 2554, 3332, 4241, 5861, 7713,11128,15373,24137,36794, +/*340*/ 1002, 1161, 1312, 1468, 1670, 1906, 2312, 2750, 3528, 4432, 6042, 7889,11290,15512,24220,36797, +/*350*/ 1244, 1397, 1548, 1701, 1906, 2136, 2542, 2980, 3755, 4653, 6258, 8094,11480,15679,24322,36806, +/*360*/ 1664, 1812, 1960, 2110, 2312, 2542, 2940, 3378, 4145, 5034, 6622, 8446,11807,15972,24509,36814, +/*370*/ 2105, 2255, 2403, 2554, 2750, 2980, 3378, 3804, 4565, 5449, 7025, 8832,12168,16293,24737,36840, +/*380*/ 2897, 3042, 3184, 3332, 3528, 3755, 4145, 4565, 5312, 6182, 7736, 9517,12810,16884,25174,36916, +/*390*/ 3812, 3960, 4099, 4241, 4432, 4653, 5034, 5449, 6182, 7034, 8565,10324,13571,17589,25737,37067, +/*3A0*/ 5446, 5588, 5721, 5861, 6042, 6258, 6622, 7025, 7736, 8565,10060,11776,14955,18890,26839,37587, +/*3B0*/ 7318, 7449, 7579, 7713, 7889, 8094, 8446, 8832, 9517,10324,11776,13452,16566,20435,28206,38453, +/*3C0*/ 10776,10889,11006,11128,11290,11480,11807,12168,12810,13571,14955,16566,19583,23362,30927,40482, +/*3D0*/ 15051,15159,15265,15373,15512,15679,15972,16293,16884,17589,18890,20435,23362,27047,34399,43349, +/*3E0*/ 23970,24021,24075,24137,24220,24322,24509,24737,25174,25737,26839,28206,30927,34399,41141,49238, +/*3F0*/ 36777,36786,36791,36794,36797,36806,36814,36840,36916,37067,37587,38453,40482,43349,49238,56471, + +/* 400 */ + +/*400*/ 582, 752, 880, 1002, 1221, 1457, 1866, 2304, 3099, 4011, 5639, 7497,10935,15202,24061,36780, +/*410*/ 752, 894, 1034, 1161, 1372, 1608, 2017, 2457, 3244, 4153, 5773, 7628,11057,15307,24109,36789, +/*420*/ 880, 1034, 1179, 1312, 1519, 1755, 2164, 2602, 3383, 4290, 5906, 7756,11173,15407,24160,36794, +/*430*/ 1002, 1161, 1312, 1468, 1670, 1906, 2312, 2750, 3528, 4432, 6042, 7889,11290,15512,24220,36797, +/*440*/ 1221, 1372, 1519, 1670, 1860, 2096, 2500, 2940, 3713, 4613, 6216, 8060,11443,15648,24299,36806, +/*450*/ 1457, 1608, 1755, 1906, 2096, 2341, 2741, 3176, 3949, 4844, 6440, 8270,11639,15821,24407,36811, +/*460*/ 1866, 2017, 2164, 2312, 2500, 2741, 3133, 3571, 4332, 5216, 6801, 8616,11963,16103,24589,36823, +/*470*/ 2304, 2457, 2602, 2750, 2940, 3176, 3571, 3997, 4753, 5633, 7202, 9003,12321,16427,24813,36845, +/*480*/ 3099, 3244, 3383, 3528, 3713, 3949, 4332, 4753, 5497, 6361, 7909, 9685,12960,17012,25248,36925, +/*490*/ 4011, 4153, 4290, 4432, 4613, 4844, 5216, 5633, 6361, 7213, 8733,10483,13716,17711,25799,37075, +/*4A0*/ 5639, 5773, 5906, 6042, 6216, 6440, 6801, 7202, 7909, 8733,10219,11926,15088,19001,26885,37598, +/*4B0*/ 7497, 7628, 7756, 7889, 8060, 8270, 8616, 9003, 9685,10483,11926,13597,16688,20532,28254,38459, +/*4C0*/ 10935,11057,11173,11290,11443,11639,11963,12321,12960,13716,15088,16688,19688,23438,30944,40490, +/*4D0*/ 15202,15307,15407,15512,15648,15821,16103,16427,17012,17711,19001,20532,23438,27100,34413,43351, +/*4E0*/ 24061,24109,24160,24220,24299,24407,24589,24813,25248,25799,26885,28254,30944,34413,41147,49241, +/*4F0*/ 36780,36789,36794,36797,36806,36811,36823,36845,36925,37075,37598,38459,40490,43351,49241,56477, + +/* 500 */ + +/*500*/ 801, 980, 1108, 1244, 1457, 1684, 2093, 2539, 3324, 4224, 5849, 7707,11119,15378,24160,36797, +/*510*/ 980, 1127, 1264, 1397, 1608, 1838, 2244, 2684, 3466, 4369, 5986, 7835,11244,15475,24214,36800, +/*520*/ 1108, 1264, 1412, 1548, 1755, 1983, 2392, 2829, 3608, 4508, 6119, 7960,11361,15571,24265,36803, +/*530*/ 1244, 1397, 1548, 1701, 1906, 2136, 2542, 2980, 3755, 4653, 6258, 8094,11480,15679,24322,36806, +/*540*/ 1457, 1608, 1755, 1906, 2096, 2341, 2741, 3176, 3949, 4844, 6440, 8270,11639,15821,24407,36811, +/*550*/ 1684, 1838, 1983, 2136, 2341, 2616, 3008, 3446, 4210, 5099, 6687, 8506,11858,16009,24529,36820, +/*560*/ 2093, 2244, 2392, 2542, 2741, 3008, 3389, 3826, 4582, 5463, 7040, 8844,12171,16285,24700,36831, +/*570*/ 2539, 2684, 2829, 2980, 3176, 3446, 3826, 4258, 5011, 5883, 7443, 9233,12531,16611,24924,36854, +/*580*/ 3324, 3466, 3608, 3755, 3949, 4210, 4582, 5011, 5744, 6608, 8145, 9909,13162,17185,25353,36936, +/*590*/ 4224, 4369, 4508, 4653, 4844, 5099, 5463, 5883, 6608, 7449, 8963,10705,13915,17878,25890,37087, +/*5A0*/ 5849, 5986, 6119, 6258, 6440, 6687, 7040, 7443, 8145, 8963,10438,12134,15273,19157,26961,37607, +/*5B0*/ 7707, 7835, 7960, 8094, 8270, 8506, 8844, 9233, 9909,10705,12134,13787,16861,20671,28319,38468, +/*5C0*/ 11119,11244,11361,11480,11639,11858,12171,12531,13162,13915,15273,16861,19830,23543,30984,40499, +/*5D0*/ 15378,15475,15571,15679,15821,16009,16285,16611,17185,17878,19157,20671,23543,27172,34430,43360, +/*5E0*/ 24160,24214,24265,24322,24407,24529,24700,24924,25353,25890,26961,28319,30984,34430,41155,49244, +/*5F0*/ 36797,36800,36803,36806,36811,36820,36831,36854,36936,37087,37607,38468,40499,43360,49244,56480, + +/* 600 */ + +/*600*/ 1227, 1397, 1531, 1664, 1866, 2093, 2505, 2943, 3707, 4616, 6230, 8062,11458,15668,24342,36803, +/*610*/ 1397, 1545, 1681, 1812, 2017, 2244, 2650, 3085, 3855, 4755, 6361, 8193,11574,15770,24401,36806, +/*620*/ 1531, 1681, 1823, 1960, 2164, 2392, 2792, 3227, 4000, 4892, 6489, 8318,11688,15870,24455,36808, +/*630*/ 1664, 1812, 1960, 2110, 2312, 2542, 2940, 3378, 4145, 5034, 6622, 8446,11807,15972,24509,36814, +/*640*/ 1866, 2017, 2164, 2312, 2500, 2741, 3133, 3571, 4332, 5216, 6801, 8616,11963,16103,24589,36823, +/*650*/ 2093, 2244, 2392, 2542, 2741, 3008, 3389, 3826, 4582, 5463, 7040, 8844,12171,16285,24700,36831, +/*660*/ 2505, 2650, 2792, 2940, 3133, 3389, 3741, 4179, 4929, 5804, 7366, 9159,12460,16543,24865,36848, +/*670*/ 2943, 3085, 3227, 3378, 3571, 3826, 4179, 4628, 5372, 6238, 7784, 9560,12833,16878,25098,36874, +/*680*/ 3707, 3855, 4000, 4145, 4332, 4582, 4929, 5372, 6096, 6952, 8477,10225,13449,17441,25515,36953, +/*690*/ 4616, 4755, 4892, 5034, 5216, 5463, 5804, 6238, 6952, 7793, 9290,11014,14196,18128,26038,37110, +/*6A0*/ 6230, 6361, 6489, 6622, 6801, 7040, 7366, 7784, 8477, 9290,10747,12429,15540,19384,27095,37621, +/*6B0*/ 8062, 8193, 8318, 8446, 8616, 8844, 9159, 9560,10225,11014,12429,14066,17108,20881,28422,38482, +/*6C0*/ 11458,11574,11688,11807,11963,12171,12460,12833,13449,14196,15540,17108,20046,23711,31050,40507, +/*6D0*/ 15668,15770,15870,15972,16103,16285,16543,16878,17441,18128,19384,20881,23711,27285,34453,43374, +/*6E0*/ 24342,24401,24455,24509,24589,24700,24865,25098,25515,26038,27095,28422,31050,34453,41167,49247, +/*6F0*/ 36803,36806,36808,36814,36823,36831,36848,36874,36953,37110,37621,38482,40507,43374,49247,56486, + +/* 700 */ + +/*700*/ 1701, 1843, 1977, 2105, 2304, 2539, 2943, 3369, 4133, 5037, 6628, 8452,11824,15992,24589,36828, +/*710*/ 1843, 1991, 2125, 2255, 2457, 2684, 3085, 3517, 4281, 5173, 6761, 8577,11941,16097,24634,36831, +/*720*/ 1977, 2125, 2267, 2403, 2602, 2829, 3227, 3659, 4420, 5307, 6892, 8702,12051,16196,24683,36837, +/*730*/ 2105, 2255, 2403, 2554, 2750, 2980, 3378, 3804, 4565, 5449, 7025, 8832,12168,16293,24737,36840, +/*740*/ 2304, 2457, 2602, 2750, 2940, 3176, 3571, 3997, 4753, 5633, 7202, 9003,12321,16427,24813,36845, +/*750*/ 2539, 2684, 2829, 2980, 3176, 3446, 3826, 4258, 5011, 5883, 7443, 9233,12531,16611,24924,36854, +/*760*/ 2943, 3085, 3227, 3378, 3571, 3826, 4179, 4628, 5372, 6238, 7784, 9560,12833,16878,25098,36874, +/*770*/ 3369, 3517, 3659, 3804, 3997, 4258, 4628, 5139, 5866, 6727, 8256,10009,13253,17253,25356,36911, +/*780*/ 4133, 4281, 4420, 4565, 4753, 5011, 5372, 5866, 6571, 7420, 8926,10659,13850,17799,25751,36990, +/*790*/ 5037, 5173, 5307, 5449, 5633, 5883, 6238, 6727, 7420, 8264, 9742,11446,14594,18478,26274,37155, +/*7A0*/ 6628, 6761, 6892, 7025, 7202, 7443, 7784, 8256, 8926, 9742,11179,12838,15912,19711,27299,37658, +/*7B0*/ 8452, 8577, 8702, 8832, 9003, 9233, 9560,10009,10659,11446,12838,14461,17461,21180,28598,38513, +/*7C0*/ 11824,11941,12051,12168,12321,12531,12833,13253,13850,14594,15912,17461,20350,23961,31172,40527, +/*7D0*/ 15992,16097,16196,16293,16427,16611,16878,17253,17799,18478,19711,21180,23961,27470,34507,43391, +/*7E0*/ 24589,24634,24683,24737,24813,24924,25098,25356,25751,26274,27299,28598,31172,34507,41187,49255, +/*7F0*/ 36828,36831,36837,36840,36845,36854,36874,36911,36990,37155,37658,38513,40527,43391,49255,56497, + +/* 800 */ + +/*800*/ 2471, 2645, 2770, 2897, 3099, 3324, 3707, 4133, 4903, 5775, 7344, 9153,12489,16606,25032,36891, +/*810*/ 2645, 2787, 2914, 3042, 3244, 3466, 3855, 4281, 5037, 5912, 7477, 9276,12594,16696,25080,36896, +/*820*/ 2770, 2914, 3054, 3184, 3383, 3608, 4000, 4420, 5170, 6045, 7605, 9395,12699,16787,25123,36908, +/*830*/ 2897, 3042, 3184, 3332, 3528, 3755, 4145, 4565, 5312, 6182, 7736, 9517,12810,16884,25174,36916, +/*840*/ 3099, 3244, 3383, 3528, 3713, 3949, 4332, 4753, 5497, 6361, 7909, 9685,12960,17012,25248,36925, +/*850*/ 3324, 3466, 3608, 3755, 3949, 4210, 4582, 5011, 5744, 6608, 8145, 9909,13162,17185,25353,36936, +/*860*/ 3707, 3855, 4000, 4145, 4332, 4582, 4929, 5372, 6096, 6952, 8477,10225,13449,17441,25515,36953, +/*870*/ 4133, 4281, 4420, 4565, 4753, 5011, 5372, 5866, 6571, 7420, 8926,10659,13850,17799,25751,36990, +/*880*/ 4903, 5037, 5170, 5312, 5497, 5744, 6096, 6571, 7224, 8074, 9554,11264,14415,18305,26115,37081, +/*890*/ 5775, 5912, 6045, 6182, 6361, 6608, 6952, 7420, 8074, 8940,10392,12074,15174,18995,26649,37257, +/*8A0*/ 7344, 7477, 7605, 7736, 7909, 8145, 8477, 8926, 9554,10392,11798,13432,16455,20194,27629,37749, +/*8B0*/ 9153, 9276, 9395, 9517, 9685, 9909,10225,10659,11264,12074,13432,15032,17983,21634,28893,38590, +/*8C0*/ 12489,12594,12699,12810,12960,13162,13449,13850,14415,15174,16455,17983,20813,24345,31396,40581, +/*8D0*/ 16606,16696,16787,16884,17012,17185,17441,17799,18305,18995,20194,21634,24345,27768,34649,43422, +/*8E0*/ 25032,25080,25123,25174,25248,25353,25515,25751,26115,26649,27629,28893,31396,34649,41226,49272, +/*8F0*/ 36891,36896,36908,36916,36925,36936,36953,36990,37081,37257,37749,38590,40581,43422,49272,56511, + +/* 900 */ + +/*900*/ 3403, 3574, 3690, 3812, 4011, 4224, 4616, 5037, 5775, 6639, 8193, 9972,13256,17330,25603,37047, +/*910*/ 3574, 3704, 3835, 3960, 4153, 4369, 4755, 5173, 5912, 6773, 8318,10088,13361,17415,25637,37056, +/*920*/ 3690, 3835, 3971, 4099, 4290, 4508, 4892, 5307, 6045, 6900, 8440,10205,13463,17501,25683,37064, +/*930*/ 3812, 3960, 4099, 4241, 4432, 4653, 5034, 5449, 6182, 7034, 8565,10324,13571,17589,25737,37067, +/*940*/ 4011, 4153, 4290, 4432, 4613, 4844, 5216, 5633, 6361, 7213, 8733,10483,13716,17711,25799,37075, +/*950*/ 4224, 4369, 4508, 4653, 4844, 5099, 5463, 5883, 6608, 7449, 8963,10705,13915,17878,25890,37087, +/*960*/ 4616, 4755, 4892, 5034, 5216, 5463, 5804, 6238, 6952, 7793, 9290,11014,14196,18128,26038,37110, +/*970*/ 5037, 5173, 5307, 5449, 5633, 5883, 6238, 6727, 7420, 8264, 9742,11446,14594,18478,26274,37155, +/*980*/ 5775, 5912, 6045, 6182, 6361, 6608, 6952, 7420, 8074, 8940,10392,12074,15174,18995,26649,37257, +/*990*/ 6639, 6773, 6900, 7034, 7213, 7449, 7793, 8264, 8940, 9906,11318,12966,16006,19756,27234,37479, +/*9A0*/ 8193, 8318, 8440, 8565, 8733, 8963, 9290, 9742,10392,11318,12665,14276,17233,20898,28155,37959, +/*9B0*/ 9972,10088,10205,10324,10483,10705,11014,11446,12074,12966,14276,15861,18745,22313,29385,38777, +/*9C0*/ 13256,13361,13463,13571,13716,13915,14196,14594,15174,16006,17233,18745,21501,24944,31780,40712, +/*9D0*/ 17330,17415,17501,17589,17711,17878,18128,18478,18995,19756,20898,22313,24944,28268,34936,43508, +/*9E0*/ 25603,25637,25683,25737,25799,25890,26038,26274,26649,27234,28155,29385,31780,34936,41340,49315, +/*9F0*/ 37047,37056,37064,37067,37075,37087,37110,37155,37257,37479,37959,38777,40712,43508,49315,56534, + +/* A00 */ + +/*A00*/ 5071, 5207, 5327, 5446, 5639, 5849, 6230, 6628, 7344, 8193, 9705,11446,14659,18648,26743,37567, +/*A10*/ 5207, 5341, 5466, 5588, 5773, 5986, 6361, 6761, 7477, 8318, 9824,11554,14759,18731,26768,37570, +/*A20*/ 5327, 5466, 5596, 5721, 5906, 6119, 6489, 6892, 7605, 8440, 9940,11662,14855,18810,26799,37576, +/*A30*/ 5446, 5588, 5721, 5861, 6042, 6258, 6622, 7025, 7736, 8565,10060,11776,14955,18890,26839,37587, +/*A40*/ 5639, 5773, 5906, 6042, 6216, 6440, 6801, 7202, 7909, 8733,10219,11926,15088,19001,26885,37598, +/*A50*/ 5849, 5986, 6119, 6258, 6440, 6687, 7040, 7443, 8145, 8963,10438,12134,15273,19157,26961,37607, +/*A60*/ 6230, 6361, 6489, 6622, 6801, 7040, 7366, 7784, 8477, 9290,10747,12429,15540,19384,27095,37621, +/*A70*/ 6628, 6761, 6892, 7025, 7202, 7443, 7784, 8256, 8926, 9742,11179,12838,15912,19711,27299,37658, +/*A80*/ 7344, 7477, 7605, 7736, 7909, 8145, 8477, 8926, 9554,10392,11798,13432,16455,20194,27629,37749, +/*A90*/ 8193, 8318, 8440, 8565, 8733, 8963, 9290, 9742,10392,11318,12665,14276,17233,20898,28155,37959, +/*AA0*/ 9705, 9824, 9940,10060,10219,10438,10747,11179,11798,12665,13892,15483,18370,21938,28993,38408, +/*AB0*/ 11446,11554,11662,11776,11926,12134,12429,12838,13432,14276,15483,17106,19896,23362,30214,39218, +/*AC0*/ 14659,14759,14855,14955,15088,15273,15540,15912,16455,17233,18370,19896,22543,25887,32476,41042, +/*AD0*/ 18648,18731,18810,18890,19001,19157,19384,19711,20194,20898,21938,23362,25887,29112,35490,43738, +/*AE0*/ 26743,26768,26799,26839,26885,26961,27095,27299,27629,28155,28993,30214,32476,35490,41630,49428, +/*AF0*/ 37567,37570,37576,37587,37598,37607,37621,37658,37749,37959,38408,39218,41042,43738,49428,56594, + +/* B00 */ + +/*B00*/ 6940, 7082, 7199, 7318, 7497, 7707, 8062, 8452, 9153, 9972,11446,13142,16293,20231,28118,38445, +/*B10*/ 7082, 7213, 7335, 7449, 7628, 7835, 8193, 8577, 9276,10088,11554,13245,16384,20290,28157,38448, +/*B20*/ 7199, 7335, 7463, 7579, 7756, 7960, 8318, 8702, 9395,10205,11662,13344,16475,20359,28183,38451, +/*B30*/ 7318, 7449, 7579, 7713, 7889, 8094, 8446, 8832, 9517,10324,11776,13452,16566,20435,28206,38453, +/*B40*/ 7497, 7628, 7756, 7889, 8060, 8270, 8616, 9003, 9685,10483,11926,13597,16688,20532,28254,38459, +/*B50*/ 7707, 7835, 7960, 8094, 8270, 8506, 8844, 9233, 9909,10705,12134,13787,16861,20671,28319,38468, +/*B60*/ 8062, 8193, 8318, 8446, 8616, 8844, 9159, 9560,10225,11014,12429,14066,17108,20881,28422,38482, +/*B70*/ 8452, 8577, 8702, 8832, 9003, 9233, 9560,10009,10659,11446,12838,14461,17461,21180,28598,38513, +/*B80*/ 9153, 9276, 9395, 9517, 9685, 9909,10225,10659,11264,12074,13432,15032,17983,21634,28893,38590, +/*B90*/ 9972,10088,10205,10324,10483,10705,11014,11446,12074,12966,14276,15861,18745,22313,29385,38777, +/*BA0*/ 11446,11554,11662,11776,11926,12134,12429,12838,13432,14276,15483,17106,19896,23362,30214,39218, +/*BB0*/ 13142,13245,13344,13452,13597,13787,14066,14461,15032,15861,17106,18898,21572,24924,31521,40110, +/*BC0*/ 16293,16384,16475,16566,16688,16861,17108,17461,17983,18745,19896,21572,24078,27305,33635,41772, +/*BD0*/ 20231,20290,20359,20435,20532,20671,20881,21180,21634,22313,23362,24924,27305,30436,36510,44329, +/*BE0*/ 28118,28157,28183,28206,28254,28319,28422,28598,28893,29385,30214,31521,33635,36510,42289,49752, +/*BF0*/ 38445,38448,38451,38453,38459,38468,38482,38513,38590,38777,39218,40110,41772,44329,49752,56767, + +/* C00 */ + +/*C00*/ 10426,10560,10671,10776,10935,11119,11458,11824,12489,13256,14659,16293,19381,23208,30893,40473, +/*C10*/ 10560,10679,10787,10889,11057,11244,11574,11941,12594,13361,14759,16384,19447,23254,30899,40476, +/*C20*/ 10671,10787,10901,11006,11173,11361,11688,12051,12699,13463,14855,16475,19512,23305,30913,40479, +/*C30*/ 10776,10889,11006,11128,11290,11480,11807,12168,12810,13571,14955,16566,19583,23362,30927,40482, +/*C40*/ 10935,11057,11173,11290,11443,11639,11963,12321,12960,13716,15088,16688,19688,23438,30944,40490, +/*C50*/ 11119,11244,11361,11480,11639,11858,12171,12531,13162,13915,15273,16861,19830,23543,30984,40499, +/*C60*/ 11458,11574,11688,11807,11963,12171,12460,12833,13449,14196,15540,17108,20046,23711,31050,40507, +/*C70*/ 11824,11941,12051,12168,12321,12531,12833,13253,13850,14594,15912,17461,20350,23961,31172,40527, +/*C80*/ 12489,12594,12699,12810,12960,13162,13449,13850,14415,15174,16455,17983,20813,24345,31396,40581, +/*C90*/ 13256,13361,13463,13571,13716,13915,14196,14594,15174,16006,17233,18745,21501,24944,31780,40712, +/*CA0*/ 14659,14759,14855,14955,15088,15273,15540,15912,16455,17233,18370,19896,22543,25887,32476,41042, +/*CB0*/ 16293,16384,16475,16566,16688,16861,17108,17461,17983,18745,19896,21572,24078,27305,33635,41772, +/*CC0*/ 19381,19447,19512,19583,19688,19830,20046,20350,20813,21501,22543,24078,26359,29484,35516,43235, +/*CD0*/ 23208,23254,23305,23362,23438,23543,23711,23961,24345,24944,25887,27305,29484,32595,38334,45664, +/*CE0*/ 30893,30899,30913,30927,30944,30984,31050,31172,31396,31780,32476,33635,35516,38334,43675,50622, +/*CF0*/ 40473,40476,40479,40482,40490,40499,40507,40527,40581,40712,41042,41772,43235,45664,50622,57247, + +/* D00 */ + +/*D00*/ 14762,14873,14972,15051,15202,15378,15668,15992,16606,17330,18648,20231,23208,26964,34385,43346, +/*D10*/ 14873,14975,15071,15159,15307,15475,15770,16097,16696,17415,18731,20290,23254,26995,34385,43346, +/*D20*/ 14972,15071,15171,15265,15407,15571,15870,16196,16787,17501,18810,20359,23305,27018,34391,43349, +/*D30*/ 15051,15159,15265,15373,15512,15679,15972,16293,16884,17589,18890,20435,23362,27047,34399,43349, +/*D40*/ 15202,15307,15407,15512,15648,15821,16103,16427,17012,17711,19001,20532,23438,27100,34413,43351, +/*D50*/ 15378,15475,15571,15679,15821,16009,16285,16611,17185,17878,19157,20671,23543,27172,34430,43360, +/*D60*/ 15668,15770,15870,15972,16103,16285,16543,16878,17441,18128,19384,20881,23711,27285,34453,43374, +/*D70*/ 15992,16097,16196,16293,16427,16611,16878,17253,17799,18478,19711,21180,23961,27470,34507,43391, +/*D80*/ 16606,16696,16787,16884,17012,17185,17441,17799,18305,18995,20194,21634,24345,27768,34649,43422, +/*D90*/ 17330,17415,17501,17589,17711,17878,18128,18478,18995,19756,20898,22313,24944,28268,34936,43508, +/*DA0*/ 18648,18731,18810,18890,19001,19157,19384,19711,20194,20898,21938,23362,25887,29112,35490,43738, +/*DB0*/ 20231,20290,20359,20435,20532,20671,20881,21180,21634,22313,23362,24924,27305,30436,36510,44329, +/*DC0*/ 23208,23254,23305,23362,23438,23543,23711,23961,24345,24944,25887,27305,29484,32595,38334,45664, +/*DD0*/ 26964,26995,27018,27047,27100,27172,27285,27470,27768,28268,29112,30436,32595,35979,41312,48159, +/*DE0*/ 34385,34385,34391,34399,34413,34430,34453,34507,34649,34936,35490,36510,38334,41312,46139,52514, +/*DF0*/ 43346,43346,43349,43349,43351,43360,43374,43391,43422,43508,43738,44329,45664,48159,52514,58506, + +/* E00 */ + +/*E00*/ 23799,23862,23916,23970,24061,24160,24342,24589,25032,25603,26743,28118,30893,34385,41133,49230, +/*E10*/ 23862,23918,23975,24021,24109,24214,24401,24634,25080,25637,26768,28157,30899,34385,41135,49232, +/*E20*/ 23916,23975,24026,24075,24160,24265,24455,24683,25123,25683,26799,28183,30913,34391,41138,49235, +/*E30*/ 23970,24021,24075,24137,24220,24322,24509,24737,25174,25737,26839,28206,30927,34399,41141,49238, +/*E40*/ 24061,24109,24160,24220,24299,24407,24589,24813,25248,25799,26885,28254,30944,34413,41147,49241, +/*E50*/ 24160,24214,24265,24322,24407,24529,24700,24924,25353,25890,26961,28319,30984,34430,41155,49244, +/*E60*/ 24342,24401,24455,24509,24589,24700,24865,25098,25515,26038,27095,28422,31050,34453,41167,49247, +/*E70*/ 24589,24634,24683,24737,24813,24924,25098,25356,25751,26274,27299,28598,31172,34507,41187,49255, +/*E80*/ 25032,25080,25123,25174,25248,25353,25515,25751,26115,26649,27629,28893,31396,34649,41226,49272, +/*E90*/ 25603,25637,25683,25737,25799,25890,26038,26274,26649,27234,28155,29385,31780,34936,41340,49315, +/*EA0*/ 26743,26768,26799,26839,26885,26961,27095,27299,27629,28155,28993,30214,32476,35490,41630,49428, +/*EB0*/ 28118,28157,28183,28206,28254,28319,28422,28598,28893,29385,30214,31521,33635,36510,42289,49752, +/*EC0*/ 30893,30899,30913,30927,30944,30984,31050,31172,31396,31780,32476,33635,35516,38334,43675,50622, +/*ED0*/ 34385,34385,34391,34399,34413,34430,34453,34507,34649,34936,35490,36510,38334,41312,46139,52514, +/*EE0*/ 41133,41135,41138,41141,41147,41155,41167,41187,41226,41340,41630,42289,43675,46139,50235,56054, +/*EF0*/ 49230,49232,49235,49238,49241,49244,49247,49255,49272,49315,49428,49752,50622,52514,56054,61273, + +/* F00 */ + +/*F00*/ 36754,36757,36760,36777,36780,36797,36803,36828,36891,37047,37567,38445,40473,43346,49230,56457, +/*F10*/ 36757,36760,36766,36786,36789,36800,36806,36831,36896,37056,37570,38448,40476,43346,49232,56460, +/*F20*/ 36760,36766,36780,36791,36794,36803,36808,36837,36908,37064,37576,38451,40479,43349,49235,56463, +/*F30*/ 36777,36786,36791,36794,36797,36806,36814,36840,36916,37067,37587,38453,40482,43349,49238,56471, +/*F40*/ 36780,36789,36794,36797,36806,36811,36823,36845,36925,37075,37598,38459,40490,43351,49241,56477, +/*F50*/ 36797,36800,36803,36806,36811,36820,36831,36854,36936,37087,37607,38468,40499,43360,49244,56480, +/*F60*/ 36803,36806,36808,36814,36823,36831,36848,36874,36953,37110,37621,38482,40507,43374,49247,56486, +/*F70*/ 36828,36831,36837,36840,36845,36854,36874,36911,36990,37155,37658,38513,40527,43391,49255,56497, +/*F80*/ 36891,36896,36908,36916,36925,36936,36953,36990,37081,37257,37749,38590,40581,43422,49272,56511, +/*F90*/ 37047,37056,37064,37067,37075,37087,37110,37155,37257,37479,37959,38777,40712,43508,49315,56534, +/*FA0*/ 37567,37570,37576,37587,37598,37607,37621,37658,37749,37959,38408,39218,41042,43738,49428,56594, +/*FB0*/ 38445,38448,38451,38453,38459,38468,38482,38513,38590,38777,39218,40110,41772,44329,49752,56767, +/*FC0*/ 40473,40476,40479,40482,40490,40499,40507,40527,40581,40712,41042,41772,43235,45664,50622,57247, +/*FD0*/ 43346,43346,43349,43349,43351,43360,43374,43391,43422,43508,43738,44329,45664,48159,52514,58506, +/*FE0*/ 49230,49232,49235,49238,49241,49244,49247,49255,49272,49315,49428,49752,50622,52514,56054,61273, +/*FF0*/ 56457,56460,56463,56471,56477,56480,56486,56497,56511,56534,56594,56767,57247,58506,61273,65535, +} Index: apps/codecs/libsc68/io68/ymoutorg.h =================================================================== --- apps/codecs/libsc68/io68/ymoutorg.h (revision 0) +++ apps/codecs/libsc68/io68/ymoutorg.h (revision 0) @@ -0,0 +1,257 @@ +{ + 0x19,0x37,0x68,0x9c,0xe6,0x139,0x1cb,0x26a,0x380,0x4c7,0x6ff,0x995,0xe55,0x1432,0x207f,0x3227, + 0x44,0x73,0xa7,0xd3,0x120,0x172,0x203,0x2a1,0x3b6,0x4f9,0x738,0x9c8,0xe84,0x1465,0x208d,0x3223, + 0x72,0xa3,0xd9,0x104,0x14e,0x1a2,0x233,0x2d0,0x3e3,0x526,0x763,0x9ef,0xeab,0x1486,0x20ad,0x320a, + 0x96,0xd6,0x102,0x133,0x17c,0x1ce,0x260,0x2fc,0x412,0x552,0x78b,0xa17,0xed0,0x149f,0x20be,0x3226, + 0xdb,0x121,0x14d,0x17b,0x1c4,0x218,0x2a8,0x343,0x458,0x596,0x7d1,0xa56,0xf09,0x14d8,0x20d4,0x321f, + 0x130,0x16c,0x19d,0x1cc,0x214,0x267,0x2fa,0x392,0x4a4,0x5e5,0x817,0xa9f,0xf49,0x1515,0x20f6,0x322b, + 0x1cd,0x1fe,0x232,0x25e,0x2a8,0x2f8,0x387,0x41f,0x52e,0x66a,0x89b,0xb1d,0xfbe,0x157c,0x213c,0x3232, + 0x26b,0x29e,0x2d0,0x2fb,0x342,0x393,0x41e,0x4b9,0x5c5,0x6fd,0x929,0xba6,0x103d,0x15e7,0x2193,0x322e, + 0x378,0x3ba,0x3e3,0x411,0x457,0x4a5,0x52f,0x5c3,0x6d0,0x802,0xa24,0xc9a,0x1127,0x16c0,0x2238,0x324a, + 0x4c0,0x4fe,0x523,0x551,0x597,0x5e2,0x66b,0x6fc,0x7fb,0x930,0xb4f,0xdb6,0x1235,0x17bf,0x22f5,0x3291, + 0x711,0x740,0x76b,0x791,0x7d5,0x821,0x8a4,0x933,0xa30,0xb52,0xd65,0xfc4,0x1422,0x1993,0x2487,0x3344, + 0x9a4,0x9d3,0xa00,0xa24,0xa66,0xab0,0xb2a,0xbb3,0xca8,0xdc7,0xfc7,0x1218,0x1665,0x1bb7,0x2672,0x3485, + 0xe70,0xe97,0xec0,0xee2,0xf20,0xf60,0xfd6,0x1056,0x113b,0x124a,0x1436,0x165f,0x1a9f,0x1fd1,0x2a3c,0x3750, + 0x145e,0x148b,0x14a9,0x14ca,0x14fa,0x1538,0x159c,0x160d,0x16e6,0x17df,0x19ac,0x1bd2,0x1fda,0x24f9,0x2f19,0x3b4d, + 0x20e1,0x20fd,0x2107,0x211d,0x213b,0x2160,0x21a0,0x21ef,0x228a,0x2351,0x24da,0x26be,0x2a7e,0x2f31,0x3884,0x438d, + 0x32b2,0x32cb,0x32c5,0x32c6,0x32ce,0x32c4,0x32cc,0x32d1,0x32e9,0x331e,0x33cd,0x34ef,0x37b9,0x3baa,0x43aa,0x4d99, + 0x47,0x70,0xab,0xd5,0x122,0x173,0x203,0x2a3,0x3b8,0x4fa,0x736,0x9c7,0xe81,0x1466,0x2092,0x3221, + 0x7b,0xb4,0xe2,0x10e,0x158,0x1ad,0x23e,0x2d9,0x3ee,0x530,0x76b,0x9f7,0xeaf,0x1482,0x20ac,0x3227, + 0xa0,0xe4,0x10f,0x13f,0x187,0x1db,0x26c,0x309,0x41b,0x55d,0x797,0xa22,0xeda,0x14aa,0x20b8,0x3222, + 0xce,0x108,0x13c,0x16b,0x1b4,0x209,0x298,0x335,0x448,0x58a,0x7c1,0xa4a,0xef9,0x14ca,0x20c9,0x320d, + 0x126,0x155,0x188,0x1b3,0x1fe,0x250,0x2e1,0x37a,0x48d,0x5cc,0x800,0xa89,0xf34,0x1500,0x20ec,0x3231, + 0x176,0x1a7,0x1da,0x207,0x24e,0x2a0,0x32f,0x3cb,0x4d9,0x617,0x84b,0xacd,0xf76,0x153b,0x210e,0x3232, + 0x1ff,0x23f,0x26c,0x297,0x2de,0x330,0x3be,0x455,0x563,0x69f,0x8ce,0xb4b,0xfe9,0x159b,0x215b,0x322c, + 0x29c,0x2df,0x306,0x334,0x37a,0x3c9,0x456,0x4ee,0x5fa,0x732,0x95a,0xbd3,0x106c,0x1610,0x21a9,0x3233, + 0x3bc,0x3f0,0x419,0x446,0x48c,0x4db,0x563,0x5fa,0x700,0x836,0xa56,0xcc9,0x114d,0x16e7,0x223f,0x3254, + 0x4fe,0x52c,0x55d,0x588,0x5cb,0x617,0x69f,0x730,0x835,0x962,0xb7a,0xde7,0x125c,0x17e0,0x2302,0x328f, + 0x747,0x770,0x79f,0x7c6,0x809,0x854,0x8d6,0x963,0xa5b,0xb88,0xd92,0xfea,0x1448,0x19b2,0x2492,0x334f, + 0x9d2,0xa04,0xa30,0xa58,0xa96,0xadf,0xb5c,0xbe5,0xcd7,0xdf0,0xff2,0x123d,0x1682,0x1bcf,0x2685,0x347d, + 0xe99,0xeca,0xeeb,0xf12,0xf4c,0xf8d,0x1000,0x107f,0x1162,0x1270,0x1454,0x168f,0x1ab8,0x1fdc,0x2a49,0x375a, + 0x1486,0x14b6,0x14d1,0x14eb,0x1523,0x155c,0x15c1,0x1637,0x170a,0x1802,0x19ca,0x1bdb,0x1ff3,0x2507,0x2f10,0x3b5d, + 0x20fd,0x210b,0x2128,0x2131,0x214e,0x2175,0x21b8,0x2205,0x22a3,0x235b,0x24e5,0x26cb,0x2a7f,0x2f43,0x387b,0x438b, + 0x32cd,0x32c5,0x32c8,0x32cf,0x32ca,0x32c4,0x32ce,0x32d9,0x32ed,0x332b,0x33cf,0x3503,0x37c4,0x3b8f,0x43b0,0x4d98, + 0x64,0xac,0xd5,0x106,0x14f,0x1a2,0x234,0x2d0,0x3e6,0x528,0x764,0x9ef,0xead,0x1488,0x20aa,0x321f, + 0xa4,0xe4,0x110,0x13e,0x187,0x1da,0x26c,0x307,0x41e,0x55d,0x797,0xa20,0xecd,0x14ab,0x20c2,0x320c, + 0xcd,0x10c,0x141,0x16c,0x1b8,0x209,0x29a,0x336,0x448,0x589,0x7c2,0xa4c,0xefe,0x14ce,0x20cb,0x322f, + 0x107,0x13b,0x16e,0x199,0x1e5,0x235,0x2c7,0x361,0x474,0x5b2,0x7eb,0xa72,0xf1f,0x14ec,0x20dc,0x3233, + 0x152,0x18d,0x1b9,0x1e3,0x22d,0x27e,0x30f,0x3a7,0x4ba,0x5f7,0x82c,0xab1,0xf5b,0x151a,0x20fd,0x321c, + 0x19b,0x1de,0x207,0x235,0x27e,0x2ce,0x35e,0x3f7,0x508,0x643,0x874,0xaf5,0xf9c,0x1553,0x2125,0x322d, + 0x22c,0x26d,0x298,0x2c7,0x30e,0x35e,0x3e9,0x483,0x592,0x6c8,0x8f7,0xb75,0x100f,0x15bc,0x2160,0x322b, + 0x2d3,0x304,0x332,0x360,0x3a7,0x3f8,0x483,0x51a,0x627,0x75d,0x980,0xbff,0x108d,0x1632,0x21b2,0x3238, + 0x3ec,0x41a,0x44a,0x474,0x4bd,0x508,0x592,0x626,0x72c,0x860,0xa7e,0xcef,0x116f,0x16fe,0x2246,0x325a, + 0x523,0x559,0x588,0x5b3,0x5f9,0x642,0x6cb,0x75c,0x85e,0x985,0xba4,0xe07,0x1279,0x17f9,0x231b,0x3287, + 0x769,0x79f,0x7c4,0x7f1,0x833,0x87d,0x900,0x98b,0xa86,0xbaa,0xdb4,0x100b,0x1467,0x19c6,0x24a8,0x334a, + 0x9fc,0xa33,0xa58,0xa82,0xabf,0xb04,0xb84,0xc09,0xcfa,0xe15,0x1012,0x1255,0x16a6,0x1beb,0x2684,0x3488, + 0xec8,0xef2,0xf14,0xf35,0xf72,0xfb5,0x1026,0x10a5,0x1187,0x1290,0x1477,0x16ad,0x1ac6,0x1ff2,0x2a48,0x3755, + 0x14b1,0x14cf,0x14f5,0x1513,0x1547,0x157f,0x15e7,0x1653,0x1727,0x1819,0x19de,0x1c00,0x2001,0x24f8,0x2f17,0x3b57, + 0x210f,0x2127,0x2135,0x213f,0x2166,0x2186,0x21c8,0x2219,0x22ad,0x2370,0x24f1,0x26c0,0x2a8b,0x2f47,0x387a,0x4393, + 0x32cc,0x32c3,0x32c6,0x32cb,0x32bc,0x32c8,0x32cd,0x32d7,0x32f2,0x331b,0x33cf,0x3500,0x37ba,0x3ba7,0x43b0,0x4d77, + 0x90,0xdc,0x101,0x135,0x17d,0x1cf,0x262,0x2fd,0x413,0x553,0x78c,0xa16,0xed1,0x14a0,0x20bd,0x3230, + 0xdc,0x10b,0x140,0x16a,0x1b5,0x209,0x299,0x334,0x448,0x588,0x7c3,0xa4b,0xefb,0x14cd,0x20c5,0x3227, + 0x109,0x13d,0x172,0x19b,0x1e5,0x238,0x2c6,0x363,0x474,0x5b4,0x7e8,0xa73,0xf1f,0x14ef,0x20e5,0x320c, + 0x138,0x16f,0x19b,0x1c9,0x212,0x264,0x2f2,0x38e,0x49e,0x5dd,0x813,0xa98,0xf44,0x1509,0x20f8,0x3226, + 0x177,0x1b7,0x1e3,0x212,0x25a,0x2ac,0x33b,0x3d4,0x4e6,0x620,0x854,0xad5,0xf7c,0x153d,0x210c,0x3220, + 0x1c8,0x206,0x235,0x262,0x2ab,0x2fd,0x38b,0x421,0x531,0x66f,0x89e,0xb1f,0xfbd,0x1577,0x2132,0x322c, + 0x264,0x296,0x2c9,0x2f2,0x33b,0x38a,0x418,0x4af,0x5bd,0x6f5,0x91e,0xb98,0x1033,0x15de,0x2173,0x3232, + 0x301,0x331,0x364,0x38f,0x3d4,0x425,0x4ad,0x543,0x650,0x785,0x9ab,0xc1f,0x10ae,0x164c,0x21ca,0x323b, + 0x40c,0x44a,0x473,0x4a1,0x4e3,0x532,0x5bc,0x650,0x756,0x885,0xaa3,0xd14,0x1196,0x171b,0x225f,0x3255, + 0x54d,0x58b,0x5b2,0x5df,0x620,0x66f,0x6f5,0x784,0x880,0x9b0,0xbc7,0xe29,0x129f,0x1814,0x2322,0x328f, + 0x798,0x7cc,0x7f6,0x81a,0x85b,0x8a7,0x926,0x9b3,0xaad,0xbca,0xdd9,0x102f,0x1485,0x19e4,0x24ae,0x3349, + 0xa2b,0xa55,0xa83,0xaa8,0xae8,0xb31,0xbaa,0xc2e,0xd1f,0xe3c,0x1036,0x1280,0x16bc,0x1bfe,0x2692,0x3484, + 0xee9,0xf10,0xf39,0xf5b,0xf95,0xfd4,0x1048,0x10c8,0x11a9,0x12b0,0x1496,0x16ba,0x1ae3,0x2004,0x2a47,0x3759, + 0x14cb,0x14f5,0x1511,0x1532,0x1563,0x159f,0x1602,0x1675,0x1746,0x1837,0x19ff,0x1c14,0x2012,0x2517,0x2f1e,0x3b4d, + 0x2121,0x2139,0x2144,0x2157,0x2176,0x2190,0x21d9,0x2222,0x22b9,0x237d,0x24fe,0x26d6,0x2a8b,0x2f29,0x387b,0x4387, + 0x32ba,0x32c9,0x32d1,0x32c5,0x32cd,0x32cb,0x32d0,0x32d2,0x32f3,0x3328,0x33db,0x34fc,0x37c2,0x3bb0,0x43b0,0x4da7, + 0xf3,0x11c,0x154,0x17c,0x1c8,0x219,0x2aa,0x346,0x458,0x598,0x7cc,0xa59,0xf0c,0x14de,0x20d9,0x3212, + 0x129,0x159,0x188,0x1b6,0x1ff,0x253,0x2e2,0x37c,0x48e,0x5cc,0x801,0xa87,0xf38,0x14f6,0x20f5,0x3222, + 0x14a,0x18e,0x1b8,0x1e7,0x22e,0x281,0x310,0x3aa,0x4ba,0x5f8,0x82c,0xab0,0xf5c,0x151d,0x2100,0x3227, + 0x17a,0x1b9,0x1e4,0x212,0x25a,0x2ac,0x33d,0x3d7,0x4e6,0x625,0x856,0xada,0xf7a,0x153b,0x2112,0x3219, + 0x1ca,0x1fc,0x232,0x25a,0x2a5,0x2f4,0x383,0x41e,0x52b,0x666,0x895,0xb19,0xfb5,0x1573,0x212d,0x3228, + 0x21d,0x250,0x282,0x2ab,0x2f6,0x345,0x3d2,0x46a,0x576,0x6b3,0x8e0,0xb5c,0xff4,0x15ac,0x2154,0x3233, + 0x2af,0x2e3,0x310,0x33c,0x380,0x3d2,0x45e,0x4f5,0x600,0x734,0x960,0xbd8,0x106b,0x1608,0x2199,0x322e, + 0x341,0x380,0x3a9,0x3d5,0x41d,0x46b,0x4f6,0x58a,0x693,0x7c6,0x9ed,0xc5e,0x10e9,0x167a,0x21e7,0x3233, + 0x456,0x492,0x4ba,0x4e5,0x52b,0x579,0x5fe,0x693,0x79a,0x8c5,0xae6,0xd50,0x11c4,0x174b,0x2275,0x3254, + 0x59f,0x5cb,0x5f8,0x623,0x667,0x6b2,0x737,0x7c6,0x8c7,0x9f2,0xc04,0xe68,0x12cc,0x183d,0x233a,0x3291, + 0x7e0,0x80a,0x838,0x85d,0x89e,0x8e9,0x969,0x9f5,0xae8,0xc0b,0xe13,0x1063,0x14b5,0x1a05,0x24b9,0x3358, + 0xa63,0xa98,0xac1,0xae7,0xb29,0xb6d,0xbe7,0xc6e,0xd5f,0xe6e,0x106c,0x12b2,0x16e8,0x1c27,0x26a1,0x347b, + 0xf1e,0xf50,0xf74,0xf95,0xfcf,0x1011,0x1083,0x10fd,0x11dd,0x12e6,0x14c4,0x16f0,0x1b0a,0x2012,0x2a5d,0x3761, + 0x14fd,0x152a,0x1549,0x1566,0x1597,0x15cd,0x1631,0x16a4,0x1770,0x1863,0x1a25,0x1c2c,0x2030,0x252e,0x2f19,0x3b4f, + 0x214b,0x2152,0x2166,0x2179,0x218e,0x21b7,0x21f8,0x223f,0x22d4,0x2395,0x250d,0x26ee,0x2a8d,0x2f4d,0x387d,0x438b, + 0x32c9,0x32c9,0x32c7,0x32ca,0x32cd,0x32c4,0x32d0,0x32d8,0x32f0,0x3326,0x33d3,0x34fc,0x37c5,0x3b91,0x43af,0x4d97, + 0x130,0x17a,0x1a3,0x1d1,0x21c,0x26e,0x2fd,0x396,0x4a8,0x5e6,0x81b,0xaa1,0xf4e,0x1515,0x2103,0x3225, + 0x16f,0x1b1,0x1dc,0x209,0x252,0x2a5,0x334,0x3ce,0x4dd,0x61a,0x84d,0xad1,0xf78,0x1539,0x2115,0x3214, + 0x19e,0x1da,0x20c,0x23a,0x283,0x2d1,0x35f,0x3fa,0x50c,0x646,0x876,0xafb,0xf9d,0x1552,0x211f,0x3232, + 0x1d9,0x206,0x239,0x264,0x2ad,0x2fe,0x38d,0x426,0x536,0x671,0x8a0,0xb1e,0xfbd,0x157e,0x2133,0x322c, + 0x21e,0x255,0x284,0x2ad,0x2f5,0x345,0x3d2,0x46b,0x57b,0x6b1,0x8df,0xb5c,0xff8,0x15aa,0x2156,0x322c, + 0x269,0x2a6,0x2cf,0x2fd,0x345,0x396,0x420,0x4b9,0x5c4,0x6fe,0x929,0xba0,0x103a,0x15de,0x217a,0x322c, + 0x2f8,0x336,0x35f,0x38d,0x3d2,0x423,0x4aa,0x542,0x64c,0x780,0x9a9,0xc1c,0x10a8,0x1648,0x21b1,0x322d, + 0x39a,0x3cb,0x3fa,0x426,0x46d,0x4bb,0x545,0x5d5,0x6e1,0x810,0xa2e,0xca2,0x1123,0x16b3,0x21fd,0x323f, + 0x4ae,0x4dc,0x50e,0x537,0x57b,0x5c8,0x64d,0x6e2,0x7e3,0x911,0xb29,0xd8f,0x1202,0x177f,0x2298,0x3260, + 0x5e4,0x618,0x648,0x671,0x6b4,0x6fe,0x783,0x812,0x914,0xa32,0xc48,0xea7,0x1309,0x1872,0x2359,0x3286, + 0x81f,0x859,0x87f,0x8a7,0x8ea,0x932,0x9ae,0xa37,0xb31,0xc4f,0xe51,0x10a5,0x14ec,0x1a33,0x24d5,0x334e, + 0xaaf,0xae6,0xb06,0xb30,0xb6c,0xbb0,0xc2c,0xcb4,0xd9d,0xeb4,0x10a7,0x12e0,0x1721,0x1c50,0x26b2,0x347d, + 0xf6a,0xf94,0xfb7,0xfd9,0x1011,0x1051,0x10c1,0x1139,0x1218,0x1320,0x14fe,0x1726,0x1b2b,0x203d,0x2a63,0x375d, + 0x1544,0x1565,0x1584,0x15a1,0x15d4,0x1609,0x166b,0x16d9,0x17a2,0x1898,0x1a4f,0x1c66,0x204f,0x2529,0x2f1b,0x3b5a, + 0x216c,0x217f,0x2187,0x2199,0x21bb,0x21db,0x2216,0x2262,0x22f7,0x23b1,0x2526,0x26fc,0x2a99,0x2f4c,0x387b,0x4396, + 0x32cd,0x32ca,0x32d3,0x32cd,0x32ca,0x32d1,0x32d0,0x32d6,0x32fc,0x3323,0x33db,0x3503,0x37bf,0x3ba2,0x43b3,0x4d92, + 0x1c5,0x20f,0x23a,0x268,0x2ab,0x2fe,0x38c,0x425,0x535,0x66f,0x89f,0xb21,0xfc3,0x1577,0x214b,0x323b, + 0x20f,0x23e,0x273,0x29a,0x2e4,0x335,0x3c1,0x45a,0x568,0x6a3,0x8d1,0xb50,0xfee,0x15a9,0x2158,0x322c, + 0x23c,0x26d,0x2a0,0x2ca,0x313,0x363,0x3ef,0x485,0x595,0x6cf,0x8fa,0xb78,0x1014,0x15c6,0x216e,0x3216, + 0x26b,0x29f,0x2c9,0x2f5,0x33c,0x390,0x41b,0x4b3,0x5bd,0x6f6,0x921,0xb9c,0x1038,0x15df,0x2183,0x322e, + 0x2a9,0x2e7,0x310,0x33e,0x386,0x3d5,0x45e,0x4f7,0x603,0x739,0x963,0xbd9,0x106e,0x160f,0x2197,0x322c, + 0x2f9,0x331,0x361,0x38d,0x3d5,0x422,0x4ae,0x543,0x651,0x782,0x9a9,0xc1e,0x10ac,0x1647,0x21bc,0x3233, + 0x390,0x3c0,0x3f0,0x41a,0x460,0x4ae,0x538,0x5ce,0x6d3,0x806,0xa25,0xc97,0x1119,0x16aa,0x21f3,0x323e, + 0x429,0x457,0x48a,0x4b4,0x4fa,0x546,0x5cb,0x660,0x766,0x894,0xab0,0xd1a,0x1193,0x1718,0x2240,0x3240, + 0x52f,0x56d,0x597,0x5c0,0x605,0x650,0x6d7,0x763,0x867,0x991,0xba4,0xe07,0x126e,0x17da,0x22dd,0x3250, + 0x66c,0x6a7,0x6ce,0x6f9,0x73a,0x784,0x807,0x895,0x990,0xab5,0xcc0,0xf13,0x1371,0x18cc,0x238b,0x3292, + 0x8ae,0x8de,0x904,0x92a,0x96b,0x9b1,0xa2f,0xab8,0xbae,0xcc3,0xec4,0x1111,0x1550,0x1a8c,0x2501,0x3351, + 0xb39,0xb60,0xb8a,0xbad,0xbec,0xc30,0xcaa,0xd29,0xe14,0xf26,0x1113,0x1350,0x1774,0x1c97,0x26d4,0x3490, + 0xfe3,0x1006,0x102b,0x104b,0x1089,0x10c4,0x1134,0x11ae,0x1286,0x138a,0x155d,0x1772,0x1b81,0x207d,0x2a71,0x375b, + 0x15a7,0x15c8,0x15ee,0x1607,0x1638,0x166f,0x16d1,0x173c,0x1804,0x18f1,0x1aa9,0x1cb0,0x2086,0x2564,0x2f24,0x3b4f, + 0x21af,0x21c1,0x21cd,0x21e2,0x21ff,0x2217,0x2257,0x22a4,0x2330,0x23e8,0x2550,0x271f,0x2aad,0x2f40,0x3887,0x4393, + 0x32b8,0x32d5,0x32d4,0x32cf,0x32c7,0x32d6,0x32dc,0x32e6,0x32f8,0x332c,0x33db,0x34fc,0x37c4,0x3baf,0x43a8,0x4d98, + 0x27b,0x2a3,0x2d9,0x302,0x34a,0x39a,0x427,0x4bf,0x5cb,0x704,0x92e,0xbad,0x1040,0x15f9,0x21a3,0x3223, + 0x2ac,0x2dd,0x30d,0x33a,0x381,0x3d0,0x45d,0x4f5,0x5fe,0x733,0x961,0xbda,0x1074,0x1617,0x21b7,0x3237, + 0x2cf,0x312,0x33c,0x369,0x3af,0x3fd,0x489,0x51e,0x62a,0x761,0x98b,0xbfe,0x1091,0x1639,0x21c2,0x3236, + 0x2fd,0x33e,0x368,0x396,0x3d9,0x429,0x4b5,0x54a,0x655,0x789,0x9ae,0xc24,0x10b3,0x1651,0x21cf,0x323f, + 0x345,0x37e,0x3b1,0x3da,0x422,0x46e,0x4fa,0x58f,0x698,0x7cb,0x9ed,0xc63,0x10e9,0x1682,0x21e7,0x3241, + 0x39d,0x3cf,0x400,0x428,0x470,0x4be,0x546,0x5db,0x6e2,0x814,0xa33,0xca7,0x1124,0x16bd,0x2208,0x3242, + 0x42d,0x460,0x48b,0x4b4,0x4fa,0x549,0x5d0,0x65f,0x765,0x895,0xab0,0xd18,0x1193,0x1716,0x224e,0x323f, + 0x4b9,0x4f8,0x520,0x54d,0x590,0x5dc,0x664,0x6f4,0x7f7,0x922,0xb39,0xd9d,0x1211,0x1781,0x228a,0x3243, + 0x5c5,0x603,0x62b,0x657,0x69a,0x6e4,0x768,0x7f5,0x8f5,0xa16,0xc2b,0xe85,0x12e6,0x1848,0x2316,0x3264, + 0x70b,0x736,0x764,0x78b,0x7cc,0x816,0x897,0x922,0xa1c,0xb3e,0xd42,0xf97,0x13e3,0x1930,0x23cb,0x32a0, + 0x93e,0x968,0x996,0x9bb,0x9fb,0xa41,0xab9,0xb40,0xc30,0xd4d,0xf44,0x117f,0x15b6,0x1ae7,0x2538,0x3359, + 0xbba,0xbe9,0xc14,0xc39,0xc77,0xcb6,0xd2e,0xdad,0xe96,0xfa2,0x118e,0x13c2,0x17dc,0x1ced,0x270b,0x347f, + 0x105f,0x108d,0x10aa,0x10d1,0x1107,0x1143,0x11b1,0x1228,0x12fc,0x13fb,0x15c9,0x17e2,0x1bd4,0x20b9,0x2a9a,0x3759, + 0x161a,0x1649,0x1662,0x167f,0x16a9,0x16df,0x1743,0x17a8,0x1870,0x1953,0x1b04,0x1d00,0x20d1,0x2593,0x2f1b,0x3b54, + 0x220c,0x2212,0x2222,0x2231,0x224c,0x226c,0x22a0,0x22ee,0x2378,0x2429,0x258a,0x2750,0x2acc,0x2f60,0x3884,0x438e, + 0x32e2,0x32df,0x32d5,0x32dd,0x32dd,0x32d5,0x32e3,0x32e6,0x32ff,0x332c,0x33de,0x3502,0x37c5,0x3ba6,0x43b1,0x4da6, + 0x386,0x3c9,0x3ee,0x41c,0x464,0x4b2,0x53a,0x5d0,0x6d7,0x809,0xa2f,0xca3,0x1132,0x16cd,0x2247,0x325c, + 0x3bd,0x3fd,0x427,0x453,0x497,0x4e6,0x56e,0x603,0x70a,0x83c,0xa5c,0xcd1,0x1156,0x16ed,0x225d,0x3241, + 0x3ee,0x429,0x456,0x47f,0x4c6,0x50f,0x59a,0x62f,0x734,0x867,0xa85,0xcf4,0x1173,0x170a,0x2260,0x3262, + 0x420,0x451,0x481,0x4a8,0x4ee,0x53c,0x5c6,0x657,0x75e,0x88d,0xaad,0xd1a,0x119a,0x172a,0x2271,0x325a, + 0x467,0x496,0x4c3,0x4f0,0x533,0x582,0x609,0x698,0x79d,0x8ce,0xae8,0xd53,0x11d1,0x1759,0x228e,0x3256, + 0x4b4,0x4e9,0x511,0x53f,0x581,0x5ce,0x655,0x6e7,0x7e6,0x916,0xb2e,0xd95,0x1209,0x1784,0x22a9,0x3259, + 0x535,0x572,0x59c,0x5c6,0x60a,0x656,0x6d9,0x769,0x86b,0x993,0xba9,0xe0b,0x1273,0x17e2,0x22d9,0x3264, + 0x5cc,0x604,0x630,0x659,0x69e,0x6e8,0x76c,0x7f5,0x8f6,0xa1e,0xc26,0xe8a,0x12e6,0x184b,0x231a,0x3270, + 0x6de,0x70c,0x73a,0x760,0x7a4,0x7eb,0x86b,0x8f8,0x9ef,0xb15,0xd18,0xf6a,0x13b9,0x1908,0x23a2,0x328a, + 0x815,0x83e,0x86c,0x893,0x8d1,0x919,0x996,0xa20,0xb14,0xc2c,0xe2c,0x1075,0x14b1,0x19e6,0x2453,0x32bd, + 0xa35,0xa6d,0xa93,0xabb,0xaf6,0xb3d,0xbb4,0xc39,0xd26,0xe36,0x1022,0x125c,0x167f,0x1b94,0x25b3,0x3368, + 0xcb4,0xce9,0xd07,0xd2c,0xd69,0xdab,0xe1d,0xe9f,0xf7b,0x1085,0x1264,0x1483,0x1896,0x1d91,0x2766,0x3498, + 0x114f,0x1175,0x1195,0x11b3,0x11ea,0x1226,0x1289,0x1303,0x13d6,0x14ca,0x168f,0x189e,0x1c7a,0x2146,0x2add,0x3760, + 0x16fd,0x171b,0x1734,0x1754,0x177c,0x17af,0x180e,0x1872,0x192a,0x1a0f,0x1baf,0x1da6,0x2158,0x25f1,0x2f55,0x3b5a, + 0x2297,0x22b8,0x22c6,0x22d0,0x22f1,0x2307,0x2337,0x237b,0x2401,0x24a5,0x25fd,0x27ab,0x2b1d,0x2f8b,0x386d,0x438b, + 0x32fd,0x32f6,0x32fb,0x32f8,0x32f0,0x32ff,0x3300,0x3301,0x331d,0x3351,0x33f5,0x3513,0x37c6,0x3ba9,0x43b8,0x4d8f, + 0x4ce,0x513,0x53c,0x565,0x5aa,0x5f4,0x67d,0x70e,0x812,0x940,0xb59,0xdc4,0x1245,0x17cf,0x2317,0x32a5, + 0x510,0x53f,0x571,0x596,0x5dd,0x629,0x6b0,0x740,0x842,0x96d,0xb87,0xdf5,0x126a,0x17f3,0x231f,0x32a3, + 0x53d,0x56b,0x59c,0x5c4,0x609,0x653,0x6d9,0x769,0x86b,0x997,0xbae,0xe17,0x128c,0x180b,0x2331,0x3299, + 0x567,0x59c,0x5c2,0x5ed,0x630,0x67a,0x703,0x791,0x893,0x9be,0xbd3,0xe3b,0x12a8,0x1822,0x233f,0x329d, + 0x5a1,0x5de,0x608,0x633,0x677,0x6c1,0x742,0x7d3,0x8d4,0x9fb,0xc12,0xe72,0x12de,0x184e,0x2354,0x329c, + 0x5ef,0x627,0x653,0x67f,0x6c2,0x709,0x790,0x81a,0x91c,0xa41,0xc52,0xeb3,0x1315,0x1879,0x2365,0x329e, + 0x680,0x6af,0x6dc,0x705,0x746,0x78f,0x813,0x89f,0x999,0xac0,0xcc8,0xf21,0x137c,0x18d7,0x239a,0x32ad, + 0x712,0x741,0x76d,0x795,0x7d8,0x822,0x8a2,0x92d,0xa25,0xb40,0xd49,0xf9d,0x13eb,0x193c,0x23dd,0x32b0, + 0x811,0x848,0x871,0x899,0x8d7,0x91f,0x99f,0xa25,0xb1a,0xc37,0xe32,0x107b,0x14b6,0x19e8,0x245f,0x32bc, + 0x93e,0x975,0x99c,0x9c3,0xa02,0xa45,0xac4,0xb4b,0xc37,0xd4c,0xf40,0x117e,0x15ad,0x1ac9,0x24fb,0x32ee, + 0xb67,0xb99,0xbbe,0xbe0,0xc1d,0xc62,0xcd5,0xd56,0xe3c,0xf47,0x112d,0x135b,0x175e,0x1c68,0x264d,0x33a6, + 0xde0,0xe06,0xe2c,0xe4b,0xe88,0xec6,0xf38,0xfb1,0x108d,0x1190,0x1362,0x1582,0x1976,0x1e50,0x27f6,0x34ba, + 0x1265,0x1287,0x12a7,0x12c2,0x12fa,0x1334,0x1396,0x140a,0x14d3,0x15c3,0x1778,0x1977,0x1d42,0x21fa,0x2b36,0x3771, + 0x17f9,0x1816,0x1837,0x1852,0x1878,0x18ac,0x1900,0x195e,0x1a1a,0x1aea,0x1c8a,0x1e67,0x2207,0x2687,0x2fa7,0x3b5a, + 0x237c,0x2387,0x238a,0x23a2,0x23b7,0x23c6,0x23ff,0x2438,0x24b4,0x2559,0x269a,0x2838,0x2b7e,0x2fca,0x3894,0x4388, + 0x3325,0x333a,0x333e,0x3321,0x3335,0x3334,0x3334,0x3346,0x3355,0x3381,0x3420,0x3533,0x37dc,0x3bb2,0x43b0,0x4d97, + 0x728,0x74a,0x77b,0x7a4,0x7e6,0x830,0x8b4,0x940,0xa3a,0xb63,0xd6c,0xfd2,0x1434,0x19a5,0x24a9,0x3367, + 0x752,0x781,0x7aa,0x7d7,0x81a,0x85d,0x8e5,0x970,0xa69,0xb91,0xd9b,0xff7,0x145a,0x19bf,0x24ac,0x3364, + 0x775,0x7b0,0x7d8,0x802,0x842,0x88d,0x90d,0x99a,0xa92,0xbb4,0xdc3,0x1018,0x1474,0x19da,0x24b9,0x3366, + 0x7a1,0x7da,0x800,0x82b,0x86a,0x8b3,0x935,0x9bb,0xab7,0xbdb,0xde2,0x1039,0x1491,0x19ef,0x24c8,0x3366, + 0x7e4,0x817,0x844,0x86d,0x8ac,0x8f3,0x975,0xa00,0xaf4,0xc17,0xe1c,0x1072,0x14c1,0x1a19,0x24d7,0x3371, + 0x836,0x860,0x890,0x8b6,0x8f5,0x93e,0x9be,0xa46,0xb3c,0xc59,0xe5c,0x10ac,0x14f2,0x1a45,0x24ea,0x336c, + 0x8bc,0x8e9,0x90f,0x936,0x978,0x9bd,0xa3b,0xac3,0xbb4,0xcd0,0xec7,0x1116,0x1554,0x1a90,0x251e,0x3366, + 0x93f,0x977,0x99b,0x9c2,0xa03,0xa49,0xac4,0xb4c,0xc39,0xd51,0xf4b,0x118b,0x15c2,0x1aed,0x2553,0x336e, + 0xa3d,0xa72,0xa98,0xabe,0xaf9,0xb41,0xbb7,0xc3d,0xd25,0xe36,0x1027,0x1262,0x1675,0x1b9b,0x25b8,0x337d, + 0xb6c,0xb92,0xbb8,0xbe1,0xc1b,0xc5e,0xcd6,0xd53,0xe3a,0xf46,0x112b,0x135b,0x1768,0x1c69,0x2654,0x33b0, + 0xd84,0xda8,0xdd0,0xdef,0xe2c,0xe6b,0xed8,0xf57,0x1030,0x1135,0x1307,0x1523,0x1914,0x1df3,0x2780,0x3440, + 0xfe5,0x1008,0x1032,0x1052,0x1087,0x10c1,0x112d,0x11a0,0x1273,0x1369,0x152b,0x1738,0x1b03,0x1fc7,0x2919,0x353d, + 0x1453,0x147b,0x1493,0x14b1,0x14e1,0x1515,0x1575,0x15df,0x169e,0x1783,0x1926,0x1b17,0x1eb9,0x233e,0x2c3e,0x37d2, + 0x19cb,0x19f4,0x1a0a,0x1a18,0x1a48,0x1a74,0x1ac3,0x1b1f,0x1bc6,0x1c89,0x1e0c,0x1fda,0x234d,0x27af,0x303c,0x3b83, + 0x2515,0x2508,0x2521,0x252a,0x253a,0x254d,0x2578,0x25aa,0x2617,0x26a9,0x27d8,0x295f,0x2c6a,0x307a,0x38d2,0x4388, + 0x33fa,0x33fc,0x33ee,0x33f6,0x33f6,0x33e3,0x33ee,0x33fc,0x340b,0x3437,0x34be,0x35b5,0x3837,0x3bd8,0x43b0,0x4d91, + 0x9b4,0x9e8,0xa14,0xa3d,0xa7a,0xac4,0xb3f,0xbc9,0xcbd,0xdd5,0xfdc,0x122a,0x167e,0x1bd2,0x2698,0x349d, + 0x9e9,0xa1f,0xa43,0xa6f,0xaac,0xaf4,0xb71,0xbf7,0xcea,0xe04,0xfff,0x124b,0x1698,0x1beb,0x26b0,0x34ad, + 0xa10,0xa4b,0xa70,0xa96,0xad4,0xb15,0xb99,0xc1d,0xd08,0xe27,0x1020,0x1270,0x16b2,0x1c02,0x26ac,0x34a6, + 0xa40,0xa6a,0xa97,0xabc,0xafb,0xb41,0xbbb,0xc44,0xd33,0xe4a,0x1045,0x128d,0x16ce,0x1c19,0x26b3,0x34ae, + 0xa82,0xaab,0xad6,0xaf8,0xb3c,0xb7f,0xbf9,0xc7d,0xd6f,0xe85,0x1079,0x12c1,0x16f9,0x1c39,0x26c7,0x34a1, + 0xac9,0xaf7,0xb17,0xb45,0xb80,0xbc7,0xc3d,0xcc2,0xdaf,0xec4,0x10b8,0x12f4,0x1729,0x1c5b,0x26d2,0x34a2, + 0xb3e,0xb73,0xb97,0xbbd,0xbfb,0xc40,0xcb8,0xd39,0xe22,0xf35,0x1125,0x135a,0x1786,0x1cac,0x26f2,0x349c, + 0xbc9,0xbf6,0xc1d,0xc45,0xc81,0xcc3,0xd3b,0xdb7,0xea3,0xfb2,0x118d,0x13cd,0x17e6,0x1cf7,0x271f,0x34ab, + 0xcc5,0xced,0xd18,0xd35,0xd72,0xdb0,0xe25,0xea4,0xf83,0x108d,0x126c,0x1493,0x189d,0x1d9e,0x2778,0x34bc, + 0xde4,0xe0a,0xe32,0xe50,0xe88,0xecc,0xf3a,0xfb5,0x1090,0x1191,0x1365,0x1583,0x196a,0x1e54,0x2809,0x34d9, + 0xfe7,0x1018,0x1033,0x1055,0x1087,0x10c5,0x1131,0x11a4,0x1277,0x136f,0x152e,0x173a,0x1b11,0x1fc6,0x291b,0x3557, + 0x123f,0x126a,0x1286,0x12a7,0x12da,0x130e,0x1374,0x13e1,0x14a9,0x1591,0x1748,0x1940,0x1cf6,0x2184,0x2a71,0x363a, + 0x169d,0x16b1,0x16d5,0x16ee,0x1719,0x174c,0x17a2,0x1804,0x18be,0x1991,0x1b23,0x1cfd,0x207a,0x24e1,0x2d7d,0x3888, + 0x1c0c,0x1c1c,0x1c2f,0x1c46,0x1c69,0x1c91,0x1cdb,0x1d2a,0x1dc1,0x1e82,0x1fe7,0x21a3,0x24f0,0x2912,0x3167,0x3c15, + 0x26ed,0x2706,0x270f,0x2705,0x2725,0x2733,0x274c,0x2781,0x27df,0x285c,0x2969,0x2acc,0x2dbd,0x3191,0x3974,0x43ab, + 0x3535,0x352f,0x352e,0x3534,0x351f,0x3536,0x3534,0x3534,0x3546,0x355f,0x35d0,0x36ae,0x38ef,0x3c5a,0x43d3,0x4d89, + 0xe88,0xec0,0xede,0xf06,0xf41,0xf79,0xff4,0x1071,0x1158,0x1265,0x144e,0x1680,0x1aba,0x1ffb,0x2a79,0x3791, + 0xec0,0xeeb,0xf12,0xf30,0xf6b,0xfad,0x101f,0x109a,0x1182,0x128c,0x1473,0x16aa,0x1ad5,0x200b,0x2a6e,0x3785, + 0xee5,0xf0c,0xf35,0xf55,0xf90,0xfd0,0x1045,0x10bf,0x11a3,0x12aa,0x148f,0x16c5,0x1ae8,0x2019,0x2a7c,0x3781, + 0xf0a,0xf2f,0xf54,0xf77,0xfb4,0xff2,0x1065,0x10e4,0x11bb,0x12c8,0x14b0,0x16e0,0x1b01,0x2026,0x2a75,0x3784, + 0xf3c,0xf6d,0xf8c,0xfb5,0xfea,0x102a,0x1099,0x1117,0x11f7,0x12ff,0x14de,0x1708,0x1b1d,0x2042,0x2a84,0x3788, + 0xf7d,0xfb1,0xfd1,0xff4,0x102a,0x1068,0x10dc,0x1157,0x1232,0x133a,0x1509,0x173c,0x1b47,0x205e,0x2a88,0x3785, + 0xff1,0x101e,0x1042,0x1064,0x109f,0x10db,0x114b,0x11c4,0x1298,0x139f,0x1574,0x1790,0x1b99,0x2097,0x2a98,0x378d, + 0x1080,0x109f,0x10c7,0x10e3,0x111a,0x1156,0x11c2,0x123b,0x1311,0x140b,0x15da,0x17f8,0x1be3,0x20e1,0x2ac3,0x3786, + 0x1163,0x118d,0x11aa,0x11c8,0x11fd,0x1236,0x12a1,0x1314,0x13e2,0x14de,0x1694,0x18ac,0x1c8f,0x2156,0x2aff,0x378b, + 0x1267,0x1298,0x12b6,0x12d3,0x1305,0x133c,0x139f,0x1410,0x14dd,0x15c7,0x1784,0x1986,0x1d4f,0x2206,0x2b49,0x37a4, + 0x145e,0x1483,0x14a1,0x14bb,0x14ea,0x1523,0x1581,0x15e8,0x16ab,0x178e,0x1935,0x1b24,0x1eb1,0x234c,0x2c46,0x37e5, + 0x16a6,0x16c3,0x16de,0x16fc,0x1726,0x1753,0x17b0,0x180e,0x18c1,0x199a,0x1b28,0x1cfe,0x2082,0x24e2,0x2d8d,0x38a1, + 0x1ae5,0x1afc,0x1b10,0x1b19,0x1b49,0x1b70,0x1bbc,0x1c0c,0x1caf,0x1d68,0x1ed9,0x2094,0x23de,0x2803,0x301d,0x3aaa, + 0x202a,0x202d,0x204d,0x205a,0x2073,0x2091,0x20c8,0x210b,0x2189,0x222f,0x236d,0x24fc,0x2811,0x2bfb,0x33cf,0x3dab, + 0x2ad5,0x2ade,0x2ada,0x2adf,0x2ae0,0x2aee,0x2b01,0x2b17,0x2b59,0x2bba,0x2c96,0x2dd3,0x3072,0x33fd,0x3b49,0x44a4, + 0x380c,0x380d,0x3802,0x37f1,0x380c,0x3804,0x3806,0x380f,0x381b,0x381d,0x3864,0x390d,0x3af6,0x3e0a,0x44c4,0x4ddc, + 0x14a1,0x14b4,0x14df,0x14fb,0x1529,0x1567,0x15ce,0x163f,0x1711,0x180e,0x19d7,0x1bfe,0x200d,0x2529,0x2f46,0x3b86, + 0x14bc,0x14e2,0x14fe,0x1522,0x1555,0x158b,0x15f6,0x1668,0x172b,0x182b,0x19f8,0x1c15,0x201f,0x2535,0x2f53,0x3b8c, + 0x14d7,0x1506,0x1524,0x153f,0x156c,0x15a9,0x1612,0x1682,0x1751,0x1846,0x1a0f,0x1c29,0x202b,0x2540,0x2f54,0x3b82, + 0x14f7,0x1520,0x153c,0x1564,0x1590,0x15c8,0x1630,0x169c,0x176c,0x1861,0x1a18,0x1c3c,0x2038,0x2544,0x2f53,0x3b90, + 0x152c,0x1554,0x1573,0x1590,0x15c3,0x15f7,0x1660,0x16d0,0x178c,0x188b,0x1a4b,0x1c5e,0x205b,0x255d,0x2f4e,0x3b8e, + 0x156b,0x158a,0x15ae,0x15cc,0x15fb,0x1632,0x1692,0x1703,0x17c9,0x18b8,0x1a76,0x1c86,0x206c,0x256e,0x2f57,0x3b90, + 0x15d5,0x15f5,0x1617,0x1631,0x165d,0x1697,0x16f4,0x1762,0x1826,0x1915,0x1ac2,0x1cd0,0x20b3,0x2590,0x2f64,0x3b79, + 0x1640,0x166d,0x1687,0x16a1,0x16d4,0x1703,0x1761,0x17cd,0x188a,0x1973,0x1b24,0x1d21,0x20f0,0x25bf,0x2f61,0x3b90, + 0x1714,0x173d,0x1757,0x176f,0x179c,0x17d1,0x182a,0x188f,0x194b,0x1a26,0x1bc9,0x1dbf,0x2160,0x261e,0x2f8a,0x3b8a, + 0x181b,0x1839,0x184b,0x1869,0x1892,0x18c0,0x191d,0x1979,0x1a2d,0x1b08,0x1c9b,0x1e7c,0x221b,0x269e,0x2fc5,0x3b93, + 0x19ec,0x1a06,0x1a21,0x1a34,0x1a5f,0x1a86,0x1ada,0x1b34,0x1bd9,0x1ca6,0x1e23,0x1fed,0x2360,0x27bd,0x3061,0x3bbb, + 0x1c1c,0x1c29,0x1c47,0x1c58,0x1c77,0x1ca0,0x1ce8,0x1d37,0x1dd1,0x1e8e,0x1ff7,0x21aa,0x24f7,0x2923,0x3178,0x3c2c, + 0x2033,0x2048,0x2052,0x206e,0x2080,0x2098,0x20d2,0x2115,0x2194,0x2238,0x2374,0x2508,0x2817,0x2c02,0x33df,0x3dca, + 0x2562,0x2572,0x257d,0x2573,0x258b,0x25a0,0x25c5,0x25f6,0x264b,0x26d4,0x27e7,0x2942,0x2c15,0x2fc8,0x371f,0x407d, + 0x2fbc,0x2f9f,0x2fac,0x2fb5,0x2fb9,0x2fbe,0x2fc0,0x2fc4,0x2fe4,0x3022,0x30c5,0x31ca,0x3411,0x374e,0x3e1a,0x46cb, + 0x3c0e,0x3c0b,0x3c0a,0x3c0e,0x3c0e,0x3c00,0x3c11,0x3c0f,0x3c0c,0x3c11,0x3c2a,0x3c93,0x3e23,0x40c8,0x46e1,0x4f11, + 0x2117,0x212d,0x213f,0x214f,0x216d,0x218f,0x21c3,0x221f,0x22ba,0x236e,0x2505,0x26e9,0x2a9f,0x2f60,0x38a2,0x43af, + 0x212e,0x2140,0x2152,0x2160,0x217a,0x21a2,0x21e3,0x222a,0x22c6,0x2384,0x250d,0x26f1,0x2aab,0x2f65,0x38a6,0x43a3, + 0x213b,0x215a,0x2162,0x2171,0x2191,0x21af,0x21f0,0x223e,0x22d4,0x2396,0x2517,0x26f3,0x2aad,0x2f67,0x38a8,0x43bd, + 0x2150,0x2162,0x2176,0x2184,0x219d,0x21be,0x21fd,0x224c,0x22e5,0x23a1,0x251d,0x26f6,0x2aaf,0x2f6d,0x38a4,0x43b3, + 0x2178,0x2181,0x218a,0x21a1,0x21bc,0x21df,0x221e,0x2260,0x22fa,0x23b7,0x2522,0x270c,0x2ab4,0x2f68,0x38a3,0x43ad, + 0x2197,0x21aa,0x21b8,0x21c1,0x21de,0x21ff,0x2237,0x2286,0x231a,0x23d1,0x2541,0x2712,0x2ac2,0x2f74,0x389f,0x43a8, + 0x21d2,0x21e8,0x21fa,0x21ff,0x2218,0x2240,0x2275,0x22bf,0x2353,0x23fd,0x2573,0x273b,0x2ab8,0x2f72,0x38a4,0x43a7, + 0x2221,0x2233,0x223e,0x2257,0x226a,0x2283,0x22c1,0x2305,0x2392,0x2444,0x259d,0x2764,0x2aed,0x2f6d,0x38a6,0x43ad, + 0x22c2,0x22cd,0x22dd,0x22e9,0x22fc,0x231d,0x2350,0x2397,0x240d,0x24be,0x2616,0x27be,0x2b2f,0x2f9b,0x38a7,0x43b6, + 0x238b,0x2381,0x23a7,0x23ad,0x23c0,0x23d6,0x2406,0x2440,0x24c2,0x255f,0x269b,0x2844,0x2b92,0x2fde,0x38b7,0x438a, + 0x2513,0x2527,0x2529,0x2535,0x253e,0x254c,0x257f,0x25b3,0x2617,0x26b0,0x27d5,0x295d,0x2c73,0x3084,0x38ed,0x43ae, + 0x26fe,0x2714,0x2712,0x2714,0x2728,0x2732,0x274e,0x277c,0x27d9,0x2855,0x2966,0x2ad0,0x2db7,0x3194,0x397c,0x43cf, + 0x2ad9,0x2abe,0x2ad9,0x2adc,0x2ac5,0x2ae2,0x2afa,0x2b0d,0x2b53,0x2bb0,0x2c8b,0x2dcc,0x305f,0x33f6,0x3b3b,0x44ab, + 0x2fa8,0x2fa9,0x2fa1,0x2f9f,0x2fa8,0x2fa4,0x2fa4,0x2fb9,0x2fd1,0x3016,0x30ae,0x31ad,0x33fe,0x373e,0x3e05,0x46c2, + 0x38fe,0x3909,0x3903,0x38e8,0x3905,0x3906,0x3902,0x3908,0x390d,0x3905,0x3940,0x39d2,0x3b7b,0x3e38,0x443b,0x4c2e, + 0x4434,0x4427,0x442a,0x4425,0x4421,0x4434,0x4435,0x4425,0x442b,0x4428,0x4423,0x4444,0x4507,0x46ff,0x4c50,0x5388, + 0x3331,0x3338,0x3334,0x332b,0x3330,0x3322,0x332d,0x3336,0x332c,0x337d,0x341d,0x353b,0x3802,0x3bdf,0x43de,0x4dc4, + 0x333a,0x3336,0x3330,0x332a,0x3329,0x332d,0x332e,0x332b,0x3350,0x3377,0x341b,0x3543,0x37fc,0x3bd9,0x43d4,0x4dcf, + 0x333b,0x332e,0x3330,0x332e,0x3327,0x3334,0x3335,0x3331,0x3345,0x337a,0x3412,0x3544,0x37fe,0x3bd9,0x43d4,0x4dc4, + 0x3331,0x3332,0x332a,0x3330,0x3328,0x332f,0x3330,0x3334,0x3334,0x3378,0x3423,0x3528,0x37f7,0x3bd7,0x43d0,0x4dc7, + 0x3331,0x3333,0x3335,0x332b,0x332d,0x332c,0x332e,0x332f,0x3350,0x3370,0x3426,0x3545,0x37f6,0x3bde,0x43df,0x4dbb, + 0x3334,0x3338,0x332b,0x332b,0x3326,0x3333,0x3334,0x3330,0x334f,0x337e,0x3422,0x3546,0x37f8,0x3bbe,0x43d6,0x4dc6, + 0x332b,0x3332,0x3335,0x332f,0x3338,0x332f,0x3329,0x3340,0x334e,0x337e,0x3427,0x353d,0x3801,0x3be6,0x43db,0x4dbc, + 0x333f,0x3335,0x333d,0x3339,0x3339,0x3336,0x3331,0x3340,0x3355,0x337b,0x342c,0x354d,0x37ea,0x3bd7,0x43d8,0x4dbe, + 0x3357,0x334e,0x334d,0x3356,0x3355,0x3343,0x3352,0x334f,0x3363,0x339e,0x3438,0x354f,0x3800,0x3bd9,0x43e1,0x4db5, + 0x3375,0x3389,0x3381,0x3383,0x3388,0x3381,0x337f,0x338c,0x339a,0x33b6,0x345d,0x3563,0x3816,0x3be6,0x43d7,0x4db7, + 0x3436,0x3417,0x3430,0x3438,0x342b,0x3432,0x342a,0x3426,0x343d,0x3462,0x34e8,0x35e2,0x3853,0x3bfd,0x43e7,0x4da2, + 0x355e,0x3553,0x355a,0x355a,0x355b,0x3554,0x355b,0x3559,0x3558,0x357d,0x35e6,0x36c8,0x3908,0x3c76,0x43f1,0x4dc5, + 0x3822,0x3820,0x3829,0x3816,0x3820,0x3826,0x3801,0x381e,0x3828,0x3827,0x3874,0x3915,0x3b00,0x3e0c,0x44d7,0x4df6, + 0x3c11,0x3c0f,0x3c09,0x3c13,0x3bf2,0x3c0d,0x3c0c,0x3c00,0x3c10,0x3c0e,0x3c1e,0x3c98,0x3e1f,0x40c3,0x46eb,0x4f24, + 0x4431,0x4442,0x4434,0x4443,0x4438,0x4437,0x442f,0x4437,0x442f,0x443b,0x4431,0x4446,0x4519,0x4707,0x4c54,0x5394, + 0x4e4a,0x4e42,0x4e43,0x4e3b,0x4e41,0x4e3d,0x4e12,0x4e3b,0x4e3c,0x4e39,0x4e33,0x4e37,0x4e5a,0x4f7a,0x53b3,0x5a34,} Index: apps/codecs/libsc68/io68/shifter_io.c =================================================================== --- apps/codecs/libsc68/io68/shifter_io.c (revision 0) +++ apps/codecs/libsc68/io68/shifter_io.c (revision 0) @@ -0,0 +1,217 @@ +/* + * sc68 - Atari ST shifter IO plugin (50/60hz and resolution) + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#if defined(INCLUDE_SHARED68) +#include "emu68/struct68.h" +#endif + +typedef struct { + io68_t io; + u8 data_0a; + u8 data_60; +} shifter_io68_t; + +static int68_t _shifter_readB(shifter_io68_t * const shifterio, + addr68_t addr) +{ + switch ((u8)addr) { + case 0x0A: + return shifterio->data_0a; + case 0x60: + return shifterio->data_60; + } + return 0; +} + +static void _shifter_writeB(shifter_io68_t * const shifterio, + addr68_t addr, int68_t v) +{ + switch ((u8)addr) { + case 0x0A: + shifterio->data_0a = v; + break; + case 0x60: + shifterio->data_60 = v; + break; + } +} + + +static void shifter_readB(io68_t * const io68) +{ + emu68_t * const emu68 = io68->emu68; + emu68->bus_data = + _shifter_readB((shifter_io68_t*)io68, emu68->bus_addr); +} + + +static void shifter_readW(io68_t * const io68) +{ + emu68_t * const emu68 = io68->emu68; + io68->emu68->bus_data = + 0 + | (_shifter_readB((shifter_io68_t*)io68, emu68->bus_addr+0)<<8) + | (_shifter_readB((shifter_io68_t*)io68, emu68->bus_addr+1) ); +} + +static void shifter_readL(io68_t * const io68) +{ + emu68_t * const emu68 = io68->emu68; + emu68->bus_data = + 0 + | (_shifter_readB((shifter_io68_t*)io68, emu68->bus_addr+0)<<24) + | (_shifter_readB((shifter_io68_t*)io68, emu68->bus_addr+1)<<16) + | (_shifter_readB((shifter_io68_t*)io68, emu68->bus_addr+2)<<8 ) + | (_shifter_readB((shifter_io68_t*)io68, emu68->bus_addr+3) ); +} + +static void shifter_writeB(io68_t * const io68) +{ + emu68_t * const emu68 = io68->emu68; + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr, emu68->bus_data); +} + +static void shifter_writeW(io68_t * const io68) +{ + emu68_t * const emu68 = io68->emu68; + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr+0, emu68->bus_data>>8); + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr+1, emu68->bus_data ); +} + +static void shifter_writeL(io68_t * const io68) +{ + emu68_t * const emu68 = io68->emu68; + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr+0, emu68->bus_data>>24); + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr+1, emu68->bus_data>>16); + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr+2, emu68->bus_data>> 8); + _shifter_writeB((shifter_io68_t*)io68, + emu68->bus_addr+3, emu68->bus_data ); +} + +static interrupt68_t *shifter_interrupt(io68_t * const io, + const cycle68_t cycle) +{ + return 0; +} + +static cycle68_t shifter_next_interrupt(io68_t * const io, + const cycle68_t cycle) +{ + return IO68_NO_INT; +} + +static void _shifter_reset(shifter_io68_t * const shifter, const int hz) +{ + switch (hz) { + case 60: + shifter->data_0a = 0xfc; + shifter->data_60 = 0x00; + break; + case 70: + shifter->data_0a = 0xfe; + shifter->data_60 = 0x02; + break; + case 50: + default: + shifter->data_0a = 0xfe; + shifter->data_60 = 0x00; + } +} + +static int shifter_reset(io68_t * const io) +{ + if (io) { + _shifter_reset((shifter_io68_t *)io, 50); + return 0; + } else { + return -1; + } +} + +static void shifter_adjust_cycle(io68_t * const io, const cycle68_t cycle) +{ +} + +static void shifter_destroy(io68_t * const io) +{ + emu68_free(io); +} + +static io68_t const shifter_io = +{ + 0, + "Shifter", + 0xFFFF8200, 0xFFFF82FF, + shifter_readB, shifter_readW, shifter_readL, + shifter_writeB, shifter_writeW, shifter_writeL, + shifter_interrupt, shifter_next_interrupt, + shifter_adjust_cycle, + shifter_reset, + shifter_destroy, + 0 +}; + +int shifterio_init(int * argc, char ** argv) +{ + argc = argc; argv = argv; + return 0; +} + +void shifterio_shutdown(void) +{ +} + +io68_t * shifterio_create(emu68_t * const emu68, int hz) +{ + shifter_io68_t * const io = + emu68 + ? emu68_alloc(sizeof(*io)) + : 0 + ; + + if (io) { + io->io = shifter_io; + _shifter_reset(io, hz); + } + return &io->io; +} + +int shifterio_reset(io68_t * const io, int hz) +{ + if (io) { + _shifter_reset((shifter_io68_t *)io, hz); + return 0; + } else { + return -1; + } +} Index: apps/codecs/libsc68/io68/shifter_io.h =================================================================== --- apps/codecs/libsc68/io68/shifter_io.h (revision 0) +++ apps/codecs/libsc68/io68/shifter_io.h (revision 0) @@ -0,0 +1,93 @@ +/** + * @ingroup io68_lib + * @file io68/shifter_io.h + * @author Benjamin Gerard + * @date 1999/06/10 + * @brief shifter IO plugin header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_SHIFTER_IO_H_ +#define _IO68_SHIFTER_IO_H_ + +#include "io68_api.h" + +/** @defgroup io68_lib_shifter Atari-ST shifter (video chip) + * @ingroup io68_lib + * + * Atari-ST shifter emulator is limited to 50/60Hz detection. + * It is used by some player to adapt the replay speed. + * By default this shifter always claims to be in 50hz. + * + * + * Video address (Low byte always 0 on STF) + * + * - 8201 : Hi byte of video address + * - 8203 : Mid byte of video address + * + * Video counter (read only) + * + * - 8205 : Hi byte of video counter + * - 8207 : Mid byte of video counter + * - 8209 : Low byte of video counter + * + * Syncro mode + * + * - 820A : + * - bit-0 0:interne(*) 1:externe + * - bit-1 0:60hz 1:50hz + * + * Color table (16 word entries) + * + * - 8240-825E : + * - STF 3 bit per componant 0x777 + * - STE 4 bit per componant 0xFFF but msb is lsb + * (for backward compatibility) + * + * Resolution + * + * - 8260 (bit-1 bit-0) + * - 0 0 : 320x200x16 + * - 0 1 : 640x200x2 + * - 1 0 : 640x400x1 (70hz) + * - 1 1 : reserved + * @{ + */ + +IO68_EXTERN +/** Init shifter io library. + * @return error-code + */ +int shifterio_init(int * argc, char ** argv); + +IO68_EXTERN +/** Shutdown shifter io library. + */ +void shifterio_shutdown(void); + +IO68_EXTERN +/** Create shifter io instance. + * + * @param emu68 68000 emulator instance + * @param hz Initial frequency (50,60 or 70), default 50 + * + * @return Created shifter instance + * @retval 0 + */ +io68_t * shifterio_create(emu68_t * const emu68, int hz); + +IO68_EXTERN +/** Reset shifter and set new vertical refresh rate. */ +int shifterio_reset(io68_t * const io, int hz); + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _IO68_SHIFTER_IO_H_ */ Index: apps/codecs/libsc68/io68/mw_io.c =================================================================== --- apps/codecs/libsc68/io68/mw_io.c (revision 0) +++ apps/codecs/libsc68/io68/mw_io.c (revision 0) @@ -0,0 +1,286 @@ +/* + * sc68 - MicroWire IO plugin (STE soundchip) + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "mw_io.h" +#include "mwemul.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/struct68.h" +#include "emu68/assert68.h" +#endif + +typedef struct { + io68_t io; + mw_t mw; +} mw_io68_t; + +static int68_t _mw_readB(mw_io68_t * const mwio, const u8 addr) +{ + const uint_t ct = mwio->mw.ct >> mwio->mw.ct_fix; + + /* Just need to be sure no one reads these word registers in byte */ + assert(addr != MW_DATA); + assert(addr != MW_CTRL); + + switch (addr) { + case MW_CTH: + return (u8) ( ct >> 16 ); + case MW_CTM: + return (u8) ( ct >> 8 ); + case MW_CTL: + return (u8) ct; + } + /* return (addr >= 0 && addr < 64) */ + return (addr > 0 && addr < 64) + ? mwio->mw.map[addr] + : 0 + ; +} + +static int68_t _mw_readW(mw_io68_t * const mwio, const u8 addr) +{ + switch (mwio->io.emu68->bus_addr) { + case MW_DATA: case MW_CTRL: + return ( mwio->mw.map[addr+0] << 8 ) + mwio->mw.map[addr+1]; + break; + } + return _mw_readB(mwio, mwio->io.emu68->bus_addr+1); +} + +static void mwio_readB(io68_t * const io) +{ + io->emu68->bus_data = + _mw_readB((mw_io68_t *)io, io->emu68->bus_addr); +/* msg68_debug("microwire: read BYTE [%06x] => %02x\n", */ +/* io->emu68->bus_addr & 0xFFFFFF, */ +/* io->emu68->bus_data & 0xFFFFFFFF); */ +} + +static void mwio_readW(io68_t * const io) +{ + io->emu68->bus_data = + _mw_readW((mw_io68_t *)io, io->emu68->bus_addr); +/* msg68_debug("microwire: read WORD [%06x] => %04x\n", */ +/* io->emu68->bus_addr & 0xFFFFFF, */ +/* io->emu68->bus_data & 0xFFFF); */ +} + +static void mwio_readL(io68_t * const io) +{ + io->emu68->bus_data = + ( _mw_readW((mw_io68_t *)io, io->emu68->bus_addr+0) << 16 ) + | + ( _mw_readW((mw_io68_t *)io, io->emu68->bus_addr+2) ) + ; +/* msg68_debug("microwire: read LONG [%06x] => %08x\n", */ +/* io->emu68->bus_addr & 0xFFFFFF, */ +/* io->emu68->bus_data & 0xFFFFFFFF); */ +} + +static void _mw_writeB(mw_io68_t * const mwio, const u8 addr, int68_t v) +{ + /* Just need to be sure no one writes these word registers in byte */ + assert(addr != MW_DATA); + assert(addr != MW_CTRL); + + /* Skip even line in any case. */ + if ( ! ( addr & 1 ) ) { + return; + } + + switch (addr) { + + case MW_ACTI: + v &= 3; /* ??? should we ? */ + + /* Reload internal counters + * + * $$$ Should we do this whatever the value or only if dma is + * started ? This is probably not a great deal ! + */ + mwio->mw.ct = mw_counter_read(&mwio->mw,MW_BASH); + mwio->mw.end = mw_counter_read(&mwio->mw,MW_ENDH); + break; + + case MW_CTH: case MW_CTM: case MW_CTL: + return; + + } + + /* if (addr >= 0 && addr < 64) */ + if (addr > 0 && addr < 64) + mwio->mw.map[addr] = v; +} + +static void _mw_writeW(mw_io68_t * const mwio, const u8 addr, int68_t v) +{ + if (addr == MW_CTRL) { + mwio->mw.map[MW_CTRL+0] = v >> 8; + mwio->mw.map[MW_CTRL+1] = v; + } else if (addr == MW_DATA) { + mwio->mw.map[MW_DATA+0] = v >> 8; + mwio->mw.map[MW_DATA+1] = v; + mw_command(&mwio->mw); + } else if ( !(addr & 1) ) { + _mw_writeB(mwio, addr+1, v); + } +} + +static void _mw_writeL(mw_io68_t * const mwio, const u8 addr, int68_t v) +{ + if (addr == MW_DATA) { + /* Write both Ctrl and Data register .... My guess is that someone + * tries to run a command this way (which seems buggy in real + * world). + */ + mwio->mw.map[MW_DATA+0] = v >> 24; + mwio->mw.map[MW_DATA+1] = v >> 16; + mwio->mw.map[MW_CTRL+2] = v >> 8; + mwio->mw.map[MW_CTRL+3] = v; + + mw_command(&mwio->mw); + + } else if ( !(addr & 1) ) { + /* Any other (even) long access are translate to word access */ + _mw_writeW(mwio, addr+0, v); + _mw_writeW(mwio, addr+2, v >> 16); + } +} + +static void mwio_writeB(io68_t * const io) +{ +/* msg68_debug("microwire: write BYTE [%06x] <= %02x\n", */ +/* io->emu68->bus_addr & 0xFFFFFF, */ +/* io->emu68->bus_data & 0xFF); */ + _mw_writeB((mw_io68_t *)io, + io->emu68->bus_addr, io->emu68->bus_data); +} + +static void mwio_writeW(io68_t * const io) +{ +/* msg68_debug("microwire: write WORD [%06x] <= %04x\n", */ +/* io->emu68->bus_addr & 0xFFFFFF, */ +/* io->emu68->bus_data & 0xFFFF); */ + _mw_writeW((mw_io68_t *)io, + io->emu68->bus_addr, io->emu68->bus_data); +} + +static void mwio_writeL(io68_t * const io) +{ +/* msg68_debug("microwire: write LONG [%06x] <= %08x\n", */ +/* io->emu68->bus_addr & 0xFFFFFF, */ +/* io->emu68->bus_data & 0xFFFFFFFF); */ + _mw_writeL((mw_io68_t *)io, + io->emu68->bus_addr, io->emu68->bus_data); +} + +static interrupt68_t * mwio_interrupt(io68_t * const io, cycle68_t cycle) +{ + return 0; +} + +static cycle68_t mwio_next_interrupt(io68_t * const io, cycle68_t cycle) +{ + return IO68_NO_INT; +} + +static void mwio_adjust_cycle(io68_t * const io, cycle68_t cycle) +{ +} + +static int mwio_reset(io68_t * const io) +{ + return mw_reset(&((mw_io68_t *)io)->mw); +} + +static void mwio_destroy(io68_t * const io) +{ + if (io) { + mw_cleanup(&((mw_io68_t *)io)->mw); + } +} + +static io68_t mw_io = { + 0, + "STE-MicroWire", + 0xFFFF8900, 0xFFFF8925, + mwio_readB, mwio_readW, mwio_readL, + mwio_writeB, mwio_writeW, mwio_writeL, + mwio_interrupt, mwio_next_interrupt, + mwio_adjust_cycle, + mwio_reset, + mwio_destroy, + 0 +}; + +int mwio_init(int * argc, char ** argv) +{ + return mw_init(argc, argv); +} + +void mwio_shutdown(void) +{ + mw_shutdown(); +} + +io68_t * mwio_create(emu68_t * const emu68, mw_parms_t * const parms) +{ + mw_io68_t * mwio = 0; + + if (emu68) { + mwio = emu68_alloc(sizeof(*mwio)); + if (mwio) { + mw_setup_t setup; + if (parms) { + setup.parms = *parms; + } else { + setup.parms.engine = MW_ENGINE_DEFAULT; + setup.parms.hz = 0; + } + setup.mem = emu68->mem; + setup.log2mem = emu68->log2mem; + mwio->io = mw_io; + mw_setup(&mwio->mw, &setup); + } + } + return &mwio->io; +} + +mw_t * mwio_emulator(io68_t * const io) +{ + return io + ? &((mw_io68_t*)io)->mw + : 0 + ; +} + +int mwio_sampling_rate(io68_t * const io, int sampling_rate) +{ + return mw_sampling_rate(mwio_emulator(io), sampling_rate); +} Index: apps/codecs/libsc68/io68/ym_io.c =================================================================== --- apps/codecs/libsc68/io68/ym_io.c (revision 0) +++ apps/codecs/libsc68/io68/ym_io.c (revision 0) @@ -0,0 +1,337 @@ +/* + * sc68 - YM-2149 io plugin + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "ym_io.h" +#include "ymemul.h" + +typedef struct +{ + io68_t io; + struct { + int68_t mul; + uint68_t div; + } clock; + + ym_t ym; +} ym_io68_t; + +/* Convert cpu-cycle to ym-cycle. */ +static inline +cycle68_t cycle_cputoym(const ym_io68_t * const ymio, const cycle68_t cycle) +{ + if (!ymio->clock.div) { + return ymio->clock.mul < 0 + ? (cycle >> -ymio->clock.mul) + : (cycle << ymio->clock.mul) + ; + } else { + u64 cycle64 = cycle; + cycle64 *= ymio->clock.mul; + cycle64 /= ymio->clock.div; + return cycle64; + } +} + +/* Convert ym-cycle to cpu-cycle. */ +static inline +cycle68_t cycle_ymtocpu(const ym_io68_t * const ymio, const cycle68_t cycle) +{ + if (!ymio->clock.div) { + return ymio->clock.mul < 0 + ? (cycle << -ymio->clock.mul) + : (cycle >> ymio->clock.mul) + ; + } else { + u64 cycle64 = cycle; + cycle64 *= ymio->clock.div; + cycle64 /= ymio->clock.mul; + return cycle64; + } +} + + +static inline +int _readB(ym_io68_t * const ymio, + const addr68_t addr, const cycle68_t ymcycle) +{ + return (addr&3) + ? 0 + : ym_readreg(&ymio->ym, ymcycle) + ; +} + + +static void ymio_readB(io68_t * const io) +{ + emu68_t * const emu68 = io->emu68; + ym_io68_t * const ymio = (ym_io68_t *)io; + cycle68_t ymcycle = cycle_cputoym(ymio,emu68->cycle); + emu68->bus_data = + _readB(ymio,emu68->bus_addr,ymcycle); +} + +static inline +int _readW(ym_io68_t * const ymio, + const addr68_t addr, const cycle68_t ymcycle) +{ + return (addr&3) + ? 0 + : (ym_readreg(&ymio->ym, ymcycle)<<8) + ; +} + +static void ymio_readW(io68_t * const io) +{ + emu68_t * const emu68 = io->emu68; + ym_io68_t * const ymio = (ym_io68_t *)io; + const cycle68_t ymcycle = cycle_cputoym(ymio,emu68->cycle); + emu68->bus_data = + _readW(ymio,emu68->bus_addr,ymcycle); +} + +static inline +int68_t _readL(ym_io68_t * const ymio, + const addr68_t addr, const cycle68_t ymcycle) +{ + return (_readW(ymio,addr,ymcycle) << 16) | _readW(ymio,addr+2,ymcycle); +} + +static void ymio_readL(io68_t * const io) +{ + emu68_t * const emu68 = io->emu68; + ym_io68_t * const ymio = (ym_io68_t *)io; + cycle68_t ymcycle = cycle_cputoym(ymio,emu68->cycle); + emu68->bus_data = + _readL(ymio, emu68->bus_addr, ymcycle); +} + +static inline +void _writeB(ym_io68_t * const ymio, + const addr68_t addr, const int68_t v, const cycle68_t ymcycle) +{ + if (!(addr&2)) { + /* CTRL register */ + ymio->ym.ctrl = (u8)v; + } else { + /* DATA register */ + ym_writereg(&ymio->ym, (u8)v, ymcycle); + } +} + +static void ymio_writeB(io68_t * const io) +{ + const emu68_t * const emu68 = io->emu68; + ym_io68_t * const ymio = (ym_io68_t *)io; + const cycle68_t ymcycle = cycle_cputoym(ymio,emu68->cycle); + _writeB(ymio,emu68->bus_addr,emu68->bus_data,ymcycle); +} + +static inline +void _writeW(ym_io68_t * const ymio, + const addr68_t addr, const int68_t v, const cycle68_t ymcycle) +{ + _writeB(ymio,addr,v>>8,ymcycle); + /* that's the way it is ! */ + /* _writeB(ymio, addr+1, v, cycle); */ +} + +static void ymio_writeW(io68_t * const io) +{ + const emu68_t * const emu68 = io->emu68; + ym_io68_t * const ymio = (ym_io68_t *)io; + const cycle68_t ymcycle = cycle_cputoym(ymio,emu68->cycle); + _writeW(ymio,emu68->bus_addr,emu68->bus_data,ymcycle); +} + +static void ymio_writeL(io68_t * const io) +{ + const emu68_t * const emu68 = io->emu68; + const addr68_t addr = emu68->bus_addr; + const int68_t data = emu68->bus_data; + ym_io68_t * const ymio = (ym_io68_t *)io; + const cycle68_t ymcycle = cycle_cputoym(ymio,emu68->cycle); + _writeW(ymio, addr , data>>16, ymcycle); + _writeW(ymio, addr+2, data, ymcycle); +} + +static interrupt68_t * +ymio_interrupt(io68_t * const io, const cycle68_t cycle) +{ + return 0; +} + +static cycle68_t +ymio_nextinterrupt(io68_t * const io, const cycle68_t cycle) +{ + return IO68_NO_INT; +} + +static int ymio_reset(io68_t * const io) +{ + ym_io68_t * const ymio = (ym_io68_t *)io; + const cycle68_t ymcycle = cycle_cputoym(ymio,io->emu68->cycle); + ym_reset(&ymio->ym,ymcycle); + return 0; +} + +static void ymio_adjust_cycle(io68_t * const io, const cycle68_t cycle) +{ + ym_io68_t * const ymio = (ym_io68_t *)io; + const cycle68_t ymcycle = cycle_cputoym(ymio,io->emu68->cycle); + ym_adjust_cycle(&ymio->ym, ymcycle); +} + + +static void ymio_destroy(io68_t * const io) +{ + if (io) { + ym_io68_t * const ymio = (ym_io68_t *)io; + + ym_cleanup(&ymio->ym); + emu68_free(io); + } +} + +static io68_t ym_io = +{ + 0, + "YM-2149", + 0xFFFF8800, 0xFFFF88FF, + ymio_readB, ymio_readW, ymio_readL, + ymio_writeB, ymio_writeW, ymio_writeL, + ymio_interrupt, ymio_nextinterrupt, + ymio_adjust_cycle, + ymio_reset, + ymio_destroy, + 0 +}; + +int ymio_init(int * argc, char ** argv) +{ + return ym_init(argc,argv); +} + +void ymio_shutdown(void) +{ + ym_shutdown(); +} + +static int get_power_of_2(int v) +{ + int p,r; + for ( p=0,r=1; r; ++p, r<<=1 ) { + if (r == v) return p; + } + return -1; +} + + +io68_t * ymio_create(emu68_t * const emu68, ym_parms_t * const parms) +{ + ym_io68_t * ymio = 0; + + if (emu68) { + ymio = emu68_alloc(sizeof(*ymio)); + if (ymio) { + int s,p; + uint68_t quotient,numerator,denominator; + ymio->io = ym_io; + ym_setup(&ymio->ym, parms); + + if (emu68->clock > ymio->ym.clock) { + numerator = emu68->clock; + denominator = ymio->ym.clock; + s = -1; + } else { + numerator = ymio->ym.clock; + denominator = emu68->clock; + s = 1; + } + quotient = numerator / denominator; + + if (quotient * denominator == numerator && + (p = get_power_of_2(quotient), p >= 0)) { + ymio->clock.div = 0; + ymio->clock.mul = s*p; + } else { + ymio->clock.div = emu68->clock; + ymio->clock.mul = ymio->ym.clock; + } + } + } + return &ymio->io; +} + +int ymio_sampling_rate(io68_t * const io, int sampling_rate) +{ + return io + ? ym_sampling_rate(&((ym_io68_t*)io)->ym,sampling_rate) + : sampling_rate + ; +} + +ym_t * ymio_emulator(io68_t * const io) +{ + return io + ? &((ym_io68_t*)io)->ym + : 0 + ; +} + +uint68_t ymio_buffersize(const io68_t * const io, const cycle68_t cycles) +{ + if (io) { + const ym_io68_t * const ymio = (const ym_io68_t *)io; + return ym_buffersize(&ymio->ym,cycle_cputoym(ymio,cycles)); + } + return 0; +} + +int ymio_run(const io68_t * const io, s32 * output, const cycle68_t cycles) +{ + if (io) { + ym_io68_t * const ymio = (ym_io68_t *)io; + return ym_run(&ymio->ym,output,cycle_cputoym(ymio,cycles)); + } + return 0; +} + +/** Convert a cpu-cycle to ym-cycle. */ +cycle68_t ymio_cycle_cpu2ym(const io68_t * const io, const cycle68_t cycles) +{ + ym_io68_t * const ymio = (ym_io68_t *)io; + return cycle_cputoym(ymio,cycles); +} + +/** Convert a ym-cycle to cpu-cycle. */ +cycle68_t ymio_cycle_ym2cpu(const io68_t * const io, const cycle68_t cycles) +{ + ym_io68_t * const ymio = (ym_io68_t *)io; + return cycle_ymtocpu(ymio,cycles); +} Index: apps/codecs/libsc68/io68/mw_io.h =================================================================== --- apps/codecs/libsc68/io68/mw_io.h (revision 0) +++ apps/codecs/libsc68/io68/mw_io.h (revision 0) @@ -0,0 +1,81 @@ +/** + * @ingroup io68_lib + * @file io68/mw_io.h + * @author Benjamin Gerard + * @date 1999/03/20 + * @brief STE sound IO plugin header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_MW_IO_H_ +#define _IO68_MW_IO_H_ + +#include "io68_api.h" +#include "mwemul.h" + +/** @addtogroup io68_lib_mw + * @{ + */ + +/** @name Microwire/LMC (STE sound) IO plugin. + * @{ + */ + +IO68_EXTERN +/** Init the mwio library. + * + * The mwio_init() function setup the microwire IO plugin and the + * microwire emulator library by calling the mw_init() function. + * + * @param argc pointer to argument count + * @param argv arguemnt array + * @return error status + * @retval 0 on success + * @retval -1 on success + */ +int mwio_init(int * argc, char ** argv); + +IO68_EXTERN +/** Shutdown mwio library. */ +void mwio_shutdown(void); + +IO68_EXTERN +/** Create a microwire plugin instance. */ +io68_t * mwio_create(emu68_t * emu68, mw_parms_t * const parms); + +IO68_EXTERN +/** Get/Set sampling rate. + * + * @param io MW IO instance + * @param hz @ref mw_hz_e "sampling rate" + * + * @return current @ref mw_hz_e "sampling rate" + * + */ +int mwio_sampling_rate(io68_t * const io, int hz); + +IO68_EXTERN +/** Get/Set emulator engine. + * + * @param io MW IO instance + * @param engine @ref mw_engine_e "MW engine descriptor" + * + * @return @ref mw_engine_e "MW engine descriptor" + */ +uint68_t mwio_engine(io68_t * const io, int); + +IO68_EXTERN +/** Get microwire emulator instance attached to the mwio plugin. */ +mw_t * mwio_emulator(io68_t * const io); + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _IO68_MW_IO_H_ */ Index: apps/codecs/libsc68/io68/ym_io.h =================================================================== --- apps/codecs/libsc68/io68/ym_io.h (revision 0) +++ apps/codecs/libsc68/io68/ym_io.h (revision 0) @@ -0,0 +1,94 @@ +/** + * @ingroup io68_ym_devel + * @file io68/ym_io.h + * @author Benjamin Gerard + * @date 1999/03/20 + * @brief YM-2149 emulator plugin header. + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_YM_IO_H_ +#define _IO68_YM_IO_H_ + +#include "io68_api.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/struct68.h" +#endif + +#include "ymemul.h" + +/** @addtogroup io68_ym_devel + * @{ + */ + +/** @name Yamaha-2149 IO plugin + * @{ + */ + +IO68_EXTERN +/** Initialize YM-2149 library. */ +int ymio_init(int * argc, char ** argv); + +IO68_EXTERN +/** Shutdown YM-2149 library. */ +void ymio_shutdown(void); + +IO68_EXTERN +/** Create Yamaha-2149 IO plugin instance. + * + * @param emu68 68K emulator instance + * @param parms YM-2149 creation parameters + * + * @return created io instance + * @retval 0 Failure + */ +io68_t * ymio_create(emu68_t * const emu68, ym_parms_t * const parms); + +IO68_EXTERN +/** Get/Set sampling rate. + * + * @param io YM IO instance + * @param hz 0:read current sampling rate, >0:new requested sampling rate + * + * @return actual sampling rate + * + */ +int ymio_sampling_rate(io68_t * const io, int sampling_rate); + +IO68_EXTERN +/** Get ym-2149 emulator instance. */ +ym_t * ymio_emulator(io68_t * const io); + +IO68_EXTERN +/** Run ym emulator. + * @see ym_run() + */ +int ymio_run(const io68_t * const io, s32 * output, const cycle68_t cycles); + +IO68_EXTERN +/** Get required sample buffer size. + * @see ym_buffersize() + */ +uint68_t ymio_buffersize(const io68_t * const io, const cycle68_t cycles); + +IO68_EXTERN +/** Convert a cpu-cycle to ym-cycle. */ +cycle68_t ymio_cycle_cpu2ym(const io68_t * const io, const cycle68_t cycles); + +IO68_EXTERN +/** Convert a ym-cycle to cpu-cycle. */ +cycle68_t ymio_cycle_ym2cpu(const io68_t * const io, const cycle68_t cycles); + + +/** @} */ + +/** + * @} + */ + +#endif /* #ifndef _IO68_YM_IO_H_ */ Index: apps/codecs/libsc68/io68/io68_api.h =================================================================== --- apps/codecs/libsc68/io68/io68_api.h (revision 0) +++ apps/codecs/libsc68/io68/io68_api.h (revision 0) @@ -0,0 +1,31 @@ +/** + * @ingroup io68_devel + * @file io68/io68_api.h + * @author Benjamin Gerard + * @date 2009/02/10 + * @brief io68 export header. + * + */ + +/* $Id: io68.h 75 2009-02-04 19:12:14Z benjihan $ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifndef _IO68_IO68_API_H_ +#define _IO68_IO68_API_H_ + +#ifndef IO68_API +# ifdef IO68_EXPORT +# include "sc68/sc68.h" +# define IO68_EXTERN SC68_EXTERN +# define IO68_API SC68_API +# elif defined (__cplusplus) +# define IO68_EXTERN extern "C" +# define IO68_API IO68_EXTERN +# else +# define IO68_EXTERN extern +# define IO68_API IO68_EXTERN +# endif +#endif + +#endif /* #ifndef _IO68_IO68_API_H_ */ Index: apps/codecs/libsc68/io68/paulaemul.c =================================================================== --- apps/codecs/libsc68/io68/paulaemul.c (revision 0) +++ apps/codecs/libsc68/io68/paulaemul.c (revision 0) @@ -0,0 +1,519 @@ +/* + * sc68 - Paula emulator (Amiga soundchip) + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + * $Id$ + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef HAVE_CONFIG_OPTION68_H +# include +#else +# include "default_option68.h" +#endif + +#include "paulaemul.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/assert68.h" +#include "file68/msg68.h" +#endif + +#ifndef DEBUG_PL_O +# define DEBUG_PL_O 0 +#endif +int pl_cat = msg68_DEFAULT; + +/* Define this once to calculate and copy past the volume table. This + * is required only if PL_VOL_FIX or Tvol[] are modified. + */ +#undef PAULA_CALCUL_TABLE + +#ifdef PAULA_CALCUL_TABLE +# include +# include +#endif + +#define PL_VOL_FIX 16 +#define PL_VOL_MUL (1<ct_fix; + const int fix = 40; + + paula->hz = f; + paula->clock = clock_type; + tmp = (clock_type == PAULA_CLOCK_PAL) + ? PAULA_PAL_FRQ + : PAULA_NTSC_FRQ + ; + tmp <<= fix; + tmp /= f; + + if ( ct_fix < fix ) + tmp >>= fix - ct_fix; + else + tmp <<= ct_fix - fix; + msg68(pl_cat,"paula : clock -- *%s*\n", + clock_type == PAULA_CLOCK_PAL ? "PAL" : "NTSC"); + paula->clkperspl = (plct_t) tmp; + return f; +} + +int paula_sampling_rate(paula_t * const paula, int hz) +{ + switch (hz) { + case PAULA_HZ_QUERY: + hz = paula ? (int) paula->hz : default_parms.hz; + break; + + case PAULA_HZ_DEFAULT: + hz = default_parms.hz; + + default: + if (hz < SAMPLING_RATE_MIN) { + msg68(pl_cat,"paula : sampling rate out of range -- *%dhz*\n", hz); + hz = SAMPLING_RATE_MIN; + } + if (hz > SAMPLING_RATE_MAX) { + msg68(pl_cat,"paula : sampling rate out of range -- *%dhz*\n", hz); + hz = SAMPLING_RATE_MAX; + } + if (!paula) { + default_parms.hz = hz; + } else { + set_clock(paula, paula->clock, hz); + } + msg68(pl_cat,"paula : %s sampling rate -- *%dhz*\n", + paula ? "select" : "default", hz); + break; + } + return hz; +} + +/* ,-----------------------------------------------------------------. + * | Set/Get emulator engine | + * `-----------------------------------------------------------------' + */ + +static +const char * pl_engine_name(const int engine) +{ + switch (engine) { + case PAULA_ENGINE_SIMPLE: return "SIMPLE"; + case PAULA_ENGINE_LINEAR: return "LINEAR"; + } + return 0; +} + +int paula_engine(paula_t * const paula, int engine) +{ + switch (engine) { + case PAULA_ENGINE_QUERY: + engine = paula ? paula->engine : default_parms.engine; + break; + + default: + msg68_warning("paula : invalid engine -- %d\n", engine); + case PAULA_ENGINE_DEFAULT: + engine = default_parms.engine; + case PAULA_ENGINE_SIMPLE: + case PAULA_ENGINE_LINEAR: + *(paula ? &paula->engine : &default_parms.engine) = engine; + msg68(pl_cat, "paula : %s engine -- *%s*\n", + paula ? "select" : "default", + pl_engine_name(engine)); + break; + } + return engine; +} + +int paula_clock(paula_t * const paula, int clock) +{ + switch (clock) { + case PAULA_CLOCK_QUERY: + clock = paula ? paula->clock : default_parms.clock; + break; + + default: + clock = default_parms.clock; + case PAULA_CLOCK_PAL: + case PAULA_CLOCK_NTSC: + if (paula) { + set_clock(paula, clock, paula->hz); + } else { + default_parms.clock = clock; + } + break; + } + return clock; +} + +/* ,-----------------------------------------------------------------. + * | paula reset | + * `-----------------------------------------------------------------' + */ + +int paula_reset(paula_t * const paula) +{ + unsigned i; + + /* reset shadow registers */ + for (i=0; imap); i++) { + paula->map[i] = 0; + } + + /* reset voices */ + for (i=0; i<4; i++) { + paula->voice[i].adr = 0; + paula->voice[i].start = 0; + paula->voice[i].end = 2; + } + + /* Reset DMACON and INTENA/REQ to something that + * seems acceptable to me. + */ + paula->dmacon = 1 << 9; /* DMA general activate, DMA audio desactivate. */ + paula->intreq = 0; /* No interrupt request. */ + paula->intena = 1 << 14; /* Master interrupt enable, audio int disable. */ + paula->adkcon = 0; /* No modulation. */ + + return 0; +} + +void paula_cleanup(paula_t * const paula) {} + +static void pl_info(paula_t * const paula) +{ + const char * clock = (paula->clock == PAULA_CLOCK_PAL) + ? "PAL" + : "NTSC" + ; + + msg68_info("paula : engine -- *%s*\n", pl_engine_name(paula->engine)); + msg68_info("paula : clock -- *%s*\n", clock); + msg68_info("paula : sampling rate -- *%dhz*\n", (int)paula->hz); +} + + +int paula_setup(paula_t * const paula, + paula_setup_t * const setup) +{ + + if (!paula || !setup || !setup->mem) { + return -1; + } + + /* Default sampling rate */ + if (!setup->parms.hz) { + setup->parms.hz = default_parms.hz; + } + + /* Default clock mode */ + if (setup->parms.clock == PAULA_CLOCK_DEFAULT) { + setup->parms.clock = default_parms.clock; + } + + paula->mem = setup->mem; + paula->log2mem = setup->log2mem; + paula->ct_fix = ( sizeof(plct_t) << 3 ) - paula->log2mem; + + setup->parms.engine = paula_engine(paula, setup->parms.engine); + paula_reset(paula); + set_clock(paula, setup->parms.clock, setup->parms.hz); + + pl_info(paula); + + return 0; +} + +#if 0 +static void poll_irq(paula_t * const paula, unsigned int N) +{ + u8 *p = paula->map + PAULA_VOICE(N); + paulav_t * w = paula->voice+N; + + /* Reload internal when interrupt is DENIED */ + if ( + (paula->intreq + | + ~((paula->intena << (8*sizeof(int)-1-14) >> (8*sizeof(int)-1)) + & paula->intena)) & (1 << (N + 7))) { + uint68_t a,l; + + /* Get sample pointer. */ + a = (uint68_t) ( ((p[1] << 16) | (p[2] << 8) | p[3]) & 0x7FFFE ) + << PAULA_ct_fix; + w->adr = w->start = a; + /* Get length */ + l = (p[4] << 8) | p[5]; + l |= (!l) << 16; + l <<= (1 + PAULA_ct_fix); + w->end = a + l; + } + paula->intreq |= 1 << (N + 7); +} +#endif + +/* Mix with laudio channel data (1 char instead of 2) */ + +static void mix_one(paula_t * const paula, + int N, const int shift, + s32 * b, int n) +{ + const u8 * const mem = paula->mem; + paulav_t * const w = paula->voice+N; + u8 * const p = paula->map+PAULA_VOICE(N); + s16 * b2 = (s16 *)b + shift; + const int ct_fix = paula->ct_fix; + plct_t adr, stp, readr, reend, end, vol, per; + u8 last, hasloop; + + /* Mask to get the fractionnal part of the sample counter. Therefore + * forcing it to 0 will disable linear interpolation by forcing + * exact sample point. + */ + const plct_t imask = paula->engine == PAULA_ENGINE_LINEAR + ? ( ( (plct_t) 1 << ct_fix ) - 1 ) + : 0 + ; + const signed_plct_t one = (signed_plct_t) 1 << ct_fix; + + hasloop = 0; + + /* $$$ dunno exactly what if volume is not in proper range [0..64] */ + vol = p[9] & 127; + if (vol >= 64) { + vol = 64; + } + vol = volume[vol]; + + per = ( p[6] << 8 ) + p[7]; + if (!per) per = 1; /* or is it +1 for all ?? */ + stp = paula->clkperspl / per; + + /* Audio irq disable for this voice : + * Internal will be reload at end of block + */ + readr = ( p[1] << 16 ) | ( p[2] << 8 ) | p[3]; + readr <<= ct_fix; + reend = ((p[4] << 8) | p[5]); + reend |= (!reend) << 16; /* 0 is 0x10000 */ + reend <<= (1 + ct_fix); /* +1 as unit is 16-bit word */ + reend += readr; + assert( reend > readr ); + if (reend < readr) { + /* $$$ ??? dunno why I did this !!! */ + return; + } + + adr = w->adr; + end = w->end; + if (end < adr) { + return; + } + + /* mix stereo */ + do { + int idx; + signed_plct_t low, v0, v1; + + low = adr & imask; + idx = adr >> ct_fix; /* current index */ + last = mem[idx++]; /* save last sample read */ + + if ( ( (plct_t) idx << ct_fix ) >= end ) + idx = readr >> ct_fix; /* loop index */ + v1 = (s8) mem[idx]; /* next sample */ + v0 = (s8) last; /* current sample */ + + /* linear interpolation (or not if imask is zero) */ + v0 = ( v1 * low + v0 * ( one - low ) ) >> ct_fix; + + /* apply volume */ + v0 *= vol; + v0 >>= PL_MIX_FIX; + + if (v0 < -16384 || v0 >= 16384) + msg68_critical("paula : pcm clipping -- %d\n", (int) v0); + + assert(v0 >= -16384); + assert(v0 < 16384); + + /* Store and advance output buffer */ + *b2 += v0; + b2 += 2; + + /* Advance */ + adr += stp; + if (adr >= end) { + plct_t relen = reend - readr; + hasloop = 1; + adr = readr + adr - end; + end = reend; + while (adr >= end) { + adr -= relen; + } + } + } while (--n); + + last &= 0xFF; + p[0xA] = last + (last << 8); + w->adr = adr; + if (hasloop) { + w->start = readr; + w->end = end; + } +} + +/* ,-----------------------------------------------------------------. + * | Paula process | + * `-----------------------------------------------------------------' + */ + +static void clear_buffer(s32 * b, int n) +{ + const s32 v = 0; + if (n & 1) { *b++ = v; } + if (n & 2) { *b++ = v; *b++ = v; } + if (n >>= 2, n) do { + *b++ = v; *b++ = v; *b++ = v; *b++ = v; + } while (--n); +} + +void paula_mix(paula_t * const paula, s32 * splbuf, int n) +{ + + if ( n > 0 ) { + int i; + clear_buffer(splbuf, n); + for (i=0; i<4; i++) { + const int right = (i^msw_first)&1; + if ((paula->dmacon >> 9) & (paula->dmacon >> i) & 1) { + mix_one(paula, i, right, splbuf, n); + } + } + } + + /* HaxXx: assuming next mix is next frame reset beam V/H position. */ + paula->vhpos = 0; +} Index: apps/codecs/libsc68/io68/io68.c =================================================================== --- apps/codecs/libsc68/io68/io68.c (revision 0) +++ apps/codecs/libsc68/io68/io68.c (revision 0) @@ -0,0 +1,77 @@ +/* + * sc68 - IO plugin initialization + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "io68.h" + +#if defined(INCLUDE_SHARED68) +#include "file68/msg68.h" +#endif + +static const struct { + const char * name; + int (* init) (int *, char **); + void (* shutdown)(void); +} func[] = { + { "paula", paulaio_init, paulaio_shutdown }, + { "ym-2149", ymio_init, ymio_shutdown }, + { "microwire", mwio_init, mwio_shutdown }, + { "mfp-68901", mfpio_init, mfpio_shutdown }, + { "shifter", shifterio_init, shifterio_shutdown }, +}; + +const int max = sizeof(func) / sizeof(*func); + +int io68_init(int * argc, char ** argv) +{ + int i,err; + for ( err = i = 0; i < max; ++i ) { + if (func[i].init) { + err = func[i].init(argc, argv); + if (err) { + msg68_error("io68: failed to initialize *%s* IO plugin\n",func[i].name); + break; + } + } + } + return err; +} + +void io68_shutdown(void) +{ + int i; + for ( i=0; i < max; ++i ) { + if (func[i].shutdown) + func[i].shutdown(); + } +} + +void io68_destroy(io68_t * const io) +{ + if (io && io->destroy) { + io->destroy(io); + } +} Index: apps/codecs/libsc68/io68/ym_linear_table.c =================================================================== --- apps/codecs/libsc68/io68/ym_linear_table.c (revision 0) +++ apps/codecs/libsc68/io68/ym_linear_table.c (revision 0) @@ -0,0 +1,64 @@ +/* + * sc68 - YM-2149 emulator - Linear Volume Table + * Copyright (C) 2001-2009 Benjamin Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +/* Table of 5 bit D/A output level for 1 channel. */ +static const u16 ymout1c5bit[32] = +#if 0 +/* -1.5dB by step */ +{ + 310, 369, 438, 521, 619, 735, 874, 1039, + 1234, 1467, 1744, 2072, 2463, 2927, 3479, 4135, + 4914, 5841, 6942, 8250, 9806, 11654, 13851, 16462, + 19565, 23253, 27636, 32845, 39037, 46395, 55141, 65535 +} +#else +/* rescale in range [0..65535] */ +{ + 0, 59, 128, 212, 310, 427, 566, 732, + 928, 1162, 1440, 1770, 2163, 2629, 3184, 3843, + 4625, 5557, 6663, 7977, 9541, 11398, 13605, 16229, + 19346, 23052, 27456, 32690, 38911, 46304, 55092, 65535 +} +#endif +; + +/* Create a linear 3 channels 5 bit per channels DAC table. + */ +void ym_create_5bit_linear_table(s16 * out, unsigned int level) +{ + int i; + const unsigned int min = ymout1c5bit[00]; + const unsigned int max = ymout1c5bit[31]; + const unsigned int div = max-min ? max-min : 1; + const int center = ( level + 1 ) >> 1; + for (i=0; i<32*32*32; ++i) { + int tmp = + ( (unsigned int) ymout1c5bit[0x1F & (i>>10)] + + (unsigned int) ymout1c5bit[0x1F & (i>> 5)] + + (unsigned int) ymout1c5bit[0x1F & (i>> 0)] - + 3u * min ) / 3u * level / div; + out[i] = tmp - center; + } + msg68_info("ym-2149: volume model -- *linear* -- [%d..%d]\n", + out[0],out[0x7FFF]); +} Index: apps/codecs/libsc68/io68/ym_blep.c =================================================================== --- apps/codecs/libsc68/io68/ym_blep.c (revision 0) +++ apps/codecs/libsc68/io68/ym_blep.c (revision 0) @@ -0,0 +1,481 @@ +/* + * sc68 - YM-2149 blep synthesis engine + * Copyright (C) 200X-2009 Antti Lankila + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef HAVE_CONFIG_OPTION68_H +# include +#else +# include "default_option68.h" +#endif + +#include "ymemul.h" + +#if defined(INCLUDE_SHARED68) +#include "file68/msg68.h" +#endif + +#include +#include + +enum { + TONE_HI_MASK = 0xf, + NOISE_MASK = 0x1f, + CTL_ENV_MASK = 0xf, + + BLEP_SIZE = 1280, + + MAX_MIXBUF = 2048, +}; + +static const s32 sine_integral[BLEP_SIZE] = { + 65536,65536,65536,65536,65536,65536,65535,65536,65536,65535,65536,65535,65536, + 65535,65535,65534,65535,65534,65534,65533,65533,65532,65531,65530,65530,65528,65527, + 65526,65524,65522,65520,65517,65515,65512,65508,65504,65500,65495,65490,65483,65478, + 65469,65462,65453,65443,65432,65420,65408,65393,65378,65361,65343,65323,65301,65278, + 65252,65226,65195,65164,65129,65092,65052,65010,64963,64915,64862,64805,64746,64681, + 64613,64540,64463,64380,64293,64200,64102,63998,63887,63770,63648,63518,63380,63236, + 63084,62924,62756,62580,62394,62199,61996,61783,61560,61327,61083,60829,60563,60287, + 60000,59699,59388,59064,58727,58378,58016,57641,57252,56850,56434,56004,55560,55101, + 54629,54141,53640,53123,52591,52046,51485,50908,50318,49713,49092,48456,47807,47143, + 46464,45771,45064,44342,43609,42860,42099,41325,40539,39740,38930,38109,37276,36433, + 35579,34718,33846,32966,32078,31183,30282,29374,28461,27544,26622,25697,24769,23841, + 22911,21980,21050,20122,19196,18272,17354,16438,15529,14626,13731,12843,11964,11095, + 10236,9390,8554,7733,6924,6131,5353,4590,3846,3118,2409,1718,1048,397,-232,-841, + -1426,-1991,-2532,-3050,-3543,-4013,-4459,-4879,-5275,-5646,-5990,-6310,-6605,-6873, + -7115,-7333,-7525,-7692,-7832,-7950,-8041,-8108,-8152,-8171,-8168,-8142,-8093,-8023, + -7932,-7820,-7689,-7538,-7369,-7182,-6979,-6759,-6525,-6275,-6013,-5737,-5451,-5154, + -4846,-4530,-4206,-3876,-3539,-3198,-2853,-2504,-2155,-1803,-1453,-1103,-755,-410, + -69,268,598,924,1241,1550,1851,2142,2423,2693,2952,3198,3432,3653,3860,4054,4232, + 4396,4545,4678,4797,4899,4986,5057,5112,5150,5174,5182,5174,5150,5112,5059,4992, + 4910,4814,4706,4584,4450,4305,4148,3981,3803,3617,3421,3218,3007,2790,2566,2339, + 2106,1870,1631,1390,1147,905,662,421,180,-57,-291,-522,-747,-969,-1183,-1392,-1593, + -1788,-1973,-2150,-2319,-2477,-2625,-2764,-2892,-3008,-3114,-3208,-3291,-3362,-3420, + -3468,-3503,-3526,-3538,-3537,-3525,-3501,-3467,-3420,-3364,-3297,-3219,-3132,-3035, + -2929,-2815,-2693,-2562,-2425,-2282,-2132,-1976,-1817,-1652,-1483,-1313,-1138,-963, + -786,-608,-430,-253,-76,98,270,440,605,768,926,1078,1226,1368,1503,1632,1753,1868, + 1975,2073,2164,2245,2319,2384,2439,2486,2523,2551,2571,2580,2581,2573,2556,2530, + 2496,2453,2402,2344,2277,2204,2123,2037,1943,1844,1740,1630,1516,1398,1276,1151, + 1024,893,762,629,495,361,227,94,-38,-169,-298,-423,-547,-667,-783,-895,-1003,-1106, + -1204,-1297,-1383,-1465,-1539,-1608,-1670,-1725,-1774,-1815,-1850,-1878,-1898,-1911, + -1918,-1917,-1910,-1895,-1875,-1846,-1813,-1772,-1726,-1674,-1617,-1553,-1487,-1413, + -1338,-1256,-1172,-1084,-994,-900,-804,-707,-608,-508,-407,-306,-205,-103,-4,95,193, + 289,382,473,562,647,729,808,881,953,1018,1080,1137,1189,1236,1277,1315,1346,1372, + 1393,1408,1418,1423,1422,1416,1404,1388,1367,1341,1309,1275,1235,1190,1143,1092, + 1036,978,917,854,786,719,648,575,503,428,353,278,202,127,51,-23,-96,-168,-239,-308, + -375,-440,-502,-561,-618,-672,-723,-770,-814,-853,-891,-922,-952,-976,-997,-1014, + -1027,-1035,-1039,-1041,-1037,-1029,-1019,-1004,-985,-964,-938,-909,-878,-843,-806, + -766,-723,-678,-632,-584,-533,-482,-429,-375,-321,-266,-211,-156,-100,-45,9,62,115, + 167,217,266,312,359,401,442,482,518,552,583,612,639,661,682,700,714,726,734,740, + 743,742,740,733,725,714,700,683,665,643,620,594,567,538,507,474,441,405,369,332, + 294,256,216,178,138,98,60,20,-18,-55,-93,-129,-164,-197,-231,-262,-291,-320,-347, + -371,-395,-415,-435,-452,-467,-480,-491,-500,-507,-512,-515,-515,-513,-510,-505, + -497,-489,-477,-464,-451,-434,-417,-398,-379,-357,-335,-311,-287,-263,-237,-210, + -184,-158,-130,-103,-76,-49,-22,4,31,56,80,105,128,151,172,192,212,230,247,263,277, + 291,302,312,321,329,334,339,343,344,344,343,341,337,332,325,318,310,299,289,277, + 264,251,236,221,206,189,172,156,138,120,102,84,66,48,30,12,-5,-22,-39,-55,-71,-86, + -101,-114,-128,-141,-152,-162,-173,-182,-190,-197,-204,-209,-213,-217,-220,-221, + -221,-222,-220,-218,-215,-212,-206,-202,-195,-189,-182,-173,-165,-156,-146,-136, + -126,-115,-104,-93,-82,-71,-58,-47,-36,-24,-13,-2,9,20,31,40,51,59,69,77,85,92,99, + 106,111,117,121,125,129,131,134,135,137,137,136,136,134,133,130,128,124,120,117, + 111,107,101,95,90,83,77,71,63,57,49,43,35,29,21,14,8,0,-6,-13,-19,-25,-30,-37,-42, + -47,-51,-56,-60,-64,-67,-70,-73,-75,-77,-78,-79,-81,-81,-80,-81,-80,-79,-77,-76, + -74,-72,-70,-67,-64,-61,-57,-54,-51,-46,-43,-38,-35,-30,-27,-22,-18,-13,-10,-5,-1, + 2,7,10,14,17,20,24,27,29,32,34,37,38,41,41,43,45,45,45,47,46,46,46,46,45,45,43, + 43,41,39,38,36,35,32,31,28,26,24,22,19,17,14,12,10,7,5,2,1,-2,-5,-6,-8,-10,-12, + -14,-16,-17,-18,-20,-20,-22,-23,-24,-24,-25,-25,-25,-26,-26,-25,-26,-25,-24,-25, + -23,-23,-22,-22,-20,-19,-19,-17,-16,-14,-14,-12,-11,-10,-8,-7,-5,-5,-3,-1,-1,1,2,3, + 4,6,6,7,8,9,10,11,11,11,12,13,13,13,13,14,13,14,14,13,13,14,12,13,12,11,12,10,10, + 10,9,8,8,7,6,5,5,4,4,3,2,1,1,0,-1,-1,-2,-2,-3,-4,-3,-5,-5,-5,-5,-6,-6,-6,-7,-6,-7, + -7,-7,-7,-7,-6,-7,-7,-6,-6,-7,-5,-6,-6,-5,-4,-5,-4,-4,-4,-3,-3,-2,-2,-2,-1,-1,-1, + 0,0,0,0,1,1,2,1,2,2,3,2,3,3,3,3,3,3,3,3,4,3,3,3,4,3,3,3,2,3,3,2,3,2,2,2,1,2,1,2, + 1,1,0,1,0,0,0,0,0,0,-1,0,-1,-1,-1,-1,-1,-1,-1,-2,-1,-1,-2,-1,-2,-1,-2,-1,-2,-1, + -1,-2,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,-1,0,-1,0,0,-1,0,0,0,0,0,1,0,0,1,0,0,1,0,1, + 0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0, + 0,0,-1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +}; + +/* these are the envelopes. First 32 values are used for first iteration, the next 64 + * describe how the envelope loops. I know this is pretty lame, but I wanted as + * simple implementation as possible. */ +static const uint8_t envelopes[16][32+64] = { + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, }, + { 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0, + 31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, }, + { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, }, +}; + +extern int ym_cat; /* defined in ymemul.c */ + +static void ym2149_new_output_level(ym_t * const ym) +{ + ym_blep_t *orig = &ym->emu.blep; + + u32 i; + s16 output; + + u16 dacstate = 0; + for (i = 0; i < 3; i ++) { + u16 mask = orig->tonegen[i].tonemix | orig->tonegen[i].flip_flop; + mask &= orig->tonegen[i].noisemix | orig->noise_output; + dacstate |= mask & ((orig->env_output & orig->tonegen[i].envmask) | orig->tonegen[i].volmask); + } + + output = (ym->ymout5[dacstate] + 1) >> 1; + + if (output != orig->global_output_level) { + /* add a new blep before the others */ + orig->blep_idx -= 1; + orig->blep_idx &= MAX_BLEPS - 1; + + orig->blepstate[orig->blep_idx].stamp = orig->time; + orig->blepstate[orig->blep_idx].level = orig->global_output_level - output; + orig->global_output_level = output; + } +} + +static void ym2149_clock(ym_t * const ym, cycle68_t cycles) +{ + ym_blep_t *orig = &ym->emu.blep; + + while (cycles) { + int iter = cycles; + int i; + int change = 0; + + for (i = 0; i < 3; i ++) { + if (iter > orig->tonegen[i].count) + iter = orig->tonegen[i].count; + } + + if (iter > orig->noise_count) + iter = orig->noise_count; + + if (iter > orig->env_count) + iter = orig->env_count; + + cycles -= iter; + orig->time += iter; + + /* clock subsystems forward */ + for (i = 0; i < 3; i ++) { + orig->tonegen[i].count -= iter; + if (orig->tonegen[i].count == 0) { + orig->tonegen[i].flip_flop = ~orig->tonegen[i].flip_flop; + orig->tonegen[i].count = orig->tonegen[i].event; + change = 1; + } + } + + orig->noise_count -= iter; + if (orig->noise_count == 0) { + u16 new_noise; + orig->noise_state = + (orig->noise_state >> 1) | + (((orig->noise_state ^ (orig->noise_state >> 2)) & 1) << 16); + orig->noise_count = orig->noise_event; + + new_noise = orig->noise_state & 1 ? 0xffff : 0x0000; + change = change || orig->noise_output != new_noise; + orig->noise_output = new_noise; + } + + orig->env_count -= iter; + if (orig->env_count == 0) { + u16 new_env = envelopes[ym->reg.name.env_shape & CTL_ENV_MASK][orig->env_state]; + new_env |= (new_env << 5) | (new_env << 10); + if (++ orig->env_state == 96) + orig->env_state = 32; + orig->env_count = orig->env_event; + + change = change || new_env != orig->env_output; + orig->env_output = new_env; + } + + if (change) + ym2149_new_output_level(ym); + } +} + +static s32 ym2149_output(ym_t * const ym, const u8 subsample) +{ + ym_blep_t *orig = &ym->emu.blep; + + u32 i = orig->blep_idx; + s32 output = 0; + while (1) { + s16 age = orig->time - orig->blepstate[i].stamp; + if (age >= BLEP_SIZE-1) + break; + /* JOS says that we should have several subphases of SINC for + * this, and we should then interpolate between them linearly. + * What I got here is better than nothing, though. */ + output += ((sine_integral[age] * (256 - subsample) + + sine_integral[age+1] * subsample + + 128) >> 8) * orig->blepstate[i].level; + i = (i + 1) & (MAX_BLEPS - 1); + } + /* Terminate the blep train by keeping the last stamp invalid. */ + orig->blepstate[i].stamp = orig->time - BLEP_SIZE; + + return ((output + (1 << 15)) >> 16) + orig->global_output_level; +} + +static s32 highpass(ym_t * const ym, s32 output) +{ + ym_blep_t *orig = &ym->emu.blep; + + orig->hp = (orig->hp * 511 + (output << 6) + (1 << 8)) >> 9; + output -= (orig->hp + (1 << 5)) >> 6; + + if (output > 32767) + output = 32767; + if (output < -32768) + output = -32768; + + return output; +} + +/* run output synthesis for some clocks */ +static int mix_to_buffer(ym_t * const ym, cycle68_t cycles, s32 *output) +{ + ym_blep_t *orig = &ym->emu.blep; + + assert(cycles >= 0); + + u32 len = 0; + while (cycles) { + cycle68_t iter = cycles; + u8 makesample = 0; + if (iter > orig->cycles_to_next_sample >> 8) { + iter = orig->cycles_to_next_sample >> 8; + makesample = 1; + } + + /* Simulate ym2149 for iter clocks */ + ym2149_clock(ym, iter); + cycles -= iter; + orig->cycles_to_next_sample -= iter << 8; + + /* Generate output. + * To improve accuracy, we interpolate the sinc table. */ + if (makesample) { + assert(orig->cycles_to_next_sample <= 0xff); + output[len ++] = highpass(ym, ym2149_output(ym, orig->cycles_to_next_sample)); + assert(len < MAX_MIXBUF); + orig->cycles_to_next_sample += orig->cycles_per_sample; + } + } + return len; +} + +/* mix for ymcycles cycles. */ +static int run(ym_t * const ym, s32 * output, const cycle68_t ymcycles) +{ + ym_blep_t *orig = &ym->emu.blep; + + u32 len = 0, voice; + s32 newevent; + + /* Walk the static list of allocated events */ + cycle68_t currcycle = 0; + ym_waccess_t *access; + for (access = ym->waccess; access != ym->waccess_nxt; access ++) { + if (access->ymcycle > ymcycles) { + TRACE68(ym_cat, "access reg %X out of frame: (%u > %u)\n", + access->reg, access->ymcycle, ymcycles); + } + + /* mix up to this cycle, update state */ + len += mix_to_buffer(ym, access->ymcycle - currcycle, output + len); + ym->reg.index[access->reg] = access->val; + + /* update various internal variables in response to writes. + * unfortunately pointers don't work for this, so... */ + switch (access->reg) { + case 0: /* per_x_lo, per_x_hi */ + case 1: + case 2: + case 3: + case 4: + case 5: + voice = access->reg >> 1; + newevent = ym->reg.index[voice << 1] | ((ym->reg.index[(voice << 1) + 1] & TONE_HI_MASK) << 8); + if (newevent == 0) + newevent = 1; + newevent <<= 3; + + /* The chip performs count >= event. If the condition is + * true, event triggers immediately. However, I have inverted + * the count to occur towards zero. Changes in event must + * therefore affect the prevailing count. If new event time + * is greater than current, the count must increase as the + * current state will be delayed. */ + orig->tonegen[voice].count += newevent - orig->tonegen[voice].event; + orig->tonegen[voice].event = newevent; + /* I do not deal with negative counts in the hot path. */ + if (orig->tonegen[voice].count < 0) + orig->tonegen[voice].count = 0; + break; + + case 6: /* per_noise */ + newevent = ym->reg.name.per_noise & NOISE_MASK; + if (newevent == 0) + newevent = 1; + newevent <<= 4; + + orig->noise_count += newevent - orig->noise_event; + orig->noise_event = newevent; + if (orig->noise_count < 0) + orig->noise_count = 0; + break; + + case 7: /* mixer */ + orig->tonegen[0].tonemix = access->val & 1 ? 0xffff : 0; + orig->tonegen[1].tonemix = access->val & 2 ? 0xffff : 0; + orig->tonegen[2].tonemix = access->val & 4 ? 0xffff : 0; + orig->tonegen[0].noisemix = access->val & 8 ? 0xffff : 0; + orig->tonegen[1].noisemix = access->val & 16 ? 0xffff : 0; + orig->tonegen[2].noisemix = access->val & 32 ? 0xffff : 0; + break; + + case 8: /* volume */ + case 9: + case 10: + voice = access->reg - 8; + orig->tonegen[voice].envmask = access->val & 0x10 + ? 0x1f << (voice*5) : 0; + orig->tonegen[voice].volmask = access->val & 0x10 + ? 0 : (((access->val & 0xf) << 1) | 1) << (voice*5); + break; + + case 11: /* per_env_lo, per_env_hi */ + case 12: + newevent = ym->reg.name.per_env_lo | (ym->reg.name.per_env_hi << 8); + if (newevent == 0) + newevent = 1; + newevent <<= 3; + + orig->env_count += newevent - orig->env_event; + orig->env_event = newevent; + if (orig->env_count < 0) + orig->env_count = 0; + break; + + case 13: /* env_shape */ + orig->env_state = 0; + break; + } + + ym2149_new_output_level(ym); + + currcycle = access->ymcycle; + } + + /* mix stuff outside writes */ + len += mix_to_buffer(ym, ymcycles - currcycle, output + len); + + /* Reset all access lists. */ + ym_waccess_list_t * const regs_n = &ym->noi_regs; + ym_waccess_list_t * const regs_e = &ym->env_regs; + ym_waccess_list_t * const regs_t = &ym->ton_regs; + regs_n->head = regs_n->tail = regs_e->head = regs_e->tail = regs_t->head = regs_t->tail = 0; + + /* Set free ptr to start of list */ + ym->waccess = ym->static_waccess; + ym->waccess_nxt = ym->waccess; + return len; +} + +static int reset(ym_t * const ym, const cycle68_t ymcycle) +{ + ym_blep_t *orig = &ym->emu.blep; + + u32 tmp = orig->cycles_per_sample; + memset(orig, 0, sizeof(ym_blep_t)); + + orig->cycles_per_sample = tmp; + orig->noise_state = 1; + orig->time = BLEP_SIZE; + orig->tonegen[0].event = 8; + orig->tonegen[1].event = 8; + orig->tonegen[2].event = 8; + orig->noise_event = 16; + orig->env_event = 8; + + return 0; +} + +/* Get required length of buffer at run(s32 *output) (number of frames). */ +static int buffersize(const ym_t const * ym, const cycle68_t ymcycles) +{ + return MAX_MIXBUF; +} + +static int sampling_rate(ym_t * const ym, const int hz) +{ + ym_blep_t *orig = &ym->emu.blep; + orig->cycles_per_sample = (ym->clock << 8) / hz; + return hz; +} + +int ym_blep_setup(ym_t * const ym) +{ + ym->cb_cleanup = 0; + ym->cb_reset = reset; + ym->cb_run = run; + ym->cb_buffersize = buffersize; + ym->cb_sampling_rate = sampling_rate; + return 0; +} Index: apps/codecs/libsc68/io68/ym_puls.c =================================================================== --- apps/codecs/libsc68/io68/ym_puls.c (revision 0) +++ apps/codecs/libsc68/io68/ym_puls.c (revision 0) @@ -0,0 +1,1158 @@ +/* + * sc68 - YM-2149 pulse engine + * Copyright (C) 2001-2009 Ben(jamin) Gerard + * + * + * This program is free software: 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 + * MERCHANTABILITY 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. + * If not, see . + * + */ + +/* $Id$ */ + +/* Copyright (C) 1998-2009 Benjamin Gerard */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef HAVE_CONFIG_OPTION68_H +# include +#else +# include "default_option68.h" +#endif + + +#include "ymemul.h" + +#if defined(INCLUDE_SHARED68) +#include "emu68/assert68.h" + +#include "file68/msg68.h" +#include "file68/string68.h" +#include "file68/option68.h" +#endif + +extern int ym_cat; /* defined in ymemul.c */ + +#ifndef INTMSB +# define INTMSB (sizeof(int)*8-1) +#endif + +#define YM_PULS_FILTER 1 /* 0:none 1:fast 2:slow */ + +#define YM_OUT_MSK(C,B,A) \ + (((((C)&0x1F)<<10)) \ + |((((B)&0x1F)<< 5)) \ + |((((A)&0x1F) ))) + +const int ym_smsk_table[8] = { + /* 000 */ YM_OUT_MSK(00,00,00), + /* 001 */ YM_OUT_MSK(00,00,-1), + /* 010 */ YM_OUT_MSK(00,-1,00), + /* 011 */ YM_OUT_MSK(00,-1,-1), + /* 100 */ YM_OUT_MSK(-1,00,00), + /* 101 */ YM_OUT_MSK(-1,00,-1), + /* 110 */ YM_OUT_MSK(-1,-1,00), + /* 111 */ YM_OUT_MSK(-1,-1,-1) +}; + + +/*********************/ +/* Filters functions */ +/*********************/ + +static void filter_none(ym_t * const); +static void filter_1pole(ym_t * const); +static void filter_2pole(ym_t * const); +static void filter_mixed(ym_t * const); +static void filter_boxcar(ym_t * const); +static struct { + const char * name; + ym_puls_filter_t filter; +} filters[] = { + { "2-poles", filter_2pole }, /* first is default */ + { "none", filter_none }, + { "boxcar", filter_boxcar}, + { "1-pole", filter_1pole }, + { "mixed", filter_mixed } +}; +static const int n_filters = sizeof(filters) / sizeof(*filters); +static int default_filter = 0; + +static int reset(ym_t * const ym, const cycle68_t ymcycle) +{ + ym_puls_t * const puls = &ym->emu.puls; + + /* Reset envelop generator */ + puls->env_bit = 0; + puls->env_ct = 0; + + /* Reset noise generator */ + puls->noise_gen = 1; + puls->noise_ct = 0; + + /* Reset tone generator */ + puls->voice_ctA = 0; + puls->voice_ctB = 0; + puls->voice_ctC = 0; + puls->levels = 0; + + /* Reset filters */ + puls->hipass_inp1 = 0; + puls->hipass_out1 = 0; + puls->lopass_out1 = 0; + + /* Reset butterworth */ + puls->btw.x[0] = puls->btw.x[1] = 0; + puls->btw.y[0] = puls->btw.y[1] = 0; + + /* Butterworth low-pass cutoff=15.625khz sampling=250khz */ + puls->btw.a[0] = 0x01eac69f; /* fix 30 */ + puls->btw.a[1] = 0x03d58d3f; + puls->btw.a[2] = 0x01eac69f; + puls->btw.b[0] = -0x5d1253b0; + puls->btw.b[1] = 0x24bd6e2f; + + return 0; +} + +/* ,-----------------------------------------------------------------. + * | Noise generator | + * `-----------------------------------------------------------------' + */ + +/* Perform noise generator for N ym-cycles + * + * The noise generator will use the 16 Less Signifiant Bit of the + * 32 output buffer for each entry. 16 Most Signifiant Bit are + * clear by this function. + * + * **BEFORE** envelop_generator() and tone_generator(). + */ +static int noise_generator(ym_t * const ym, int ymcycles) +{ + ym_puls_t * const puls = &ym->emu.puls; + int rem_cycles; + int v, noise_gen, ct, per, msk; + s32 * b; + + rem_cycles = ymcycles & 7; + if(!(ymcycles >>= 3)) goto finish; + + /* All inits */ + ct = puls->noise_ct; + noise_gen = puls->noise_gen; + per = ym->reg.name.per_noise & 0x1F; + + per <<= 1; /* because the noise generator base frequency is + master/16 but we have to match the envelop + generator frequency which is master/8. + */ + + msk = ym_smsk_table[7 & (ym->reg.name.ctl_mixer >> 3)]; + v = (u16)(-(noise_gen & 1) | msk); + b = puls->noiptr; + do { + if (++ct >= per) { + ct = 0; + + /* *** Based on MAME. Bit have been reversed for optimzation :) *** + * + * The Random Number Generator of the 8910 is a 17-bit shift + * register. The input to the shift register is bit0 XOR bit2. + * bit0 is the output. + */ + + /* bit 17 := bit 0 ^ bit 2 */ + noise_gen |= ((noise_gen^(noise_gen>>2)) & 1)<<17; + noise_gen >>= 1; + v = (u16)(-(noise_gen & 1) | msk); + } + *b++ = v; + } while (--ymcycles); + + /* Save value for next pass */ + puls->noiptr = b; + puls->noise_gen = noise_gen; + puls->noise_ct = ct; + + finish: + /* return not mixed cycle */ + return rem_cycles; +} + +/* Flush all noise registers write access and perform noise generation + * until given cycle. The given ymcycle should/must be greater than the + * latest write access cycle stamp. + */ +static void do_noise(ym_t * const ym, cycle68_t ymcycle) +{ + ym_puls_t * const puls = &ym->emu.puls; + ym_waccess_t * access; + ym_waccess_list_t * const regs = &ym->noi_regs; + cycle68_t lastcycle; + + puls->noiptr = ym->outbuf; + if (!ymcycle) { + return; + } + + for (access=regs->head, lastcycle=0; access; access=access->link) { + int ymcycles = access->ymcycle-lastcycle; + + assert(access->ymcycle <= ymcycle); + + if (ymcycles) { + lastcycle = access->ymcycle - noise_generator(ym,ymcycles); + } + ym->reg.index[access->reg] = access->val; + } + lastcycle = ymcycle - noise_generator(ym, ymcycle-lastcycle); + regs->head = regs->tail = 0; +} + +/* ,-----------------------------------------------------------------. + * | Envelop generator | + * `-----------------------------------------------------------------' + */ + +#if YM_ENV_TABLE + +#undef V +#define V(X) YM_OUT_MSK(X,X,X) + +static const int env_uplo[64] = { + V(000),V(001),V(002),V(003),V(004),V(005),V(006),V(007), + V(010),V(011),V(012),V(013),V(014),V(015),V(016),V(017), + V(020),V(021),V(022),V(023),V(024),V(025),V(026),V(027), + V(030),V(031),V(032),V(033),V(034),V(035),V(036),V(037), + + V(000),V(000),V(000),V(000),V(000),V(000),V(000),V(000), + V(000),V(000),V(000),V(000),V(000),V(000),V(000),V(000), + V(000),V(000),V(000),V(000),V(000),V(000),V(000),V(000), + V(000),V(000),V(000),V(000),V(000),V(000),V(000),V(000), +}; + +static const int env_uphi[64] = { + V(000),V(001),V(002),V(003),V(004),V(005),V(006),V(007), + V(010),V(011),V(012),V(013),V(014),V(015),V(016),V(017), + V(020),V(021),V(022),V(023),V(024),V(025),V(026),V(027), + V(030),V(031),V(032),V(033),V(034),V(035),V(036),V(037), + + V(037),V(037),V(037),V(037),V(037),V(037),V(037),V(037), + V(037),V(037),V(037),V(037),V(037),V(037),V(037),V(037), + V(037),V(037),V(037),V(037),V(037),V(037),V(037),V(037), + V(037),V(037),V(037),V(037),V(037),V(037),V(037),V(037), +}; + +static const int env_upup[64] = { + V(000),V(001),V(002),V(003),V(004),V(005),V(006),V(007), + V(010),V(011),V(012),V(013),V(014),V(015),V(016),V(017), + V(020),V(021),V(022),V(023),V(024),V(025),V(026),V(027), + V(030),V(031),V(032),V(033),V(034),V(035),V(036),V(037), + + V(000),V(001),V(002),V(003),V(004),V(005),V(006),V(007), + V(010),V(011),V(012),V(013),V(014),V(015),V(016),V(017), + V(020),V(021),V(022),V(023),V(024),V(025),V(026),V(027), + V(030),V(031),V(032),V(033),V(034),V(035),V(036),V(037) +}; + +static const int env_updw[64] = { + V(000),V(001),V(002),V(003),V(004),V(005),V(006),V(007), + V(010),V(011),V(012),V(013),V(014),V(015),V(016),V(017), + V(020),V(021),V(022),V(023),V(024),V(025),V(026