static int pcx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

                            AVPacket *avpkt)

{

    const uint8_t *buf = avpkt->data;

    int buf_size       = avpkt->size;

    AVFrame *const p   = data;

    int compressed, xmin, ymin, xmax, ymax;

    unsigned int w, h, bits_per_pixel, bytes_per_line, nplanes, stride, y, x,

                 bytes_per_scanline;

    uint8_t *ptr;

    const uint8_t *buf_end = buf + buf_size;

    const uint8_t *bufstart = buf;

    uint8_t *scanline;

    int ret = -1;



    if (buf[0] != 0x0a || buf[1] > 5) {

        av_log(avctx, AV_LOG_ERROR, "this is not PCX encoded data\n");

        return AVERROR_INVALIDDATA;

    }



    compressed = buf[2];

    xmin       = AV_RL16(buf + 4);

    ymin       = AV_RL16(buf + 6);

    xmax       = AV_RL16(buf + 8);

    ymax       = AV_RL16(buf + 10);



    if (xmax < xmin || ymax < ymin) {

        av_log(avctx, AV_LOG_ERROR, "invalid image dimensions\n");

        return AVERROR_INVALIDDATA;

    }



    w = xmax - xmin + 1;

    h = ymax - ymin + 1;



    bits_per_pixel     = buf[3];

    bytes_per_line     = AV_RL16(buf + 66);

    nplanes            = buf[65];

    bytes_per_scanline = nplanes * bytes_per_line;



    if (bytes_per_scanline < (w * bits_per_pixel * nplanes + 7) / 8 ||

        (!compressed && bytes_per_scanline > buf_size / h)) {

        av_log(avctx, AV_LOG_ERROR, "PCX data is corrupted\n");

        return AVERROR_INVALIDDATA;

    }



    switch ((nplanes << 8) + bits_per_pixel) {

    case 0x0308:

        avctx->pix_fmt = AV_PIX_FMT_RGB24;

        break;

    case 0x0108:

    case 0x0104:

    case 0x0102:

    case 0x0101:

    case 0x0401:

    case 0x0301:

    case 0x0201:

        avctx->pix_fmt = AV_PIX_FMT_PAL8;

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");

        return AVERROR_INVALIDDATA;

    }



    buf += 128;



    if ((ret = ff_set_dimensions(avctx, w, h)) < 0)

        return ret;



    if ((ret = ff_get_buffer(avctx, p, 0)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

        return ret;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    ptr    = p->data[0];

    stride = p->linesize[0];



    scanline = av_malloc(bytes_per_scanline);

    if (!scanline)

        return AVERROR(ENOMEM);



    if (nplanes == 3 && bits_per_pixel == 8) {

        for (y = 0; y < h; y++) {

            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);



            for (x = 0; x < w; x++) {

                ptr[3 * x]     = scanline[x];

                ptr[3 * x + 1] = scanline[x + bytes_per_line];

                ptr[3 * x + 2] = scanline[x + (bytes_per_line << 1)];

            }



            ptr += stride;

        }

    } else if (nplanes == 1 && bits_per_pixel == 8) {

        const uint8_t *palstart = bufstart + buf_size - 769;



        if (buf_size < 769) {

            av_log(avctx, AV_LOG_ERROR, "File is too short\n");

            ret = avctx->err_recognition & AV_EF_EXPLODE ?

                  AVERROR_INVALIDDATA : buf_size;

            goto end;

        }



        for (y = 0; y < h; y++, ptr += stride) {

            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);

            memcpy(ptr, scanline, w);

        }



        if (buf != palstart) {

            av_log(avctx, AV_LOG_WARNING, "image data possibly corrupted\n");

            buf = palstart;

        }

        if (*buf++ != 12) {

            av_log(avctx, AV_LOG_ERROR, "expected palette after image data\n");

            ret = avctx->err_recognition & AV_EF_EXPLODE ?

                  AVERROR_INVALIDDATA : buf_size;

            goto end;

        }

    } else if (nplanes == 1) {   /* all packed formats, max. 16 colors */

        GetBitContext s;



        for (y = 0; y < h; y++) {

            init_get_bits(&s, scanline, bytes_per_scanline << 3);



            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);



            for (x = 0; x < w; x++)

                ptr[x] = get_bits(&s, bits_per_pixel);

            ptr += stride;

        }

    } else {    /* planar, 4, 8 or 16 colors */

        int i;



        for (y = 0; y < h; y++) {

            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);



            for (x = 0; x < w; x++) {

                int m = 0x80 >> (x & 7), v = 0;

                for (i = nplanes - 1; i >= 0; i--) {

                    v <<= 1;

                    v  += !!(scanline[i * bytes_per_line + (x >> 3)] & m);

                }

                ptr[x] = v;

            }

            ptr += stride;

        }

    }



    if (nplanes == 1 && bits_per_pixel == 8) {

        pcx_palette(&buf, (uint32_t *)p->data[1], 256);

    } else if (bits_per_pixel < 8) {

        const uint8_t *palette = bufstart + 16;

        pcx_palette(&palette, (uint32_t *)p->data[1], 16);

    }



    *got_frame = 1;



    ret = buf - bufstart;

