bcimgviewpatched.c

/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* Badly Coded Image Viewer BCImgView, a product of Badly Coded,
   Inc. */

/* This is an example insecure program for CSci 4271 only: don't copy
   code from here to any program that is supposed to work
   correctly! */

/* The GUI parts of this program are modeled after an example image
   viewer from an older version of the Gnome developer documentation,
   which has a similar looking interface but supports standard image
   formats without parsing them itself. It seems to not be currently
   hosted on the Gnome developer web page, but it can still be found
   in a few places online, like: */

/*
  https://tecnocode.co.uk/misc/platform-demos/image-viewer.c.xhtml
  https://web.archive.org/web/20210306070147/https://developer.gnome.org/gnome-devel-demos/stable/image-viewer.c.html.en
*/

/* Code that was copied verbatim from a non-buggy source is probably
   less likely to contain vulnerabilities. However, you shouldn't
   believe everything that comments in this code tell you; the
   comments might have bugs too.
 */

#include <assert.h>
#include <errno.h>
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <sys/time.h>
#include <sys/resource.h>

#ifndef DISABLE_GUI
#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#endif

#ifndef MIN
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#endif

/* Struct containing information about a parsed image. The pixel data
   is kept in an uncompressed format with red, green, and blue bytes
   per pixel. Rows are each stored left to right and the rows are top
   to bottom, with no padding. Sometimes a copy of this information is
   also kept after the end of the pixel data. */
struct image_info {
    long width;             /* width in pixels */
    long height;            /* height in pixels */
    void (*cleanup)(void);  /* destructor callback */
    unsigned char magic[8]; /* reserved for magic number */
    time_t create_time;     /* creation time, in Unix format */
    unsigned char *pixels;  /* pointer to pixel data */
};

/* Each Badly Coded image format is identified by a unique 8 bytes at
   the beginning of the file. */
unsigned char bcraw_magic[8] =
    {0x00, 0x42, 0x43, 0x52, 0xc3, 0x84, 0x57, 0x0a};

unsigned char bcprog_magic[8] =
    {0x42, 0x43, 0x50, 0x52, 0xc3, 0x96, 0x47, 0x0a};

unsigned char bcflat_magic[8] =
    {0x42, 0x43, 0x46, 0x4c, 0xc3, 0x84, 0x54, 0x0a};

/* To reduce the need for error checking code elsewhere in the
   program, this wrapper around malloc() will print an error message
   and then exit the program if an allocation fails. */
void *xmalloc(size_t size) {
    void *p = malloc(size);
    if (!p) {
        fprintf(stderr, "Out of memory in allocation of %zd bytes\n", size);
        exit(1);
    }
    return p;
}

/* Also as a way of shortening error reporting code, many branches
   that detect something unexpected about the input file will copy a
   description of the problem into this global, in addition to
   returning a failure status. This is similar to how the standard
   library uses "errno". */
const char *format_problem = 0;

/* Most numeric metadata in Badly Coded image files is stored as
   big-endian 64-bit integers, commonly interpreted as unsigned. This
   routine will read one such number from a stdio stream. Note that it
   would not work correctly to just use fread() on its own if the
   system is little-endian like x86-64. */
uint64_t read_u64_bigendian(FILE *fh) {
    unsigned char bytes[8];
    uint64_t x = 0;
    int i, pos = 0;
    size_t num_read;

    num_read = fread(bytes, 8, 1, fh);
    if (num_read != 1) {
        format_problem = "short read of u64";
        return -1;
    }
    
    for (i = 7; i >= 0; i--) {
        x |= (uint64_t)bytes[i] << pos;
        pos += 8;
    }

    return x;
}

/* Printf format to log information about each displayed image */
const char *logging_fmt = "Displaying image of width %ld and height %ld"
    " from %s";

/* The tagged-data section of a Badly Coded image file contains
   optional information of various kinds: each kind of data is
   preceeded by a 4-byte type identifier and an 8-byte size (which
   counts bytes after the type identifier and size). A type identifier
   "DATA" represents the end of the tagged-data section, and is
   followed directly by the image data without another size. The
   function reads this region of a file, returning 1 if the format was
   correct or 0 if there was an error. */
int process_tagged_data(FILE *fh, struct image_info *info) {
    unsigned char ident[4];
    unsigned long size;
    size_t num_read;

    for (;;) {
        num_read = fread(ident, 4, 1, fh);
        if (num_read != 1) {
            format_problem = "short read of tag";
            return 0;
        }
        if (!memcmp(ident, "DATA", 4)) {
            /* We've reached the end of the tagged data */
            return 1;
        }
        size = read_u64_bigendian(fh);
        if (size == -1) {
            return 0;
        } else if (size > (1LL << 40)) {
            /* Reject any ridiculously large tag sizes. Code for
               specific tags may enforce more restrictive
               limitations. */
            format_problem = "tag too large";
            return 0;
        }
        if (!memcmp(ident, "TIME", 4)) {
            /* Creation time information */
            if (size != 8) {
                format_problem = "wrong size for TIME";
                return 0;
            }
            info->create_time = read_u64_bigendian(fh);
        } else if (!memcmp(ident, "FRMT", 4)) {
            /* Format for file information printing */
            char *fmt_buf = xmalloc(size + 1);
            num_read = fread(fmt_buf, 1, size, fh);
            if (num_read != size) {
                format_problem = "short read of format";
                return 0;
            }
            /* Add null terminator */
            fmt_buf[size] = 0;
            logging_fmt = fmt_buf;
        } else {
            /* An unrecognized tag is an error. */
            format_problem = "unrecognized tag";
            return 0;
        }
    }
    
}

/* Read the pixel data from a BCRAW image into the internal
   format. For the sake of 8-byte alignment, 8 contiguous pixels (24
   bytes) are read as a single unit. Returns 1 on success, or 0 for an
   error such as a short read.  */
int read_raw_data(FILE *fh, struct image_info *info) {
    int row, col;
    size_t num_read;
    unsigned char *p = info->pixels;

    for (row = 0; row < info->height; row++) {
        for (col = 0; col < info->width - 8; col += 8) {
            num_read = fread(p, 3, 8, fh);
            if (num_read != 8) {
                format_problem = "short read of raw data";
                return 0;
            }
            p += 3*8;
        }

        /* This loop covers any pixels in a row left over after the
           24-byte groups */
        for (; col < info->width; col++) {
            num_read = fread(p, 3, 1, fh);
            if (num_read != 1) {
                format_problem = "short read of raw data";
                return 0;
            }
            p += 3;
        }
    }
    return 1;
}

/* Desired alignment for the image_info data structure, in bytes. */
#ifdef __GNUC__
#define TRAILER_ALIGNMENT __alignof__(struct image_info)
#else
#define TRAILER_ALIGNMENT 8
#endif

/* Choose a location for the trailing image_info structure at the end
   of the memory allocation for an image (after the pixels) with
   proper alignment. This will add 0-7 bytes of padding in between the
   pixels and the image_info trailer. */
struct image_info *trailer_location(unsigned char *base, size_t pixel_bytes) {
    unsigned char *pixels_end = base + pixel_bytes;
    unsigned long trailer_loc = (unsigned long)pixels_end;
    unsigned long extra = trailer_loc % TRAILER_ALIGNMENT;
    unsigned long pad = (TRAILER_ALIGNMENT - extra) % TRAILER_ALIGNMENT;
    return (struct image_info *)(trailer_loc + pad);
}

/* Read a BCRAW image from a file into our internal format. Only the
   magic number should have been read before calling this
   routine. Returns a pointer to an image_info structure representing
   the image, or a null pointer on failure such as invalid or
   unsupported image contents. */
struct image_info *parse_bcraw(FILE *fh) {
    struct image_info *info, *info_footer;
    size_t num_read;
    int num_bytes, is_ok;
    long width, height;
    unsigned char flags[8], *pixels;

