unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur)

{

    int i, n, r, bit;

    ElsRungNode *rung_node;



    if (ctx->err)

        return 0;



    /* decode unary prefix */

    for (n = 0; n < ELS_EXPGOLOMB_LEN + 1; n++)

        if (ff_els_decode_bit(ctx, &ur->prefix_rung[n]))

            break;



    /* handle the error/overflow case */

    if (ctx->err || n >= ELS_EXPGOLOMB_LEN) {

        ctx->err = AVERROR(EOVERFLOW);

        return 0;

    }



    /* handle the zero case */

    if (!n)

        return 0;



    /* initialize probability tree */

    if (!ur->rem_rung_list) {

        ur->rem_rung_list = av_realloc(NULL, RUNG_SPACE);

        if (!ur->rem_rung_list) {

            ctx->err = AVERROR(ENOMEM);

            return 0;

        }

        memset(ur->rem_rung_list, 0, RUNG_SPACE);

        ur->rung_list_size = RUNG_SPACE;

        ur->avail_index    = ELS_EXPGOLOMB_LEN;

    }



    /* decode the remainder */

    for (i = 0, r = 0, bit = 0; i < n; i++) {

        if (!i)

            rung_node = &ur->rem_rung_list[n];

        else {

            if (!rung_node->next_index) {

                if (ur->rung_list_size <= (ur->avail_index + 2) * sizeof(ElsRungNode)) {

                    // remember rung_node position

                    ptrdiff_t pos     = rung_node - ur->rem_rung_list;

                    ur->rem_rung_list = av_realloc(ur->rem_rung_list,

                                                   ur->rung_list_size +

                                                   RUNG_SPACE);

                    if (!ur->rem_rung_list) {

                        av_free(ur->rem_rung_list);

                        ctx->err = AVERROR(ENOMEM);

                        return 0;

                    }

                    memset((uint8_t *) ur->rem_rung_list + ur->rung_list_size, 0,

                           RUNG_SPACE);

                    ur->rung_list_size += RUNG_SPACE;

                    // restore rung_node position in the new list

                    rung_node = &ur->rem_rung_list[pos];

                }

                rung_node->next_index = ur->avail_index;

                ur->avail_index      += 2;

            }

            rung_node = &ur->rem_rung_list[rung_node->next_index + bit];

        }



        bit = ff_els_decode_bit(ctx, &rung_node->rung);

        if (ctx->err)

            return bit;



        r = (r << 1) + bit;

    }



    return (1 << n) - 1 + r; /* make value from exp golomb code */

}

unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur)

{

    int i, n, r, bit;

    ElsRungNode *rung_node;



    if (ctx->err)

        return 0;



    

    for (n = 0; n < ELS_EXPGOLOMB_LEN + 1; n++)

        if (ff_els_decode_bit(ctx, &ur->prefix_rung[n]))

            break;



    

    if (ctx->err || n >= ELS_EXPGOLOMB_LEN) {

        ctx->err = AVERROR(EOVERFLOW);

        return 0;

    }



    

    if (!n)

        return 0;



    

    if (!ur->rem_rung_list) {

        ur->rem_rung_list = av_realloc(NULL, RUNG_SPACE);

        if (!ur->rem_rung_list) {

            ctx->err = AVERROR(ENOMEM);

            return 0;

        }

        memset(ur->rem_rung_list, 0, RUNG_SPACE);

        ur->rung_list_size = RUNG_SPACE;

        ur->avail_index    = ELS_EXPGOLOMB_LEN;

    }



    

    for (i = 0, r = 0, bit = 0; i < n; i++) {

        if (!i)

            rung_node = &ur->rem_rung_list[n];

        else {

            if (!rung_node->next_index) {

                if (ur->rung_list_size <= (ur->avail_index + 2) * sizeof(ElsRungNode)) {

                    

                    ptrdiff_t pos     = rung_node - ur->rem_rung_list;

                    ur->rem_rung_list = av_realloc(ur->rem_rung_list,

                                                   ur->rung_list_size +

                                                   RUNG_SPACE);

                    if (!ur->rem_rung_list) {

                        av_free(ur->rem_rung_list);

                        ctx->err = AVERROR(ENOMEM);

                        return 0;

                    }

                    memset((uint8_t *) ur->rem_rung_list + ur->rung_list_size, 0,

                           RUNG_SPACE);

                    ur->rung_list_size += RUNG_SPACE;

                    

                    rung_node = &ur->rem_rung_list[pos];

                }

                rung_node->next_index = ur->avail_index;

                ur->avail_index      += 2;

            }

            rung_node = &ur->rem_rung_list[rung_node->next_index + bit];

        }



        bit = ff_els_decode_bit(ctx, &rung_node->rung);

        if (ctx->err)

            return bit;



        r = (r << 1) + bit;

    }



    return (1 << n) - 1 + r; 

}

        ctx->err = AVERROR(EOVERFLOW);
unsigned FUNC_0(ElsDecCtx *VAR_0, ElsUnsignedRung *VAR_1)