end:

    av_free(scanline);

    return ret;

}

static int pcx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

                            AVPacket *avpkt)

{

    const uint8_t *buf = avpkt->data;

    int buf_size       = avpkt->size;

    AVFrame *const p   = data;

    int compressed, xmin, ymin, xmax, ymax;

    unsigned int w, h, bits_per_pixel, bytes_per_line, nplanes, stride, y, x,

                 bytes_per_scanline;

    uint8_t *ptr;

    const uint8_t *buf_end = buf + buf_size;

    const uint8_t *bufstart = buf;

    uint8_t *scanline;

    int ret = -1;



    if (buf[0] != 0x0a || buf[1] > 5) {

        av_log(avctx, AV_LOG_ERROR, "this is not PCX encoded data\n");

        return AVERROR_INVALIDDATA;

    }



    compressed = buf[2];

    xmin       = AV_RL16(buf + 4);

    ymin       = AV_RL16(buf + 6);

    xmax       = AV_RL16(buf + 8);

    ymax       = AV_RL16(buf + 10);



    if (xmax < xmin || ymax < ymin) {

        av_log(avctx, AV_LOG_ERROR, "invalid image dimensions\n");

        return AVERROR_INVALIDDATA;

    }



    w = xmax - xmin + 1;

    h = ymax - ymin + 1;



    bits_per_pixel     = buf[3];

    bytes_per_line     = AV_RL16(buf + 66);

    nplanes            = buf[65];

    bytes_per_scanline = nplanes * bytes_per_line;



    if (bytes_per_scanline < (w * bits_per_pixel * nplanes + 7) / 8 ||

        (!compressed && bytes_per_scanline > buf_size / h)) {

        av_log(avctx, AV_LOG_ERROR, "PCX data is corrupted\n");

        return AVERROR_INVALIDDATA;

    }



    switch ((nplanes << 8) + bits_per_pixel) {

    case 0x0308:

        avctx->pix_fmt = AV_PIX_FMT_RGB24;

        break;

    case 0x0108:

    case 0x0104:

    case 0x0102:

    case 0x0101:

    case 0x0401:

    case 0x0301:

    case 0x0201:

        avctx->pix_fmt = AV_PIX_FMT_PAL8;

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "invalid PCX file\n");

        return AVERROR_INVALIDDATA;

    }



    buf += 128;



    if ((ret = ff_set_dimensions(avctx, w, h)) < 0)

        return ret;



    if ((ret = ff_get_buffer(avctx, p, 0)) < 0) {

        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

        return ret;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    ptr    = p->data[0];

    stride = p->linesize[0];



    scanline = av_malloc(bytes_per_scanline);

    if (!scanline)

        return AVERROR(ENOMEM);



    if (nplanes == 3 && bits_per_pixel == 8) {

        for (y = 0; y < h; y++) {

            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);



            for (x = 0; x < w; x++) {

                ptr[3 * x]     = scanline[x];

                ptr[3 * x + 1] = scanline[x + bytes_per_line];

                ptr[3 * x + 2] = scanline[x + (bytes_per_line << 1)];

            }



            ptr += stride;

        }

    } else if (nplanes == 1 && bits_per_pixel == 8) {

        const uint8_t *palstart = bufstart + buf_size - 769;



        if (buf_size < 769) {

            av_log(avctx, AV_LOG_ERROR, "File is too short\n");

            ret = avctx->err_recognition & AV_EF_EXPLODE ?

                  AVERROR_INVALIDDATA : buf_size;

            goto end;

        }



        for (y = 0; y < h; y++, ptr += stride) {

            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);

            memcpy(ptr, scanline, w);

        }



        if (buf != palstart) {

            av_log(avctx, AV_LOG_WARNING, "image data possibly corrupted\n");

            buf = palstart;

        }

        if (*buf++ != 12) {

            av_log(avctx, AV_LOG_ERROR, "expected palette after image data\n");

            ret = avctx->err_recognition & AV_EF_EXPLODE ?

                  AVERROR_INVALIDDATA : buf_size;

            goto end;

        }

    } else if (nplanes == 1) {   

        GetBitContext s;



        for (y = 0; y < h; y++) {

            init_get_bits(&s, scanline, bytes_per_scanline << 3);



            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);



            for (x = 0; x < w; x++)

                ptr[x] = get_bits(&s, bits_per_pixel);

            ptr += stride;

        }

    } else {    

        int i;



        for (y = 0; y < h; y++) {

            buf = pcx_rle_decode(buf, buf_end,

                                 scanline, bytes_per_scanline, compressed);



            for (x = 0; x < w; x++) {

                int m = 0x80 >> (x & 7), v = 0;

                for (i = nplanes - 1; i >= 0; i--) {

                    v <<= 1;

                    v  += !!(scanline[i * bytes_per_line + (x >> 3)] & m);

                }

                ptr[x] = v;

            }

            ptr += stride;

        }

    }



    if (nplanes == 1 && bits_per_pixel == 8) {

        pcx_palette(&buf, (uint32_t *)p->data[1], 256);

    } else if (bits_per_pixel < 8) {

        const uint8_t *palette = bufstart + 16;

        pcx_palette(&palette, (uint32_t *)p->data[1], 16);

    }



    *got_frame = 1;



    ret = buf - bufstart;