    num_read = fread(flags, 8, 1, fh);
    if (num_read != 1) {
        format_problem = "short read of flags";
        return 0;
    }

    if (flags[0] != 0 || flags[1] != 0 || flags[2] != 0 || flags[3] != 0 ||
        flags[4] != 0 || flags[5] != 0 || flags[6] != 0) {
        format_problem = "reserved flags should be 0";
        return 0;
    }

    if (flags[7] != 8) {
        format_problem = "unsupported depth";
        return 0; /* format should be 8, for 8 bit-deep RGB */
    }

    width = read_u64_bigendian(fh);
    if (width == -1) return 0;

    height = read_u64_bigendian(fh);
    if (height == -1) return 0;

    num_bytes = 3 * width * height;
    pixels = xmalloc(num_bytes +
                     TRAILER_ALIGNMENT + sizeof(struct image_info));
    info_footer = trailer_location(pixels, num_bytes);
    info_footer->width = width;
    info_footer->height = height;
    info_footer->pixels = pixels;
    info_footer->create_time = -1;
    info_footer->cleanup = 0;

    is_ok = process_tagged_data(fh, info_footer);
    if (!is_ok) {
        free(pixels);
        return 0;
    }

    num_read = read_raw_data(fh, info_footer);
    if (!num_read) {
        free(pixels);
        return 0;
    }

    /* Copy metadata from the footer into a new separate object */
    info = xmalloc(sizeof(struct image_info));
    info->width = info_footer->width;
    info->height = info_footer->height;
    info->create_time = info_footer->create_time;
    info->pixels = info_footer->pixels;
    info->cleanup = info_footer->cleanup;
    return info;
}

/* Read and transform the image data from a BCPROG file into our
   internal format. This happens in two steps. First, as the rows are
   being read, they are re-ordered from the progressive on-disk order
   into a normal sequential order. Then, the pixels in each row are
   expanded from the 8-bit format to 24-bit format. */
int read_prog_data(FILE *fh, struct image_info *info) {
    int row, col;
    size_t num_read;
    unsigned char *p = info->pixels;

    /* Step 1: decode progressive row ordering to sequential */
    /* Pass 1: multiples of 4 */
    row = 0;
    do {
        unsigned char *row_start = p + row * 3 * info->width;
        num_read = fread(row_start, info->width, 1, fh);
        if (num_read != 1) {
            format_problem = "short read of row";
            return 0;
        }
        row += 4;
    } while (row < info->height);
    /* Pass 2: odd multiples of 2 */
    row = 2;
    do {
        unsigned char *row_start = p + row * 3 * info->width;
        num_read = fread(row_start, info->width, 1, fh);
        if (num_read != 1) {
            format_problem = "short read of row";
            return 0;
        }
        row += 4;
    } while (row < info->height);
    /* Pass 3: odd rows */
    row = 1;
    do {
        unsigned char *row_start = p + row * 3 * info->width;
        num_read = fread(row_start, info->width, 1, fh);
        if (num_read != 1) {
            format_problem = "short read of row";
            return 0;
        }
        row += 2;
    } while (row < info->height);

    /* Step 2: decode 8-bit palette to 24-bit color */
    for (row = 0; row < info->height; row++) {
        /* This inner loop needs to run backwards because the decoding
           expands the pixel data. */
        unsigned char *row_p = p + row * 3 * info->width;
        for (col = info->width - 1; col >= 0; col--) {
            unsigned char packed = row_p[col];
            int r, g, b;
            if (packed >= 216) {
                format_problem = "invalid packed byte";
                return 0;
            }
            /* A number between 0 and 6**3-1 is interpreted like a
               number in base 6, where the three digits represent the
               red, blue, and green components. Digits between 0 and 5
               are scaled by 51 to 8-bit samples between 0 and 255. */
            b = packed % 6;
            packed /= 6;
            g = packed % 6;
            packed /= 6;
            r = packed;
            row_p[3 * col] = 51 * r;
            row_p[3 * col + 1] = 51 * g;
            row_p[3 * col + 2] = 51 * b;
        }
    }
    return 1;
}

/* Read a BCPROG image from a file into our internal format. Only the
   magic number should have been read before calling this
   routine. Returns a pointer to an image_info structure representing
   the image, or a null pointer on failure such as invalid or
   unsupported image contents. */
struct image_info *parse_bcprog(FILE *fh) {
    struct image_info *info, *info_footer;
    size_t num_read;
    int num_bytes, is_ok;
    long width, height;
    unsigned char flags[8], *pixels;

    num_read = fread(flags, 8, 1, fh);
    if (num_read != 1) return 0;

    if (flags[0] != 0 || flags[1] != 0 || flags[2] != 0 || flags[3] != 0 ||
        flags[4] != 0 || flags[5] != 0) {
        format_problem = "reserved flags should be 0";
        return 0;
    }

    if (flags[6] != 0x01) {
        format_problem = "unsupported passes number";
        return 0; /* 1 = 3 pass row progressive */
    }

    if (flags[7] != 0xd8) {
        format_problem = "unsupported color depth";
        return 0; /* 0xd8 = 216 color "web safe" 6x6x6 cube palette */
    }

    width = read_u64_bigendian(fh);
    if (width == -1) return 0;

    height = read_u64_bigendian(fh);
    if (height == -1) return 0;

    /* Size must be positive, and tall enough for the progressive
       algorithm */
    if (height < 2 || width < 1) {
        format_problem = "size too small";
        return 0;
    }

    /* Size limited to SVGA-era 800x600 */
    if (height > 600 || width > 800) {
        format_problem = "size too large";
        return 0;
    }

    num_bytes = 3 * width * height;
    pixels = xmalloc(num_bytes +
                     TRAILER_ALIGNMENT + sizeof(struct image_info));
    info_footer = trailer_location(pixels, num_bytes);
    info_footer->width = width;
    info_footer->height = height;
    info_footer->pixels = pixels;
    info_footer->create_time = -1;
    info_footer->cleanup = 0;

    is_ok = process_tagged_data(fh, info_footer);
    if (!is_ok) {
        free(pixels);
        return 0;
    }

    num_read = read_prog_data(fh, info_footer);
    if (!num_read) {
        free(pixels);
        return 0;
    }

    /* Copy metadata from the footer into a new separate object */
    info = xmalloc(sizeof(struct image_info));
    info->width = info_footer->width;
    info->height = info_footer->height;
    info->create_time = info_footer->create_time;
    info->pixels = info_footer->pixels;
    info->cleanup = info_footer->cleanup;
    return info;
}

/* Compressed data from a BCFLAT file is buffered up to FLATBUF (100)
   bytes at once. The compressed data is variable-length, so we can't
   tell how much to read for each row in advance. 100 bytes is a
   compromise between not having to do too many short reads, and not
   wasting too much time moving data down in the buffer. (We could
   save data movement in the buffer by using circular indexing, but
   that would make the code more complex.) To decide how much space to
   keep for uncompressed data, we need to keep track of the maximum
   factor by which the size of data can increase as it is
   decompressed. */
#define FLATBUF 100
#define EXPANSION 10

/* In the BCFLAT image format, each sample after the first in a row is
   represented as a difference relative to the pixel before it. The
   differences are encoded with codewords that range from 3 to 13 bits
   long, and represent 1-8 bytes each. Because most other operations
   on data use 8-bit words, we need a buffer to hold bits that were
   left over from a previous codeword. It's easiest if this buffer can
   hold at least (13 - 1) + 8 = 24 bits, so 32 bits is enough; we
   assume an int holds at least 32 bits. This buffer is managed
   somewhat like a shift register in that the next bits to parse are
   at the most significant position; bits move left through the
   register as they are processed. "reg" represents the register
   contents, while "reg_size" keeps track of how many positions are in
   use. */