{

    int VAR_2, VAR_3, VAR_4, VAR_5;

    ElsRungNode *rung_node;



    if (VAR_0->err)

        return 0;



    

    for (VAR_3 = 0; VAR_3 < ELS_EXPGOLOMB_LEN + 1; VAR_3++)

        if (ff_els_decode_bit(VAR_0, &VAR_1->prefix_rung[VAR_3]))

            break;



    

    if (VAR_0->err || VAR_3 >= ELS_EXPGOLOMB_LEN) {

        VAR_0->err = AVERROR(EOVERFLOW);

        return 0;

    }



    

    if (!VAR_3)

        return 0;



    

    if (!VAR_1->rem_rung_list) {

        VAR_1->rem_rung_list = av_realloc(NULL, RUNG_SPACE);

        if (!VAR_1->rem_rung_list) {

            VAR_0->err = AVERROR(ENOMEM);

            return 0;

        }

        memset(VAR_1->rem_rung_list, 0, RUNG_SPACE);

        VAR_1->rung_list_size = RUNG_SPACE;

        VAR_1->avail_index    = ELS_EXPGOLOMB_LEN;

    }



    

    for (VAR_2 = 0, VAR_4 = 0, VAR_5 = 0; VAR_2 < VAR_3; VAR_2++) {

        if (!VAR_2)

            rung_node = &VAR_1->rem_rung_list[VAR_3];

        else {

            if (!rung_node->next_index) {

                if (VAR_1->rung_list_size <= (VAR_1->avail_index + 2) * sizeof(ElsRungNode)) {

                    

                    ptrdiff_t pos     = rung_node - VAR_1->rem_rung_list;

                    VAR_1->rem_rung_list = av_realloc(VAR_1->rem_rung_list,

                                                   VAR_1->rung_list_size +

                                                   RUNG_SPACE);

                    if (!VAR_1->rem_rung_list) {

                        av_free(VAR_1->rem_rung_list);

                        VAR_0->err = AVERROR(ENOMEM);

                        return 0;

                    }

                    memset((uint8_t *) VAR_1->rem_rung_list + VAR_1->rung_list_size, 0,

                           RUNG_SPACE);

                    VAR_1->rung_list_size += RUNG_SPACE;

                    

                    rung_node = &VAR_1->rem_rung_list[pos];

                }

                rung_node->next_index = VAR_1->avail_index;

                VAR_1->avail_index      += 2;

            }

            rung_node = &VAR_1->rem_rung_list[rung_node->next_index + VAR_5];

        }



        VAR_5 = ff_els_decode_bit(VAR_0, &rung_node->rung);

        if (VAR_0->err)

            return VAR_5;



        VAR_4 = (VAR_4 << 1) + VAR_5;

    }



    return (1 << VAR_3) - 1 + VAR_4; 

}

unsigned FUNC_0(ElsDecCtx *VAR_0, ElsUnsignedRung *VAR_1)
{ int VAR_2, VAR_3, VAR_4, VAR_5; ElsRungNode *rung_node; if (VAR_0->err)
return 0; for (VAR_3 = 0; VAR_3 < ELS_EXPGOLOMB_LEN + 1; VAR_3++) if (ff_els_decode_bit(VAR_0, &VAR_1->prefix_rung[VAR_3]))
break; if (VAR_0->err || VAR_3 >= ELS_EXPGOLOMB_LEN) { VAR_0->err = AVERROR(EOVERFLOW); return 0; } if (!VAR_3)
return 0; if (!VAR_1->rem_rung_list) { VAR_1->rem_rung_list = av_realloc(NULL, RUNG_SPACE); if (!VAR_1->rem_rung_list) { VAR_0->err = AVERROR(ENOMEM); return 0; } memset(VAR_1->rem_rung_list, 0, RUNG_SPACE); VAR_1->rung_list_size = RUNG_SPACE; VAR_1->avail_index    = ELS_EXPGOLOMB_LEN; } for (VAR_2 = 0, VAR_4 = 0, VAR_5 = 0; VAR_2 < VAR_3; VAR_2++) { if (!VAR_2)
rung_node = &VAR_1->rem_rung_list[VAR_3]; else { if (!rung_node->next_index) { if (VAR_1->rung_list_size <= (VAR_1->avail_index + 2) * sizeof(ElsRungNode)) { ptrdiff_t pos     = rung_node - VAR_1->rem_rung_list; VAR_1->rem_rung_list = av_realloc(VAR_1->rem_rung_list,
VAR_1->rung_list_size +
RUNG_SPACE); if (!VAR_1->rem_rung_list) { av_free(VAR_1->rem_rung_list); VAR_0->err = AVERROR(ENOMEM); return 0; } memset((uint8_t *) VAR_1->rem_rung_list + VAR_1->rung_list_size, 0,
RUNG_SPACE); VAR_1->rung_list_size += RUNG_SPACE; rung_node = &VAR_1->rem_rung_list[pos]; } rung_node->next_index = VAR_1->avail_index; VAR_1->avail_index      += 2; } rung_node = &VAR_1->rem_rung_list[rung_node->next_index + VAR_5]; } VAR_5 = ff_els_decode_bit(VAR_0, &rung_node->rung); if (VAR_0->err)
return VAR_5; VAR_4 = (VAR_4 << 1) + VAR_5; } return (1 << VAR_3) - 1 + VAR_4; }