static int build_huff(const uint8_t *src, VLC *vlc)

{

    int i;

    HuffEntry he[256];

    int last;

    uint32_t codes[256];

    uint8_t bits[256];

    uint8_t syms[256];

    uint32_t code;



    for (i = 0; i < 256; i++) {

        he[i].sym = i;

        he[i].len = *src++;

    }

    qsort(he, 256, sizeof(*he), huff_cmp);



    if (!he[0].len || he[0].len > 32)

        return -1;



    last = 255;

    while (he[last].len == 255 && last)

        last--;



    code = 1;

    for (i = last; i >= 0; i--) {

        codes[i] = code >> (32 - he[i].len);

        bits[i]  = he[i].len;

        syms[i]  = he[i].sym;

        code += 0x80000000u >> (he[i].len - 1);

    }



    return init_vlc_sparse(vlc, FFMIN(he[last].len, 9), last + 1,

                           bits,  sizeof(*bits),  sizeof(*bits),

                           codes, sizeof(*codes), sizeof(*codes),

                           syms,  sizeof(*syms),  sizeof(*syms), 0);

}

static int build_huff(const uint8_t *src, VLC *vlc)

{

    int i;

    HuffEntry he[256];

    int last;

    uint32_t codes[256];

    uint8_t bits[256];

    uint8_t syms[256];

    uint32_t code;



    for (i = 0; i < 256; i++) {

        he[i].sym = i;

        he[i].len = *src++;

    }

    qsort(he, 256, sizeof(*he), huff_cmp);



    if (!he[0].len || he[0].len > 32)

        return -1;



    last = 255;

    while (he[last].len == 255 && last)

        last--;



    code = 1;

    for (i = last; i >= 0; i--) {

        codes[i] = code >> (32 - he[i].len);

        bits[i]  = he[i].len;

        syms[i]  = he[i].sym;

        code += 0x80000000u >> (he[i].len - 1);

    }



    return init_vlc_sparse(vlc, FFMIN(he[last].len, 9), last + 1,

                           bits,  sizeof(*bits),  sizeof(*bits),

                           codes, sizeof(*codes), sizeof(*codes),

                           syms,  sizeof(*syms),  sizeof(*syms), 0);

}

static int FUNC_0(const uint8_t *VAR_0, VLC *VAR_1)

{

    int VAR_2;

    HuffEntry he[256];

    int VAR_3;

    uint32_t codes[256];

    uint8_t bits[256];

    uint8_t syms[256];

    uint32_t code;



    for (VAR_2 = 0; VAR_2 < 256; VAR_2++) {

        he[VAR_2].sym = VAR_2;

        he[VAR_2].len = *VAR_0++;

    }

    qsort(he, 256, sizeof(*he), huff_cmp);



    if (!he[0].len || he[0].len > 32)

        return -1;



    VAR_3 = 255;

    while (he[VAR_3].len == 255 && VAR_3)

        VAR_3--;



    code = 1;

    for (VAR_2 = VAR_3; VAR_2 >= 0; VAR_2--) {

        codes[VAR_2] = code >> (32 - he[VAR_2].len);

        bits[VAR_2]  = he[VAR_2].len;

        syms[VAR_2]  = he[VAR_2].sym;

        code += 0x80000000u >> (he[VAR_2].len - 1);

    }



    return init_vlc_sparse(VAR_1, FFMIN(he[VAR_3].len, 9), VAR_3 + 1,

                           bits,  sizeof(*bits),  sizeof(*bits),

                           codes, sizeof(*codes), sizeof(*codes),

                           syms,  sizeof(*syms),  sizeof(*syms), 0);

}

static int FUNC_0(const uint8_t *VAR_0, VLC *VAR_1)
{ int VAR_2; HuffEntry he[256]; int VAR_3; uint32_t codes[256]; uint8_t bits[256]; uint8_t syms[256]; uint32_t code; for (VAR_2 = 0; VAR_2 < 256; VAR_2++) { he[VAR_2].sym = VAR_2; he[VAR_2].len = *VAR_0++; } qsort(he, 256, sizeof(*he), huff_cmp); if (!he[0].len || he[0].len > 32)
return -1; VAR_3 = 255; while (he[VAR_3].len == 255 && VAR_3)
VAR_3--; code = 1; for (VAR_2 = VAR_3; VAR_2 >= 0; VAR_2--) { codes[VAR_2] = code >> (32 - he[VAR_2].len); bits[VAR_2]  = he[VAR_2].len; syms[VAR_2]  = he[VAR_2].sym; code += 0x80000000u >> (he[VAR_2].len - 1); } return init_vlc_sparse(VAR_1, FFMIN(he[VAR_3].len, 9), VAR_3 + 1,
bits,  sizeof(*bits),  sizeof(*bits),
codes, sizeof(*codes), sizeof(*codes),
syms,  sizeof(*syms),  sizeof(*syms), 0); }