struct flat_decode_state {
    unsigned int reg;   /* shift register of codeword bits */
    int reg_size;       /* number of bits in the register */
    unsigned char last; /* previous pixel value */
};

/* Summary of BCFLAT codewords:

   000            2 samples: 0, 0        expansion 5.33
   0010           3 samples: 0, 0, 0     expansion 6
   00110          4 samples: 0, 0, 0, 0  expansion 6.4
   0011100        5 samples, all 0       expansion 5.71
   0011101        6 samples, all 0       expansion 6.86
   0011110        7 samples, all 0       expansion 8
   0011111        8 samples, all 0       expansion 9.14

   0100xx         2 samples, +1..+4 x2   expansion 2.66
   0101xx         2 samples, -4..-1 x2   expansion 2.66
   0110xx         3 samples, +1..+4 x3   expansion 4
   0111xx         3 samples, -4..-1 x3   expansion 4

   100            one sample, 0 difference   expansion 2.66
   1010           one sample, difference +1  expansion 2
   1011           one sample, difference -1  expansion 2
   11000x         one sample, difference +2, +3
   11001x         one sample, difference -3, -2
   11010xx        one sample, difference +4...+7
   11011xx        one sample, difference -7...-4
   1110000xxx     one sample, difference +8...+15
   1110001xxx     one sample, difference -15...-8
   1110010xxxx    one sample, difference +16...+31
   1110011xxxx    one sample, difference -31...-16
   1110100xxxxx   one sample, difference +32...+63
   1110101xxxxx   one sample, difference -63...-32
   1110110xxxxxx  one sample, difference +64...+127
   1110111xxxxxx  one sample, difference -127...-64
   1111000        one sample, difference (+/-)128

   Notice that no codeword is a prefix of any other codeword. This is
   what allows a sequence of variable-length codes to be uniquely
   decoded without delimiters.
*/