end:

    av_free(scanline);

    return ret;

}

    scanline = av_malloc(bytes_per_scanline);
static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,

                            AVPacket *VAR_3)

{

    const uint8_t *VAR_4 = VAR_3->VAR_1;

    int VAR_5       = VAR_3->size;

    AVFrame *const p   = VAR_1;

    int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10;

    unsigned int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18,

                 VAR_19;

    uint8_t *ptr;

    const uint8_t *VAR_20 = VAR_4 + VAR_5;

    const uint8_t *VAR_21 = VAR_4;

    uint8_t *scanline;

    int VAR_22 = -1;



    if (VAR_4[0] != 0x0a || VAR_4[1] > 5) {

        av_log(VAR_0, AV_LOG_ERROR, "this is not PCX encoded VAR_1\n");

        return AVERROR_INVALIDDATA;

    }



    VAR_6 = VAR_4[2];

    VAR_7       = AV_RL16(VAR_4 + 4);

    VAR_8       = AV_RL16(VAR_4 + 6);

    VAR_9       = AV_RL16(VAR_4 + 8);

    VAR_10       = AV_RL16(VAR_4 + 10);



    if (VAR_9 < VAR_7 || VAR_10 < VAR_8) {

        av_log(VAR_0, AV_LOG_ERROR, "invalid image dimensions\n");

        return AVERROR_INVALIDDATA;

    }



    VAR_11 = VAR_9 - VAR_7 + 1;

    VAR_12 = VAR_10 - VAR_8 + 1;



    VAR_13     = VAR_4[3];

    VAR_14     = AV_RL16(VAR_4 + 66);

    VAR_15            = VAR_4[65];

    VAR_19 = VAR_15 * VAR_14;



    if (VAR_19 < (VAR_11 * VAR_13 * VAR_15 + 7) / 8 ||

        (!VAR_6 && VAR_19 > VAR_5 / VAR_12)) {

        av_log(VAR_0, AV_LOG_ERROR, "PCX VAR_1 is corrupted\n");

        return AVERROR_INVALIDDATA;

    }



    switch ((VAR_15 << 8) + VAR_13) {

    case 0x0308:

        VAR_0->pix_fmt = AV_PIX_FMT_RGB24;

        break;

    case 0x0108:

    case 0x0104:

    case 0x0102:

    case 0x0101:

    case 0x0401:

    case 0x0301:

    case 0x0201:

        VAR_0->pix_fmt = AV_PIX_FMT_PAL8;

        break;

    default:

        av_log(VAR_0, AV_LOG_ERROR, "invalid PCX file\n");

        return AVERROR_INVALIDDATA;

    }



    VAR_4 += 128;



    if ((VAR_22 = ff_set_dimensions(VAR_0, VAR_11, VAR_12)) < 0)

        return VAR_22;



    if ((VAR_22 = ff_get_buffer(VAR_0, p, 0)) < 0) {

        av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");

        return VAR_22;

    }



    p->pict_type = AV_PICTURE_TYPE_I;



    ptr    = p->VAR_1[0];

    VAR_16 = p->linesize[0];



    scanline = av_malloc(VAR_19);

    if (!scanline)

        return AVERROR(ENOMEM);



    if (VAR_15 == 3 && VAR_13 == 8) {

        for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++) {

            VAR_4 = pcx_rle_decode(VAR_4, VAR_20,

                                 scanline, VAR_19, VAR_6);



            for (VAR_18 = 0; VAR_18 < VAR_11; VAR_18++) {

                ptr[3 * VAR_18]     = scanline[VAR_18];

                ptr[3 * VAR_18 + 1] = scanline[VAR_18 + VAR_14];

                ptr[3 * VAR_18 + 2] = scanline[VAR_18 + (VAR_14 << 1)];

            }



            ptr += VAR_16;

        }

    } else if (VAR_15 == 1 && VAR_13 == 8) {

        const uint8_t *VAR_23 = VAR_21 + VAR_5 - 769;



        if (VAR_5 < 769) {

            av_log(VAR_0, AV_LOG_ERROR, "File is too short\n");

            VAR_22 = VAR_0->err_recognition & AV_EF_EXPLODE ?

                  AVERROR_INVALIDDATA : VAR_5;

            goto end;

        }



        for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++, ptr += VAR_16) {

            VAR_4 = pcx_rle_decode(VAR_4, VAR_20,

                                 scanline, VAR_19, VAR_6);

            memcpy(ptr, scanline, VAR_11);

        }



        if (VAR_4 != VAR_23) {

            av_log(VAR_0, AV_LOG_WARNING, "image VAR_1 possibly corrupted\n");

            VAR_4 = VAR_23;

        }

        if (*VAR_4++ != 12) {

            av_log(VAR_0, AV_LOG_ERROR, "expected VAR_27 after image VAR_1\n");

            VAR_22 = VAR_0->err_recognition & AV_EF_EXPLODE ?

                  AVERROR_INVALIDDATA : VAR_5;

            goto end;

        }

    } else if (VAR_15 == 1) {   

        GetBitContext s;



        for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++) {

            init_get_bits(&s, scanline, VAR_19 << 3);



            VAR_4 = pcx_rle_decode(VAR_4, VAR_20,

                                 scanline, VAR_19, VAR_6);



            for (VAR_18 = 0; VAR_18 < VAR_11; VAR_18++)

                ptr[VAR_18] = get_bits(&s, VAR_13);

            ptr += VAR_16;

        }

    } else {    

        int VAR_24;



        for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++) {

            VAR_4 = pcx_rle_decode(VAR_4, VAR_20,

                                 scanline, VAR_19, VAR_6);



            for (VAR_18 = 0; VAR_18 < VAR_11; VAR_18++) {

                int VAR_25 = 0x80 >> (VAR_18 & 7), VAR_26 = 0;

                for (VAR_24 = VAR_15 - 1; VAR_24 >= 0; VAR_24--) {

                    VAR_26 <<= 1;

                    VAR_26  += !!(scanline[VAR_24 * VAR_14 + (VAR_18 >> 3)] & VAR_25);

                }

                ptr[VAR_18] = VAR_26;

            }

            ptr += VAR_16;

        }

    }



    if (VAR_15 == 1 && VAR_13 == 8) {

        pcx_palette(&VAR_4, (uint32_t *)p->VAR_1[1], 256);

    } else if (VAR_13 < 8) {

        const uint8_t *VAR_27 = VAR_21 + 16;

        pcx_palette(&VAR_27, (uint32_t *)p->VAR_1[1], 16);

    }



    *VAR_2 = 1;



    VAR_22 = VAR_4 - VAR_21;

