-module(packkit@internal@lzma).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/packkit/internal/lzma.gleam").
-export([new/3, properties_to_byte/1, properties_of_byte/1, decode_into/2, encode_literal_only/2, encode_with_lz77/2]).
-export_type([properties/0, decoder/0, encoder/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-type properties() :: {properties, integer(), integer(), integer()}.

-opaque decoder() :: {decoder,
        integer(),
        integer(),
        bitstring(),
        list(integer()),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        properties(),
        gleam@dict:dict(integer(), integer())}.

-type encoder() :: {encoder,
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        properties(),
        gleam@dict:dict(integer(), integer()),
        list(integer()),
        integer(),
        list(integer())}.

-file("src/packkit/internal/lzma.gleam", 326).
?DOC(false).
-spec previous_output_byte(decoder()) -> integer().
previous_output_byte(Decoder) ->
    case erlang:element(5, Decoder) of
        [Head | _] ->
            Head;

        [] ->
            0
    end.

-file("src/packkit/internal/lzma.gleam", 348).
?DOC(false).
-spec nth_back(list(integer()), integer()) -> {ok, integer()} | {error, nil}.
nth_back(Values, N) ->
    case {Values, N} of
        {[Head | _], 0} ->
            {ok, Head};

        {[_ | Rest], _} ->
            nth_back(Rest, N - 1);

        {[], _} ->
            {error, nil}
    end.

-file("src/packkit/internal/lzma.gleam", 337).
?DOC(false).
-spec byte_at_distance(decoder(), integer()) -> integer().
byte_at_distance(Decoder, Distance) ->
    case Distance =< 0 of
        true ->
            0;

        false ->
            case nth_back(erlang:element(5, Decoder), Distance - 1) of
                {ok, Value} ->
                    Value;

                {error, _} ->
                    0
            end
    end.

-file("src/packkit/internal/lzma.gleam", 333).
?DOC(false).
-spec match_byte(decoder()) -> integer().
match_byte(Decoder) ->
    byte_at_distance(Decoder, erlang:element(9, Decoder) + 1).

-file("src/packkit/internal/lzma.gleam", 356).
?DOC(false).
-spec advance_state_literal(decoder()) -> decoder().
advance_state_literal(Decoder) ->
    New_state = case erlang:element(8, Decoder) of
        0 ->
            0;

        1 ->
            0;

        2 ->
            0;

        3 ->
            0;

        4 ->
            1;

        5 ->
            2;

        6 ->
            3;

        7 ->
            4;

        8 ->
            5;

        9 ->
            6;

        10 ->
            4;

        _ ->
            5
    end,
    {decoder,
        erlang:element(2, Decoder),
        erlang:element(3, Decoder),
        erlang:element(4, Decoder),
        erlang:element(5, Decoder),
        erlang:element(6, Decoder),
        erlang:element(7, Decoder),
        New_state,
        erlang:element(9, Decoder),
        erlang:element(10, Decoder),
        erlang:element(11, Decoder),
        erlang:element(12, Decoder),
        erlang:element(13, Decoder),
        erlang:element(14, Decoder)}.

-file("src/packkit/internal/lzma.gleam", 403).
?DOC(false).
-spec match_next(integer()) -> integer().
match_next(State) ->
    case State < 7 of
        true ->
            7;

        false ->
            10
    end.

-file("src/packkit/internal/lzma.gleam", 488).
?DOC(false).
-spec short_rep_next(integer()) -> integer().
short_rep_next(State) ->
    case State < 7 of
        true ->
            9;

        false ->
            11
    end.

-file("src/packkit/internal/lzma.gleam", 495).
?DOC(false).
-spec rep_next(integer()) -> integer().
rep_next(State) ->
    case State < 7 of
        true ->
            8;

        false ->
            11
    end.

-file("src/packkit/internal/lzma.gleam", 812).
?DOC(false).
-spec emit_byte(decoder(), integer()) -> decoder().
emit_byte(Decoder, Byte) ->
    {decoder,
        erlang:element(2, Decoder),
        erlang:element(3, Decoder),
        erlang:element(4, Decoder),
        [Byte | erlang:element(5, Decoder)],
        erlang:element(6, Decoder) + 1,
        erlang:element(7, Decoder),
        erlang:element(8, Decoder),
        erlang:element(9, Decoder),
        erlang:element(10, Decoder),
        erlang:element(11, Decoder),
        erlang:element(12, Decoder),
        erlang:element(13, Decoder),
        erlang:element(14, Decoder)}.

-file("src/packkit/internal/lzma.gleam", 509).
?DOC(false).
-spec copy_loop(decoder(), integer(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
copy_loop(Decoder, Distance, Remaining) ->
    case Remaining of
        0 ->
            {ok, Decoder};

        _ ->
            gleam@bool:guard(
                (Distance >= erlang:element(6, Decoder)) andalso (erlang:element(
                    6,
                    Decoder
                )
                < erlang:element(7, Decoder)),
                {error,
                    {codec_invalid_data,
                        <<"LZMA back-reference exceeds dictionary"/utf8>>}},
                fun() ->
                    Byte = byte_at_distance(Decoder, Distance + 1),
                    Decoder@1 = emit_byte(Decoder, Byte),
                    copy_loop(Decoder@1, Distance, Remaining - 1)
                end
            )
    end.

-file("src/packkit/internal/lzma.gleam", 502).
?DOC(false).
-spec apply_copy(decoder(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
apply_copy(Decoder, Length) ->
    copy_loop(Decoder, erlang:element(9, Decoder), Length).

-file("src/packkit/internal/lzma.gleam", 820).
?DOC(false).
-spec prob_key(integer(), integer()) -> integer().
prob_key(Table, Sub_index) ->
    (Table * 65536) + Sub_index.

-file("src/packkit/internal/lzma.gleam", 824).
?DOC(false).
-spec mask_for(integer()) -> integer().
mask_for(Bits) ->
    erlang:'bsl'(1, Bits) - 1.

-file("src/packkit/internal/lzma.gleam", 828).
?DOC(false).
-spec read_u32_be(bitstring()) -> {ok, {integer(), bitstring()}} |
    {error, packkit@error:codec_error()}.
read_u32_be(Bytes) ->
    case Bytes of
        <<Value:32/big-unsigned, Rest/binary>> ->
            {ok, {Value, Rest}};

        _ ->
            {error,
                {codec_invalid_data,
                    <<"LZMA range coder priming requires 4 bytes"/utf8>>}}
    end.

-file("src/packkit/internal/lzma.gleam", 151).
?DOC(false).
-spec new(bitstring(), properties(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
new(Input, Props, Output_limit) ->
    case Input of
        <<First, Rest/binary>> ->
            gleam@bool:guard(
                First /= 0,
                {error,
                    {codec_invalid_data,
                        <<"LZMA range coder must start with a zero byte"/utf8>>}},
                fun() ->
                    gleam@result:'try'(
                        read_u32_be(Rest),
                        fun(_use0) ->
                            {Code, Rest@1} = _use0,
                            {ok,
                                {decoder,
                                    16#FFFFFFFF,
                                    Code,
                                    Rest@1,
                                    [],
                                    0,
                                    Output_limit,
                                    0,
                                    0,
                                    0,
                                    0,
                                    0,
                                    Props,
                                    maps:new()}}
                        end
                    )
                end
            );

        _ ->
            {error,
                {codec_invalid_data,
                    <<"LZMA range coder needs at least 5 priming bytes"/utf8>>}}
    end.

-file("src/packkit/internal/lzma.gleam", 838).
?DOC(false).
-spec list_reverse_to_bit_array(list(integer()), bitstring()) -> bitstring().
list_reverse_to_bit_array(Values, Acc) ->
    case Values of
        [] ->
            Acc;

        [Head | Rest] ->
            list_reverse_to_bit_array(Rest, <<Head, Acc/bitstring>>)
    end.

-file("src/packkit/internal/lzma.gleam", 865).
?DOC(false).
-spec properties_to_byte(properties()) -> integer().
properties_to_byte(Props) ->
    ((erlang:element(4, Props) * 45) + (erlang:element(3, Props) * 9)) + erlang:element(
        2,
        Props
    ).

-file("src/packkit/internal/lzma.gleam", 986).
?DOC(false).
-spec literal_state_after(integer()) -> integer().
literal_state_after(State) ->
    case State of
        0 ->
            0;

        1 ->
            0;

        2 ->
            0;

        3 ->
            0;

        4 ->
            1;

        5 ->
            2;

        6 ->
            3;

        7 ->
            4;

        8 ->
            5;

        9 ->
            6;

        10 ->
            4;

        _ ->
            5
    end.

-file("src/packkit/internal/lzma.gleam", 1101).
?DOC(false).
-spec flush_cache_bytes(integer(), integer(), integer(), list(integer())) -> list(integer()).
flush_cache_bytes(Cache_byte, Cache_size, Carry, Out_rev) ->
    case Cache_size of
        0 ->
            Out_rev;

        _ ->
            Byte = erlang:'band'(Cache_byte + Carry, 16#FF),
            flush_cache_bytes(16#FF, Cache_size - 1, Carry, [Byte | Out_rev])
    end.

-file("src/packkit/internal/lzma.gleam", 1239).
?DOC(false).
-spec byte_at_input(bitstring(), integer()) -> integer().
byte_at_input(Bytes, Pos) ->
    case gleam_stdlib:bit_array_slice(Bytes, Pos, 1) of
        {ok, <<B>>} ->
            B;

        _ ->
            0
    end.

-file("src/packkit/internal/lzma.gleam", 1246).
?DOC(false).
-spec lzma_hash3(integer(), integer(), integer()) -> integer().
lzma_hash3(B0, B1, B2) ->
    erlang:'band'(
        erlang:'bxor'(
            erlang:'bxor'(B0 * 2654435761, B1 * 40503),
            B2 * 2246822519
        ),
        16#FFFF
    ).

-file("src/packkit/internal/lzma.gleam", 1258).
?DOC(false).
-spec lzma_match_length(bitstring(), integer(), integer(), integer(), integer()) -> integer().
lzma_match_length(Bytes, Prev, Cur, Cap, Acc) ->
    case Acc >= Cap of
        true ->
            Acc;

        false ->
            case byte_at_input(Bytes, Prev + Acc) =:= byte_at_input(
                Bytes,
                Cur + Acc
            ) of
                true ->
                    lzma_match_length(Bytes, Prev, Cur, Cap, Acc + 1);

                false ->
                    Acc
            end
    end.

-file("src/packkit/internal/lzma.gleam", 1348).
?DOC(false).
-spec lzma_short_rep_next_state(integer()) -> integer().
lzma_short_rep_next_state(State) ->
    case State < 7 of
        true ->
            9;

        false ->
            11
    end.

-file("src/packkit/internal/lzma.gleam", 1478).
?DOC(false).
-spec which_rep_slot(encoder(), integer()) -> gleam@option:option(integer()).
which_rep_slot(Encoder, Distance_value) ->
    case true of
        _ when Distance_value =:= erlang:element(7, Encoder) ->
            {some, 0};

        _ when Distance_value =:= erlang:element(8, Encoder) ->
            {some, 1};

        _ when Distance_value =:= erlang:element(9, Encoder) ->
            {some, 2};

        _ when Distance_value =:= erlang:element(10, Encoder) ->
            {some, 3};

        _ ->
            none
    end.

-file("src/packkit/internal/lzma.gleam", 1582).
?DOC(false).
-spec lzma_rep_next_state(integer()) -> integer().
lzma_rep_next_state(State) ->
    case State < 7 of
        true ->
            8;

        false ->
            11
    end.

-file("src/packkit/internal/lzma.gleam", 1589).
?DOC(false).
-spec lzma_match_next_state(integer()) -> integer().
lzma_match_next_state(State) ->
    case State < 7 of
        true ->
            7;

        false ->
            10
    end.

-file("src/packkit/internal/lzma.gleam", 1709).
?DOC(false).
-spec high_bit_pos_loop(integer(), integer()) -> integer().
high_bit_pos_loop(Value, Pos) ->
    case Value =< 1 of
        true ->
            Pos;

        false ->
            high_bit_pos_loop(erlang:'bsr'(Value, 1), Pos + 1)
    end.

-file("src/packkit/internal/lzma.gleam", 1705).
?DOC(false).
-spec high_bit_pos(integer()) -> integer().
high_bit_pos(Value) ->
    high_bit_pos_loop(Value, 0).

-file("src/packkit/internal/lzma.gleam", 1693).
?DOC(false).
-spec compute_pos_slot(integer()) -> integer().
compute_pos_slot(Distance) ->
    case Distance < 4 of
        true ->
            Distance;

        false ->
            High_bit = high_bit_pos(Distance),
            Next_bit = erlang:'band'(erlang:'bsr'(Distance, High_bit - 1), 1),
            (High_bit * 2) + Next_bit
    end.

-file("src/packkit/internal/lzma.gleam", 788).
?DOC(false).
-spec normalize(decoder()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
normalize(Decoder) ->
    case erlang:element(2, Decoder) < 16777216 of
        false ->
            {ok, Decoder};

        true ->
            case erlang:element(4, Decoder) of
                <<Byte, Rest/binary>> ->
                    {ok,
                        {decoder,
                            erlang:'band'(
                                erlang:element(2, Decoder) * 256,
                                16#FFFFFFFF
                            ),
                            erlang:'band'(
                                (erlang:element(3, Decoder) * 256) + Byte,
                                16#FFFFFFFF
                            ),
                            Rest,
                            erlang:element(5, Decoder),
                            erlang:element(6, Decoder),
                            erlang:element(7, Decoder),
                            erlang:element(8, Decoder),
                            erlang:element(9, Decoder),
                            erlang:element(10, Decoder),
                            erlang:element(11, Decoder),
                            erlang:element(12, Decoder),
                            erlang:element(13, Decoder),
                            erlang:element(14, Decoder)}};

                _ ->
                    {error,
                        {codec_invalid_data,
                            <<"LZMA range coder ran out of input bytes"/utf8>>}}
            end
    end.

-file("src/packkit/internal/lzma.gleam", 688).
?DOC(false).
-spec decode_direct_bits_loop(decoder(), integer(), integer()) -> {ok,
        {integer(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_direct_bits_loop(Decoder, Remaining, Acc) ->
    case Remaining of
        0 ->
            {ok, {Acc, Decoder}};

        _ ->
            New_range = erlang:'bsr'(erlang:element(2, Decoder), 1),
            case erlang:element(3, Decoder) >= New_range of
                true ->
                    Decoder@1 = {decoder,
                        New_range,
                        erlang:element(3, Decoder) - New_range,
                        erlang:element(4, Decoder),
                        erlang:element(5, Decoder),
                        erlang:element(6, Decoder),
                        erlang:element(7, Decoder),
                        erlang:element(8, Decoder),
                        erlang:element(9, Decoder),
                        erlang:element(10, Decoder),
                        erlang:element(11, Decoder),
                        erlang:element(12, Decoder),
                        erlang:element(13, Decoder),
                        erlang:element(14, Decoder)},
                    gleam@result:'try'(
                        normalize(Decoder@1),
                        fun(Decoder@2) ->
                            decode_direct_bits_loop(
                                Decoder@2,
                                Remaining - 1,
                                (Acc * 2) + 1
                            )
                        end
                    );

                false ->
                    Decoder@3 = {decoder,
                        New_range,
                        erlang:element(3, Decoder),
                        erlang:element(4, Decoder),
                        erlang:element(5, Decoder),
                        erlang:element(6, Decoder),
                        erlang:element(7, Decoder),
                        erlang:element(8, Decoder),
                        erlang:element(9, Decoder),
                        erlang:element(10, Decoder),
                        erlang:element(11, Decoder),
                        erlang:element(12, Decoder),
                        erlang:element(13, Decoder),
                        erlang:element(14, Decoder)},
                    gleam@result:'try'(
                        normalize(Decoder@3),
                        fun(Decoder@4) ->
                            decode_direct_bits_loop(
                                Decoder@4,
                                Remaining - 1,
                                Acc * 2
                            )
                        end
                    )
            end
    end.

-file("src/packkit/internal/lzma.gleam", 681).
?DOC(false).
-spec decode_direct_bits(decoder(), integer()) -> {ok, {integer(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_direct_bits(Decoder, Count) ->
    decode_direct_bits_loop(Decoder, Count, 0).

-file("src/packkit/internal/lzma.gleam", 643).
?DOC(false).
-spec decode_bit(decoder(), integer()) -> {ok, {integer(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_bit(Decoder, Key) ->
    Prob = case gleam_stdlib:map_get(erlang:element(14, Decoder), Key) of
        {ok, Value} ->
            Value;

        {error, _} ->
            1024
    end,
    Bound = erlang:'bsr'(erlang:element(2, Decoder), 11) * Prob,
    case erlang:element(3, Decoder) < Bound of
        true ->
            New_prob = Prob + erlang:'bsr'(2048 - Prob, 5),
            Decoder@1 = {decoder,
                Bound,
                erlang:element(3, Decoder),
                erlang:element(4, Decoder),
                erlang:element(5, Decoder),
                erlang:element(6, Decoder),
                erlang:element(7, Decoder),
                erlang:element(8, Decoder),
                erlang:element(9, Decoder),
                erlang:element(10, Decoder),
                erlang:element(11, Decoder),
                erlang:element(12, Decoder),
                erlang:element(13, Decoder),
                gleam@dict:insert(erlang:element(14, Decoder), Key, New_prob)},
            gleam@result:'try'(
                normalize(Decoder@1),
                fun(Decoder@2) -> {ok, {0, Decoder@2}} end
            );

        false ->
            New_prob@1 = Prob - erlang:'bsr'(Prob, 5),
            Decoder@3 = {decoder,
                erlang:element(2, Decoder) - Bound,
                erlang:element(3, Decoder) - Bound,
                erlang:element(4, Decoder),
                erlang:element(5, Decoder),
                erlang:element(6, Decoder),
                erlang:element(7, Decoder),
                erlang:element(8, Decoder),
                erlang:element(9, Decoder),
                erlang:element(10, Decoder),
                erlang:element(11, Decoder),
                erlang:element(12, Decoder),
                erlang:element(13, Decoder),
                gleam@dict:insert(erlang:element(14, Decoder), Key, New_prob@1)},
            gleam@result:'try'(
                normalize(Decoder@3),
                fun(Decoder@4) -> {ok, {1, Decoder@4}} end
            )
    end.

-file("src/packkit/internal/lzma.gleam", 723).
?DOC(false).
-spec decode_bit_tree_loop(
    decoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, {integer(), decoder()}} | {error, packkit@error:codec_error()}.
decode_bit_tree_loop(Decoder, Table, Base, Remaining, Symbol, Total_bits) ->
    case Remaining of
        0 ->
            {ok, {Symbol - erlang:'bsl'(1, Total_bits), Decoder}};

        _ ->
            gleam@result:'try'(
                decode_bit(Decoder, prob_key(Table, Base + Symbol)),
                fun(_use0) ->
                    {Bit, Decoder@1} = _use0,
                    decode_bit_tree_loop(
                        Decoder@1,
                        Table,
                        Base,
                        Remaining - 1,
                        (Symbol * 2) + Bit,
                        Total_bits
                    )
                end
            )
    end.

-file("src/packkit/internal/lzma.gleam", 714).
?DOC(false).
-spec decode_bit_tree(decoder(), integer(), integer(), integer()) -> {ok,
        {integer(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_bit_tree(Decoder, Table, Base, Num_bits) ->
    decode_bit_tree_loop(Decoder, Table, Base, Num_bits, 1, Num_bits).

-file("src/packkit/internal/lzma.gleam", 759).
?DOC(false).
-spec decode_reverse_bit_tree_loop(
    decoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, {integer(), decoder()}} | {error, packkit@error:codec_error()}.
decode_reverse_bit_tree_loop(
    Decoder,
    Table,
    Base,
    Remaining,
    Symbol,
    Result_acc,
    Bit_index
) ->
    case Remaining of
        0 ->
            {ok, {Result_acc, Decoder}};

        _ ->
            gleam@result:'try'(
                decode_bit(Decoder, prob_key(Table, Base + Symbol)),
                fun(_use0) ->
                    {Bit, Decoder@1} = _use0,
                    decode_reverse_bit_tree_loop(
                        Decoder@1,
                        Table,
                        Base,
                        Remaining - 1,
                        (Symbol * 2) + Bit,
                        Result_acc + erlang:'bsl'(Bit, Bit_index),
                        Bit_index + 1
                    )
                end
            )
    end.

-file("src/packkit/internal/lzma.gleam", 750).
?DOC(false).
-spec decode_reverse_bit_tree(decoder(), integer(), integer(), integer()) -> {ok,
        {integer(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_reverse_bit_tree(Decoder, Table, Base, Num_bits) ->
    decode_reverse_bit_tree_loop(Decoder, Table, Base, Num_bits, 1, 0, 0).

-file("src/packkit/internal/lzma.gleam", 106).
?DOC(false).
-spec properties_of_byte(integer()) -> {ok, properties()} |
    {error, packkit@error:codec_error()}.
properties_of_byte(Byte) ->
    gleam@bool:guard(
        Byte > 224,
        {error, {codec_invalid_data, <<"invalid LZMA properties byte"/utf8>>}},
        fun() ->
            Pb = Byte div 45,
            Remainder = Byte - (Pb * 45),
            Lp = Remainder div 9,
            Lc = Remainder - (Lp * 9),
            gleam@bool:guard(
                (Lc + Lp) > 4,
                {error,
                    {codec_invalid_data, <<"LZMA lc + lp must be <= 4"/utf8>>}},
                fun() ->
                    gleam@bool:guard(
                        Pb > 4,
                        {error,
                            {codec_invalid_data,
                                <<"LZMA pb out of range"/utf8>>}},
                        fun() -> {ok, {properties, Lc, Lp, Pb}} end
                    )
                end
            )
        end
    ).

-file("src/packkit/internal/lzma.gleam", 533).
?DOC(false).
-spec decode_length(
    decoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, {integer(), decoder()}} | {error, packkit@error:codec_error()}.
decode_length(Decoder, Pos_state, T_choice, T_choice2, T_low, T_mid, T_high) ->
    gleam@result:'try'(
        decode_bit(Decoder, prob_key(T_choice, 0)),
        fun(_use0) ->
            {Choice, Decoder@1} = _use0,
            case Choice of
                0 ->
                    gleam@result:'try'(
                        decode_bit_tree(Decoder@1, T_low, Pos_state * 8, 3),
                        fun(_use0@1) ->
                            {Value, Decoder@2} = _use0@1,
                            {ok, {2 + Value, Decoder@2}}
                        end
                    );

                _ ->
                    gleam@result:'try'(
                        decode_bit(Decoder@1, prob_key(T_choice2, 0)),
                        fun(_use0@2) ->
                            {Choice2, Decoder@3} = _use0@2,
                            case Choice2 of
                                0 ->
                                    gleam@result:'try'(
                                        decode_bit_tree(
                                            Decoder@3,
                                            T_mid,
                                            Pos_state * 8,
                                            3
                                        ),
                                        fun(_use0@3) ->
                                            {Value@1, Decoder@4} = _use0@3,
                                            {ok, {(2 + 8) + Value@1, Decoder@4}}
                                        end
                                    );

                                _ ->
                                    gleam@result:'try'(
                                        decode_bit_tree(Decoder@3, T_high, 0, 8),
                                        fun(_use0@4) ->
                                            {Value@2, Decoder@5} = _use0@4,
                                            {ok,
                                                {((2 + 8) + 8) + Value@2,
                                                    Decoder@5}}
                                        end
                                    )
                            end
                        end
                    )
            end
        end
    ).

-file("src/packkit/internal/lzma.gleam", 271).
?DOC(false).
-spec decode_literal_normal(decoder(), integer(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
decode_literal_normal(Decoder, Base, Symbol) ->
    case Symbol >= 16#100 of
        true ->
            Byte = erlang:'band'(Symbol, 16#FF),
            Decoder@1 = emit_byte(Decoder, Byte),
            {ok, advance_state_literal(Decoder@1)};

        false ->
            gleam@result:'try'(
                decode_bit(Decoder, prob_key(6, Base + Symbol)),
                fun(_use0) ->
                    {Bit, Decoder@2} = _use0,
                    decode_literal_normal(Decoder@2, Base, (Symbol * 2) + Bit)
                end
            )
    end.

-file("src/packkit/internal/lzma.gleam", 292).
?DOC(false).
-spec decode_literal_matched(decoder(), integer(), integer(), integer()) -> {ok,
        decoder()} |
    {error, packkit@error:codec_error()}.
decode_literal_matched(Decoder, Base, Symbol, Match_b) ->
    case Symbol >= 16#100 of
        true ->
            Byte = erlang:'band'(Symbol, 16#FF),
            Decoder@1 = emit_byte(Decoder, Byte),
            {ok, advance_state_literal(Decoder@1)};

        false ->
            Match_bit = erlang:'band'(erlang:'bsr'(Match_b, 7), 16#01),
            Next_match = erlang:'band'(Match_b * 2, 16#FF),
            Prob_offset = (16#100 + (Match_bit * 16#100)) + Symbol,
            gleam@result:'try'(
                decode_bit(Decoder, prob_key(6, Base + Prob_offset)),
                fun(_use0) ->
                    {Bit, Decoder@2} = _use0,
                    case Bit =:= Match_bit of
                        true ->
                            decode_literal_matched(
                                Decoder@2,
                                Base,
                                (Symbol * 2) + Bit,
                                Next_match
                            );

                        false ->
                            decode_literal_normal(
                                Decoder@2,
                                Base,
                                (Symbol * 2) + Bit
                            )
                    end
                end
            )
    end.

-file("src/packkit/internal/lzma.gleam", 254).
?DOC(false).
-spec decode_literal(decoder()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
decode_literal(Decoder) ->
    Prev_byte = previous_output_byte(Decoder),
    Lit_pos_state = erlang:'band'(
        erlang:element(6, Decoder),
        mask_for(erlang:element(3, erlang:element(13, Decoder)))
    ),
    Lit_high = erlang:'bsr'(
        Prev_byte,
        8 - erlang:element(2, erlang:element(13, Decoder))
    ),
    Context_index = erlang:'bor'(
        erlang:'bsl'(
            Lit_pos_state,
            erlang:element(2, erlang:element(13, Decoder))
        ),
        Lit_high
    ),
    Prob_base = Context_index * 16#300,
    case erlang:element(8, Decoder) < 7 of
        true ->
            decode_literal_normal(Decoder, Prob_base, 1);

        false ->
            decode_literal_matched(Decoder, Prob_base, 1, match_byte(Decoder))
    end.

-file("src/packkit/internal/lzma.gleam", 587).
?DOC(false).
-spec decode_distance(decoder(), integer()) -> {ok, {integer(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_distance(Decoder, Length) ->
    Len_state = case (Length - 2) < 4 of
        true ->
            Length - 2;

        false ->
            4 - 1
    end,
    gleam@result:'try'(
        decode_bit_tree(Decoder, 7, Len_state * 64, 6),
        fun(_use0) ->
            {Pos_slot, Decoder@1} = _use0,
            case Pos_slot < 4 of
                true ->
                    {ok, {Pos_slot, Decoder@1}};

                false ->
                    Num_direct_bits = erlang:'bsr'(Pos_slot, 1) - 1,
                    Base = erlang:'bsl'(
                        erlang:'bor'(2, erlang:'band'(Pos_slot, 1)),
                        Num_direct_bits
                    ),
                    case Pos_slot < 14 of
                        true ->
                            Offset = Base - Pos_slot,
                            gleam@result:'try'(
                                decode_reverse_bit_tree(
                                    Decoder@1,
                                    8,
                                    Offset,
                                    Num_direct_bits
                                ),
                                fun(_use0@1) ->
                                    {Extra, Decoder@2} = _use0@1,
                                    {ok, {Base + Extra, Decoder@2}}
                                end
                            );

                        false ->
                            High_bits = Num_direct_bits - 4,
                            gleam@result:'try'(
                                decode_direct_bits(Decoder@1, High_bits),
                                fun(_use0@2) ->
                                    {Top, Decoder@3} = _use0@2,
                                    Middle = erlang:'bsl'(Top, 4),
                                    gleam@result:'try'(
                                        decode_reverse_bit_tree(
                                            Decoder@3,
                                            9,
                                            0,
                                            4
                                        ),
                                        fun(_use0@3) ->
                                            {Align_bits, Decoder@4} = _use0@3,
                                            {ok,
                                                {(Base + Middle) + Align_bits,
                                                    Decoder@4}}
                                        end
                                    )
                                end
                            )
                    end
            end
        end
    ).

-file("src/packkit/internal/lzma.gleam", 376).
?DOC(false).
-spec decode_match(decoder(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
decode_match(Decoder, Pos_state) ->
    _ = Pos_state,
    Decoder@1 = {decoder,
        erlang:element(2, Decoder),
        erlang:element(3, Decoder),
        erlang:element(4, Decoder),
        erlang:element(5, Decoder),
        erlang:element(6, Decoder),
        erlang:element(7, Decoder),
        erlang:element(8, Decoder),
        erlang:element(9, Decoder),
        erlang:element(9, Decoder),
        erlang:element(10, Decoder),
        erlang:element(11, Decoder),
        erlang:element(13, Decoder),
        erlang:element(14, Decoder)},
    gleam@result:'try'(
        decode_length(Decoder@1, Pos_state, 10, 11, 12, 13, 14),
        fun(_use0) ->
            {Length, Decoder@2} = _use0,
            gleam@result:'try'(
                decode_distance(Decoder@2, Length),
                fun(_use0@1) ->
                    {Distance, Decoder@3} = _use0@1,
                    Decoder@4 = {decoder,
                        erlang:element(2, Decoder@3),
                        erlang:element(3, Decoder@3),
                        erlang:element(4, Decoder@3),
                        erlang:element(5, Decoder@3),
                        erlang:element(6, Decoder@3),
                        erlang:element(7, Decoder@3),
                        match_next(erlang:element(8, Decoder@3)),
                        Distance,
                        erlang:element(10, Decoder@3),
                        erlang:element(11, Decoder@3),
                        erlang:element(12, Decoder@3),
                        erlang:element(13, Decoder@3),
                        erlang:element(14, Decoder@3)},
                    apply_copy(Decoder@4, Length)
                end
            )
        end
    ).

-file("src/packkit/internal/lzma.gleam", 456).
?DOC(false).
-spec apply_rep_match(decoder(), integer(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
apply_rep_match(Decoder, Selected, Pos_state) ->
    {Rep1, Rep2, Rep3} = case true of
        _ when Selected =:= erlang:element(9, Decoder) ->
            {erlang:element(10, Decoder),
                erlang:element(11, Decoder),
                erlang:element(12, Decoder)};

        _ when Selected =:= erlang:element(10, Decoder) ->
            {erlang:element(9, Decoder),
                erlang:element(11, Decoder),
                erlang:element(12, Decoder)};

        _ when Selected =:= erlang:element(11, Decoder) ->
            {erlang:element(9, Decoder),
                erlang:element(10, Decoder),
                erlang:element(12, Decoder)};

        _ ->
            {erlang:element(9, Decoder),
                erlang:element(10, Decoder),
                erlang:element(11, Decoder)}
    end,
    Decoder@1 = {decoder,
        erlang:element(2, Decoder),
        erlang:element(3, Decoder),
        erlang:element(4, Decoder),
        erlang:element(5, Decoder),
        erlang:element(6, Decoder),
        erlang:element(7, Decoder),
        rep_next(erlang:element(8, Decoder)),
        Selected,
        Rep1,
        Rep2,
        Rep3,
        erlang:element(13, Decoder),
        erlang:element(14, Decoder)},
    gleam@result:'try'(
        decode_length(Decoder@1, Pos_state, 15, 16, 17, 18, 19),
        fun(_use0) ->
            {Length, Decoder@2} = _use0,
            apply_copy(Decoder@2, Length)
        end
    ).

-file("src/packkit/internal/lzma.gleam", 412).
?DOC(false).
-spec decode_rep(decoder(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
decode_rep(Decoder, Pos_state) ->
    gleam@result:'try'(
        decode_bit(Decoder, prob_key(2, erlang:element(8, Decoder))),
        fun(_use0) ->
            {G0, Decoder@1} = _use0,
            case G0 of
                0 ->
                    gleam@result:'try'(
                        decode_bit(
                            Decoder@1,
                            prob_key(
                                5,
                                (erlang:element(8, Decoder@1) * 16) + Pos_state
                            )
                        ),
                        fun(_use0@1) ->
                            {G0_long, Decoder@2} = _use0@1,
                            case G0_long of
                                0 ->
                                    Decoder@3 = {decoder,
                                        erlang:element(2, Decoder@2),
                                        erlang:element(3, Decoder@2),
                                        erlang:element(4, Decoder@2),
                                        erlang:element(5, Decoder@2),
                                        erlang:element(6, Decoder@2),
                                        erlang:element(7, Decoder@2),
                                        short_rep_next(
                                            erlang:element(8, Decoder@2)
                                        ),
                                        erlang:element(9, Decoder@2),
                                        erlang:element(10, Decoder@2),
                                        erlang:element(11, Decoder@2),
                                        erlang:element(12, Decoder@2),
                                        erlang:element(13, Decoder@2),
                                        erlang:element(14, Decoder@2)},
                                    apply_copy(Decoder@3, 1);

                                _ ->
                                    apply_rep_match(
                                        Decoder@2,
                                        erlang:element(9, Decoder@2),
                                        Pos_state
                                    )
                            end
                        end
                    );

                _ ->
                    gleam@result:'try'(
                        decode_bit(
                            Decoder@1,
                            prob_key(3, erlang:element(8, Decoder@1))
                        ),
                        fun(_use0@2) ->
                            {G1, Decoder@4} = _use0@2,
                            case G1 of
                                0 ->
                                    apply_rep_match(
                                        Decoder@4,
                                        erlang:element(10, Decoder@4),
                                        Pos_state
                                    );

                                _ ->
                                    gleam@result:'try'(
                                        decode_bit(
                                            Decoder@4,
                                            prob_key(
                                                4,
                                                erlang:element(8, Decoder@4)
                                            )
                                        ),
                                        fun(_use0@3) ->
                                            {G2, Decoder@5} = _use0@3,
                                            case G2 of
                                                0 ->
                                                    apply_rep_match(
                                                        Decoder@5,
                                                        erlang:element(
                                                            11,
                                                            Decoder@5
                                                        ),
                                                        Pos_state
                                                    );

                                                _ ->
                                                    apply_rep_match(
                                                        Decoder@5,
                                                        erlang:element(
                                                            12,
                                                            Decoder@5
                                                        ),
                                                        Pos_state
                                                    )
                                            end
                                        end
                                    )
                            end
                        end
                    )
            end
        end
    ).

-file("src/packkit/internal/lzma.gleam", 212).
?DOC(false).
-spec loop_until(decoder(), integer()) -> {ok, decoder()} |
    {error, packkit@error:codec_error()}.
loop_until(Decoder, Desired_output) ->
    case erlang:element(6, Decoder) >= Desired_output of
        true ->
            {ok, Decoder};

        false ->
            Pos_state = erlang:'band'(
                erlang:element(6, Decoder),
                mask_for(erlang:element(4, erlang:element(13, Decoder)))
            ),
            case decode_bit(
                Decoder,
                prob_key(0, (erlang:element(8, Decoder) * 16) + Pos_state)
            ) of
                {error, E} ->
                    {error, E};

                {ok, {0, Decoder@1}} ->
                    case decode_literal(Decoder@1) of
                        {error, E@1} ->
                            {error, E@1};

                        {ok, Decoder@2} ->
                            loop_until(Decoder@2, Desired_output)
                    end;

                {ok, {_, Decoder@3}} ->
                    case decode_bit(
                        Decoder@3,
                        prob_key(1, erlang:element(8, Decoder@3))
                    ) of
                        {error, E@2} ->
                            {error, E@2};

                        {ok, {0, Decoder@4}} ->
                            case decode_match(Decoder@4, Pos_state) of
                                {error, E@3} ->
                                    {error, E@3};

                                {ok, Decoder@5} ->
                                    loop_until(Decoder@5, Desired_output)
                            end;

                        {ok, {_, Decoder@6}} ->
                            case decode_rep(Decoder@6, Pos_state) of
                                {error, E@4} ->
                                    {error, E@4};

                                {ok, Decoder@7} ->
                                    loop_until(Decoder@7, Desired_output)
                            end
                    end
            end
    end.

-file("src/packkit/internal/lzma.gleam", 191).
?DOC(false).
-spec decode_into(decoder(), integer()) -> {ok, {bitstring(), decoder()}} |
    {error, packkit@error:codec_error()}.
decode_into(Decoder, Desired_output) ->
    gleam@result:'try'(
        loop_until(Decoder, Desired_output),
        fun(Decoder@1) ->
            Bytes = list_reverse_to_bit_array(
                erlang:element(5, Decoder@1),
                <<>>
            ),
            {ok, {Bytes, Decoder@1}}
        end
    ).

-file("src/packkit/internal/lzma.gleam", 904).
?DOC(false).
-spec new_encoder(properties()) -> encoder().
new_encoder(Props) ->
    {encoder, 16#FFFFFFFF, 0, 0, 1, 0, 0, 0, 0, 0, Props, maps:new(), [], 0, []}.

-file("src/packkit/internal/lzma.gleam", 1083).
?DOC(false).
-spec shift_low_left_byte(integer()) -> integer().
shift_low_left_byte(Low) ->
    Truncated = case Low >= 4294967296 of
        true ->
            Low - (4294967296 * (case 4294967296 of
                0 -> 0;
                Gleam@denominator -> Low div Gleam@denominator
            end));

        false ->
            Low
    end,
    Raw = Truncated * 256,
    case Raw >= 4294967296 of
        true ->
            Raw - (4294967296 * (case 4294967296 of
                0 -> 0;
                Gleam@denominator@1 -> Raw div Gleam@denominator@1
            end));

        false ->
            Raw
    end.

-file("src/packkit/internal/lzma.gleam", 1049).
?DOC(false).
-spec shift_low_encoder(encoder()) -> encoder().
shift_low_encoder(Encoder) ->
    case (erlang:element(3, Encoder) < 16#FF000000) orelse (erlang:element(
        3,
        Encoder
    )
    > 16#FFFFFFFF) of
        true ->
            Carry = case 4294967296 of
                0 -> 0;
                Gleam@denominator -> erlang:element(3, Encoder) div Gleam@denominator
            end,
            Flushed = flush_cache_bytes(
                erlang:element(4, Encoder),
                erlang:element(5, Encoder),
                Carry,
                erlang:element(15, Encoder)
            ),
            New_cache = erlang:'band'(
                erlang:element(3, Encoder) div 16777216,
                16#FF
            ),
            New_low = shift_low_left_byte(erlang:element(3, Encoder)),
            {encoder,
                erlang:element(2, Encoder),
                New_low,
                New_cache,
                1,
                erlang:element(6, Encoder),
                erlang:element(7, Encoder),
                erlang:element(8, Encoder),
                erlang:element(9, Encoder),
                erlang:element(10, Encoder),
                erlang:element(11, Encoder),
                erlang:element(12, Encoder),
                erlang:element(13, Encoder),
                erlang:element(14, Encoder),
                Flushed};

        false ->
            New_low@1 = shift_low_left_byte(erlang:element(3, Encoder)),
            {encoder,
                erlang:element(2, Encoder),
                New_low@1,
                erlang:element(4, Encoder),
                erlang:element(5, Encoder) + 1,
                erlang:element(6, Encoder),
                erlang:element(7, Encoder),
                erlang:element(8, Encoder),
                erlang:element(9, Encoder),
                erlang:element(10, Encoder),
                erlang:element(11, Encoder),
                erlang:element(12, Encoder),
                erlang:element(13, Encoder),
                erlang:element(14, Encoder),
                erlang:element(15, Encoder)}
    end.

-file("src/packkit/internal/lzma.gleam", 1033).
?DOC(false).
-spec normalize_encoder(encoder()) -> encoder().
normalize_encoder(Encoder) ->
    case erlang:element(2, Encoder) < 16777216 of
        false ->
            Encoder;

        true ->
            Encoder@1 = shift_low_encoder(Encoder),
            Encoder@2 = {encoder,
                erlang:element(2, Encoder@1) * 256,
                erlang:element(3, Encoder@1),
                erlang:element(4, Encoder@1),
                erlang:element(5, Encoder@1),
                erlang:element(6, Encoder@1),
                erlang:element(7, Encoder@1),
                erlang:element(8, Encoder@1),
                erlang:element(9, Encoder@1),
                erlang:element(10, Encoder@1),
                erlang:element(11, Encoder@1),
                erlang:element(12, Encoder@1),
                erlang:element(13, Encoder@1),
                erlang:element(14, Encoder@1),
                erlang:element(15, Encoder@1)},
            normalize_encoder(Encoder@2)
    end.

-file("src/packkit/internal/lzma.gleam", 1003).
?DOC(false).
-spec encode_bit(encoder(), integer(), integer()) -> encoder().
encode_bit(Encoder, Key, Bit) ->
    Prob = case gleam_stdlib:map_get(erlang:element(12, Encoder), Key) of
        {ok, Value} ->
            Value;

        {error, _} ->
            1024
    end,
    New_bound = erlang:'bsr'(erlang:element(2, Encoder), 11) * Prob,
    Encoder@1 = case Bit of
        0 ->
            New_prob = Prob + erlang:'bsr'(2048 - Prob, 5),
            {encoder,
                New_bound,
                erlang:element(3, Encoder),
                erlang:element(4, Encoder),
                erlang:element(5, Encoder),
                erlang:element(6, Encoder),
                erlang:element(7, Encoder),
                erlang:element(8, Encoder),
                erlang:element(9, Encoder),
                erlang:element(10, Encoder),
                erlang:element(11, Encoder),
                gleam@dict:insert(erlang:element(12, Encoder), Key, New_prob),
                erlang:element(13, Encoder),
                erlang:element(14, Encoder),
                erlang:element(15, Encoder)};

        _ ->
            New_prob@1 = Prob - erlang:'bsr'(Prob, 5),
            {encoder,
                erlang:element(2, Encoder) - New_bound,
                erlang:element(3, Encoder) + New_bound,
                erlang:element(4, Encoder),
                erlang:element(5, Encoder),
                erlang:element(6, Encoder),
                erlang:element(7, Encoder),
                erlang:element(8, Encoder),
                erlang:element(9, Encoder),
                erlang:element(10, Encoder),
                erlang:element(11, Encoder),
                gleam@dict:insert(erlang:element(12, Encoder), Key, New_prob@1),
                erlang:element(13, Encoder),
                erlang:element(14, Encoder),
                erlang:element(15, Encoder)}
    end,
    normalize_encoder(Encoder@1).

-file("src/packkit/internal/lzma.gleam", 968).
?DOC(false).
-spec encode_literal_bits(encoder(), integer(), integer(), integer(), integer()) -> encoder().
encode_literal_bits(Encoder, Base, Symbol, Byte, Remaining) ->
    case Remaining of
        0 ->
            Encoder;

        _ ->
            Bit_pos = Remaining - 1,
            Bit = erlang:'band'(erlang:'bsr'(Byte, Bit_pos), 1),
            Encoder@1 = encode_bit(Encoder, prob_key(6, Base + Symbol), Bit),
            encode_literal_bits(
                Encoder@1,
                Base,
                (Symbol * 2) + Bit,
                Byte,
                Remaining - 1
            )
    end.

-file("src/packkit/internal/lzma.gleam", 948).
?DOC(false).
-spec encode_literal_byte(encoder(), integer()) -> encoder().
encode_literal_byte(Encoder, Byte) ->
    Prev_byte = case erlang:element(13, Encoder) of
        [Head | _] ->
            Head;

        [] ->
            0
    end,
    Lit_pos_state = erlang:'band'(
        erlang:element(14, Encoder),
        mask_for(erlang:element(3, erlang:element(11, Encoder)))
    ),
    Lit_high = erlang:'bsr'(
        Prev_byte,
        8 - erlang:element(2, erlang:element(11, Encoder))
    ),
    Context_index = erlang:'bor'(
        erlang:'bsl'(
            Lit_pos_state,
            erlang:element(2, erlang:element(11, Encoder))
        ),
        Lit_high
    ),
    Prob_base = Context_index * 16#300,
    Encoder@1 = encode_literal_bits(Encoder, Prob_base, 1, Byte, 8),
    {encoder,
        erlang:element(2, Encoder@1),
        erlang:element(3, Encoder@1),
        erlang:element(4, Encoder@1),
        erlang:element(5, Encoder@1),
        literal_state_after(erlang:element(6, Encoder@1)),
        erlang:element(7, Encoder@1),
        erlang:element(8, Encoder@1),
        erlang:element(9, Encoder@1),
        erlang:element(10, Encoder@1),
        erlang:element(11, Encoder@1),
        erlang:element(12, Encoder@1),
        erlang:element(13, Encoder@1),
        erlang:element(14, Encoder@1),
        erlang:element(15, Encoder@1)}.

-file("src/packkit/internal/lzma.gleam", 923).
?DOC(false).
-spec encode_literal_only_loop(encoder(), bitstring()) -> encoder().
encode_literal_only_loop(Encoder, Input) ->
    case Input of
        <<Byte, Rest/binary>> ->
            Pos_state = erlang:'band'(
                erlang:element(14, Encoder),
                mask_for(erlang:element(4, erlang:element(11, Encoder)))
            ),
            Encoder@1 = encode_bit(
                Encoder,
                prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
                0
            ),
            Encoder@2 = encode_literal_byte(Encoder@1, Byte),
            Encoder@3 = {encoder,
                erlang:element(2, Encoder@2),
                erlang:element(3, Encoder@2),
                erlang:element(4, Encoder@2),
                erlang:element(5, Encoder@2),
                erlang:element(6, Encoder@2),
                erlang:element(7, Encoder@2),
                erlang:element(8, Encoder@2),
                erlang:element(9, Encoder@2),
                erlang:element(10, Encoder@2),
                erlang:element(11, Encoder@2),
                erlang:element(12, Encoder@2),
                [Byte | erlang:element(13, Encoder@2)],
                erlang:element(14, Encoder@2) + 1,
                erlang:element(15, Encoder@2)},
            encode_literal_only_loop(Encoder@3, Rest);

        _ ->
            Encoder
    end.

-file("src/packkit/internal/lzma.gleam", 1116).
?DOC(false).
-spec finish_encoder(encoder()) -> encoder().
finish_encoder(Encoder) ->
    _pipe = Encoder,
    _pipe@1 = shift_low_encoder(_pipe),
    _pipe@2 = shift_low_encoder(_pipe@1),
    _pipe@3 = shift_low_encoder(_pipe@2),
    _pipe@4 = shift_low_encoder(_pipe@3),
    shift_low_encoder(_pipe@4).

-file("src/packkit/internal/lzma.gleam", 875).
?DOC(false).
-spec encode_literal_only(bitstring(), properties()) -> bitstring().
encode_literal_only(Bytes, Props) ->
    Encoder = new_encoder(Props),
    Encoder@1 = encode_literal_only_loop(Encoder, Bytes),
    Encoder@2 = finish_encoder(Encoder@1),
    list_reverse_to_bit_array(erlang:element(15, Encoder@2), <<>>).

-file("src/packkit/internal/lzma.gleam", 1326).
?DOC(false).
-spec emit_lzma_short_rep(encoder(), integer()) -> encoder().
emit_lzma_short_rep(Encoder, Pos_state) ->
    Encoder@1 = encode_bit(
        Encoder,
        prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
        1
    ),
    Encoder@2 = encode_bit(
        Encoder@1,
        prob_key(1, erlang:element(6, Encoder@1)),
        1
    ),
    Encoder@3 = encode_bit(
        Encoder@2,
        prob_key(2, erlang:element(6, Encoder@2)),
        0
    ),
    Encoder@4 = encode_bit(
        Encoder@3,
        prob_key(5, (erlang:element(6, Encoder@3) * 16) + Pos_state),
        0
    ),
    {encoder,
        erlang:element(2, Encoder@4),
        erlang:element(3, Encoder@4),
        erlang:element(4, Encoder@4),
        erlang:element(5, Encoder@4),
        lzma_short_rep_next_state(erlang:element(6, Encoder@4)),
        erlang:element(7, Encoder@4),
        erlang:element(8, Encoder@4),
        erlang:element(9, Encoder@4),
        erlang:element(10, Encoder@4),
        erlang:element(11, Encoder@4),
        erlang:element(12, Encoder@4),
        erlang:element(13, Encoder@4),
        erlang:element(14, Encoder@4) + 1,
        erlang:element(15, Encoder@4)}.

-file("src/packkit/internal/lzma.gleam", 1405).
?DOC(false).
-spec encode_matched_literal_bits(
    encoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    boolean(),
    integer()
) -> encoder().
encode_matched_literal_bits(
    Encoder,
    Base,
    Symbol,
    Byte,
    Match_byte,
    Matched,
    Remaining
) ->
    case Remaining of
        0 ->
            Encoder;

        _ ->
            Bit_pos = Remaining - 1,
            Bit = erlang:'band'(erlang:'bsr'(Byte, Bit_pos), 1),
            case Matched of
                true ->
                    Match_bit = erlang:'band'(
                        erlang:'bsr'(Match_byte, Bit_pos),
                        1
                    ),
                    Prob_offset = (16#100 + (Match_bit * 16#100)) + Symbol,
                    Encoder@1 = encode_bit(
                        Encoder,
                        prob_key(6, Base + Prob_offset),
                        Bit
                    ),
                    encode_matched_literal_bits(
                        Encoder@1,
                        Base,
                        (Symbol * 2) + Bit,
                        Byte,
                        Match_byte,
                        Bit =:= Match_bit,
                        Remaining - 1
                    );

                false ->
                    Encoder@2 = encode_bit(
                        Encoder,
                        prob_key(6, Base + Symbol),
                        Bit
                    ),
                    encode_matched_literal_bits(
                        Encoder@2,
                        Base,
                        (Symbol * 2) + Bit,
                        Byte,
                        Match_byte,
                        false,
                        Remaining - 1
                    )
            end
    end.

-file("src/packkit/internal/lzma.gleam", 1355).
?DOC(false).
-spec emit_lzma_literal(encoder(), bitstring(), integer(), integer()) -> encoder().
emit_lzma_literal(Encoder, Bytes, Pos, Byte) ->
    Pos_state = erlang:'band'(
        Pos,
        mask_for(erlang:element(4, erlang:element(11, Encoder)))
    ),
    Encoder@1 = encode_bit(
        Encoder,
        prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
        0
    ),
    Prev_byte = case Pos of
        0 ->
            0;

        _ ->
            byte_at_input(Bytes, Pos - 1)
    end,
    Lit_pos_state = erlang:'band'(
        Pos,
        mask_for(erlang:element(3, erlang:element(11, Encoder@1)))
    ),
    Lit_high = erlang:'bsr'(
        Prev_byte,
        8 - erlang:element(2, erlang:element(11, Encoder@1))
    ),
    Context_index = erlang:'bor'(
        erlang:'bsl'(
            Lit_pos_state,
            erlang:element(2, erlang:element(11, Encoder@1))
        ),
        Lit_high
    ),
    Prob_base = Context_index * 16#300,
    Encoder@2 = case erlang:element(6, Encoder@1) < 7 of
        true ->
            encode_literal_bits(Encoder@1, Prob_base, 1, Byte, 8);

        false ->
            Match_byte = byte_at_input(
                Bytes,
                (Pos - erlang:element(7, Encoder@1)) - 1
            ),
            encode_matched_literal_bits(
                Encoder@1,
                Prob_base,
                1,
                Byte,
                Match_byte,
                true,
                8
            )
    end,
    {encoder,
        erlang:element(2, Encoder@2),
        erlang:element(3, Encoder@2),
        erlang:element(4, Encoder@2),
        erlang:element(5, Encoder@2),
        literal_state_after(erlang:element(6, Encoder@2)),
        erlang:element(7, Encoder@2),
        erlang:element(8, Encoder@2),
        erlang:element(9, Encoder@2),
        erlang:element(10, Encoder@2),
        erlang:element(11, Encoder@2),
        erlang:element(12, Encoder@2),
        erlang:element(13, Encoder@2),
        erlang:element(14, Encoder@2) + 1,
        erlang:element(15, Encoder@2)}.

-file("src/packkit/internal/lzma.gleam", 1310).
?DOC(false).
-spec emit_lzma_literal_or_short_rep(
    encoder(),
    bitstring(),
    integer(),
    integer()
) -> encoder().
emit_lzma_literal_or_short_rep(Encoder, Bytes, Pos, Byte) ->
    Back = (Pos - erlang:element(7, Encoder)) - 1,
    case (Back >= 0) andalso (byte_at_input(Bytes, Back) =:= Byte) of
        true ->
            Pos_state = erlang:'band'(
                Pos,
                mask_for(erlang:element(4, erlang:element(11, Encoder)))
            ),
            emit_lzma_short_rep(Encoder, Pos_state);

        false ->
            emit_lzma_literal(Encoder, Bytes, Pos, Byte)
    end.

-file("src/packkit/internal/lzma.gleam", 1726).
?DOC(false).
-spec encode_bit_tree_loop(
    encoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> encoder().
encode_bit_tree_loop(Encoder, Table, Base, Remaining, Context, Value) ->
    case Remaining of
        0 ->
            Encoder;

        _ ->
            Bit_pos = Remaining - 1,
            Bit = erlang:'band'(erlang:'bsr'(Value, Bit_pos), 1),
            Encoder@1 = encode_bit(
                Encoder,
                prob_key(Table, Base + Context),
                Bit
            ),
            encode_bit_tree_loop(
                Encoder@1,
                Table,
                Base,
                Remaining - 1,
                (Context * 2) + Bit,
                Value
            )
    end.

-file("src/packkit/internal/lzma.gleam", 1716).
?DOC(false).
-spec encode_bit_tree(encoder(), integer(), integer(), integer(), integer()) -> encoder().
encode_bit_tree(Encoder, Table, Base, Num_bits, Value) ->
    encode_bit_tree_loop(Encoder, Table, Base, Num_bits, 1, Value).

-file("src/packkit/internal/lzma.gleam", 1596).
?DOC(false).
-spec encode_lzma_length(
    encoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> encoder().
encode_lzma_length(
    Encoder,
    Pos_state,
    Length,
    T_choice,
    T_choice2,
    T_low,
    T_mid,
    T_high
) ->
    Value = Length - 2,
    case Value < 8 of
        true ->
            Encoder@1 = encode_bit(Encoder, prob_key(T_choice, 0), 0),
            encode_bit_tree(Encoder@1, T_low, Pos_state * 8, 3, Value);

        false ->
            case Value < (8 + 8) of
                true ->
                    Encoder@2 = encode_bit(Encoder, prob_key(T_choice, 0), 1),
                    Encoder@3 = encode_bit(Encoder@2, prob_key(T_choice2, 0), 0),
                    Mid_value = Value - 8,
                    encode_bit_tree(
                        Encoder@3,
                        T_mid,
                        Pos_state * 8,
                        3,
                        Mid_value
                    );

                false ->
                    Encoder@4 = encode_bit(Encoder, prob_key(T_choice, 0), 1),
                    Encoder@5 = encode_bit(Encoder@4, prob_key(T_choice2, 0), 1),
                    High_value = (Value - 8) - 8,
                    encode_bit_tree(Encoder@5, T_high, 0, 8, High_value)
            end
    end.

-file("src/packkit/internal/lzma.gleam", 1518).
?DOC(false).
-spec emit_lzma_rep_match(encoder(), integer(), integer(), integer()) -> encoder().
emit_lzma_rep_match(Encoder, Pos_state, Length, Slot) ->
    Encoder@1 = encode_bit(Encoder, prob_key(1, erlang:element(6, Encoder)), 1),
    Encoder@8 = case Slot of
        0 ->
            Encoder@2 = encode_bit(
                Encoder@1,
                prob_key(2, erlang:element(6, Encoder@1)),
                0
            ),
            encode_bit(
                Encoder@2,
                prob_key(5, (erlang:element(6, Encoder@2) * 16) + Pos_state),
                1
            );

        1 ->
            Encoder@3 = encode_bit(
                Encoder@1,
                prob_key(2, erlang:element(6, Encoder@1)),
                1
            ),
            encode_bit(Encoder@3, prob_key(3, erlang:element(6, Encoder@3)), 0);

        2 ->
            Encoder@4 = encode_bit(
                Encoder@1,
                prob_key(2, erlang:element(6, Encoder@1)),
                1
            ),
            Encoder@5 = encode_bit(
                Encoder@4,
                prob_key(3, erlang:element(6, Encoder@4)),
                1
            ),
            encode_bit(Encoder@5, prob_key(4, erlang:element(6, Encoder@5)), 0);

        _ ->
            Encoder@6 = encode_bit(
                Encoder@1,
                prob_key(2, erlang:element(6, Encoder@1)),
                1
            ),
            Encoder@7 = encode_bit(
                Encoder@6,
                prob_key(3, erlang:element(6, Encoder@6)),
                1
            ),
            encode_bit(Encoder@7, prob_key(4, erlang:element(6, Encoder@7)), 1)
    end,
    Encoder@9 = encode_lzma_length(
        Encoder@8,
        Pos_state,
        Length,
        15,
        16,
        17,
        18,
        19
    ),
    {New_rep0, New_rep1, New_rep2, New_rep3} = case Slot of
        0 ->
            {erlang:element(7, Encoder@9),
                erlang:element(8, Encoder@9),
                erlang:element(9, Encoder@9),
                erlang:element(10, Encoder@9)};

        1 ->
            {erlang:element(8, Encoder@9),
                erlang:element(7, Encoder@9),
                erlang:element(9, Encoder@9),
                erlang:element(10, Encoder@9)};

        2 ->
            {erlang:element(9, Encoder@9),
                erlang:element(7, Encoder@9),
                erlang:element(8, Encoder@9),
                erlang:element(10, Encoder@9)};

        _ ->
            {erlang:element(10, Encoder@9),
                erlang:element(7, Encoder@9),
                erlang:element(8, Encoder@9),
                erlang:element(9, Encoder@9)}
    end,
    {encoder,
        erlang:element(2, Encoder@9),
        erlang:element(3, Encoder@9),
        erlang:element(4, Encoder@9),
        erlang:element(5, Encoder@9),
        lzma_rep_next_state(erlang:element(6, Encoder@9)),
        New_rep0,
        New_rep1,
        New_rep2,
        New_rep3,
        erlang:element(11, Encoder@9),
        erlang:element(12, Encoder@9),
        erlang:element(13, Encoder@9),
        erlang:element(14, Encoder@9) + Length,
        erlang:element(15, Encoder@9)}.

-file("src/packkit/internal/lzma.gleam", 1762).
?DOC(false).
-spec encode_reverse_bit_tree_loop(
    encoder(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> encoder().
encode_reverse_bit_tree_loop(
    Encoder,
    Table,
    Base,
    Remaining,
    Context,
    Value,
    Emitted
) ->
    case Remaining of
        0 ->
            Encoder;

        _ ->
            Bit = erlang:'band'(erlang:'bsr'(Value, Emitted), 1),
            Encoder@1 = encode_bit(
                Encoder,
                prob_key(Table, Base + Context),
                Bit
            ),
            encode_reverse_bit_tree_loop(
                Encoder@1,
                Table,
                Base,
                Remaining - 1,
                (Context * 2) + Bit,
                Value,
                Emitted + 1
            )
    end.

-file("src/packkit/internal/lzma.gleam", 1752).
?DOC(false).
-spec encode_reverse_bit_tree(
    encoder(),
    integer(),
    integer(),
    integer(),
    integer()
) -> encoder().
encode_reverse_bit_tree(Encoder, Table, Base, Num_bits, Value) ->
    encode_reverse_bit_tree_loop(Encoder, Table, Base, Num_bits, 1, Value, 0).

-file("src/packkit/internal/lzma.gleam", 1809).
?DOC(false).
-spec encode_direct_bit(encoder(), integer()) -> encoder().
encode_direct_bit(Encoder, Bit) ->
    New_range = erlang:'bsr'(erlang:element(2, Encoder), 1),
    Encoder@1 = case Bit of
        0 ->
            {encoder,
                New_range,
                erlang:element(3, Encoder),
                erlang:element(4, Encoder),
                erlang:element(5, Encoder),
                erlang:element(6, Encoder),
                erlang:element(7, Encoder),
                erlang:element(8, Encoder),
                erlang:element(9, Encoder),
                erlang:element(10, Encoder),
                erlang:element(11, Encoder),
                erlang:element(12, Encoder),
                erlang:element(13, Encoder),
                erlang:element(14, Encoder),
                erlang:element(15, Encoder)};

        _ ->
            {encoder,
                New_range,
                erlang:element(3, Encoder) + New_range,
                erlang:element(4, Encoder),
                erlang:element(5, Encoder),
                erlang:element(6, Encoder),
                erlang:element(7, Encoder),
                erlang:element(8, Encoder),
                erlang:element(9, Encoder),
                erlang:element(10, Encoder),
                erlang:element(11, Encoder),
                erlang:element(12, Encoder),
                erlang:element(13, Encoder),
                erlang:element(14, Encoder),
                erlang:element(15, Encoder)}
    end,
    normalize_encoder(Encoder@1).

-file("src/packkit/internal/lzma.gleam", 1793).
?DOC(false).
-spec encode_direct_bits_loop(encoder(), integer(), integer()) -> encoder().
encode_direct_bits_loop(Encoder, Value, Remaining) ->
    case Remaining of
        0 ->
            Encoder;

        _ ->
            Bit_pos = Remaining - 1,
            Bit = erlang:'band'(erlang:'bsr'(Value, Bit_pos), 1),
            Encoder@1 = encode_direct_bit(Encoder, Bit),
            encode_direct_bits_loop(Encoder@1, Value, Remaining - 1)
    end.

-file("src/packkit/internal/lzma.gleam", 1789).
?DOC(false).
-spec encode_direct_bits(encoder(), integer(), integer()) -> encoder().
encode_direct_bits(Encoder, Value, Num_bits) ->
    encode_direct_bits_loop(Encoder, Value, Num_bits).

-file("src/packkit/internal/lzma.gleam", 1645).
?DOC(false).
-spec encode_lzma_distance(encoder(), integer(), integer()) -> encoder().
encode_lzma_distance(Encoder, Distance, Length) ->
    Len_state = case (Length - 2) < 4 of
        true ->
            Length - 2;

        false ->
            4 - 1
    end,
    Pos_slot = compute_pos_slot(Distance),
    Encoder@1 = encode_bit_tree(Encoder, 7, Len_state * 64, 6, Pos_slot),
    case Pos_slot < 4 of
        true ->
            Encoder@1;

        false ->
            Num_direct_bits = erlang:'bsr'(Pos_slot, 1) - 1,
            Base = erlang:'bsl'(
                erlang:'bor'(2, erlang:'band'(Pos_slot, 1)),
                Num_direct_bits
            ),
            case Pos_slot < 14 of
                true ->
                    Offset = Base - Pos_slot,
                    Extra = Distance - Base,
                    encode_reverse_bit_tree(
                        Encoder@1,
                        8,
                        Offset,
                        Num_direct_bits,
                        Extra
                    );

                false ->
                    High_bits = Num_direct_bits - 4,
                    Extra@1 = Distance - Base,
                    Top = erlang:'bsr'(Extra@1, 4),
                    Encoder@2 = encode_direct_bits(Encoder@1, Top, High_bits),
                    Align_value = erlang:'band'(Extra@1, mask_for(4)),
                    encode_reverse_bit_tree(Encoder@2, 9, 0, 4, Align_value)
            end
    end.

-file("src/packkit/internal/lzma.gleam", 1488).
?DOC(false).
-spec emit_lzma_new_distance_match(encoder(), integer(), integer(), integer()) -> encoder().
emit_lzma_new_distance_match(Encoder, Pos_state, Length, Distance_value) ->
    Encoder@1 = encode_bit(Encoder, prob_key(1, erlang:element(6, Encoder)), 0),
    Encoder@2 = encode_lzma_length(
        Encoder@1,
        Pos_state,
        Length,
        10,
        11,
        12,
        13,
        14
    ),
    Encoder@3 = encode_lzma_distance(Encoder@2, Distance_value, Length),
    {encoder,
        erlang:element(2, Encoder@3),
        erlang:element(3, Encoder@3),
        erlang:element(4, Encoder@3),
        erlang:element(5, Encoder@3),
        lzma_match_next_state(erlang:element(6, Encoder@3)),
        Distance_value,
        erlang:element(7, Encoder@3),
        erlang:element(8, Encoder@3),
        erlang:element(9, Encoder@3),
        erlang:element(11, Encoder@3),
        erlang:element(12, Encoder@3),
        erlang:element(13, Encoder@3),
        erlang:element(14, Encoder@3) + Length,
        erlang:element(15, Encoder@3)}.

-file("src/packkit/internal/lzma.gleam", 1454).
?DOC(false).
-spec emit_lzma_match(encoder(), integer(), integer(), integer()) -> encoder().
emit_lzma_match(Encoder, Pos_state, Length, Distance_value) ->
    Encoder@1 = encode_bit(
        Encoder,
        prob_key(0, (erlang:element(6, Encoder) * 16) + Pos_state),
        1
    ),
    case which_rep_slot(Encoder@1, Distance_value) of
        {some, Slot} ->
            emit_lzma_rep_match(Encoder@1, Pos_state, Length, Slot);

        none ->
            emit_lzma_new_distance_match(
                Encoder@1,
                Pos_state,
                Length,
                Distance_value
            )
    end.

-file("src/packkit/internal/lzma.gleam", 1275).
?DOC(false).
-spec update_hashes_in_range(
    bitstring(),
    gleam@dict:dict(integer(), integer()),
    integer(),
    integer(),
    integer()
) -> gleam@dict:dict(integer(), integer()).
update_hashes_in_range(Bytes, Hashes, From, To, Size) ->
    case (From >= To) orelse ((From + 3) > Size) of
        true ->
            Hashes;

        false ->
            Key = lzma_hash3(
                byte_at_input(Bytes, From),
                byte_at_input(Bytes, From + 1),
                byte_at_input(Bytes, From + 2)
            ),
            update_hashes_in_range(
                Bytes,
                gleam@dict:insert(Hashes, Key, From),
                From + 1,
                To,
                Size
            )
    end.

-file("src/packkit/internal/lzma.gleam", 1161).
?DOC(false).
-spec lz77_main_loop(
    bitstring(),
    integer(),
    integer(),
    encoder(),
    gleam@dict:dict(integer(), integer())
) -> encoder().
lz77_main_loop(Bytes, Pos, Size, Encoder, Hashes) ->
    case Pos >= Size of
        true ->
            Encoder;

        false ->
            case (Pos + 3) > Size of
                true ->
                    Byte = byte_at_input(Bytes, Pos),
                    Encoder@1 = emit_lzma_literal_or_short_rep(
                        Encoder,
                        Bytes,
                        Pos,
                        Byte
                    ),
                    lz77_main_loop(Bytes, Pos + 1, Size, Encoder@1, Hashes);

                false ->
                    B0 = byte_at_input(Bytes, Pos),
                    B1 = byte_at_input(Bytes, Pos + 1),
                    B2 = byte_at_input(Bytes, Pos + 2),
                    Key = lzma_hash3(B0, B1, B2),
                    case gleam_stdlib:map_get(Hashes, Key) of
                        {error, _} ->
                            Encoder@2 = emit_lzma_literal_or_short_rep(
                                Encoder,
                                Bytes,
                                Pos,
                                B0
                            ),
                            Hashes@1 = gleam@dict:insert(Hashes, Key, Pos),
                            lz77_main_loop(
                                Bytes,
                                Pos + 1,
                                Size,
                                Encoder@2,
                                Hashes@1
                            );

                        {ok, Prev} ->
                            Distance = Pos - Prev,
                            case (Distance =< 0) orelse (Distance > 16#8000) of
                                true ->
                                    Encoder@3 = emit_lzma_literal_or_short_rep(
                                        Encoder,
                                        Bytes,
                                        Pos,
                                        B0
                                    ),
                                    Hashes@2 = gleam@dict:insert(
                                        Hashes,
                                        Key,
                                        Pos
                                    ),
                                    lz77_main_loop(
                                        Bytes,
                                        Pos + 1,
                                        Size,
                                        Encoder@3,
                                        Hashes@2
                                    );

                                false ->
                                    Cap = case (Size - Pos) < 273 of
                                        true ->
                                            Size - Pos;

                                        false ->
                                            273
                                    end,
                                    M_len = lzma_match_length(
                                        Bytes,
                                        Prev,
                                        Pos,
                                        Cap,
                                        0
                                    ),
                                    case M_len >= 3 of
                                        true ->
                                            Pos_state = erlang:'band'(
                                                Pos,
                                                mask_for(
                                                    erlang:element(
                                                        4,
                                                        erlang:element(
                                                            11,
                                                            Encoder
                                                        )
                                                    )
                                                )
                                            ),
                                            Encoder@4 = emit_lzma_match(
                                                Encoder,
                                                Pos_state,
                                                M_len,
                                                Distance - 1
                                            ),
                                            Hashes@3 = update_hashes_in_range(
                                                Bytes,
                                                gleam@dict:insert(
                                                    Hashes,
                                                    Key,
                                                    Pos
                                                ),
                                                Pos + 1,
                                                Pos + M_len,
                                                Size
                                            ),
                                            lz77_main_loop(
                                                Bytes,
                                                Pos + M_len,
                                                Size,
                                                Encoder@4,
                                                Hashes@3
                                            );

                                        false ->
                                            Encoder@5 = emit_lzma_literal_or_short_rep(
                                                Encoder,
                                                Bytes,
                                                Pos,
                                                B0
                                            ),
                                            Hashes@4 = gleam@dict:insert(
                                                Hashes,
                                                Key,
                                                Pos
                                            ),
                                            lz77_main_loop(
                                                Bytes,
                                                Pos + 1,
                                                Size,
                                                Encoder@5,
                                                Hashes@4
                                            )
                                    end
                            end
                    end
            end
    end.

-file("src/packkit/internal/lzma.gleam", 1150).
?DOC(false).
-spec encode_with_lz77(bitstring(), properties()) -> bitstring().
encode_with_lz77(Bytes, Props) ->
    Size = erlang:byte_size(Bytes),
    Encoder = new_encoder(Props),
    Encoder@1 = lz77_main_loop(Bytes, 0, Size, Encoder, maps:new()),
    Encoder@2 = finish_encoder(Encoder@1),
    list_reverse_to_bit_array(erlang:element(15, Encoder@2), <<>>).