/* The following large table holds the information about all the
   possible BCFLAT codewords in a way that enables fast lookup. The
   table has 2**13 = 8192 entries because codewords are up to 13 bits
   long. A 13-bit codeword is found exactly once in the table, at an
   index equal to its codeword: for instance the codeword
   1110110010101 is at index 7573, where you will see 0x551d. If a
   codeword is b bits long, it appears 2**(13-b) times, at all the
   locations whose indexes start with the codeword. For instance the
   codeword 000 appears 1024 times at the locations whose indexes
   start with 000 in binary, namely 0 through 1023, where you will see
   0x23.

   The information about each codeword is packed into 16 bits. The top
   8 bits represent the difference between samples that is encoded.
   (It's most intuitive to think of as signed, though an unsigned
   interpretation would be equivalent.) The next 4 bits count how many
   sample differences have that value. The final, lowest 4 bits are
   the length of the codeword in bits. Every codeword is at least 3
   bits long.

   This table is pretty long, but it replaces over 100 lines of
   hard-to-audit if statements and bitwise arithmetic in a previous
   version.
*/
const unsigned short flat_codeword_info[8192] = {
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  10*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  20*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  30*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  40*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  50*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  60*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  70*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  80*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*  90*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 100*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 110*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 120*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 130*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 140*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 150*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 160*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 170*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 180*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 190*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 200*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 210*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 220*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 230*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 240*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 250*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 260*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 270*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 280*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 290*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 300*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 310*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 320*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 330*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 340*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 350*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 360*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 370*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 380*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 390*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 400*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 410*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 420*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 430*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 440*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 450*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 460*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 470*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 480*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 490*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 500*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 510*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 520*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 530*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 540*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 550*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 560*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 570*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 580*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 590*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 600*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 610*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 620*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 630*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 640*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 650*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 660*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 670*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 680*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 690*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 700*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 710*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 720*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 730*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 740*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 750*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 760*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 770*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 780*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 790*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 800*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 810*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 820*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 830*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 840*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 850*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 860*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 870*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 880*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 890*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 900*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 910*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 920*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 930*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 940*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 950*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 960*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 970*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 980*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/* 990*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*1000*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*1010*/
   0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,  0x23,/*1020*/
   0x23,  0x23,  0x23,  0x23,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1030*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1040*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1050*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1060*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1070*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1080*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1090*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1100*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1110*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1120*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1130*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1140*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1150*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1160*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1170*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1180*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1190*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1200*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1210*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1220*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1230*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1240*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1250*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1260*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1270*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1280*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1290*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1300*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1310*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1320*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1330*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1340*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1350*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1360*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1370*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1380*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1390*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1400*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1410*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1420*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1430*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1440*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1450*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1460*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1470*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1480*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1490*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1500*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1510*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1520*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x34,/*1530*/
   0x34,  0x34,  0x34,  0x34,  0x34,  0x34,  0x45,  0x45,  0x45,  0x45,/*1540*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1550*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1560*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1570*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1580*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1590*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1600*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1610*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1620*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1630*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1640*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1650*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1660*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1670*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1680*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1690*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1700*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1710*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1720*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1730*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1740*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1750*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1760*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1770*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1780*/
   0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,  0x45,/*1790*/
   0x45,  0x45,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,/*1800*/
   0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,/*1810*/
   0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,/*1820*/
   0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,/*1830*/
   0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,/*1840*/
   0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x57,/*1850*/
   0x57,  0x57,  0x57,  0x57,  0x57,  0x57,  0x67,  0x67,  0x67,  0x67,/*1860*/
   0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,/*1870*/
   0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,/*1880*/
   0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,/*1890*/
   0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,/*1900*/
   0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,/*1910*/
   0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,  0x67,/*1920*/
   0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,/*1930*/
   0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,/*1940*/
   0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,/*1950*/
   0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,/*1960*/
   0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,/*1970*/
   0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,  0x77,/*1980*/
   0x77,  0x77,  0x77,  0x77,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,/*1990*/
   0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,/*2000*/
   0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,/*2010*/
   0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,/*2020*/
   0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,/*2030*/
   0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,/*2040*/
   0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87,  0x87, 0x126, 0x126,/*2050*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2060*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2070*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2080*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2090*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2100*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2110*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2120*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2130*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2140*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2150*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2160*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x126,/*2170*/
  0x126, 0x126, 0x126, 0x126, 0x126, 0x126, 0x226, 0x226, 0x226, 0x226,/*2180*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2190*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2200*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2210*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2220*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2230*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2240*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2250*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2260*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2270*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2280*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2290*/
  0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226, 0x226,/*2300*/
  0x226, 0x226, 0x226, 0x226, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2310*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2320*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2330*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2340*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2350*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2360*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2370*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2380*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2390*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2400*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2410*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2420*/
  0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326, 0x326,/*2430*/
  0x326, 0x326, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2440*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2450*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2460*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2470*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2480*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2490*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2500*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2510*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2520*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2530*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2540*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2550*/
  0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426, 0x426,/*2560*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2570*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2580*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2590*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2600*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2610*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2620*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2630*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2640*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2650*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2660*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2670*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,/*2680*/
 0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfc26,0xfd26,0xfd26,/*2690*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2700*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2710*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2720*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2730*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2740*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2750*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2760*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2770*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2780*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2790*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2800*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,/*2810*/
 0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfd26,0xfe26,0xfe26,0xfe26,0xfe26,/*2820*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2830*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2840*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2850*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2860*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2870*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2880*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2890*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2900*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2910*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2920*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2930*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,0xfe26,/*2940*/
 0xfe26,0xfe26,0xfe26,0xfe26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*2950*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*2960*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*2970*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*2980*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*2990*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3000*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3010*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3020*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3030*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3040*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3050*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3060*/
 0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,0xff26,/*3070*/
 0xff26,0xff26, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3080*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3090*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3100*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3110*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3120*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3130*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3140*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3150*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3160*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3170*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3180*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3190*/
  0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136, 0x136,/*3200*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3210*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3220*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3230*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3240*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3250*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3260*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3270*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3280*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3290*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3300*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3310*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236,/*3320*/
  0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x236, 0x336, 0x336,/*3330*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3340*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3350*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3360*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3370*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3380*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3390*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3400*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3410*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3420*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3430*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3440*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x336,/*3450*/
  0x336, 0x336, 0x336, 0x336, 0x336, 0x336, 0x436, 0x436, 0x436, 0x436,/*3460*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3470*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3480*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3490*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3500*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3510*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3520*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3530*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3540*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3550*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3560*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3570*/
  0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436, 0x436,/*3580*/
  0x436, 0x436, 0x436, 0x436,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3590*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3600*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3610*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3620*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3630*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3640*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3650*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3660*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3670*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3680*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3690*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3700*/
 0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,0xfc36,/*3710*/
 0xfc36,0xfc36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3720*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3730*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3740*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3750*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3760*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3770*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3780*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3790*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3800*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3810*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3820*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3830*/
 0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,0xfd36,/*3840*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3850*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3860*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3870*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3880*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3890*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3900*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3910*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3920*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3930*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3940*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3950*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,/*3960*/
 0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xfe36,0xff36,0xff36,/*3970*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*3980*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*3990*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4000*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4010*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4020*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4030*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4040*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4050*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4060*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4070*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4080*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,/*4090*/
 0xff36,0xff36,0xff36,0xff36,0xff36,0xff36,  0x13,  0x13,  0x13,  0x13,/*4100*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4110*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4120*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4130*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4140*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4150*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4160*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4170*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4180*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4190*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4200*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4210*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4220*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4230*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4240*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4250*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4260*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4270*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4280*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4290*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4300*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4310*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4320*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4330*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4340*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4350*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4360*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4370*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4380*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4390*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4400*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4410*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4420*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4430*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4440*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4450*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4460*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4470*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4480*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4490*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4500*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4510*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4520*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4530*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4540*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4550*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4560*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4570*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4580*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4590*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4600*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4610*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4620*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4630*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4640*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4650*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4660*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4670*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4680*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4690*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4700*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4710*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4720*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4730*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4740*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4750*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4760*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4770*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4780*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4790*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4800*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4810*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4820*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4830*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4840*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4850*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4860*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4870*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4880*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4890*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4900*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4910*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4920*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4930*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4940*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4950*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4960*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4970*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4980*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*4990*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5000*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5010*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5020*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5030*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5040*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5050*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5060*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5070*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5080*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5090*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5100*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5110*/
   0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,  0x13,/*5120*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5130*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5140*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5150*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5160*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5170*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5180*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5190*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5200*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5210*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5220*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5230*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5240*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5250*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5260*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5270*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5280*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5290*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5300*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5310*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5320*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5330*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5340*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5350*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5360*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5370*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5380*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5390*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5400*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5410*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5420*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5430*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5440*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5450*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5460*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5470*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5480*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5490*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5500*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5510*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5520*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5530*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5540*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5550*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5560*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5570*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5580*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5590*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5600*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5610*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5620*/
  0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114, 0x114,/*5630*/
  0x114, 0x114,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5640*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5650*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5660*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5670*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5680*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5690*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5700*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5710*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5720*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5730*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5740*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5750*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5760*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5770*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5780*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5790*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5800*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5810*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5820*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5830*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5840*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5850*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5860*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5870*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5880*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5890*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5900*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5910*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5920*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5930*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5940*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5950*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5960*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5970*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5980*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*5990*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6000*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6010*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6020*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6030*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6040*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6050*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6060*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6070*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6080*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6090*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6100*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6110*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6120*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6130*/
 0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,0xff14,/*6140*/
 0xff14,0xff14,0xff14,0xff14, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6150*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6160*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6170*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6180*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6190*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6200*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6210*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6220*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6230*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6240*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6250*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6260*/
  0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216, 0x216,/*6270*/
  0x216, 0x216, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6280*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6290*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6300*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6310*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6320*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6330*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6340*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6350*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6360*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6370*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6380*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6390*/
  0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316, 0x316,/*6400*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6410*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6420*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6430*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6440*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6450*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6460*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6470*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6480*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6490*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6500*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6510*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,/*6520*/
 0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfd16,0xfe16,0xfe16,/*6530*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6540*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6550*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6560*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6570*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6580*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6590*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6600*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6610*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6620*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6630*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6640*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,/*6650*/
 0xfe16,0xfe16,0xfe16,0xfe16,0xfe16,0xfe16, 0x417, 0x417, 0x417, 0x417,/*6660*/
  0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417,/*6670*/
  0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417,/*6680*/
  0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417,/*6690*/
  0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417,/*6700*/
  0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417,/*6710*/
  0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417, 0x417,/*6720*/
  0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517,/*6730*/
  0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517,/*6740*/
  0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517,/*6750*/
  0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517,/*6760*/
  0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517,/*6770*/
  0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517, 0x517,/*6780*/
  0x517, 0x517, 0x517, 0x517, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617,/*6790*/
  0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617,/*6800*/
  0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617,/*6810*/
  0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617,/*6820*/
  0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617,/*6830*/
  0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617,/*6840*/
  0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x617, 0x717, 0x717,/*6850*/
  0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717,/*6860*/
  0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717,/*6870*/
  0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717,/*6880*/
  0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717,/*6890*/
  0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717,/*6900*/
  0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717, 0x717,/*6910*/
  0x717, 0x717,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,/*6920*/
 0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,/*6930*/
 0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,/*6940*/
 0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,/*6950*/
 0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,/*6960*/
 0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,/*6970*/
 0xf917,0xf917,0xf917,0xf917,0xf917,0xf917,0xfa17,0xfa17,0xfa17,0xfa17,/*6980*/
 0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,/*6990*/
 0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,/*7000*/
 0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,/*7010*/
 0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,/*7020*/
 0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,/*7030*/
 0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,0xfa17,/*7040*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,/*7050*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,/*7060*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,/*7070*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,/*7080*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,/*7090*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,0xfb17,/*7100*/
 0xfb17,0xfb17,0xfb17,0xfb17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,/*7110*/
 0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,/*7120*/
 0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,/*7130*/
 0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,/*7140*/
 0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,/*7150*/
 0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,/*7160*/
 0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17,0xfc17, 0x81a, 0x81a,/*7170*/
  0x81a, 0x81a, 0x81a, 0x81a, 0x81a, 0x81a, 0x91a, 0x91a, 0x91a, 0x91a,/*7180*/
  0x91a, 0x91a, 0x91a, 0x91a, 0xa1a, 0xa1a, 0xa1a, 0xa1a, 0xa1a, 0xa1a,/*7190*/
  0xa1a, 0xa1a, 0xb1a, 0xb1a, 0xb1a, 0xb1a, 0xb1a, 0xb1a, 0xb1a, 0xb1a,/*7200*/
  0xc1a, 0xc1a, 0xc1a, 0xc1a, 0xc1a, 0xc1a, 0xc1a, 0xc1a, 0xd1a, 0xd1a,/*7210*/
  0xd1a, 0xd1a, 0xd1a, 0xd1a, 0xd1a, 0xd1a, 0xe1a, 0xe1a, 0xe1a, 0xe1a,/*7220*/
  0xe1a, 0xe1a, 0xe1a, 0xe1a, 0xf1a, 0xf1a, 0xf1a, 0xf1a, 0xf1a, 0xf1a,/*7230*/
  0xf1a, 0xf1a,0xf11a,0xf11a,0xf11a,0xf11a,0xf11a,0xf11a,0xf11a,0xf11a,/*7240*/
 0xf21a,0xf21a,0xf21a,0xf21a,0xf21a,0xf21a,0xf21a,0xf21a,0xf31a,0xf31a,/*7250*/
 0xf31a,0xf31a,0xf31a,0xf31a,0xf31a,0xf31a,0xf41a,0xf41a,0xf41a,0xf41a,/*7260*/
 0xf41a,0xf41a,0xf41a,0xf41a,0xf51a,0xf51a,0xf51a,0xf51a,0xf51a,0xf51a,/*7270*/
 0xf51a,0xf51a,0xf61a,0xf61a,0xf61a,0xf61a,0xf61a,0xf61a,0xf61a,0xf61a,/*7280*/
 0xf71a,0xf71a,0xf71a,0xf71a,0xf71a,0xf71a,0xf71a,0xf71a,0xf81a,0xf81a,/*7290*/
 0xf81a,0xf81a,0xf81a,0xf81a,0xf81a,0xf81a,0x101b,0x101b,0x101b,0x101b,/*7300*/
 0x111b,0x111b,0x111b,0x111b,0x121b,0x121b,0x121b,0x121b,0x131b,0x131b,/*7310*/
 0x131b,0x131b,0x141b,0x141b,0x141b,0x141b,0x151b,0x151b,0x151b,0x151b,/*7320*/
 0x161b,0x161b,0x161b,0x161b,0x171b,0x171b,0x171b,0x171b,0x181b,0x181b,/*7330*/
 0x181b,0x181b,0x191b,0x191b,0x191b,0x191b,0x1a1b,0x1a1b,0x1a1b,0x1a1b,/*7340*/
 0x1b1b,0x1b1b,0x1b1b,0x1b1b,0x1c1b,0x1c1b,0x1c1b,0x1c1b,0x1d1b,0x1d1b,/*7350*/
 0x1d1b,0x1d1b,0x1e1b,0x1e1b,0x1e1b,0x1e1b,0x1f1b,0x1f1b,0x1f1b,0x1f1b,/*7360*/
 0xe11b,0xe11b,0xe11b,0xe11b,0xe21b,0xe21b,0xe21b,0xe21b,0xe31b,0xe31b,/*7370*/
 0xe31b,0xe31b,0xe41b,0xe41b,0xe41b,0xe41b,0xe51b,0xe51b,0xe51b,0xe51b,/*7380*/
 0xe61b,0xe61b,0xe61b,0xe61b,0xe71b,0xe71b,0xe71b,0xe71b,0xe81b,0xe81b,/*7390*/
 0xe81b,0xe81b,0xe91b,0xe91b,0xe91b,0xe91b,0xea1b,0xea1b,0xea1b,0xea1b,/*7400*/
 0xeb1b,0xeb1b,0xeb1b,0xeb1b,0xec1b,0xec1b,0xec1b,0xec1b,0xed1b,0xed1b,/*7410*/
 0xed1b,0xed1b,0xee1b,0xee1b,0xee1b,0xee1b,0xef1b,0xef1b,0xef1b,0xef1b,/*7420*/
 0xf01b,0xf01b,0xf01b,0xf01b,0x201c,0x201c,0x211c,0x211c,0x221c,0x221c,/*7430*/
 0x231c,0x231c,0x241c,0x241c,0x251c,0x251c,0x261c,0x261c,0x271c,0x271c,/*7440*/
 0x281c,0x281c,0x291c,0x291c,0x2a1c,0x2a1c,0x2b1c,0x2b1c,0x2c1c,0x2c1c,/*7450*/
 0x2d1c,0x2d1c,0x2e1c,0x2e1c,0x2f1c,0x2f1c,0x301c,0x301c,0x311c,0x311c,/*7460*/
 0x321c,0x321c,0x331c,0x331c,0x341c,0x341c,0x351c,0x351c,0x361c,0x361c,/*7470*/
 0x371c,0x371c,0x381c,0x381c,0x391c,0x391c,0x3a1c,0x3a1c,0x3b1c,0x3b1c,/*7480*/
 0x3c1c,0x3c1c,0x3d1c,0x3d1c,0x3e1c,0x3e1c,0x3f1c,0x3f1c,0xc11c,0xc11c,/*7490*/
 0xc21c,0xc21c,0xc31c,0xc31c,0xc41c,0xc41c,0xc51c,0xc51c,0xc61c,0xc61c,/*7500*/
 0xc71c,0xc71c,0xc81c,0xc81c,0xc91c,0xc91c,0xca1c,0xca1c,0xcb1c,0xcb1c,/*7510*/
 0xcc1c,0xcc1c,0xcd1c,0xcd1c,0xce1c,0xce1c,0xcf1c,0xcf1c,0xd01c,0xd01c,/*7520*/
 0xd11c,0xd11c,0xd21c,0xd21c,0xd31c,0xd31c,0xd41c,0xd41c,0xd51c,0xd51c,/*7530*/
 0xd61c,0xd61c,0xd71c,0xd71c,0xd81c,0xd81c,0xd91c,0xd91c,0xda1c,0xda1c,/*7540*/
 0xdb1c,0xdb1c,0xdc1c,0xdc1c,0xdd1c,0xdd1c,0xde1c,0xde1c,0xdf1c,0xdf1c,/*7550*/
 0xe01c,0xe01c,0x401d,0x411d,0x421d,0x431d,0x441d,0x451d,0x461d,0x471d,/*7560*/
 0x481d,0x491d,0x4a1d,0x4b1d,0x4c1d,0x4d1d,0x4e1d,0x4f1d,0x501d,0x511d,/*7570*/
 0x521d,0x531d,0x541d,0x551d,0x561d,0x571d,0x581d,0x591d,0x5a1d,0x5b1d,/*7580*/
 0x5c1d,0x5d1d,0x5e1d,0x5f1d,0x601d,0x611d,0x621d,0x631d,0x641d,0x651d,/*7590*/
 0x661d,0x671d,0x681d,0x691d,0x6a1d,0x6b1d,0x6c1d,0x6d1d,0x6e1d,0x6f1d,/*7600*/
 0x701d,0x711d,0x721d,0x731d,0x741d,0x751d,0x761d,0x771d,0x781d,0x791d,/*7610*/
 0x7a1d,0x7b1d,0x7c1d,0x7d1d,0x7e1d,0x7f1d,0x811d,0x821d,0x831d,0x841d,/*7620*/
 0x851d,0x861d,0x871d,0x881d,0x891d,0x8a1d,0x8b1d,0x8c1d,0x8d1d,0x8e1d,/*7630*/
 0x8f1d,0x901d,0x911d,0x921d,0x931d,0x941d,0x951d,0x961d,0x971d,0x981d,/*7640*/
 0x991d,0x9a1d,0x9b1d,0x9c1d,0x9d1d,0x9e1d,0x9f1d,0xa01d,0xa11d,0xa21d,/*7650*/
 0xa31d,0xa41d,0xa51d,0xa61d,0xa71d,0xa81d,0xa91d,0xaa1d,0xab1d,0xac1d,/*7660*/
 0xad1d,0xae1d,0xaf1d,0xb01d,0xb11d,0xb21d,0xb31d,0xb41d,0xb51d,0xb61d,/*7670*/
 0xb71d,0xb81d,0xb91d,0xba1d,0xbb1d,0xbc1d,0xbd1d,0xbe1d,0xbf1d,0xc01d,/*7680*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7690*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7700*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7710*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7720*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7730*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7740*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7750*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7760*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7770*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7780*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7790*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7800*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7810*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7820*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7830*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7840*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7850*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7860*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7870*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7880*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7890*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7900*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7910*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7920*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7930*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7940*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7950*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7960*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7970*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7980*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*7990*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8000*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8010*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8020*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8030*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8040*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8050*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8060*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8070*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8080*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8090*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8100*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8110*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8120*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8130*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8140*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8150*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8160*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8170*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8180*/
 0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,0x8017,/*8190*/
 0x8017,0x8017 /* 8192 */
};