end:

    av_free(scanline);

    return VAR_22;

}

static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{ const uint8_t *VAR_4 = VAR_3->VAR_1; int VAR_5       = VAR_3->size; AVFrame *const p   = VAR_1; int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10; unsigned int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17, VAR_18,
VAR_19; uint8_t *ptr; const uint8_t *VAR_20 = VAR_4 + VAR_5; const uint8_t *VAR_21 = VAR_4; uint8_t *scanline; int VAR_22 = -1; if (VAR_4[0] != 0x0a || VAR_4[1] > 5) { av_log(VAR_0, AV_LOG_ERROR, "this is not PCX encoded VAR_1\n"); return AVERROR_INVALIDDATA; } VAR_6 = VAR_4[2]; VAR_7       = AV_RL16(VAR_4 + 4); VAR_8       = AV_RL16(VAR_4 + 6); VAR_9       = AV_RL16(VAR_4 + 8); VAR_10       = AV_RL16(VAR_4 + 10); if (VAR_9 < VAR_7 || VAR_10 < VAR_8) { av_log(VAR_0, AV_LOG_ERROR, "invalid image dimensions\n"); return AVERROR_INVALIDDATA; } VAR_11 = VAR_9 - VAR_7 + 1; VAR_12 = VAR_10 - VAR_8 + 1; VAR_13     = VAR_4[3]; VAR_14     = AV_RL16(VAR_4 + 66); VAR_15            = VAR_4[65]; VAR_19 = VAR_15 * VAR_14; if (VAR_19 < (VAR_11 * VAR_13 * VAR_15 + 7) / 8 ||
(!VAR_6 && VAR_19 > VAR_5 / VAR_12)) { av_log(VAR_0, AV_LOG_ERROR, "PCX VAR_1 is corrupted\n"); return AVERROR_INVALIDDATA; } switch ((VAR_15 << 8) + VAR_13) { case 0x0308:
VAR_0->pix_fmt = AV_PIX_FMT_RGB24; break; case 0x0108:
case 0x0104:
case 0x0102:
case 0x0101:
case 0x0401:
case 0x0301:
case 0x0201:
VAR_0->pix_fmt = AV_PIX_FMT_PAL8; break; default:
av_log(VAR_0, AV_LOG_ERROR, "invalid PCX file\n"); return AVERROR_INVALIDDATA; } VAR_4 += 128; if ((VAR_22 = ff_set_dimensions(VAR_0, VAR_11, VAR_12)) < 0)
return VAR_22; if ((VAR_22 = ff_get_buffer(VAR_0, p, 0)) < 0) { av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n"); return VAR_22; } p->pict_type = AV_PICTURE_TYPE_I; ptr    = p->VAR_1[0]; VAR_16 = p->linesize[0]; scanline = av_malloc(VAR_19); if (!scanline)
return AVERROR(ENOMEM); if (VAR_15 == 3 && VAR_13 == 8) { for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++) { VAR_4 = pcx_rle_decode(VAR_4, VAR_20,
scanline, VAR_19, VAR_6); for (VAR_18 = 0; VAR_18 < VAR_11; VAR_18++) { ptr[3 * VAR_18]     = scanline[VAR_18]; ptr[3 * VAR_18 + 1] = scanline[VAR_18 + VAR_14]; ptr[3 * VAR_18 + 2] = scanline[VAR_18 + (VAR_14 << 1)]; } ptr += VAR_16; } } else if (VAR_15 == 1 && VAR_13 == 8) { const uint8_t *VAR_23 = VAR_21 + VAR_5 - 769; if (VAR_5 < 769) { av_log(VAR_0, AV_LOG_ERROR, "File is too short\n"); VAR_22 = VAR_0->err_recognition & AV_EF_EXPLODE ?
AVERROR_INVALIDDATA : VAR_5; goto end; } for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++, ptr += VAR_16) { VAR_4 = pcx_rle_decode(VAR_4, VAR_20,
scanline, VAR_19, VAR_6); memcpy(ptr, scanline, VAR_11); } if (VAR_4 != VAR_23) { av_log(VAR_0, AV_LOG_WARNING, "image VAR_1 possibly corrupted\n"); VAR_4 = VAR_23; } if (*VAR_4++ != 12) { av_log(VAR_0, AV_LOG_ERROR, "expected VAR_27 after image VAR_1\n"); VAR_22 = VAR_0->err_recognition & AV_EF_EXPLODE ?
AVERROR_INVALIDDATA : VAR_5; goto end; } } else if (VAR_15 == 1) { GetBitContext s; for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++) { init_get_bits(&s, scanline, VAR_19 << 3); VAR_4 = pcx_rle_decode(VAR_4, VAR_20,
scanline, VAR_19, VAR_6); for (VAR_18 = 0; VAR_18 < VAR_11; VAR_18++) ptr[VAR_18] = get_bits(&s, VAR_13); ptr += VAR_16; } } else { int VAR_24; for (VAR_17 = 0; VAR_17 < VAR_12; VAR_17++) { VAR_4 = pcx_rle_decode(VAR_4, VAR_20,
scanline, VAR_19, VAR_6); for (VAR_18 = 0; VAR_18 < VAR_11; VAR_18++) { int VAR_25 = 0x80 >> (VAR_18 & 7), VAR_26 = 0; for (VAR_24 = VAR_15 - 1; VAR_24 >= 0; VAR_24--) { VAR_26 <<= 1; VAR_26  += !!(scanline[VAR_24 * VAR_14 + (VAR_18 >> 3)] & VAR_25); } ptr[VAR_18] = VAR_26; } ptr += VAR_16; } } if (VAR_15 == 1 && VAR_13 == 8) { pcx_palette(&VAR_4, (uint32_t *)p->VAR_1[1], 256); } else if (VAR_13 < 8) { const uint8_t *VAR_27 = VAR_21 + 16; pcx_palette(&VAR_27, (uint32_t *)p->VAR_1[1], 16); } *VAR_2 = 1; VAR_22 = VAR_4 - VAR_21; end:
av_free(scanline); return VAR_22; }