677c33d78f0f115e699fe151ab1d058593deab04
[ffmpeg.git] / libavcodec / ivi_common.c
1 /*
2  * common functions for Indeo Video Interactive codecs (Indeo4 and Indeo5)
3  *
4  * Copyright (c) 2009 Maxim Poliakovski
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * This file contains functions and data shared by both Indeo4 and
26  * Indeo5 decoders.
27  */
28
29 #define BITSTREAM_READER_LE
30 #include "libavutil/attributes.h"
31 #include "avcodec.h"
32 #include "get_bits.h"
33 #include "internal.h"
34 #include "mathops.h"
35 #include "ivi_common.h"
36 #include "ivi_dsp.h"
37
38 extern const IVIHuffDesc ff_ivi_mb_huff_desc[8];  ///< static macroblock huffman tables
39 extern const IVIHuffDesc ff_ivi_blk_huff_desc[8]; ///< static block huffman tables
40
41 static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables
42 static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables
43
44 /**
45  *  Reverse "nbits" bits of the value "val" and return the result
46  *  in the least significant bits.
47  */
48 static uint16_t inv_bits(uint16_t val, int nbits)
49 {
50     uint16_t res;
51
52     if (nbits <= 8) {
53         res = ff_reverse[val] >> (8-nbits);
54     } else
55         res = ((ff_reverse[val & 0xFF] << 8) + (ff_reverse[val >> 8])) >> (16-nbits);
56
57     return res;
58 }
59
60 /*
61  *  Generate a huffman codebook from the given descriptor
62  *  and convert it into the FFmpeg VLC table.
63  *
64  *  @param[in]   cb    pointer to codebook descriptor
65  *  @param[out]  vlc   where to place the generated VLC table
66  *  @param[in]   flag  flag: 1 - for static or 0 for dynamic tables
67  *  @return     result code: 0 - OK, -1 = error (invalid codebook descriptor)
68  */
69 static int ivi_create_huff_from_desc(const IVIHuffDesc *cb, VLC *vlc, int flag)
70 {
71     int         pos, i, j, codes_per_row, prefix, not_last_row;
72     uint16_t    codewords[256]; /* FIXME: move this temporal storage out? */
73     uint8_t     bits[256];
74
75     pos = 0; /* current position = 0 */
76
77     for (i = 0; i < cb->num_rows; i++) {
78         codes_per_row = 1 << cb->xbits[i];
79         not_last_row  = (i != cb->num_rows - 1);
80         prefix        = ((1 << i) - 1) << (cb->xbits[i] + not_last_row);
81
82         for (j = 0; j < codes_per_row; j++) {
83             if (pos >= 256) /* Some Indeo5 codebooks can have more than 256 */
84                 break;      /* elements, but only 256 codes are allowed! */
85
86             bits[pos] = i + cb->xbits[i] + not_last_row;
87             if (bits[pos] > IVI_VLC_BITS)
88                 return -1; /* invalid descriptor */
89
90             codewords[pos] = inv_bits((prefix | j), bits[pos]);
91             if (!bits[pos])
92                 bits[pos] = 1;
93
94             pos++;
95         }//for j
96     }//for i
97
98     /* number of codewords = pos */
99     return init_vlc(vlc, IVI_VLC_BITS, pos, bits, 1, 1, codewords, 2, 2,
100                     (flag ? INIT_VLC_USE_NEW_STATIC : 0) | INIT_VLC_LE);
101 }
102
103 void ff_ivi_init_static_vlc(void)
104 {
105     int i;
106     static VLC_TYPE table_data[8192 * 16][2];
107     static int initialized_vlcs = 0;
108
109     if (initialized_vlcs)
110         return;
111     for (i = 0; i < 8; i++) {
112         ivi_mb_vlc_tabs[i].table = table_data + i * 2 * 8192;
113         ivi_mb_vlc_tabs[i].table_allocated = 8192;
114         ivi_create_huff_from_desc(&ff_ivi_mb_huff_desc[i],  &ivi_mb_vlc_tabs[i],  1);
115         ivi_blk_vlc_tabs[i].table = table_data + (i * 2 + 1) * 8192;
116         ivi_blk_vlc_tabs[i].table_allocated = 8192;
117         ivi_create_huff_from_desc(&ff_ivi_blk_huff_desc[i], &ivi_blk_vlc_tabs[i], 1);
118     }
119     initialized_vlcs = 1;
120 }
121
122 /*
123  *  Copy huffman codebook descriptors.
124  *
125  *  @param[out]  dst  ptr to the destination descriptor
126  *  @param[in]   src  ptr to the source descriptor
127  */
128 static void ivi_huff_desc_copy(IVIHuffDesc *dst, const IVIHuffDesc *src)
129 {
130     dst->num_rows = src->num_rows;
131     memcpy(dst->xbits, src->xbits, src->num_rows);
132 }
133
134 /*
135  *  Compare two huffman codebook descriptors.
136  *
137  *  @param[in]  desc1  ptr to the 1st descriptor to compare
138  *  @param[in]  desc2  ptr to the 2nd descriptor to compare
139  *  @return         comparison result: 0 - equal, 1 - not equal
140  */
141 static int ivi_huff_desc_cmp(const IVIHuffDesc *desc1, const IVIHuffDesc *desc2)
142 {
143     return    desc1->num_rows != desc2->num_rows
144            || memcmp(desc1->xbits, desc2->xbits, desc1->num_rows);
145 }
146
147 int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,
148                          IVIHuffTab *huff_tab, AVCodecContext *avctx)
149 {
150     int         i, result;
151     IVIHuffDesc new_huff;
152
153     if (!desc_coded) {
154         /* select default table */
155         huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[7]
156             : &ivi_mb_vlc_tabs [7];
157     } else {
158         huff_tab->tab_sel = get_bits(gb, 3);
159         if (huff_tab->tab_sel == 7) {
160             /* custom huffman table (explicitly encoded) */
161             new_huff.num_rows = get_bits(gb, 4);
162             if (!new_huff.num_rows) {
163                 av_log(avctx, AV_LOG_ERROR, "Empty custom Huffman table!\n");
164                 return AVERROR_INVALIDDATA;
165             }
166
167             for (i = 0; i < new_huff.num_rows; i++)
168                 new_huff.xbits[i] = get_bits(gb, 4);
169
170             /* Have we got the same custom table? Rebuild if not. */
171             if (ivi_huff_desc_cmp(&new_huff, &huff_tab->cust_desc) || !huff_tab->cust_tab.table) {
172                 ivi_huff_desc_copy(&huff_tab->cust_desc, &new_huff);
173
174                 if (huff_tab->cust_tab.table)
175                     ff_free_vlc(&huff_tab->cust_tab);
176                 result = ivi_create_huff_from_desc(&huff_tab->cust_desc,
177                         &huff_tab->cust_tab, 0);
178                 if (result) {
179                     huff_tab->cust_desc.num_rows = 0; // reset faulty description
180                     av_log(avctx, AV_LOG_ERROR,
181                            "Error while initializing custom vlc table!\n");
182                     return result;
183                 }
184             }
185             huff_tab->tab = &huff_tab->cust_tab;
186         } else {
187             /* select one of predefined tables */
188             huff_tab->tab = (which_tab) ? &ivi_blk_vlc_tabs[huff_tab->tab_sel]
189                 : &ivi_mb_vlc_tabs [huff_tab->tab_sel];
190         }
191     }
192
193     return 0;
194 }
195
196 /*
197  *  Free planes, bands and macroblocks buffers.
198  *
199  *  @param[in]  planes  pointer to the array of the plane descriptors
200  */
201 static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)
202 {
203     int p, b, t;
204
205     for (p = 0; p < 3; p++) {
206         if (planes[p].bands)
207         for (b = 0; b < planes[p].num_bands; b++) {
208             av_freep(&planes[p].bands[b].bufs[0]);
209             av_freep(&planes[p].bands[b].bufs[1]);
210             av_freep(&planes[p].bands[b].bufs[2]);
211
212             if (planes[p].bands[b].blk_vlc.cust_tab.table)
213                 ff_free_vlc(&planes[p].bands[b].blk_vlc.cust_tab);
214             for (t = 0; t < planes[p].bands[b].num_tiles; t++)
215                 av_freep(&planes[p].bands[b].tiles[t].mbs);
216             av_freep(&planes[p].bands[b].tiles);
217         }
218         av_freep(&planes[p].bands);
219     }
220 }
221
222 av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg)
223 {
224     int         p, b;
225     uint32_t    b_width, b_height, align_fac, width_aligned, height_aligned, buf_size;
226     IVIBandDesc *band;
227
228     ivi_free_buffers(planes);
229
230     /* fill in the descriptor of the luminance plane */
231     planes[0].width     = cfg->pic_width;
232     planes[0].height    = cfg->pic_height;
233     planes[0].num_bands = cfg->luma_bands;
234
235     /* fill in the descriptors of the chrominance planes */
236     planes[1].width     = planes[2].width     = (cfg->pic_width  + 3) >> 2;
237     planes[1].height    = planes[2].height    = (cfg->pic_height + 3) >> 2;
238     planes[1].num_bands = planes[2].num_bands = cfg->chroma_bands;
239
240     for (p = 0; p < 3; p++) {
241         planes[p].bands = av_mallocz(planes[p].num_bands * sizeof(IVIBandDesc));
242         if (!planes[p].bands)
243             return AVERROR(ENOMEM);
244
245         /* select band dimensions: if there is only one band then it
246          *  has the full size, if there are several bands each of them
247          *  has only half size */
248         b_width  = planes[p].num_bands == 1 ? planes[p].width  : (planes[p].width  + 1) >> 1;
249         b_height = planes[p].num_bands == 1 ? planes[p].height : (planes[p].height + 1) >> 1;
250
251         /* luma   band buffers will be aligned on 16x16 (max macroblock size) */
252         /* chroma band buffers will be aligned on   8x8 (max macroblock size) */
253         align_fac       = p ? 8 : 16;
254         width_aligned   = FFALIGN(b_width , align_fac);
255         height_aligned  = FFALIGN(b_height, align_fac);
256         buf_size        = width_aligned * height_aligned * sizeof(int16_t);
257
258         for (b = 0; b < planes[p].num_bands; b++) {
259             band = &planes[p].bands[b]; /* select appropriate plane/band */
260             band->plane    = p;
261             band->band_num = b;
262             band->width    = b_width;
263             band->height   = b_height;
264             band->pitch    = width_aligned;
265             band->aheight  = height_aligned;
266             band->bufs[0]  = av_mallocz(buf_size);
267             band->bufs[1]  = av_mallocz(buf_size);
268             band->bufsize  = buf_size/2;
269             if (!band->bufs[0] || !band->bufs[1])
270                 return AVERROR(ENOMEM);
271
272             /* allocate the 3rd band buffer for scalability mode */
273             if (cfg->luma_bands > 1) {
274                 band->bufs[2] = av_mallocz(buf_size);
275                 if (!band->bufs[2])
276                     return AVERROR(ENOMEM);
277             }
278
279             planes[p].bands[0].blk_vlc.cust_desc.num_rows = 0; /* reset custom vlc */
280         }
281     }
282
283     return 0;
284 }
285
286 av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height)
287 {
288     int         p, b, x, y, x_tiles, y_tiles, t_width, t_height;
289     IVIBandDesc *band;
290     IVITile     *tile, *ref_tile;
291
292     for (p = 0; p < 3; p++) {
293         t_width  = !p ? tile_width  : (tile_width  + 3) >> 2;
294         t_height = !p ? tile_height : (tile_height + 3) >> 2;
295
296         if (!p && planes[0].num_bands == 4) {
297             t_width  >>= 1;
298             t_height >>= 1;
299         }
300         if(t_width<=0 || t_height<=0)
301             return AVERROR(EINVAL);
302
303         for (b = 0; b < planes[p].num_bands; b++) {
304             band = &planes[p].bands[b];
305             x_tiles = IVI_NUM_TILES(band->width, t_width);
306             y_tiles = IVI_NUM_TILES(band->height, t_height);
307             band->num_tiles = x_tiles * y_tiles;
308
309             av_freep(&band->tiles);
310             band->tiles = av_mallocz(band->num_tiles * sizeof(IVITile));
311             if (!band->tiles)
312                 return AVERROR(ENOMEM);
313
314             tile = band->tiles;
315
316             /* use the first luma band as reference for motion vectors
317              * and quant */
318             ref_tile = planes[0].bands[0].tiles;
319
320             for (y = 0; y < band->height; y += t_height) {
321                 for (x = 0; x < band->width; x += t_width) {
322                     tile->xpos     = x;
323                     tile->ypos     = y;
324                     tile->mb_size  = band->mb_size;
325                     tile->width    = FFMIN(band->width - x,  t_width);
326                     tile->height   = FFMIN(band->height - y, t_height);
327                     tile->is_empty = tile->data_size = 0;
328                     /* calculate number of macroblocks */
329                     tile->num_MBs  = IVI_MBs_PER_TILE(tile->width, tile->height,
330                                                       band->mb_size);
331
332                     av_freep(&tile->mbs);
333                     tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));
334                     if (!tile->mbs)
335                         return AVERROR(ENOMEM);
336
337                     tile->ref_mbs = 0;
338                     if (p || b) {
339                         if (tile->num_MBs <= ref_tile->num_MBs) {
340                             tile->ref_mbs = ref_tile->mbs;
341                         }else
342                             av_log(NULL, AV_LOG_DEBUG, "Cannot use ref_tile, too few mbs\n");
343                         ref_tile++;
344                     }
345
346                     tile++;
347                 }
348             }
349
350         }// for b
351     }// for p
352
353     return 0;
354 }
355
356 /*
357  *  Decode size of the tile data.
358  *  The size is stored as a variable-length field having the following format:
359  *  if (tile_data_size < 255) than this field is only one byte long
360  *  if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3
361  *  where X1-X3 is size of the tile data
362  *
363  *  @param[in,out]  gb  the GetBit context
364  *  @return     size of the tile data in bytes
365  */
366 static int ivi_dec_tile_data_size(GetBitContext *gb)
367 {
368     int    len;
369
370     len = 0;
371     if (get_bits1(gb)) {
372         len = get_bits(gb, 8);
373         if (len == 255)
374             len = get_bits_long(gb, 24);
375     }
376
377     /* align the bitstream reader on the byte boundary */
378     align_get_bits(gb);
379
380     return len;
381 }
382
383 /*
384  *  Decode block data:
385  *  extract huffman-coded transform coefficients from the bitstream,
386  *  dequantize them, apply inverse transform and motion compensation
387  *  in order to reconstruct the picture.
388  *
389  *  @param[in,out]  gb    the GetBit context
390  *  @param[in]      band  pointer to the band descriptor
391  *  @param[in]      tile  pointer to the tile descriptor
392  *  @return     result code: 0 - OK, -1 = error (corrupted blocks data)
393  */
394 static int ivi_decode_blocks(GetBitContext *gb, IVIBandDesc *band, IVITile *tile,
395                              AVCodecContext *avctx)
396 {
397     int         mbn, blk, num_blocks, num_coeffs, blk_size, scan_pos, run, val,
398                 pos, is_intra, mc_type = 0, mv_x, mv_y, col_mask;
399     uint8_t     col_flags[8];
400     int32_t     prev_dc, trvec[64];
401     uint32_t    cbp, sym, lo, hi, quant, buf_offs, q;
402     IVIMbInfo   *mb;
403     RVMapDesc   *rvmap = band->rv_map;
404     void (*mc_with_delta_func)(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
405     void (*mc_no_delta_func)  (int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
406     const uint16_t  *base_tab;
407     const uint8_t   *scale_tab;
408
409     prev_dc = 0; /* init intra prediction for the DC coefficient */
410
411     blk_size   = band->blk_size;
412     col_mask   = blk_size - 1; /* column mask for tracking non-zero coeffs */
413     num_blocks = (band->mb_size != blk_size) ? 4 : 1; /* number of blocks per mb */
414     num_coeffs = blk_size * blk_size;
415     if (blk_size == 8) {
416         mc_with_delta_func = ff_ivi_mc_8x8_delta;
417         mc_no_delta_func   = ff_ivi_mc_8x8_no_delta;
418     } else {
419         mc_with_delta_func = ff_ivi_mc_4x4_delta;
420         mc_no_delta_func   = ff_ivi_mc_4x4_no_delta;
421     }
422
423     for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
424         is_intra = !mb->type;
425         cbp      = mb->cbp;
426         buf_offs = mb->buf_offs;
427
428         quant = av_clip(band->glob_quant + mb->q_delta, 0, 23);
429
430         base_tab  = is_intra ? band->intra_base  : band->inter_base;
431         scale_tab = is_intra ? band->intra_scale : band->inter_scale;
432         if (scale_tab)
433             quant = scale_tab[quant];
434
435         if (!is_intra) {
436             mv_x = mb->mv_x;
437             mv_y = mb->mv_y;
438             if (band->is_halfpel) {
439                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
440                 mv_x >>= 1;
441                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
442             }
443             if (mb->type) {
444                 int dmv_x, dmv_y, cx, cy;
445
446                 dmv_x = mb->mv_x >> band->is_halfpel;
447                 dmv_y = mb->mv_y >> band->is_halfpel;
448                 cx    = mb->mv_x &  band->is_halfpel;
449                 cy    = mb->mv_y &  band->is_halfpel;
450
451                 if (   mb->xpos + dmv_x < 0
452                     || mb->xpos + dmv_x + band->mb_size + cx > band->pitch
453                     || mb->ypos + dmv_y < 0
454                     || mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
455                     return AVERROR_INVALIDDATA;
456                 }
457             }
458         }
459
460         for (blk = 0; blk < num_blocks; blk++) {
461             /* adjust block position in the buffer according to its number */
462             if (blk & 1) {
463                 buf_offs += blk_size;
464             } else if (blk == 2) {
465                 buf_offs -= blk_size;
466                 buf_offs += blk_size * band->pitch;
467             }
468
469             if (cbp & 1) { /* block coded ? */
470                 scan_pos = -1;
471                 memset(trvec, 0, num_coeffs*sizeof(trvec[0])); /* zero transform vector */
472                 memset(col_flags, 0, sizeof(col_flags));      /* zero column flags */
473
474                 while (scan_pos <= num_coeffs) {
475                     sym = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
476                     if (sym == rvmap->eob_sym)
477                         break; /* End of block */
478
479                     if (sym == rvmap->esc_sym) { /* Escape - run/val explicitly coded using 3 vlc codes */
480                         run = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1) + 1;
481                         lo  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
482                         hi  = get_vlc2(gb, band->blk_vlc.tab->table, IVI_VLC_BITS, 1);
483                         val = IVI_TOSIGNED((hi << 6) | lo); /* merge them and convert into signed val */
484                     } else {
485                         if (sym >= 256U) {
486                             av_log(avctx, AV_LOG_ERROR, "Invalid sym encountered: %d.\n", sym);
487                             return -1;
488                         }
489                         run = rvmap->runtab[sym];
490                         val = rvmap->valtab[sym];
491                     }
492
493                     /* de-zigzag and dequantize */
494                     scan_pos += run;
495                     if (scan_pos >= (unsigned)num_coeffs)
496                         break;
497                     pos = band->scan[scan_pos];
498
499                     if (!val)
500                         av_dlog(avctx, "Val = 0 encountered!\n");
501
502                     q = (base_tab[pos] * quant) >> 9;
503                     if (q > 1)
504                         val = val * q + FFSIGN(val) * (((q ^ 1) - 1) >> 1);
505                     trvec[pos] = val;
506                     col_flags[pos & col_mask] |= !!val; /* track columns containing non-zero coeffs */
507                 }// while
508
509                 if (scan_pos >= num_coeffs && sym != rvmap->eob_sym)
510                     return -1; /* corrupt block data */
511
512                 /* undoing DC coeff prediction for intra-blocks */
513                 if (is_intra && band->is_2d_trans) {
514                     prev_dc      += trvec[0];
515                     trvec[0]      = prev_dc;
516                     col_flags[0] |= !!prev_dc;
517                 }
518                 if(band->transform_size > band->blk_size){
519                     av_log(NULL, AV_LOG_ERROR, "Too large transform\n");
520                     return AVERROR_INVALIDDATA;
521                 }
522                 /* apply inverse transform */
523                 band->inv_transform(trvec, band->buf + buf_offs,
524                                     band->pitch, col_flags);
525
526                 /* apply motion compensation */
527                 if (!is_intra)
528                     mc_with_delta_func(band->buf + buf_offs,
529                                        band->ref_buf + buf_offs + mv_y * band->pitch + mv_x,
530                                        band->pitch, mc_type);
531             } else {
532                 /* block not coded */
533                 /* for intra blocks apply the dc slant transform */
534                 /* for inter - perform the motion compensation without delta */
535                 if (is_intra) {
536                     band->dc_transform(&prev_dc, band->buf + buf_offs,
537                                        band->pitch, blk_size);
538                 } else
539                     mc_no_delta_func(band->buf + buf_offs,
540                                      band->ref_buf + buf_offs + mv_y * band->pitch + mv_x,
541                                      band->pitch, mc_type);
542             }
543
544             cbp >>= 1;
545         }// for blk
546     }// for mbn
547
548     align_get_bits(gb);
549
550     return 0;
551 }
552
553 /**
554  *  Handle empty tiles by performing data copying and motion
555  *  compensation respectively.
556  *
557  *  @param[in]  avctx     ptr to the AVCodecContext
558  *  @param[in]  band      pointer to the band descriptor
559  *  @param[in]  tile      pointer to the tile descriptor
560  *  @param[in]  mv_scale  scaling factor for motion vectors
561  */
562 static int ivi_process_empty_tile(AVCodecContext *avctx, IVIBandDesc *band,
563                                   IVITile *tile, int32_t mv_scale)
564 {
565     int             x, y, need_mc, mbn, blk, num_blocks, mv_x, mv_y, mc_type;
566     int             offs, mb_offset, row_offset;
567     IVIMbInfo       *mb, *ref_mb;
568     const int16_t   *src;
569     int16_t         *dst;
570     void (*mc_no_delta_func)(int16_t *buf, const int16_t *ref_buf, uint32_t pitch,
571                              int mc_type);
572
573     if (tile->num_MBs != IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size)) {
574         av_log(avctx, AV_LOG_ERROR, "Allocated tile size %d mismatches "
575                "parameters %d in ivi_process_empty_tile()\n",
576                tile->num_MBs, IVI_MBs_PER_TILE(tile->width, tile->height, band->mb_size));
577         return AVERROR_INVALIDDATA;
578     }
579
580     offs       = tile->ypos * band->pitch + tile->xpos;
581     mb         = tile->mbs;
582     ref_mb     = tile->ref_mbs;
583     row_offset = band->mb_size * band->pitch;
584     need_mc    = 0; /* reset the mc tracking flag */
585
586     for (y = tile->ypos; y < (tile->ypos + tile->height); y += band->mb_size) {
587         mb_offset = offs;
588
589         for (x = tile->xpos; x < (tile->xpos + tile->width); x += band->mb_size) {
590             mb->xpos     = x;
591             mb->ypos     = y;
592             mb->buf_offs = mb_offset;
593
594             mb->type = 1; /* set the macroblocks type = INTER */
595             mb->cbp  = 0; /* all blocks are empty */
596
597             if (!band->qdelta_present && !band->plane && !band->band_num) {
598                 mb->q_delta = band->glob_quant;
599                 mb->mv_x    = 0;
600                 mb->mv_y    = 0;
601             }
602
603             if (band->inherit_qdelta && ref_mb)
604                 mb->q_delta = ref_mb->q_delta;
605
606             if (band->inherit_mv && ref_mb) {
607                 /* motion vector inheritance */
608                 if (mv_scale) {
609                     mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
610                     mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
611                 } else {
612                     mb->mv_x = ref_mb->mv_x;
613                     mb->mv_y = ref_mb->mv_y;
614                 }
615                 need_mc |= mb->mv_x || mb->mv_y; /* tracking non-zero motion vectors */
616                 {
617                     int dmv_x, dmv_y, cx, cy;
618
619                     dmv_x = mb->mv_x >> band->is_halfpel;
620                     dmv_y = mb->mv_y >> band->is_halfpel;
621                     cx    = mb->mv_x &  band->is_halfpel;
622                     cy    = mb->mv_y &  band->is_halfpel;
623
624                     if (   mb->xpos + dmv_x < 0
625                         || mb->xpos + dmv_x + band->mb_size + cx > band->pitch
626                         || mb->ypos + dmv_y < 0
627                         || mb->ypos + dmv_y + band->mb_size + cy > band->aheight) {
628                         av_log(avctx, AV_LOG_ERROR, "MV out of bounds\n");
629                         return AVERROR_INVALIDDATA;
630                     }
631                 }
632             }
633
634             mb++;
635             if (ref_mb)
636                 ref_mb++;
637             mb_offset += band->mb_size;
638         } // for x
639         offs += row_offset;
640     } // for y
641
642     if (band->inherit_mv && need_mc) { /* apply motion compensation if there is at least one non-zero motion vector */
643         num_blocks = (band->mb_size != band->blk_size) ? 4 : 1; /* number of blocks per mb */
644         mc_no_delta_func = (band->blk_size == 8) ? ff_ivi_mc_8x8_no_delta
645                                                  : ff_ivi_mc_4x4_no_delta;
646
647         for (mbn = 0, mb = tile->mbs; mbn < tile->num_MBs; mb++, mbn++) {
648             mv_x = mb->mv_x;
649             mv_y = mb->mv_y;
650             if (!band->is_halfpel) {
651                 mc_type = 0; /* we have only fullpel vectors */
652             } else {
653                 mc_type = ((mv_y & 1) << 1) | (mv_x & 1);
654                 mv_x >>= 1;
655                 mv_y >>= 1; /* convert halfpel vectors into fullpel ones */
656             }
657
658             for (blk = 0; blk < num_blocks; blk++) {
659                 /* adjust block position in the buffer according with its number */
660                 offs = mb->buf_offs + band->blk_size * ((blk & 1) + !!(blk & 2) * band->pitch);
661                 mc_no_delta_func(band->buf + offs,
662                                  band->ref_buf + offs + mv_y * band->pitch + mv_x,
663                                  band->pitch, mc_type);
664             }
665         }
666     } else {
667         /* copy data from the reference tile into the current one */
668         src = band->ref_buf + tile->ypos * band->pitch + tile->xpos;
669         dst = band->buf     + tile->ypos * band->pitch + tile->xpos;
670         for (y = 0; y < tile->height; y++) {
671             memcpy(dst, src, tile->width*sizeof(band->buf[0]));
672             src += band->pitch;
673             dst += band->pitch;
674         }
675     }
676
677     return 0;
678 }
679
680
681 #ifdef DEBUG
682 static uint16_t ivi_calc_band_checksum(IVIBandDesc *band)
683 {
684     int         x, y;
685     int16_t     *src, checksum;
686
687     src = band->buf;
688     checksum = 0;
689
690     for (y = 0; y < band->height; src += band->pitch, y++)
691         for (x = 0; x < band->width; x++)
692             checksum += src[x];
693
694     return checksum;
695 }
696 #endif
697
698 /*
699  *  Convert and output the current plane.
700  *  This conversion is done by adding back the bias value of 128
701  *  (subtracted in the encoder) and clipping the result.
702  *
703  *  @param[in]   plane      pointer to the descriptor of the plane being processed
704  *  @param[out]  dst        pointer to the buffer receiving converted pixels
705  *  @param[in]   dst_pitch  pitch for moving to the next y line
706  */
707 static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, int dst_pitch)
708 {
709     int             x, y;
710     const int16_t   *src  = plane->bands[0].buf;
711     uint32_t        pitch = plane->bands[0].pitch;
712
713     if (!src)
714         return;
715
716     for (y = 0; y < plane->height; y++) {
717         for (x = 0; x < plane->width; x++)
718             dst[x] = av_clip_uint8(src[x] + 128);
719         src += pitch;
720         dst += dst_pitch;
721     }
722 }
723
724 /**
725  *  Decode an Indeo 4 or 5 band.
726  *
727  *  @param[in,out]  ctx    ptr to the decoder context
728  *  @param[in,out]  band   ptr to the band descriptor
729  *  @param[in]      avctx  ptr to the AVCodecContext
730  *  @return         result code: 0 = OK, -1 = error
731  */
732 static int decode_band(IVI45DecContext *ctx,
733                        IVIBandDesc *band, AVCodecContext *avctx)
734 {
735     int         result, i, t, idx1, idx2, pos;
736     IVITile     *tile;
737
738     band->buf     = band->bufs[ctx->dst_buf];
739     if (!band->buf) {
740         av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");
741         return AVERROR_INVALIDDATA;
742     }
743     band->ref_buf = band->bufs[ctx->ref_buf];
744     band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
745
746     result = ctx->decode_band_hdr(ctx, band, avctx);
747     if (result) {
748         av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
749                result);
750         return result;
751     }
752
753     if (band->is_empty) {
754         av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
755         return AVERROR_INVALIDDATA;
756     }
757
758     band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
759
760     /* apply corrections to the selected rvmap table if present */
761     for (i = 0; i < band->num_corr; i++) {
762         idx1 = band->corr[i * 2];
763         idx2 = band->corr[i * 2 + 1];
764         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
765         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
766         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
767             band->rv_map->eob_sym ^= idx1 ^ idx2;
768         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
769             band->rv_map->esc_sym ^= idx1 ^ idx2;
770     }
771
772     pos = get_bits_count(&ctx->gb);
773
774     for (t = 0; t < band->num_tiles; t++) {
775         tile = &band->tiles[t];
776
777         if (tile->mb_size != band->mb_size) {
778             av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",
779                    band->mb_size, tile->mb_size);
780             return AVERROR_INVALIDDATA;
781         }
782         tile->is_empty = get_bits1(&ctx->gb);
783         if (tile->is_empty) {
784             result = ivi_process_empty_tile(avctx, band, tile,
785                                       (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
786             if (result < 0)
787                 break;
788             av_dlog(avctx, "Empty tile encountered!\n");
789         } else {
790             tile->data_size = ivi_dec_tile_data_size(&ctx->gb);
791             if (!tile->data_size) {
792                 av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
793                 result = AVERROR_INVALIDDATA;
794                 break;
795             }
796
797             result = ctx->decode_mb_info(ctx, band, tile, avctx);
798             if (result < 0)
799                 break;
800
801             result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);
802             if (result < 0 || ((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
803                 av_log(avctx, AV_LOG_ERROR, "Corrupted tile data encountered!\n");
804                 break;
805             }
806
807             pos += tile->data_size << 3; // skip to next tile
808         }
809     }
810
811     /* restore the selected rvmap table by applying its corrections in reverse order */
812     for (i = band->num_corr-1; i >= 0; i--) {
813         idx1 = band->corr[i*2];
814         idx2 = band->corr[i*2+1];
815         FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
816         FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
817         if (idx1 == band->rv_map->eob_sym || idx2 == band->rv_map->eob_sym)
818             band->rv_map->eob_sym ^= idx1 ^ idx2;
819         if (idx1 == band->rv_map->esc_sym || idx2 == band->rv_map->esc_sym)
820             band->rv_map->esc_sym ^= idx1 ^ idx2;
821     }
822
823 #ifdef DEBUG
824     if (band->checksum_present) {
825         uint16_t chksum = ivi_calc_band_checksum(band);
826         if (chksum != band->checksum) {
827             av_log(avctx, AV_LOG_ERROR,
828                    "Band checksum mismatch! Plane %d, band %d, received: %x, calculated: %x\n",
829                    band->plane, band->band_num, band->checksum, chksum);
830         }
831     }
832 #endif
833
834     align_get_bits(&ctx->gb);
835
836     return result;
837 }
838
839 int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
840                         AVPacket *avpkt)
841 {
842     IVI45DecContext *ctx = avctx->priv_data;
843     const uint8_t   *buf = avpkt->data;
844     int             buf_size = avpkt->size;
845     int             result, p, b;
846
847     init_get_bits(&ctx->gb, buf, buf_size * 8);
848     ctx->frame_data = buf;
849     ctx->frame_size = buf_size;
850
851     result = ctx->decode_pic_hdr(ctx, avctx);
852     if (result) {
853         av_log(avctx, AV_LOG_ERROR,
854                "Error while decoding picture header: %d\n", result);
855         return -1;
856     }
857     if (ctx->gop_invalid)
858         return AVERROR_INVALIDDATA;
859
860     if (ctx->gop_flags & IVI5_IS_PROTECTED) {
861         av_log(avctx, AV_LOG_ERROR, "Password-protected clip!\n");
862         return -1;
863     }
864
865     ctx->switch_buffers(ctx);
866
867     //{ START_TIMER;
868
869     if (ctx->is_nonnull_frame(ctx)) {
870         ctx->buf_invalid[ctx->dst_buf] = 1;
871         for (p = 0; p < 3; p++) {
872             for (b = 0; b < ctx->planes[p].num_bands; b++) {
873                 result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);
874                 if (result) {
875                     av_log(avctx, AV_LOG_ERROR,
876                            "Error while decoding band: %d, plane: %d\n", b, p);
877                     return -1;
878                 }
879             }
880         }
881         ctx->buf_invalid[ctx->dst_buf] = 0;
882     }
883     if (ctx->buf_invalid[ctx->dst_buf])
884         return -1;
885
886     //STOP_TIMER("decode_planes"); }
887
888     /* If the bidirectional mode is enabled, next I and the following P frame will */
889     /* be sent together. Unfortunately the approach below seems to be the only way */
890     /* to handle the B-frames mode. That's exactly the same Intel decoders do.     */
891     if (avctx->codec_id == AV_CODEC_ID_INDEO4 && ctx->frame_type == 0/*FRAMETYPE_INTRA*/) {
892         while (get_bits(&ctx->gb, 8)); // skip version string
893         skip_bits_long(&ctx->gb, 64);  // skip padding, TODO: implement correct 8-bytes alignment
894         if (get_bits_left(&ctx->gb) > 18 && show_bits(&ctx->gb, 18) == 0x3FFF8)
895             av_log(avctx, AV_LOG_ERROR, "Buffer contains IP frames!\n");
896     }
897
898     if (!ctx->is_nonnull_frame(ctx))
899         return buf_size;
900
901     if (ctx->frame.data[0])
902         avctx->release_buffer(avctx, &ctx->frame);
903
904     ctx->frame.reference = 0;
905     avcodec_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);
906     if ((result = ff_get_buffer(avctx, &ctx->frame)) < 0) {
907         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
908         return result;
909     }
910
911     if (ctx->is_scalable) {
912         if (avctx->codec_id == AV_CODEC_ID_INDEO4)
913             ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
914         else
915             ff_ivi_recompose53   (&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
916     } else {
917         ivi_output_plane(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
918     }
919
920     ivi_output_plane(&ctx->planes[2], ctx->frame.data[1], ctx->frame.linesize[1]);
921     ivi_output_plane(&ctx->planes[1], ctx->frame.data[2], ctx->frame.linesize[2]);
922
923     *got_frame = 1;
924     *(AVFrame*)data = ctx->frame;
925
926     return buf_size;
927 }
928
929 /**
930  *  Close Indeo5 decoder and clean up its context.
931  */
932 av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
933 {
934     IVI45DecContext *ctx = avctx->priv_data;
935
936     ivi_free_buffers(&ctx->planes[0]);
937
938     if (ctx->mb_vlc.cust_tab.table)
939         ff_free_vlc(&ctx->mb_vlc.cust_tab);
940
941     if (ctx->frame.data[0])
942         avctx->release_buffer(avctx, &ctx->frame);
943
944 #if IVI4_STREAM_ANALYSER
945     if (avctx->codec_id == AV_CODEC_ID_INDEO4) {
946     if (ctx->is_scalable)
947         av_log(avctx, AV_LOG_ERROR, "This video uses scalability mode!\n");
948     if (ctx->uses_tiling)
949         av_log(avctx, AV_LOG_ERROR, "This video uses local decoding!\n");
950     if (ctx->has_b_frames)
951         av_log(avctx, AV_LOG_ERROR, "This video contains B-frames!\n");
952     if (ctx->has_transp)
953         av_log(avctx, AV_LOG_ERROR, "Transparency mode is enabled!\n");
954     if (ctx->uses_haar)
955         av_log(avctx, AV_LOG_ERROR, "This video uses Haar transform!\n");
956     if (ctx->uses_fullpel)
957         av_log(avctx, AV_LOG_ERROR, "This video uses fullpel motion vectors!\n");
958     }
959 #endif
960
961     return 0;
962 }
963
964
965 /**
966  * These are 2x8 predefined Huffman codebooks for coding macroblock/block
967  * signals. They are specified using "huffman descriptors" in order to
968  * avoid huge static tables. The decoding tables will be generated at
969  * startup from these descriptors.
970  */
971 const IVIHuffDesc ff_ivi_mb_huff_desc[8] = {
972     {8,  {0, 4, 5, 4, 4, 4, 6, 6}},
973     {12, {0, 2, 2, 3, 3, 3, 3, 5, 3, 2, 2, 2}},
974     {12, {0, 2, 3, 4, 3, 3, 3, 3, 4, 3, 2, 2}},
975     {12, {0, 3, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2}},
976     {13, {0, 4, 4, 3, 3, 3, 3, 2, 3, 3, 2, 1, 1}},
977     {9,  {0, 4, 4, 4, 4, 3, 3, 3, 2}},
978     {10, {0, 4, 4, 4, 4, 3, 3, 2, 2, 2}},
979     {12, {0, 4, 4, 4, 3, 3, 2, 3, 2, 2, 2, 2}}
980 };
981
982 const IVIHuffDesc ff_ivi_blk_huff_desc[8] = {
983     {10, {1, 2, 3, 4, 4, 7, 5, 5, 4, 1}},
984     {11, {2, 3, 4, 4, 4, 7, 5, 4, 3, 3, 2}},
985     {12, {2, 4, 5, 5, 5, 5, 6, 4, 4, 3, 1, 1}},
986     {13, {3, 3, 4, 4, 5, 6, 6, 4, 4, 3, 2, 1, 1}},
987     {11, {3, 4, 4, 5, 5, 5, 6, 5, 4, 2, 2}},
988     {13, {3, 4, 5, 5, 5, 5, 6, 4, 3, 3, 2, 1, 1}},
989     {13, {3, 4, 5, 5, 5, 6, 5, 4, 3, 3, 2, 1, 1}},
990     {9,  {3, 4, 4, 5, 5, 5, 6, 5, 5}}
991 };
992
993
994 /**
995  *  Scan patterns shared between indeo4 and indeo5
996  */
997 const uint8_t ff_ivi_vertical_scan_8x8[64] = {
998     0,  8, 16, 24, 32, 40, 48, 56,
999     1,  9, 17, 25, 33, 41, 49, 57,
1000     2, 10, 18, 26, 34, 42, 50, 58,
1001     3, 11, 19, 27, 35, 43, 51, 59,
1002     4, 12, 20, 28, 36, 44, 52, 60,
1003     5, 13, 21, 29, 37, 45, 53, 61,
1004     6, 14, 22, 30, 38, 46, 54, 62,
1005     7, 15, 23, 31, 39, 47, 55, 63
1006 };
1007
1008 const uint8_t ff_ivi_horizontal_scan_8x8[64] = {
1009      0,  1,  2,  3,  4,  5,  6,  7,
1010      8,  9, 10, 11, 12, 13, 14, 15,
1011     16, 17, 18, 19, 20, 21, 22, 23,
1012     24, 25, 26, 27, 28, 29, 30, 31,
1013     32, 33, 34, 35, 36, 37, 38, 39,
1014     40, 41, 42, 43, 44, 45, 46, 47,
1015     48, 49, 50, 51, 52, 53, 54, 55,
1016     56, 57, 58, 59, 60, 61, 62, 63
1017 };
1018
1019 const uint8_t ff_ivi_direct_scan_4x4[16] = {
1020     0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
1021 };
1022
1023
1024 /**
1025  *  Run-value (RLE) tables.
1026  */
1027 const RVMapDesc ff_ivi_rvmap_tabs[9] = {
1028 {   /* MapTab0 */
1029     5, /* eob_sym */
1030     2, /* esc_sym */
1031     /* run table */
1032     {1,  1,  0,  1,  1,  0,  1,  1,  2,  2,  1,  1,  1,  1,  3,  3,
1033      1,  1,  2,  2,  1,  1,  4,  4,  1,  1,  1,  1,  2,  2,  5,  5,
1034      1,  1,  3,  3,  1,  1,  6,  6,  1,  2,  1,  2,  7,  7,  1,  1,
1035      8,  8,  1,  1,  4,  2,  1,  4,  2,  1,  3,  3,  1,  1,  1,  9,
1036      9,  1,  2,  1,  2,  1,  5,  5,  1,  1, 10, 10,  1,  1,  3,  3,
1037      2,  2,  1,  1, 11, 11,  6,  4,  4,  1,  6,  1,  2,  1,  2, 12,
1038      8,  1, 12,  7,  8,  7,  1, 16,  1, 16,  1,  3,  3, 13,  1, 13,
1039      2,  2,  1, 15,  1,  5, 14, 15,  1,  5, 14,  1, 17,  8, 17,  8,
1040      1,  4,  4,  2,  2,  1, 25, 25, 24, 24,  1,  3,  1,  3,  1,  8,
1041      6,  7,  6,  1, 18,  8, 18,  1,  7, 23,  2,  2, 23,  1,  1, 21,
1042     22,  9,  9, 22, 19,  1, 21,  5, 19,  5,  1, 33, 20, 33, 20,  8,
1043      4,  4,  1, 32,  2,  2,  8,  3, 32, 26,  3,  1,  7,  7, 26,  6,
1044      1,  6,  1,  1, 16,  1, 10,  1, 10,  2, 16, 29, 28,  2, 29, 28,
1045      1, 27,  5,  8,  5, 27,  1,  8,  3,  7,  3, 31, 41, 31,  1, 41,
1046      6,  1,  6,  7,  4,  4,  1,  1,  2,  1,  2, 11, 34, 30, 11,  1,
1047     30, 15, 15, 34, 36, 40, 36, 40, 35, 35, 37, 37, 39, 39, 38, 38},
1048
1049     /* value table */
1050     { 1,  -1,   0,   2,  -2,   0,   3,  -3,   1,  -1,   4,  -4,   5,  -5,   1,  -1,
1051       6,  -6,   2,  -2,   7,  -7,   1,  -1,   8,  -8,   9,  -9,   3,  -3,   1,  -1,
1052      10, -10,   2,  -2,  11, -11,   1,  -1,  12,   4, -12,  -4,   1,  -1,  13, -13,
1053       1,  -1,  14, -14,   2,   5,  15,  -2,  -5, -15,  -3,   3,  16, -16,  17,   1,
1054      -1, -17,   6,  18,  -6, -18,   2,  -2,  19, -19,   1,  -1,  20, -20,   4,  -4,
1055       7,  -7,  21, -21,   1,  -1,   2,   3,  -3,  22,  -2, -22,   8,  23,  -8,   1,
1056       2, -23,  -1,   2,  -2,  -2,  24,   1, -24,  -1,  25,   5,  -5,   1, -25,  -1,
1057       9,  -9,  26,   1, -26,   3,   1,  -1,  27,  -3,  -1, -27,   1,   3,  -1,  -3,
1058      28,  -4,   4,  10, -10, -28,   1,  -1,   1,  -1,  29,   6, -29,  -6,  30,  -4,
1059       3,   3,  -3, -30,   1,   4,  -1,  31,  -3,   1,  11, -11,  -1, -31,  32,  -1,
1060      -1,   2,  -2,   1,   1, -32,   1,   4,  -1,  -4,  33,  -1,   1,   1,  -1,   5,
1061       5,  -5, -33,  -1, -12,  12,  -5,  -7,   1,   1,   7,  34,   4,  -4,  -1,   4,
1062     -34,  -4,  35,  36,  -2, -35,  -2, -36,   2,  13,   2,  -1,   1, -13,   1,  -1,
1063      37,   1,  -5,   6,   5,  -1,  38,  -6,  -8,   5,   8,  -1,   1,   1, -37,  -1,
1064       5,  39,  -5,  -5,   6,  -6, -38, -39, -14,  40,  14,   2,   1,   1,  -2, -40,
1065      -1,  -2,   2,  -1,  -1,  -1,   1,   1,   1,  -1,   1,  -1,   1,  -1,   1,  -1}
1066 },{
1067     /* MapTab1 */
1068     0,  /* eob_sym */
1069     38, /* esc_sym */
1070     /* run table */
1071     {0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  8,  6,  8,  7,
1072      7,  9,  9, 10, 10, 11, 11,  1, 12,  1, 12, 13, 13, 16, 14, 16,
1073     14, 15, 15, 17, 17, 18,  0, 18, 19, 20, 21, 19, 22, 21, 20, 22,
1074     25, 24,  2, 25, 24, 23, 23,  2, 26, 28, 26, 28, 29, 27, 29, 27,
1075     33, 33,  1, 32,  1,  3, 32, 30, 36,  3, 36, 30, 31, 31, 35, 34,
1076     37, 41, 34, 35, 37,  4, 41,  4, 49,  8,  8, 49, 40, 38,  5, 38,
1077     40, 39,  5, 39, 42, 43, 42,  7, 57,  6, 43, 44,  6, 50,  7, 44,
1078     57, 48, 50, 48, 45, 45, 46, 47, 51, 46, 47, 58,  1, 51, 58,  1,
1079     52, 59, 53,  9, 52, 55, 55, 59, 53, 56, 54, 56, 54,  9, 64, 64,
1080     60, 63, 60, 63, 61, 62, 61, 62,  2, 10,  2, 10, 11,  1, 11, 13,
1081     12,  1, 12, 13, 16, 16,  8,  8, 14,  3,  3, 15, 14, 15,  4,  4,
1082      1, 17, 17,  5,  1,  7,  7,  5,  6,  1,  2,  2,  6, 22,  1, 25,
1083     21, 22,  8, 24,  1, 21, 25, 24,  8, 18, 18, 23,  9, 20, 23, 33,
1084     29, 33, 20,  1, 19,  1, 29, 36,  9, 36, 19, 41, 28, 57, 32,  3,
1085     28,  3,  1, 27, 49, 49,  1, 32, 26, 26,  2,  4,  4,  7, 57, 41,
1086      2,  7, 10,  5, 37, 16, 10, 27,  8,  8, 13, 16, 37, 13,  1,  5},
1087
1088     /* value table */
1089     {0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   1,   1,  -1,  -1,   1,
1090     -1,   1,  -1,   1,  -1,   1,  -1,   2,   1,  -2,  -1,   1,  -1,   1,   1,  -1,
1091     -1,   1,  -1,   1,  -1,   1,   0,  -1,   1,   1,   1,  -1,   1,  -1,  -1,  -1,
1092      1,   1,   2,  -1,  -1,   1,  -1,  -2,   1,   1,  -1,  -1,   1,   1,  -1,  -1,
1093      1,  -1,   3,   1,  -3,   2,  -1,   1,   1,  -2,  -1,  -1,  -1,   1,   1,   1,
1094      1,   1,  -1,  -1,  -1,   2,  -1,  -2,   1,   2,  -2,  -1,   1,   1,   2,  -1,
1095     -1,   1,  -2,  -1,   1,   1,  -1,   2,   1,   2,  -1,   1,  -2,  -1,  -2,  -1,
1096     -1,   1,   1,  -1,   1,  -1,   1,   1,   1,  -1,  -1,   1,   4,  -1,  -1,  -4,
1097      1,   1,   1,   2,  -1,  -1,   1,  -1,  -1,   1,  -1,  -1,   1,  -2,   1,  -1,
1098      1,   1,  -1,  -1,   1,   1,  -1,  -1,   3,   2,  -3,  -2,   2,   5,  -2,   2,
1099      2,  -5,  -2,  -2,  -2,   2,  -3,   3,   2,   3,  -3,   2,  -2,  -2,   3,  -3,
1100      6,   2,  -2,   3,  -6,   3,  -3,  -3,   3,   7,  -4,   4,  -3,   2,  -7,   2,
1101      2,  -2,  -4,   2,   8,  -2,  -2,  -2,   4,   2,  -2,   2,   3,   2,  -2,  -2,
1102      2,   2,  -2,  -8,  -2,   9,  -2,   2,  -3,  -2,   2,  -2,   2,   2,   2,   4,
1103     -2,  -4,  10,   2,   2,  -2,  -9,  -2,   2,  -2,   5,   4,  -4,   4,  -2,   2,
1104     -5,  -4,  -3,   4,   2,  -3,   3,  -2,  -5,   5,   3,   3,  -2,  -3, -10,  -4}
1105 },{
1106     /* MapTab2 */
1107     2,  /* eob_sym */
1108     11, /* esc_sym */
1109     /* run table */
1110     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  0,  1,  1,  5,  5,
1111      2,  2,  6,  6,  7,  7,  1,  8,  1,  8,  3,  3,  9,  9,  1,  2,
1112      2,  1,  4, 10,  4, 10, 11, 11,  1,  5, 12, 12,  1,  5, 13, 13,
1113      3,  3,  6,  6,  2,  2, 14, 14, 16, 16, 15,  7, 15,  8,  8,  7,
1114      1,  1, 17, 17,  4,  4,  1,  1, 18, 18,  2,  2,  5,  5, 25,  3,
1115      9,  3, 25,  9, 19, 24, 19, 24,  1, 21, 20,  1, 21, 22, 20, 22,
1116     23, 23,  8,  6, 33,  6,  8, 33,  7,  7, 26, 26,  1, 32,  1, 32,
1117     28,  4, 28, 10, 29, 27, 27, 10, 41,  4, 29,  2,  2, 41, 36, 31,
1118     49, 31, 34, 30, 34, 36, 30, 35,  1, 49, 11,  5, 35, 11,  1,  3,
1119      3,  5, 37, 37,  8, 40,  8, 40, 12, 12, 42, 42,  1, 38, 16, 57,
1120      1,  6, 16, 39, 38,  6,  7,  7, 13, 13, 39, 43,  2, 43, 57,  2,
1121     50,  9, 44,  9, 50,  4, 15, 48, 44,  4,  1, 15, 48, 14, 14,  1,
1122     45, 45,  8,  3,  5,  8, 51, 47,  3, 46, 46, 47,  5, 51,  1, 17,
1123     17, 58,  1, 58,  2, 52, 52,  2, 53,  7, 59,  6,  6, 56, 53, 55,
1124      7, 55,  1, 54, 59, 56, 54, 10,  1, 10,  4, 60,  1, 60,  8,  4,
1125      8, 64, 64, 61,  1, 63,  3, 63, 62, 61,  5, 11,  5,  3, 11, 62},
1126
1127     /* value table */
1128     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   0,   3,  -3,   1,  -1,
1129       2,  -2,   1,  -1,   1,  -1,   4,   1,  -4,  -1,   2,  -2,   1,  -1,   5,   3,
1130      -3,  -5,   2,   1,  -2,  -1,   1,  -1,   6,   2,   1,  -1,  -6,  -2,   1,  -1,
1131       3,  -3,   2,  -2,   4,  -4,   1,  -1,   1,  -1,   1,   2,  -1,   2,  -2,  -2,
1132       7,  -7,   1,  -1,   3,  -3,   8,  -8,   1,  -1,   5,  -5,   3,  -3,   1,   4,
1133       2,  -4,  -1,  -2,   1,   1,  -1,  -1,   9,   1,   1,  -9,  -1,   1,  -1,  -1,
1134       1,  -1,   3,  -3,   1,   3,  -3,  -1,   3,  -3,   1,  -1,  10,   1, -10,  -1,
1135       1,   4,  -1,   2,   1,  -1,   1,  -2,   1,  -4,  -1,   6,  -6,  -1,   1,   1,
1136       1,  -1,   1,   1,  -1,  -1,  -1,   1,  11,  -1,  -2,   4,  -1,   2, -11,   5,
1137      -5,  -4,  -1,   1,   4,   1,  -4,  -1,  -2,   2,   1,  -1,  12,   1,  -2,   1,
1138     -12,   4,   2,   1,  -1,  -4,   4,  -4,   2,  -2,  -1,   1,   7,  -1,  -1,  -7,
1139      -1,  -3,   1,   3,   1,   5,   2,   1,  -1,  -5,  13,  -2,  -1,   2,  -2, -13,
1140       1,  -1,   5,   6,   5,  -5,   1,   1,  -6,   1,  -1,  -1,  -5,  -1,  14,   2,
1141      -2,   1, -14,  -1,   8,   1,  -1,  -8,   1,   5,   1,   5,  -5,   1,  -1,   1,
1142      -5,  -1,  15,   1,  -1,  -1,  -1,   3, -15,  -3,   6,   1,  16,  -1,   6,  -6,
1143      -6,   1,  -1,   1, -16,   1,   7,  -1,   1,  -1,  -6,  -3,   6,  -7,   3,  -1}
1144 },{
1145     /* MapTab3 */
1146     0,  /* eob_sym */
1147     35, /* esc_sym */
1148     /* run table */
1149     {0,  1,  1,  2,  2,  3,  3,  4,  4,  1,  1,  5,  5,  6,  6,  7,
1150      7,  8,  8,  9,  9,  2,  2, 10, 10,  1,  1, 11, 11, 12, 12,  3,
1151      3, 13, 13,  0, 14, 14, 16, 15, 16, 15,  4,  4, 17,  1, 17,  1,
1152      5,  5, 18, 18,  2,  2,  6,  6,  8, 19,  7,  8,  7, 19, 20, 20,
1153     21, 21, 22, 24, 22, 24, 23, 23,  1,  1, 25, 25,  3,  3, 26, 26,
1154      9,  9, 27, 27, 28, 28, 33, 29,  4, 33, 29,  1,  4,  1, 32, 32,
1155      2,  2, 31, 10, 30, 10, 30, 31, 34, 34,  5,  5, 36, 36, 35, 41,
1156     35, 11, 41, 11, 37,  1,  8,  8, 37,  6,  1,  6, 40,  7,  7, 40,
1157     12, 38, 12, 39, 39, 38, 49, 13, 49, 13,  3, 42,  3, 42, 16, 16,
1158     43, 43, 14, 14,  1,  1, 44, 15, 44, 15,  2,  2, 57, 48, 50, 48,
1159     57, 50,  4, 45, 45,  4, 46, 47, 47, 46,  1, 51,  1, 17, 17, 51,
1160      8,  9,  9,  5, 58,  8, 58,  5, 52, 52, 55, 56, 53, 56, 55, 59,
1161     59, 53, 54,  1,  6, 54,  7,  7,  6,  1,  2,  3,  2,  3, 64, 60,
1162     60, 10, 10, 64, 61, 62, 61, 63,  1, 63, 62,  1, 18, 24, 18,  4,
1163     25,  4,  8, 21, 21,  1, 24, 22, 25, 22,  8, 11, 19, 11, 23,  1,
1164     20, 23, 19, 20,  5, 12,  5,  1, 16,  2, 12, 13,  2, 13,  1, 16},
1165
1166     /* value table */
1167     { 0,   1,  -1,   1,  -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,
1168      -1,   1,  -1,   1,  -1,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   1,  -1,   2,
1169      -2,   1,  -1,   0,   1,  -1,   1,   1,  -1,  -1,   2,  -2,   1,   4,  -1,  -4,
1170       2,  -2,   1,  -1,  -3,   3,   2,  -2,   2,   1,   2,  -2,  -2,  -1,   1,  -1,
1171       1,  -1,   1,   1,  -1,  -1,   1,  -1,   5,  -5,   1,  -1,   3,  -3,   1,  -1,
1172       2,  -2,   1,  -1,   1,  -1,   1,   1,   3,  -1,  -1,   6,  -3,  -6,  -1,   1,
1173       4,  -4,   1,   2,   1,  -2,  -1,  -1,   1,  -1,   3,  -3,   1,  -1,   1,   1,
1174      -1,   2,  -1,  -2,   1,   7,  -3,   3,  -1,   3,  -7,  -3,   1,  -3,   3,  -1,
1175       2,   1,  -2,   1,  -1,  -1,   1,   2,  -1,  -2,  -4,  -1,   4,   1,   2,  -2,
1176       1,  -1,  -2,   2,   8,  -8,  -1,   2,   1,  -2,  -5,   5,   1,  -1,  -1,   1,
1177      -1,   1,   4,  -1,   1,  -4,  -1,  -1,   1,   1,   9,   1,  -9,   2,  -2,  -1,
1178      -4,   3,  -3,  -4,  -1,   4,   1,   4,   1,  -1,   1,  -1,   1,   1,  -1,   1,
1179      -1,  -1,  -1,  10,   4,   1,   4,  -4,  -4, -10,   6,   5,  -6,  -5,   1,  -1,
1180       1,   3,  -3,  -1,   1,  -1,  -1,  -1,  11,   1,   1, -11,  -2,  -2,   2,   5,
1181      -2,  -5,  -5,   2,  -2,  12,   2,  -2,   2,   2,   5,  -3,  -2,   3,  -2, -12,
1182      -2,   2,   2,   2,  -5,   3,   5,  13,  -3,   7,  -3,  -3,  -7,   3, -13,   3}
1183 },{
1184     /* MapTab4 */
1185     0,  /* eob_sym */
1186     34, /* esc_sym */
1187     /* run table */
1188     {0,  1,  1,  1,  2,  2,  1,  3,  3,  1,  1,  1,  4,  4,  1,  5,
1189      2,  1,  5,  2,  1,  1,  6,  6,  1,  1,  1,  1,  1,  7,  3,  1,
1190      2,  3,  0,  1,  2,  7,  1,  1,  1,  8,  1,  1,  8,  1,  1,  1,
1191      9,  1,  9,  1,  2,  1,  1,  2,  1,  1, 10,  4,  1, 10,  1,  4,
1192      1,  1,  1,  1,  1,  3,  1,  1,  1,  3,  2,  1,  5,  1,  1,  1,
1193      2,  5,  1, 11,  1, 11,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
1194      2,  1,  6,  1,  6,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1, 12,
1195      3,  1, 12,  1,  1,  1,  2,  1,  1,  3,  1,  1,  1,  1,  1,  1,
1196      4,  1,  1,  1,  2,  1,  1,  4,  1,  1,  1,  1,  1,  1,  2,  1,
1197      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  3,  1,  2,  1,  1,  5,
1198      1,  1,  1,  1,  1,  7,  1,  7,  1,  1,  2,  3,  1,  1,  1,  1,
1199      5,  1,  1,  1,  1,  1,  1,  2, 13,  1,  1,  1,  1,  1,  1,  1,
1200      1,  1,  1,  1,  1,  1,  1,  1, 13,  2,  1,  1,  4,  1,  1,  1,
1201      3,  1,  6,  1,  1,  1, 14,  1,  1,  1,  1,  1, 14,  6,  1,  1,
1202      1,  1, 15,  2,  4,  1,  2,  3, 15,  1,  1,  1,  8,  1,  1,  8,
1203      1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1},
1204
1205     /* value table */
1206     { 0,   1,  -1,   2,   1,  -1,  -2,   1,  -1,   3,  -3,   4,   1,  -1,  -4,   1,
1207       2,   5,  -1,  -2,  -5,   6,   1,  -1,  -6,   7,  -7,   8,  -8,   1,   2,   9,
1208       3,  -2,   0,  -9,  -3,  -1,  10, -10,  11,   1, -11,  12,  -1, -12,  13, -13,
1209       1,  14,  -1, -14,   4,  15, -15,  -4,  16, -16,   1,   2,  17,  -1, -17,  -2,
1210      18, -18,  19, -19,  20,   3, -20,  21, -21,  -3,   5,  22,   2, -22, -23,  23,
1211      -5,  -2,  24,   1, -24,  -1,  25, -25,  26, -26, -27,  27,  28,  29, -28, -29,
1212       6,  30,   2, -31,  -2, -30,  31,  -6, -32,  32,  33, -33,  34, -35, -34,   1,
1213       4, -36,  -1,  35,  37,  36,   7, -37,  38,  -4, -38,  39,  41,  40, -40, -39,
1214       3,  42, -43, -41,  -7, -42,  43,  -3,  44, -44,  45, -45,  46,  47,   8, -47,
1215     -48, -46,  50, -50,  48,  49,  51, -49,  52, -52,   5, -51,  -8, -53,  53,   3,
1216     -56,  56,  55,  54, -54,   2,  60,  -2, -55,  58,   9,  -5,  59,  57, -57, -63,
1217      -3, -58, -60, -61,  61, -59, -62,  -9,   1,  64,  62,  69, -64,  63,  65, -67,
1218     -68,  66, -65,  68, -66, -69,  67, -70,  -1,  10,  71, -71,   4,  73,  72,  70,
1219       6, -76,  -3,  74, -78, -74,   1,  78,  80, -72, -75,  76,  -1,   3, -73,  79,
1220      75,  77,   1,  11,  -4, -79, -10,  -6,  -1, -77, -83, -80,   2,  81, -84,  -2,
1221      83, -81,  82, -82,  84, -87, -86,  85, -11, -85,  86, -89,  87, -88,  88,  89}
1222 },{
1223     /* MapTab5 */
1224     2,  /* eob_sym */
1225     33, /* esc_sym */
1226     /* run table */
1227     {1,  1,  0,  2,  1,  2,  1,  3,  3,  1,  1,  4,  4,  2,  2,  1,
1228      1,  5,  5,  6,  1,  6,  1,  7,  7,  3,  3,  2,  8,  2,  8,  1,
1229      1,  0,  9,  9,  1,  1, 10,  4, 10,  4, 11, 11,  2,  1,  2,  1,
1230     12, 12,  3,  3,  1,  1, 13,  5,  5, 13, 14,  1,  1, 14,  2,  2,
1231      6,  6, 15,  1,  1, 15, 16,  4,  7, 16,  4,  7,  1,  1,  3,  3,
1232      8,  8,  2,  2,  1,  1, 17, 17,  1,  1, 18, 18,  5,  5,  2,  2,
1233      1,  1,  9, 19,  9, 19, 20,  3,  3, 20,  1, 10, 21,  1, 10,  4,
1234      4, 21, 22,  6,  6, 22,  1,  1, 23, 24,  2,  2, 23, 24, 11,  1,
1235      1, 11,  7, 25,  7,  1,  1, 25,  8,  8,  3, 26,  3,  1, 12,  2,
1236      2, 26,  1, 12,  5,  5, 27,  4,  1,  4,  1, 27, 28,  1, 28, 13,
1237      1, 13,  2, 29,  2,  1, 32,  6,  1, 30, 14, 29, 14,  6,  3, 31,
1238      3,  1, 30,  1, 32, 31, 33,  9, 33,  1,  1,  7,  9,  7,  2,  2,
1239      1,  1,  4, 36, 34,  4,  5, 10, 10,  5, 34,  1,  1, 35,  8,  8,
1240     36,  3, 35,  1, 15,  3,  2,  1, 16, 15, 16,  2, 37,  1, 37,  1,
1241      1,  1,  6,  6, 38,  1, 38, 11,  1, 39, 39, 40, 11,  2, 41,  4,
1242     40,  1,  2,  4,  1,  1,  1, 41,  3,  1,  3,  1,  5,  7,  5,  7},
1243
1244     /* value table */
1245     { 1,  -1,   0,   1,   2,  -1,  -2,   1,  -1,   3,  -3,   1,  -1,   2,  -2,   4,
1246      -4,   1,  -1,   1,   5,  -1,  -5,   1,  -1,   2,  -2,   3,   1,  -3,  -1,   6,
1247      -6,   0,   1,  -1,   7,  -7,   1,   2,  -1,  -2,   1,  -1,   4,   8,  -4,  -8,
1248       1,  -1,   3,  -3,   9,  -9,   1,   2,  -2,  -1,   1,  10, -10,  -1,   5,  -5,
1249       2,  -2,   1,  11, -11,  -1,   1,   3,   2,  -1,  -3,  -2,  12, -12,   4,  -4,
1250       2,  -2,  -6,   6,  13, -13,   1,  -1,  14, -14,   1,  -1,   3,  -3,   7,  -7,
1251      15, -15,   2,   1,  -2,  -1,   1,   5,  -5,  -1, -16,   2,   1,  16,  -2,   4,
1252      -4,  -1,   1,   3,  -3,  -1,  17, -17,   1,   1,  -8,   8,  -1,  -1,   2,  18,
1253     -18,  -2,   3,   1,  -3,  19, -19,  -1,   3,  -3,   6,   1,  -6,  20,   2,   9,
1254      -9,  -1, -20,  -2,   4,  -4,   1,  -5,  21,   5, -21,  -1,   1, -22,  -1,   2,
1255      22,  -2,  10,   1, -10,  23,   1,   4, -23,   1,   2,  -1,  -2,  -4,  -7,   1,
1256       7, -24,  -1,  24,  -1,  -1,   1,   3,  -1, -25,  25,   4,  -3,  -4,  11, -11,
1257      26, -26,   6,   1,   1,  -6,  -5,  -3,   3,   5,  -1, -27,  27,   1,   4,  -4,
1258      -1,  -8,  -1,  28,   2,   8, -12, -28,  -2,  -2,   2,  12,  -1,  29,   1, -29,
1259      30, -30,   5,  -5,   1, -31,  -1,   3,  31,  -1,   1,   1,  -3, -13,   1,  -7,
1260      -1, -32,  13,   7,  32,  33, -33,  -1,  -9, -34,   9,  34,  -6,   5,   6,  -5}
1261 },{
1262     /* MapTab6 */
1263     2,  /* eob_sym */
1264     13, /* esc_sym */
1265     /* run table */
1266     {1,  1,  0,  1,  1,  2,  2,  1,  1,  3,  3,  1,  1,  0,  2,  2,
1267      4,  1,  4,  1,  1,  1,  5,  5,  1,  1,  6,  6,  2,  2,  1,  1,
1268      3,  3,  7,  7,  1,  1,  8,  8,  1,  1,  2,  2,  1,  9,  1,  9,
1269      4,  4, 10,  1,  1, 10,  1,  1, 11, 11,  3,  3,  1,  2,  1,  2,
1270      1,  1, 12, 12,  5,  5,  1,  1, 13,  1,  1, 13,  2,  2,  1,  1,
1271      6,  6,  1,  1,  4, 14,  4, 14,  3,  1,  3,  1,  1,  1, 15,  7,
1272     15,  2,  2,  7,  1,  1,  1,  8,  1,  8, 16, 16,  1,  1,  1,  1,
1273      2,  1,  1,  2,  1,  1,  3,  5,  5,  3,  4,  1,  1,  4,  1,  1,
1274     17, 17,  9,  1,  1,  9,  2,  2,  1,  1, 10, 10,  1,  6,  1,  1,
1275      6, 18,  1,  1, 18,  1,  1,  1,  2,  2,  3,  1,  3,  1,  1,  1,
1276      4,  1, 19,  1, 19,  7,  1,  1, 20,  1,  4, 20,  1,  7, 11,  2,
1277      1, 11, 21,  2,  8,  5,  1,  8,  1,  5, 21,  1,  1,  1, 22,  1,
1278      1, 22,  1,  1,  3,  3,  1, 23,  2, 12, 24,  1,  1,  2,  1,  1,
1279     12, 23,  1,  1, 24,  1,  1,  1,  4,  1,  1,  1,  2,  1,  6,  6,
1280      4,  2,  1,  1,  1,  1,  1,  1,  1, 14, 13,  3,  1, 25,  9, 25,
1281     14,  1,  9,  3, 13,  1,  1,  1,  1,  1, 10,  1,  1,  2, 10,  2},
1282
1283     /* value table */
1284     {-20,  -1,   0,   2,  -2,   1,  -1,   3,  -3,   1,  -1,   4,  -4,   0,   2,  -2,
1285        1,   5,  -1,  -5,   6,  -6,   1,  -1,   7,  -7,   1,  -1,   3,  -3,   8,  -8,
1286        2,  -2,   1,  -1,   9,  -9,   1,  -1,  10, -10,   4,  -4,  11,   1, -11,  -1,
1287        2,  -2,   1,  12, -12,  -1,  13, -13,   1,  -1,   3,  -3,  14,   5, -14,  -5,
1288      -15,  15,  -1,   1,   2,  -2,  16, -16,   1,  17, -17,  -1,   6,  -6,  18, -18,
1289        2,  -2, -19,  19,  -3,   1,   3,  -1,   4,  20,  -4,   1, -21,  21,   1,   2,
1290       -1,  -7,   7,  -2,  22, -22,  23,   2, -23,  -2,   1,  -1, -24,  24, -25,  25,
1291       -8, -26,  26,   8, -27,  27,   5,   3,  -3,  -5,  -4,  28, -28,   4,  29, -29,
1292        1,  -1,  -2, -30,  30,   2,   9,  -9, -31,  31,   2,  -2, -32,   3,  32, -33,
1293       -3,   1,  33, -34,  -1,  34, -35,  35, -10,  10,  -6,  36,   6, -36,  37, -37,
1294       -5,  38,   1, -38,  -1,   3,  39, -39,  -1,  40,   5,   1, -40,  -3,   2, -11,
1295      -41,  -2,   1,  11,  -3,  -4,  41,   3,  42,   4,  -1, -43, -42,  43,   1, -44,
1296       45,  -1,  44, -45,  -7,   7, -46,   1, -12,   2,   1, -47,  46,  12,  47,  48,
1297       -2,  -1, -48,  49,  -1, -50, -49,  50,  -6, -51,  51,  52, -13,  53,  -4,   4,
1298        6,  13, -53, -52, -54,  55,  54, -55, -56,  -2,   2,  -8,  56,   1,  -3,  -1,
1299        2,  58,   3,   8,  -2,  57, -58, -60, -59, -57,  -3,  60,  59, -14,   3,  14}
1300 },{
1301     /* MapTab7 */
1302     2,  /* eob_sym */
1303     38, /* esc_sym */
1304     /* run table */
1305     {1,  1,  0,  2,  2,  1,  1,  3,  3,  4,  4,  5,  5,  1,  1,  6,
1306      6,  2,  2,  7,  7,  8,  8,  1,  1,  3,  3,  9,  9, 10, 10,  1,
1307      1,  2,  2,  4,  4, 11,  0, 11, 12, 12, 13, 13,  1,  1,  5,  5,
1308     14, 14, 15, 16, 15, 16,  3,  3,  1,  6,  1,  6,  2,  2,  7,  7,
1309      8,  8, 17, 17,  1,  1,  4,  4, 18, 18,  2,  2,  1, 19,  1, 20,
1310     19, 20, 21, 21,  3,  3, 22, 22,  5,  5, 24,  1,  1, 23,  9, 23,
1311     24,  9,  2,  2, 10,  1,  1, 10,  6,  6, 25,  4,  4, 25,  7,  7,
1312     26,  8,  1,  8,  3,  1, 26,  3, 11, 11, 27, 27,  2, 28,  1,  2,
1313     28,  1, 12, 12,  5,  5, 29, 13, 13, 29, 32,  1,  1, 33, 31, 30,
1314     32,  4, 30, 33,  4, 31,  3, 14,  1,  1,  3, 34, 34,  2,  2, 14,
1315      6,  6, 35, 36, 35, 36,  1, 15,  1, 16, 16, 15,  7,  9,  7,  9,
1316     37,  8,  8, 37,  1,  1, 39,  2, 38, 39,  2, 40,  5, 38, 40,  5,
1317      3,  3,  4,  4, 10, 10,  1,  1,  1,  1, 41,  2, 41,  2,  6,  6,
1318      1,  1, 11, 42, 11, 43,  3, 42,  3, 17,  4, 43,  1, 17,  7,  1,
1319      8, 44,  4,  7, 44,  5,  8,  2,  5,  1,  2, 48, 45,  1, 12, 45,
1320     12, 48, 13, 13,  1,  9,  9, 46,  1, 46, 47, 47, 49, 18, 18, 49},
1321
1322     /* value table */
1323     { 1,  -1,   0,   1,  -1,   2,  -2,   1,  -1,   1,  -1,   1,  -1,   3,  -3,   1,
1324      -1,  -2,   2,   1,  -1,   1,  -1,   4,  -4,  -2,   2,   1,  -1,   1,  -1,   5,
1325      -5,  -3,   3,   2,  -2,   1,   0,  -1,   1,  -1,   1,  -1,   6,  -6,   2,  -2,
1326       1,  -1,   1,   1,  -1,  -1,  -3,   3,   7,   2,  -7,  -2,  -4,   4,   2,  -2,
1327       2,  -2,   1,  -1,   8,  -8,   3,  -3,   1,  -1,  -5,   5,   9,   1,  -9,   1,
1328      -1,  -1,   1,  -1,  -4,   4,   1,  -1,   3,  -3,   1, -10,  10,   1,   2,  -1,
1329      -1,  -2,   6,  -6,   2,  11, -11,  -2,   3,  -3,   1,  -4,   4,  -1,   3,  -3,
1330       1,   3,  12,  -3,  -5, -12,  -1,   5,   2,  -2,   1,  -1,  -7,   1,  13,   7,
1331      -1, -13,   2,  -2,   4,  -4,   1,   2,  -2,  -1,   1,  14, -14,   1,   1,   1,
1332      -1,  -5,  -1,  -1,   5,  -1,  -6,   2, -15,  15,   6,   1,  -1,  -8,   8,  -2,
1333      -4,   4,   1,   1,  -1,  -1,  16,   2, -16,  -2,   2,  -2,   4,   3,  -4,  -3,
1334      -1,  -4,   4,   1, -17,  17,  -1,  -9,   1,   1,   9,   1,  -5,  -1,  -1,   5,
1335      -7,   7,   6,  -6,   3,  -3,  18, -18,  19, -19,   1, -10,  -1,  10,  -5,   5,
1336      20, -20,  -3,   1,   3,   1,   8,  -1,  -8,   2,   7,  -1, -21,  -2,   5,  21,
1337       5,  -1,  -7,  -5,   1,  -6,  -5, -11,   6,  22,  11,   1,   1, -22,  -3,  -1,
1338       3,  -1,   3,  -3, -23,   4,  -4,   1,  23,  -1,   1,  -1,   1,  -2,   2,  -1}
1339 },{
1340     /* MapTab8 */
1341     4,  /* eob_sym */
1342     11, /* esc_sym */
1343     /* run table */
1344     {1,  1,  1,  1,  0,  2,  2,  1,  1,  3,  3,  0,  1,  1,  2,  2,
1345      4,  4,  1,  1,  5,  5,  1,  1,  2,  2,  3,  3,  6,  6,  1,  1,
1346      7,  7,  8,  1,  8,  2,  2,  1,  4,  4,  1,  3,  1,  3,  9,  9,
1347      2,  2,  1,  5,  1,  5, 10, 10,  1,  1, 11, 11,  3,  6,  3,  4,
1348      4,  6,  2,  2,  1, 12,  1, 12,  7, 13,  7, 13,  1,  1,  8,  8,
1349      2,  2, 14, 14, 16, 15, 16,  5,  5,  1,  3, 15,  1,  3,  4,  4,
1350      1,  1, 17, 17,  2,  2,  6,  6,  1, 18,  1, 18, 22, 21, 22, 21,
1351     25, 24, 25, 19,  9, 20,  9, 23, 19, 24, 20,  3, 23,  7,  3,  1,
1352      1,  7, 28, 26, 29,  5, 28, 26,  5,  8, 29,  4,  8, 27,  2,  2,
1353      4, 27,  1,  1, 10, 36, 10, 33, 33, 36, 30,  1, 32, 32,  1, 30,
1354      6, 31, 31, 35,  3,  6, 11, 11,  3,  2, 35,  2, 34,  1, 34,  1,
1355     37, 37, 12,  7, 12,  5, 41,  5,  4,  7,  1,  8, 13,  4,  1, 41,
1356     13, 38,  8, 38,  9,  1, 40, 40,  9,  1, 39,  2,  2, 49, 39, 42,
1357      3,  3, 14, 16, 49, 14, 16, 42, 43, 43,  6,  6, 15,  1,  1, 15,
1358     44, 44,  1,  1, 50, 48,  4,  5,  4,  7,  5,  2, 10, 10, 48,  7,
1359     50, 45,  2,  1, 45,  8,  8,  1, 46, 46,  3, 47, 47,  3,  1,  1},
1360
1361     /* value table */
1362     { 1,  -1,   2,  -2,   0,   1,  -1,   3,  -3,   1,  -1,   0,   4,  -4,   2,  -2,
1363       1,  -1,   5,  -5,   1,  -1,   6,  -6,   3,  -3,   2,  -2,   1,  -1,   7,  -7,
1364       1,  -1,   1,   8,  -1,   4,  -4,  -8,   2,  -2,   9,   3,  -9,  -3,   1,  -1,
1365       5,  -5,  10,   2, -10,  -2,   1,  -1,  11, -11,   1,  -1,  -4,   2,   4,   3,
1366      -3,  -2,   6,  -6,  12,   1, -12,  -1,   2,   1,  -2,  -1,  13, -13,   2,  -2,
1367       7,  -7,   1,  -1,   1,   1,  -1,   3,  -3,  14,   5,  -1, -14,  -5,   4,  -4,
1368      15, -15,   1,  -1,   8,  -8,  -3,   3,  16,   1, -16,  -1,   1,   1,  -1,  -1,
1369       1,   1,  -1,   1,   2,   1,  -2,   1,  -1,  -1,  -1,   6,  -1,   3,  -6,  17,
1370     -17,  -3,   1,   1,   1,   4,  -1,  -1,  -4,   3,  -1,   5,  -3,  -1,  -9,   9,
1371      -5,   1,  18, -18,   2,   1,  -2,   1,  -1,  -1,   1,  19,  -1,   1, -19,  -1,
1372       4,   1,  -1,   1,   7,  -4,  -2,   2,  -7,  10,  -1, -10,   1,  20,  -1, -20,
1373       1,  -1,   2,   4,  -2,   5,   1,  -5,   6,  -4,  21,   4,   2,  -6, -21,  -1,
1374      -2,   1,  -4,  -1,  -3,  22,  -1,   1,   3, -22,  -1,  11, -11,   1,   1,   1,
1375       8,  -8,   2,   2,  -1,  -2,  -2,  -1,   1,  -1,  -5,   5,   2,  23, -23,  -2,
1376       1,  -1,  24, -24,  -1,  -1,   7,   6,  -7,   5,  -6,  12,  -3,   3,   1,  -5,
1377       1,   1, -12,  25,  -1,  -5,   5, -25,  -1,   1,   9,   1,  -1,  -9,  26, -26}
1378 }
1379 };