/* Check some basic invariants over the flat_codeword_info table. */
void check_codewords(void) {
    static int already_checked = 0;
    int i;
    if (already_checked)
        return;
    for (i = 0; i < 8192; i++) {
        unsigned short cw_info = flat_codeword_info[i];
        int diff = (signed char)(cw_info >> 8);
        int repeat = (cw_info >> 4) & 0xf;
        int codelen = cw_info & 0xf;
        double expand = (repeat * 8.0) / codelen;
        assert(cw_info != 0);
        assert(repeat >= 1 && repeat <= 15);
        assert(codelen >= 3 && codelen <= 13);
        assert(diff >= -128 && diff <= 127);
        assert(expand >= 0);
        assert(expand <= EXPANSION);
    }
    already_checked = 1;
}

/* This function represents the inner loop of decoding flat-compressed
   samples. It reads compressed data from "comp_p" and writes
   corresponding uncompressed data to "uncomp_p", updating the
   decompression state "state" accordingly. On entrance
   "comp_size_inout" should point to the number of bytes of compressed
   data that comp_p points to, and on exit it is updated to point to
   the number of compressed bytes consumed. On entrance pixels_inout
   should point to the maximum number of pixels that should be
   decompressed (i.e., before the end of a row), and on exit it will
   hold the number that were actually decompressed. */
void decode_flat(unsigned char *comp_p, int *comp_size_inout,
                 unsigned char *uncomp_p, int *pixels_inout,
                 struct flat_decode_state *state) {
    /* compressed data buffer, dynamically allocated */
    unsigned char *comp_buf;
    /* decompressed data buffer */
    unsigned char uncomp_buf[EXPANSION * (FLATBUF + 1)];
    unsigned char last = state->last;
    unsigned int reg = state->reg;
    unsigned int reg_size = state->reg_size;
    unsigned char *p, *q;
    int max_pixels = *pixels_inout;
    int num_pixels = 0;
    int comp_size = *comp_size_inout;
    /* If non-zero, some of the bits in reg_size were from padding
       bytes, and so should not be used for decoding. */
    int padding_bits = 0;

    /* Pad the compressed input with two extra bytes, so that we don't
       read ahead into undefined data */
    assert(comp_size <= FLATBUF);
    comp_buf = xmalloc(FLATBUF + 2);
    memcpy(comp_buf, comp_p, comp_size);
    comp_buf[comp_size] = 0x00;
    comp_buf[comp_size + 1] = 0x00;

    p = comp_buf;
    q = uncomp_buf;

    check_codewords();
    while (num_pixels < max_pixels && p < comp_buf + comp_size + 2) {
        int codelen;
        assert(num_pixels >= 0);
        /* Read compressed data into the register until we have
           enough to cover any codeword */
        while (reg_size < 13) {
            /* We might read up to two bytes beyond the supplied
               compressed data. The bits from these bytes go into the
               shift register, but if it looks like we're about to
               match a codeword including them, we stop. */
            if (p >= comp_buf + comp_size)
                padding_bits += 8;
            reg |= (*p++) << ((32 - 8) - reg_size);
            reg_size += 8;
        }

        /* Shift the 13 highest bits of "reg" down to the
           least-significant position, to use them for the table-based
           lookup. */
        unsigned short cw_info = flat_codeword_info[reg >> 19];
        int diff = (signed char)(cw_info >> 8);
        int repeat = (cw_info >> 4) & 0xf;
        int i;
        codelen = cw_info & 0xf;
        if (codelen > (reg_size - padding_bits)) {
            /* Here's the case where the next codeword extends into
               the padding added earlier. Don't consume it yet. */
            break;
        }
        /* Decompress into "repeat" samples, each differing by "diff"
           in value. */
        for (i = 0; i < repeat; i++) {
            unsigned char next = last + diff;
            *q++ = next;
            last = next;
        }
        num_pixels += repeat;

        /* Remove the matched codeword from the shift register by
           shifting it off the top and decreasing the size
           accordingly. */
        reg <<= codelen;
        reg_size -= codelen;
    }
    /* If we've reached the end of our decoding but still have more
       than one byte's worth of bits in the shift register, "put" the
       extra bytes back so it's as if we hadn't read them in the first
       place. This is important when we get to the end of a row,
       because the next byte is the start of a new row that needs to
       be read directly, not via the shift register. */
    while (reg_size >= 8) {
        reg &= ~(0xff << (32 - reg_size));
        reg_size -= 8;
        p--;
    }
    assert(q - uncomp_buf == num_pixels);
    /* If the input is incorrectly encoded, it may produce too many
       pixels, going beyond the end of the row. The loop above always
       stops after the first codeword that that gets to or beyond the
       end of the row. But for instance if there is supposed to be one
       pixel left, and the last codeword (incorrectly) encodes two
       pixels, there will be an extra pixel. Up to EXPANSION number of
       extra pixels can occur temporarily, though it will be detected
       as a format error by the caller. */
    assert(num_pixels <= max_pixels + EXPANSION);
    memcpy(uncomp_p, uncomp_buf, num_pixels);

    *comp_size_inout = MIN(comp_size, p - comp_buf);
    free(comp_buf);
    *pixels_inout = num_pixels;
    state->reg = reg;
    state->reg_size = reg_size;
    state->last = last;
}

/* Read and decompress all the compressed samples in a BCFLAT file
   into the internal uncompressed format. A color image is stored as
   if it were a series of three grayscale images, one each for the
   red, green, and blue channels, whereas the channel information is
   interleaved in the internal format. Each row of samples is
   compressed separately, with the first sample of the row stored
   directly, and all subsequent samples compressed in terms of
   differences from the previous pixel. Because the compressed rows
   have unpredictable length, all the input bytes need to pass through
   a buffer. Since the buffer might not be long enough to hold a full
   row of samples, the decompression state is maintained across calls
   to decode_flat in one row. Returns 1 on success, 0 on an error. */
int read_flat_data(FILE *fh, struct image_info *info) {
    int channel, y;
    struct flat_decode_state state;
    unsigned char buf[FLATBUF];
    unsigned char pixel_buf[3 * EXPANSION * FLATBUF];
    int buf_read_pos = 0;
    size_t num_read;
    for (channel = 0; channel <= 2; channel++) {
        for (y = 0; y < info->height; y++) {
            unsigned char *row = info->pixels + 3 * y * info->width;
            unsigned char first;
            int x = 0;
            if (buf_read_pos > 0) {
                /* Get the first byte already buffered */
                first = buf[0];
                memmove(buf, buf + 1, buf_read_pos - 1);
                buf_read_pos--;
            } else {
                /* If the buffer is empty, read the first byte directly */
                num_read = fread(&first, 1, 1, fh);
                if (num_read != 1) {
                    format_problem = "failed to read first byte";
                    return 0;
                }
            }
            row[0 + channel] = first;
            x++;
            /* Initialize the decompression state based on the first
               sample and with an empty shift register. */
            state.last = first;
            state.reg = 0;
            state.reg_size = 0;
            while (x < info->width) {
                /* This limit ensures we stop decoding when we get to
                   the end of the row. */
                int max_pixels = info->width - x;
                int comp_size, num_pixels, i;
                if (buf_read_pos < FLATBUF) {
                    /* If there's space in the buffer, read more
                       data. Enough to fill the buffer, if
                       possible. */
                    int num_to_read = FLATBUF - buf_read_pos;
                    num_read = fread(buf + buf_read_pos, 1, num_to_read, fh);
                    if (num_read < num_to_read && !feof(fh)) {
                        format_problem = "short read";
                        return 0;
                    }
                    buf_read_pos += num_read;
                }
                comp_size = buf_read_pos;
                if (!comp_size) {
                    format_problem = "too little data";
                    return 0;
                }
                num_pixels = max_pixels;
                decode_flat(buf, &comp_size, pixel_buf, &num_pixels, &state);
                assert(num_pixels > 0);
                assert(num_pixels <= max_pixels + EXPANSION);
                if (num_pixels > max_pixels) {
                    format_problem = "excess pixels at end of row";
                    return 0;
                }
                for (i = 0; i < num_pixels; i++) {
                    /* Write samples into the uncompressed row. These
                       samples of the same color are spaced every 3rd
                       byte. */
                    assert(x < info->width);
                    row[3*x + channel] = pixel_buf[i];
                    x++;
                }
                /* memmove is similar to memcpy, but it is
                   particularly guaranteed to work correctly when the
                   source and destination regions might overlap, as
                   they can do when moving data down a buffer. */
                memmove(buf, buf + comp_size, buf_read_pos - comp_size);
                buf_read_pos -= comp_size;
            }
        }
    }
    return 1;
}

long size_limit = 26754; /* floor(sqrt(2**31/3)) */

/* Read a BCFLAT image from a file into our internal format. Only the
   magic number should have been read before calling this
   routine. Returns a pointer to an image_info structure representing
   the image, or a null pointer on failure such as invalid or
   unsupported image contents. */
struct image_info *parse_bcflat(FILE *fh) {
    struct image_info *info, *info_footer;
    size_t num_read;
    int num_bytes, is_ok;
    long width, height;
    unsigned char flags[8], *pixels;

    num_read = fread(flags, 8, 1, fh);
    if (num_read != 1) return 0;

    if (flags[0] != 0 || flags[1] != 0 || flags[2] != 0 || flags[3] != 0 ||
        flags[4] != 0 || flags[5] != 0) {
        format_problem = "reserved flags should be 0";
        return 0;
    }

    if (flags[6] != 0x0d) {
        format_problem = "unsupported dictionary size";
        return 0; /* 0x0d = 13-bit dictionary */
    }

    if (flags[7] != 0x03) {
        format_problem = "unsupported number of channels";
        return 0; /* 0x03 = 3 channels */
    }

    width = read_u64_bigendian(fh);
    if (width == -1) return 0;

    height = read_u64_bigendian(fh);
    if (height == -1) return 0;

    /* Size must be positive */
    if (height < 1 || width < 1) {
        format_problem = "size must be positive";
        return 0;
    }

    /* Sanity-check size */
    if (height > size_limit || width > size_limit) {
        format_problem = "size too large compared to stack";
        return 0;
    }

    num_bytes = 3 * width * height;
    pixels = xmalloc(num_bytes +
                     TRAILER_ALIGNMENT + sizeof(struct image_info));
    info_footer = trailer_location(pixels, num_bytes);
    info_footer->width = width;
    info_footer->height = height;
    info_footer->pixels = pixels;
    info_footer->create_time = -1;
    info_footer->cleanup = 0;

    is_ok = process_tagged_data(fh, info_footer);
    if (!is_ok) {
        free(pixels);
        return 0;
    }

    if (!read_flat_data(fh, info_footer)) {
        free(pixels);
        return 0;
    }

    /* Copy metadata from the footer into a new separate object */
    info = xmalloc(sizeof(struct image_info));
    info->width = info_footer->width;
    info->height = info_footer->height;
    info->create_time = info_footer->create_time;
    info->pixels = info_footer->pixels;
    info->cleanup = info_footer->cleanup;
    return info;
}

/* Top-level routine for reading a Badly Coded image file into an
   internal format. All this function knows how to do is to match the
   magic number and dispatch to an appropriate format-specific parse
   function. Returns an image_info pointer on success, or a null
   pointer on failure. */
struct image_info *parse_image(const char *fname) {
    FILE *fh = fopen(fname, "rb");
    size_t num_read;
    unsigned char magic[8];
    struct image_info *info;

    if (!fh) {
        fprintf(stderr, "Failed to open %s: %s\n", fname, strerror(errno));
        return 0;
    }
    
    num_read = fread(magic, 8, 1, fh);
    if (num_read != 1) {
        fprintf(stderr, "Failed to read magic number from %s\n", fname);
        fclose(fh);
        return 0;
    }

    format_problem = 0;

    if (memcmp(magic, bcraw_magic, 8) == 0) {
        info = parse_bcraw(fh);
    } else if (memcmp(magic, bcprog_magic, 8) == 0) {
        info = parse_bcprog(fh);
    } else if (memcmp(magic, bcflat_magic, 8) == 0) {
        info = parse_bcflat(fh);
    } else {
        fprintf(stderr, "%s: unrecognized format\n", fname);
        fclose(fh);
        return 0;
    }

    fclose(fh);

    if (!info) {
        /* All different sorts of file errors lead to this message. */
        if (format_problem)
            fprintf(stderr, "%s: invalid format, %s\n", fname, format_problem);
        else
            fprintf(stderr, "%s: invalid format\n", fname);
    }

    return info;
}

/* Do all the cleanup associated with an image_info that is no longer
   needed: call the destructor if present, and free both the pixel
   data and the structure. */
void free_image_info(struct image_info *info) {
    if (info->cleanup)
        (*info->cleanup)();
    free(info->pixels);
    free(info);
}

void benign_target(void) {
    /* Currently doesn't do anything useful */
    static int benign_counter;
    benign_counter++;
    return;
}

/* Normally this function is never called. The only way it could get
   executed is via some sort of control-flow hijacking attack. */
void shellcode_target(void) {
    printf("\nIf this code is executed, it means that some sort of "
           "attack has happened!\n");
    exit(1);
}

/* Callback executed for each image viewed. */
void (*per_image_callback)(void);

/* Checks logging format against a whitlist of format specifiers. */
int check_log_msg(const char *logging_fmt) {
    int s = 1, ld = 2;
    for(int i = 0; logging_fmt[i]; i++) {
        if(logging_fmt[i] == '%') {
            i++;
            if(logging_fmt[i] == '%') {/* Unlimited printable % characters are allowed. */
                continue;
            }
            if(logging_fmt[i] == 's' && s != 0) {/* One or fewer string formats are allowed. */
                s--;
            } else if(!memcmp(&logging_fmt[i],"ld",2) && ld != 0) {/* Two or fewer decimal formats are allowed */
                ld--;
                i++;
            } else {
                fprintf(stderr, "Invalid logging string\n");
                return 1;
            }
        }
    }
    return 0;
}

/* Print a log message about the image being displayed, including
   the creation time stamp. */
void print_log_msg(struct image_info *info) {
    struct tm tm_parts;
    char time_str[80];
    if (info->create_time != -1) {
        localtime_r(&info->create_time, &tm_parts);
        strftime(time_str, 80, "%a, %d %b %Y %T %z", &tm_parts);
    } else {
        strcpy(time_str, "recently");
    }
    if(check_log_msg(logging_fmt)) {
        printf("Displaying image of width %ld and height %ld"
    " from %s", info->width, info->height, time_str,
           info->create_time);
    } else {
        printf(logging_fmt, info->width, info->height, time_str,
           info->create_time);
    }
    
    printf("\n");
}

#ifndef DISABLE_GUI
/* Display an image by converting it from image_info format into the
   GDK Pixbuf structure, and associating that pixbuf with an image
   widget in the GUI. */
void display_image(struct image_info *info, GtkWidget *image) {
    GdkPixbuf *pixbuf;
    long rowstride, y;
    guchar *pixels;
    size_t rowsize;

    /* Make a pixmap with 8 bits per sample RGB and no alpha */
    pixbuf = 
        gdk_pixbuf_new(GDK_COLORSPACE_RGB, 0, 8, info->width, info->height);
    rowstride = gdk_pixbuf_get_rowstride(pixbuf);
    pixels = gdk_pixbuf_get_pixels(pixbuf);
    g_assert(gdk_pixbuf_get_n_channels(pixbuf) == 3);
    rowsize = 3 * info->width;

    /* The GDK pixbuf format is similar to ours, but sometimes has
       additional alignment padding between the rows. In other words,
       we have to copy row by row because GDK Pixbuf's rowstride might
       be bigger than our rowsize. */
    for (y = 0; y < info->height; y++) {
        memcpy(pixels + y * rowstride, info->pixels + y * rowsize, rowsize);
    }

    /* This is the function that passes the pixbuf to GTK. */
    gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);

    print_log_msg(info);

    /* After copying to the pixbuf, the image_info isn't needed
       anymore. */
    free_image_info(info);
    (*per_image_callback)();
}
#endif

/* Write an internal-formatted image into a file in the common Unix
   PPM format. Conveniently, the body of the PPM format is the same as
   our internal pixel format, only a different header is needed. */
void write_ppm(struct image_info *info, const char *out_fname) {
    FILE *fh = fopen(out_fname, "wb");
    int res;
    size_t num_written;
    if (!fh) {
        fprintf(stderr, "Failed to open %s for writing: %s\n",
                out_fname, strerror(errno));
        exit(1);
    }
    /* 255 is called the "maxval" in PPM terminolgy, and corresponds
       to 8 bits per sample. */
    fprintf(fh, "P6\n%ld %ld\n255\n", info->width, info->height);
    num_written = fwrite(info->pixels, 3 * info->width, info->height, fh);
    if (num_written != info->height) {
        fprintf(stderr, "Unable to write complete image\n");
    }
    res = fclose(fh);
    if (res != 0) {
        fprintf(stderr, "Failure on closing output: %s\n", strerror(errno));
    }
}

#ifndef DISABLE_GUI
/* Use a GTK file chooser to let a user graphically select another
   image to display. */
static void on_open_image(GtkButton* button, gpointer user_data) {
    GtkWidget *image = GTK_WIDGET(user_data);
    GtkWidget *toplevel = gtk_widget_get_toplevel(image);
    GtkFileFilter *filter = gtk_file_filter_new();
    GtkWidget *dialog =
        gtk_file_chooser_dialog_new("Open image",
                                    GTK_WINDOW(toplevel),
                                    GTK_FILE_CHOOSER_ACTION_OPEN,
                                    "_Open", GTK_RESPONSE_ACCEPT,
                                    "_Cancel", GTK_RESPONSE_CANCEL,
                                    NULL);

    /* The chooser will only display files with extensions
       corresponding to our supported formats. */
    gtk_file_filter_add_pattern(filter, "*.bcraw");
    gtk_file_filter_add_pattern(filter, "*.bcprog");
    gtk_file_filter_add_pattern(filter, "*.bcflat");
    gtk_file_filter_set_name(filter, "Badly-coded format images");
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog),
                                filter);
	
    switch (gtk_dialog_run(GTK_DIALOG(dialog))) {
    case GTK_RESPONSE_ACCEPT:
        {
            gchar *filename = 
                gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
            struct image_info *info = parse_image(filename);
            if (info)
                display_image(info, image);
            break;
        }
    default:
        break;
    }
    gtk_widget_destroy(dialog);
}

/* This is the GTK image widget used for displaying images. */
GtkWidget *global_image;

/* Create the main GUI of the image viewer. */
static GtkWidget* create_window(void) {
    GtkWidget *window;
    GtkWidget *open_button;
    GtkWidget *image;
    GtkWidget *box;
#if GTK_MAJOR_VERSION >= 3
    GtkCssProvider *css = 0;
    GtkStyleContext *style;
    guint prio = GTK_STYLE_PROVIDER_PRIORITY_APPLICATION;
#endif
    char *bgcolor = 0;

    /* Set up the UI */
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), "bcimgview");

    bgcolor = getenv("BC_BGCOLOR");
    if (bgcolor && strlen(bgcolor) > 50) {
        fprintf(stderr, "Ignoring too-long BC_BGCOLOR\n");
        bgcolor = 0;
    }
#if GTK_MAJOR_VERSION >= 3
    if (bgcolor) {
        /* Changing the color of widgets programmatically is not as
           stable a feature of GTK as the other parts of it we
           use. The recommended way to do it in recent versions is
           using this style-sheet mechanism. */
        css = gtk_css_provider_new();
        char style_str[200];
        GError *parse_error = 0;
        sprintf(style_str,
                "window {background: %.50s;} button {background: %.50s}",
                bgcolor, bgcolor);
        gtk_css_provider_load_from_data(css, style_str, strlen(style_str),
                                        &parse_error);
        if (parse_error) {
            fprintf(stderr, "Syntax error in BC_BGCOLOR: %s\n",
                    parse_error->message);
            g_error_free(parse_error);
            exit(1);
        }
        style = gtk_widget_get_style_context(GTK_WIDGET(window));
        gtk_style_context_add_provider(style, GTK_STYLE_PROVIDER(css), prio);
    }
#endif

    /* For our simple uses, GTK 2 and GTK 3 are almost completely
       compatible. This is the one line that needs to be different for
       the core functionality. */
#if GTK_MAJOR_VERSION >= 3
    box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#else
    box = gtk_vbox_new(FALSE, 5);
#endif
    open_button = gtk_button_new_with_label("Open a different image");
#if GTK_MAJOR_VERSION >= 3
    if (bgcolor) {
        style = gtk_widget_get_style_context(GTK_WIDGET(open_button));
        gtk_style_context_add_provider(style, GTK_STYLE_PROVIDER(css), prio);
    }
#endif
    image = gtk_image_new();

    gtk_box_pack_start(GTK_BOX(box), image, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(box), open_button, FALSE, FALSE, 0);

    gtk_container_add(GTK_CONTAINER(window), box);

    /* Connect signals */

    /* Show open dialog when opening a file */
    g_signal_connect(open_button, "clicked", G_CALLBACK(on_open_image), image);
	
    /* Exit when the window is closed */
    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

    global_image = image;

    return window;
}
#endif

int main(int argc, char *argv[]) {
    int res;
    struct rlimit rlim;

    per_image_callback = &benign_target;

    res = getrlimit(RLIMIT_STACK, &rlim);
    if (res == 0 && rlim.rlim_cur != RLIM_INFINITY) {
        /* We store image data on the heap rather than the stack, but
           we use the size limit for the stack, if set, to estimate
           what would constitue a reasonable amount of memory to use
           on the system. */
        size_limit = (long)sqrt(rlim.rlim_cur * 1024 / 3);
    }

    if (argc == 3 && argv[1][0] == '-' && argv[1][1] == 'c' && !argv[1][2]) {
        /* Batch conversion mode; don't start the GUI. */
        struct image_info *info = parse_image(argv[2]);
        char *out_fname = xmalloc(strlen(argv[2]) + 5);
        if (!info)
            return 1;
        strcpy(out_fname, argv[2]);
        strcat(out_fname, ".ppm");
        printf("Batch conversion output in %s\n", out_fname);
        write_ppm(info, out_fname);
        free(out_fname);
        print_log_msg(info);
        free_image_info(info);
        (*per_image_callback)();
        return 0;
#ifdef DISABLE_GUI
    } else {
        fprintf(stderr, "Usage: bcimgview-nogui -c <image>\n");
        return 1;
    }
#else
    } else if (argc == 1 || argc == 2) {
        /* GUI mode */
        GtkWidget *window;
        gtk_init(&argc, &argv);

        window = create_window();
        gtk_widget_show_all(window);

        if (argc == 2) {
            struct image_info *info = parse_image(argv[1]);
            if (info)
                display_image(info, global_image);
        }

        gtk_main();
    } else {
        fprintf(stderr, "Usage: bcimgview [-c] [<image>]\n");
        return 1;
    }
#endif
    return 0;
}