-module(gwr@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gwr/parser.gleam").
-export([parse_value_type/1, is_value_type/1, parse_global_type/1, parse_unsigned_leb128_integer/1, parse_locals_declaration/1, parse_vector/2, parse_limits/1, parse_memory/1, parse_function_type/1, parse_signed_leb128_integer/1, parse_block_type/1, parse_uninterpreted_leb128_integer/1, parse_le32_float/1, parse_le64_float/1, parse_name/1, parse_export/1, parse_instruction/1, parse_expression/1, parse_function_code/1, parse_code/1, do_parse_instructions_until/3, parse_instructions_until/2, parse_global/1, parse_section/1, parse_binary_module/1]).

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

-file("src/gwr/parser.gleam", 1007).
?DOC(
    " ***************************************************************************\n"
    " parser/types_parser\n"
    " ***************************************************************************\n"
).
-spec parse_value_type(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:value_type()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_value_type(Reader) ->
    gleam@result:'try'(case gwr@parser@byte_reader:read(Reader, 1) of
            {ok, {Reader@1, <<Value_type_id>>}} ->
                {ok, {Reader@1, Value_type_id}};

            {error, Reason} ->
                {error, Reason};

            _ ->
                _pipe = gwr@parser@parsing_error:new(),
                _pipe@1 = gwr@parser@parsing_error:add_message(
                    _pipe,
                    <<"unknown error reading value type id"/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@1)
        end, fun(_use0) ->
            {Reader@2, Value_type_id@1} = _use0,
            gleam@result:'try'(case Value_type_id@1 of
                    16#7f ->
                        {ok, {number, integer32}};

                    16#7e ->
                        {ok, {number, integer64}};

                    16#7d ->
                        {ok, {number, float32}};

                    16#7c ->
                        {ok, {number, float64}};

                    16#7b ->
                        {ok, {vector, vector128}};

                    16#70 ->
                        {ok, {reference, function_reference}};

                    16#6f ->
                        {ok, {reference, extern_reference}};

                    Unknown ->
                        _pipe@2 = gwr@parser@parsing_error:new(),
                        _pipe@3 = gwr@parser@parsing_error:add_message(
                            _pipe@2,
                            <<<<"unknown value type \""/utf8,
                                    (erlang:integer_to_binary(Unknown))/binary>>/binary,
                                "\""/utf8>>
                        ),
                        gwr@parser@parsing_error:to_error(_pipe@3)
                end, fun(Value_type) -> {ok, {Reader@2, Value_type}} end)
        end).

-file("src/gwr/parser.gleam", 1043).
-spec is_value_type(bitstring()) -> boolean().
is_value_type(Data) ->
    case Data of
        <<16#7f>> ->
            true;

        <<16#7e>> ->
            true;

        <<16#7d>> ->
            true;

        <<16#7c>> ->
            true;

        <<16#7b>> ->
            true;

        <<16#70>> ->
            true;

        <<16#6f>> ->
            true;

        _ ->
            false
    end.

-file("src/gwr/parser.gleam", 1130).
-spec parse_global_type(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:global_type()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_global_type(Reader) ->
    gleam@result:'try'(
        parse_value_type(Reader),
        fun(_use0) ->
            {Reader@1, Value_type} = _use0,
            gleam@result:'try'(case gwr@parser@byte_reader:read(Reader@1, 1) of
                    {ok, {Reader@2, <<16#00>>}} ->
                        {ok, {Reader@2, constant}};

                    {ok, {Reader@3, <<16#01>>}} ->
                        {ok, {Reader@3, variable}};

                    {ok, {_, <<Unkown>>}} ->
                        _pipe = gwr@parser@parsing_error:new(),
                        _pipe@1 = gwr@parser@parsing_error:add_message(
                            _pipe,
                            <<<<"unexpected mutability flag value \""/utf8,
                                    (erlang:integer_to_binary(Unkown))/binary>>/binary,
                                "\""/utf8>>
                        ),
                        gwr@parser@parsing_error:to_error(_pipe@1);

                    {error, Reason} ->
                        {error, Reason};

                    _ ->
                        _pipe@2 = gwr@parser@parsing_error:new(),
                        _pipe@3 = gwr@parser@parsing_error:add_message(
                            _pipe@2,
                            <<"unknown error reading mutability flag value"/utf8>>
                        ),
                        gwr@parser@parsing_error:to_error(_pipe@3)
                end, fun(_use0@1) ->
                    {Reader@4, Mutability} = _use0@1,
                    {ok, {Reader@4, {global_type, Mutability, Value_type}}}
                end)
        end
    ).

-file("src/gwr/parser.gleam", 1162).
?DOC(
    " ***************************************************************************\n"
    " parser/value_parser\n"
    " ***************************************************************************\n"
).
-spec parse_unsigned_leb128_integer(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), integer()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_unsigned_leb128_integer(Reader) ->
    gleam@result:'try'(
        gwr@parser@byte_reader:get_remaining(Reader),
        fun(Remaining_data) ->
            gleam@result:'try'(
                begin
                    _pipe = gleb128:decode_unsigned(Remaining_data),
                    gleam@result:replace_error(
                        _pipe,
                        begin
                            _pipe@1 = gwr@parser@parsing_error:new(),
                            gwr@parser@parsing_error:add_message(
                                _pipe@1,
                                <<"Couldn't decode LEB128 data"/utf8>>
                            )
                        end
                    )
                end,
                fun(_use0) ->
                    {Result, Bytes_read} = _use0,
                    Reader@1 = gwr@parser@byte_reader:advance(
                        Reader,
                        Bytes_read
                    ),
                    {ok, {Reader@1, Result}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 19).
?DOC(
    " ***************************************************************************\n"
    " parser/binary_parser\n"
    " ***************************************************************************\n"
).
-spec parse_locals_declaration(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:locals_declaration()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_locals_declaration(Reader) ->
    gleam@result:'try'(
        parse_unsigned_leb128_integer(Reader),
        fun(_use0) ->
            {Reader@1, Count} = _use0,
            gleam@result:'try'(
                parse_value_type(Reader@1),
                fun(_use0@1) ->
                    {Reader@2, Value_type} = _use0@1,
                    {ok, {Reader@2, {locals_declaration, Count, Value_type}}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 464).
?DOC(
    " ***************************************************************************\n"
    " parser/convention_parser\n"
    " ***************************************************************************\n"
).
-spec parse_vector(
    gwr@parser@byte_reader:byte_reader(),
    fun((gwr@parser@byte_reader:byte_reader()) -> {ok,
            {gwr@parser@byte_reader:byte_reader(), JKH}} |
        {error, gwr@parser@parsing_error:parsing_error()})
) -> {ok, {gwr@parser@byte_reader:byte_reader(), list(JKH)}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_vector(Reader, Parse_element) ->
    gleam@result:'try'(
        parse_unsigned_leb128_integer(Reader),
        fun(_use0) ->
            {Reader@1, Vector_length} = _use0,
            gleam@bool:guard(
                Vector_length =:= 0,
                {ok, {Reader@1, []}},
                fun() ->
                    gleam@result:'try'(
                        gleam@yielder:try_fold(
                            gleam@yielder:range(0, Vector_length - 1),
                            {Reader@1, []},
                            fun(State, _) ->
                                {Reader@2, Objects_list} = State,
                                gleam@bool:guard(
                                    not gwr@parser@byte_reader:can_read(
                                        Reader@2
                                    ),
                                    {ok, State},
                                    fun() ->
                                        gleam@result:'try'(
                                            Parse_element(Reader@2),
                                            fun(_use0@1) ->
                                                {Reader@3, Object} = _use0@1,
                                                {ok,
                                                    {Reader@3,
                                                        lists:append(
                                                            Objects_list,
                                                            [Object]
                                                        )}}
                                            end
                                        )
                                    end
                                )
                            end
                        ),
                        fun(_use0@2) ->
                            {Reader@4, Objects_list@1} = _use0@2,
                            {ok, {Reader@4, Objects_list@1}}
                        end
                    )
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 1051).
-spec parse_limits(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:limits()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_limits(Reader) ->
    gleam@result:'try'(case gwr@parser@byte_reader:read(Reader, 1) of
            {ok, {Reader@1, <<16#00>>}} ->
                {ok, {Reader@1, false}};

            {ok, {Reader@2, <<16#01>>}} ->
                {ok, {Reader@2, true}};

            {ok, {_, <<Unknown>>}} ->
                _pipe = gwr@parser@parsing_error:new(),
                _pipe@1 = gwr@parser@parsing_error:add_message(
                    _pipe,
                    <<<<"unexpected flag value \""/utf8,
                            (erlang:integer_to_binary(Unknown))/binary>>/binary,
                        "\""/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@1);

            {error, Reason} ->
                {error, Reason};

            _ ->
                _pipe@2 = gwr@parser@parsing_error:new(),
                _pipe@3 = gwr@parser@parsing_error:add_message(
                    _pipe@2,
                    <<"unknown error reading flag value"/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@3)
        end, fun(_use0) ->
            {Reader@3, Has_max} = _use0,
            gleam@result:'try'(
                parse_unsigned_leb128_integer(Reader@3),
                fun(_use0@1) ->
                    {Reader@4, Min} = _use0@1,
                    gleam@result:'try'(case Has_max of
                            true ->
                                gleam@result:'try'(
                                    parse_unsigned_leb128_integer(Reader@4),
                                    fun(_use0@2) ->
                                        {Reader@5, Max} = _use0@2,
                                        {ok, {Reader@5, {some, Max}}}
                                    end
                                );

                            false ->
                                {ok, {Reader@4, none}}
                        end, fun(_use0@3) ->
                            {Reader@6, Max@1} = _use0@3,
                            {ok, {Reader@6, {limits, Min, Max@1}}}
                        end)
                end
            )
        end).

-file("src/gwr/parser.gleam", 997).
-spec parse_memory(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:memory()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_memory(Reader) ->
    gleam@result:'try'(
        parse_limits(Reader),
        fun(_use0) ->
            {Reader@1, Limits} = _use0,
            {ok, {Reader@1, {memory, Limits}}}
        end
    ).

-file("src/gwr/parser.gleam", 1091).
?DOC(
    " Decodes a bit array into a FunctionType. The FunctionType bit array begins with 0x60 byte id\n"
    " and follows with 2 vectors, each containing an arbitrary amount of 1-byte ValueType(s).\n"
    " The first vector represents the list of parameter types of the function, while the second vector represents\n"
    " the list of result types returned by the function.\n"
).
-spec parse_function_type(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:function_type()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_function_type(Reader) ->
    gleam@result:'try'(case gwr@parser@byte_reader:read(Reader, 1) of
            {ok, {Reader@1, <<16#60>>}} ->
                gleam@result:'try'(
                    parse_vector(Reader@1, fun parse_value_type/1),
                    fun(_use0) ->
                        {Reader@2, Parameters_vec} = _use0,
                        gleam@result:'try'(
                            parse_vector(Reader@2, fun parse_value_type/1),
                            fun(_use0@1) ->
                                {Reader@3, Results_vec} = _use0@1,
                                {ok,
                                    {Reader@3,
                                        {function_type,
                                            Parameters_vec,
                                            Results_vec}}}
                            end
                        )
                    end
                );

            {ok, {_, <<Unkown>>}} ->
                _pipe = gwr@parser@parsing_error:new(),
                _pipe@1 = gwr@parser@parsing_error:add_message(
                    _pipe,
                    <<<<"unexpected function type id \""/utf8,
                            (erlang:integer_to_binary(Unkown))/binary>>/binary,
                        "\""/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@1);

            {error, Reason} ->
                {error, Reason};

            _ ->
                _pipe@2 = gwr@parser@parsing_error:new(),
                _pipe@3 = gwr@parser@parsing_error:add_message(
                    _pipe@2,
                    <<"unknown error reading function type id"/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@3)
        end, fun(_use0@2) ->
            {Reader@4, Function_type} = _use0@2,
            {ok, {Reader@4, Function_type}}
        end).

-file("src/gwr/parser.gleam", 1177).
-spec parse_signed_leb128_integer(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), integer()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_signed_leb128_integer(Reader) ->
    gleam@result:'try'(
        gwr@parser@byte_reader:get_remaining(Reader),
        fun(Remaining_data) ->
            gleam@result:'try'(
                begin
                    _pipe = gleb128:decode_signed(Remaining_data),
                    gleam@result:replace_error(
                        _pipe,
                        begin
                            _pipe@1 = gwr@parser@parsing_error:new(),
                            gwr@parser@parsing_error:add_message(
                                _pipe@1,
                                <<"Couldn't decode LEB128 data"/utf8>>
                            )
                        end
                    )
                end,
                fun(_use0) ->
                    {Result, Bytes_read} = _use0,
                    Reader@1 = gwr@parser@byte_reader:advance(
                        Reader,
                        Bytes_read
                    ),
                    {ok, {Reader@1, Result}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 884).
-spec parse_block_type(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:block_type()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_block_type(Reader) ->
    gleam@result:'try'(
        gwr@parser@byte_reader:read(Reader, 1),
        fun(_use0) ->
            {_, First_byte} = _use0,
            case is_value_type(First_byte) of
                true ->
                    gleam@result:'try'(
                        parse_value_type(Reader),
                        fun(_use0@1) ->
                            {Reader@1, Value_type} = _use0@1,
                            {ok,
                                {Reader@1,
                                    {value_type_block, {some, Value_type}}}}
                        end
                    );

                false ->
                    case First_byte of
                        <<16#40>> ->
                            {ok,
                                {gwr@parser@byte_reader:advance(Reader, 1),
                                    {value_type_block, none}}};

                        _ ->
                            gleam@result:'try'(
                                parse_signed_leb128_integer(Reader),
                                fun(_use0@2) ->
                                    {Reader@2, Index} = _use0@2,
                                    {ok, {Reader@2, {type_index_block, Index}}}
                                end
                            )
                    end
            end
        end
    ).

-file("src/gwr/parser.gleam", 1192).
-spec parse_uninterpreted_leb128_integer(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), integer()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_uninterpreted_leb128_integer(Reader) ->
    parse_signed_leb128_integer(Reader).

-file("src/gwr/parser.gleam", 1198).
-spec parse_le32_float(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), ieee_float:i_e_e_e_float()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_le32_float(Reader) ->
    gleam@result:'try'(
        gwr@parser@byte_reader:read(Reader, 4),
        fun(_use0) ->
            {Reader@1, Data} = _use0,
            {ok, {Reader@1, ieee_float:from_bytes_32_le(Data)}}
        end
    ).

-file("src/gwr/parser.gleam", 1208).
-spec parse_le64_float(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), ieee_float:i_e_e_e_float()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_le64_float(Reader) ->
    gleam@result:'try'(
        gwr@parser@byte_reader:read(Reader, 8),
        fun(_use0) ->
            {Reader@1, Data} = _use0,
            {ok, {Reader@1, ieee_float:from_bytes_64_le(Data)}}
        end
    ).

-file("src/gwr/parser.gleam", 1218).
-spec parse_name(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), binary()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_name(Reader) ->
    gleam@result:'try'(
        parse_unsigned_leb128_integer(Reader),
        fun(_use0) ->
            {Reader@1, Name_length} = _use0,
            gleam@result:'try'(
                gwr@parser@byte_reader:get_remaining(Reader@1),
                fun(Remaining_data) ->
                    Remaining_data_length = erlang:byte_size(Remaining_data),
                    gleam@bool:guard(
                        Name_length > Remaining_data_length,
                        begin
                            _pipe = gwr@parser@parsing_error:new(),
                            _pipe@1 = gwr@parser@parsing_error:add_message(
                                _pipe,
                                <<<<<<<<"Unexpected end of the name's data. Expected = "/utf8,
                                                (erlang:integer_to_binary(
                                                    Name_length
                                                ))/binary>>/binary,
                                            " bytes but got = "/utf8>>/binary,
                                        (erlang:integer_to_binary(
                                            Remaining_data_length
                                        ))/binary>>/binary,
                                    " bytes"/utf8>>
                            ),
                            gwr@parser@parsing_error:to_error(_pipe@1)
                        end,
                        fun() ->
                            gleam@result:'try'(
                                gwr@parser@byte_reader:read(
                                    Reader@1,
                                    Name_length
                                ),
                                fun(_use0@1) ->
                                    {Reader@2, Name_data} = _use0@1,
                                    gleam@result:'try'(
                                        begin
                                            _pipe@2 = gleam@bit_array:to_string(
                                                Name_data
                                            ),
                                            gleam@result:replace_error(
                                                _pipe@2,
                                                begin
                                                    _pipe@3 = gwr@parser@parsing_error:new(
                                                        
                                                    ),
                                                    gwr@parser@parsing_error:add_message(
                                                        _pipe@3,
                                                        <<"Invalid UTF-8 name data"/utf8>>
                                                    )
                                                end
                                            )
                                        end,
                                        fun(Result) ->
                                            {ok, {Reader@2, Result}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 929).
-spec parse_export(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:export()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_export(Reader) ->
    gleam@result:'try'(
        parse_name(Reader),
        fun(_use0) ->
            {Reader@1, Export_name} = _use0,
            gleam@result:'try'(case gwr@parser@byte_reader:read(Reader@1, 1) of
                    {ok, {Reader@2, <<Id>>}} when Id =:= 16#00 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@1) ->
                                {Reader@3, Index} = _use0@1,
                                {ok,
                                    {Reader@3,
                                        {export,
                                            Export_name,
                                            {function_export, Index}}}}
                            end
                        );

                    {ok, {Reader@4, <<Id@1>>}} when Id@1 =:= 16#01 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@4),
                            fun(_use0@2) ->
                                {Reader@5, Index@1} = _use0@2,
                                {ok,
                                    {Reader@5,
                                        {export,
                                            Export_name,
                                            {table_export, Index@1}}}}
                            end
                        );

                    {ok, {Reader@6, <<Id@2>>}} when Id@2 =:= 16#02 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@6),
                            fun(_use0@3) ->
                                {Reader@7, Index@2} = _use0@3,
                                {ok,
                                    {Reader@7,
                                        {export,
                                            Export_name,
                                            {memory_export, Index@2}}}}
                            end
                        );

                    {ok, {Reader@8, <<Id@3>>}} when Id@3 =:= 16#03 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@8),
                            fun(_use0@4) ->
                                {Reader@9, Index@3} = _use0@4,
                                {ok,
                                    {Reader@9,
                                        {export,
                                            Export_name,
                                            {global_export, Index@3}}}}
                            end
                        );

                    {ok, {_, <<Unknown>>}} ->
                        _pipe = gwr@parser@parsing_error:new(),
                        _pipe@1 = gwr@parser@parsing_error:add_message(
                            _pipe,
                            <<<<"unexpected export id \""/utf8,
                                    (erlang:integer_to_binary(Unknown))/binary>>/binary,
                                "\""/utf8>>
                        ),
                        gwr@parser@parsing_error:to_error(_pipe@1);

                    {error, Reason} ->
                        {error, Reason};

                    _ ->
                        _pipe@2 = gwr@parser@parsing_error:new(),
                        _pipe@3 = gwr@parser@parsing_error:add_message(
                            _pipe@2,
                            <<"unknown error reading export id"/utf8>>
                        ),
                        gwr@parser@parsing_error:to_error(_pipe@3)
                end, fun(_use0@5) ->
                    {Reader@10, Export} = _use0@5,
                    {ok, {Reader@10, Export}}
                end)
        end
    ).

-file("src/gwr/parser.gleam", 501).
?DOC(
    " ***************************************************************************\n"
    " parser/instruction_parser\n"
    " ***************************************************************************\n"
).
-spec parse_instruction(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:instruction()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_instruction(Reader) ->
    gleam@result:'try'(case gwr@parser@byte_reader:read(Reader, 1) of
            {ok, {Reader@1, <<Opcode>>}} ->
                {ok, {Reader@1, Opcode}};

            {error, Reason} ->
                {error, Reason};

            _ ->
                _pipe = gwr@parser@parsing_error:new(),
                _pipe@1 = gwr@parser@parsing_error:add_message(
                    _pipe,
                    <<"unknown error reading opcode"/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@1)
        end, fun(_use0) ->
            {Reader@2, Opcode@1} = _use0,
            gleam@result:'try'(case Opcode@1 of
                    16#00 ->
                        {ok, {Reader@2, unreachable}};

                    16#01 ->
                        {ok, {Reader@2, no_op}};

                    16#02 ->
                        gleam@result:'try'(
                            parse_block_type(Reader@2),
                            fun(_use0@1) ->
                                {Reader@3, Block_type} = _use0@1,
                                gleam@result:'try'(
                                    parse_expression(Reader@3),
                                    fun(_use0@2) ->
                                        {Reader@4, Expression} = _use0@2,
                                        {ok,
                                            {Reader@4,
                                                {block, Block_type, Expression}}}
                                    end
                                )
                            end
                        );

                    16#03 ->
                        gleam@result:'try'(
                            parse_block_type(Reader@2),
                            fun(_use0@3) ->
                                {Reader@5, Block_type@1} = _use0@3,
                                gleam@result:'try'(
                                    parse_expression(Reader@5),
                                    fun(_use0@4) ->
                                        {Reader@6, Expression@1} = _use0@4,
                                        {ok,
                                            {Reader@6,
                                                {loop,
                                                    Block_type@1,
                                                    Expression@1}}}
                                    end
                                )
                            end
                        );

                    16#04 ->
                        gleam@result:'try'(
                            parse_block_type(Reader@2),
                            fun(_use0@5) ->
                                {Reader@7, Block_type@2} = _use0@5,
                                gleam@result:'try'(
                                    parse_instructions_until(
                                        Reader@7,
                                        fun(Inst) -> case Inst of
                                                'end' ->
                                                    true;

                                                {'else', _} ->
                                                    true;

                                                _ ->
                                                    false
                                            end end
                                    ),
                                    fun(_use0@6) ->
                                        {Reader@8, Body} = _use0@6,
                                        case gleam@list:last(Body) of
                                            {ok, 'end'} ->
                                                {ok,
                                                    {Reader@8,
                                                        {'if',
                                                            Block_type@2,
                                                            Body,
                                                            none}}};

                                            {ok, {'else', _} = Els} ->
                                                {ok,
                                                    {Reader@8,
                                                        {'if',
                                                            Block_type@2,
                                                            gleam@list:take(
                                                                Body,
                                                                erlang:length(
                                                                    Body
                                                                )
                                                                - 1
                                                            ),
                                                            {some, Els}}}};

                                            _ ->
                                                _pipe@2 = gwr@parser@parsing_error:new(
                                                    
                                                ),
                                                _pipe@3 = gwr@parser@parsing_error:add_message(
                                                    _pipe@2,
                                                    <<"expected the If instruction's block to end either with an End instruction or an Else instruction"/utf8>>
                                                ),
                                                gwr@parser@parsing_error:to_error(
                                                    _pipe@3
                                                )
                                        end
                                    end
                                )
                            end
                        );

                    16#05 ->
                        gleam@result:'try'(
                            parse_expression(Reader@2),
                            fun(_use0@7) ->
                                {Reader@9, Expression@2} = _use0@7,
                                {ok, {Reader@9, {'else', Expression@2}}}
                            end
                        );

                    16#c ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@8) ->
                                {Reader@10, Label_index} = _use0@8,
                                {ok, {Reader@10, {br, Label_index}}}
                            end
                        );

                    16#d ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@9) ->
                                {Reader@11, Label_index@1} = _use0@9,
                                {ok, {Reader@11, {br_if, Label_index@1}}}
                            end
                        );

                    16#f ->
                        {ok, {Reader@2, return}};

                    16#10 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@10) ->
                                {Reader@12, Function_index} = _use0@10,
                                {ok, {Reader@12, {call, Function_index}}}
                            end
                        );

                    16#20 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@11) ->
                                {Reader@13, Local_index} = _use0@11,
                                {ok, {Reader@13, {local_get, Local_index}}}
                            end
                        );

                    16#21 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@12) ->
                                {Reader@14, Local_index@1} = _use0@12,
                                {ok, {Reader@14, {local_set, Local_index@1}}}
                            end
                        );

                    16#22 ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@13) ->
                                {Reader@15, Local_index@2} = _use0@13,
                                {ok, {Reader@15, {local_tee, Local_index@2}}}
                            end
                        );

                    16#41 ->
                        gleam@result:'try'(
                            parse_uninterpreted_leb128_integer(Reader@2),
                            fun(_use0@14) ->
                                {Reader@16, Value} = _use0@14,
                                {ok, {Reader@16, {i32_const, Value}}}
                            end
                        );

                    16#42 ->
                        gleam@result:'try'(
                            parse_uninterpreted_leb128_integer(Reader@2),
                            fun(_use0@15) ->
                                {Reader@17, Value@1} = _use0@15,
                                {ok, {Reader@17, {i64_const, Value@1}}}
                            end
                        );

                    16#43 ->
                        gleam@result:'try'(
                            parse_le32_float(Reader@2),
                            fun(_use0@16) ->
                                {Reader@18, Value@2} = _use0@16,
                                {ok, {Reader@18, {f32_const, Value@2}}}
                            end
                        );

                    16#44 ->
                        gleam@result:'try'(
                            parse_le64_float(Reader@2),
                            fun(_use0@17) ->
                                {Reader@19, Value@3} = _use0@17,
                                {ok, {Reader@19, {f64_const, Value@3}}}
                            end
                        );

                    16#45 ->
                        {ok, {Reader@2, i32_eqz}};

                    16#46 ->
                        {ok, {Reader@2, i32_eq}};

                    16#47 ->
                        {ok, {Reader@2, i32_ne}};

                    16#48 ->
                        {ok, {Reader@2, i32_lt_s}};

                    16#49 ->
                        {ok, {Reader@2, i32_lt_u}};

                    16#4a ->
                        {ok, {Reader@2, i32_gt_s}};

                    16#4b ->
                        {ok, {Reader@2, i32_gt_u}};

                    16#4c ->
                        {ok, {Reader@2, i32_le_s}};

                    16#4d ->
                        {ok, {Reader@2, i32_le_u}};

                    16#4e ->
                        {ok, {Reader@2, i32_ge_s}};

                    16#4f ->
                        {ok, {Reader@2, i32_ge_u}};

                    16#50 ->
                        {ok, {Reader@2, i64_eqz}};

                    16#51 ->
                        {ok, {Reader@2, i64_eq}};

                    16#52 ->
                        {ok, {Reader@2, i64_ne}};

                    16#53 ->
                        {ok, {Reader@2, i64_lt_s}};

                    16#54 ->
                        {ok, {Reader@2, i64_lt_u}};

                    16#55 ->
                        {ok, {Reader@2, i64_gt_s}};

                    16#56 ->
                        {ok, {Reader@2, i64_gt_u}};

                    16#57 ->
                        {ok, {Reader@2, i64_le_s}};

                    16#58 ->
                        {ok, {Reader@2, i64_le_u}};

                    16#59 ->
                        {ok, {Reader@2, i64_ge_s}};

                    16#5a ->
                        {ok, {Reader@2, i64_ge_u}};

                    16#5b ->
                        {ok, {Reader@2, f32_eq}};

                    16#5c ->
                        {ok, {Reader@2, f32_ne}};

                    16#5d ->
                        {ok, {Reader@2, f32_lt}};

                    16#5e ->
                        {ok, {Reader@2, f32_gt}};

                    16#5f ->
                        {ok, {Reader@2, f32_le}};

                    16#60 ->
                        {ok, {Reader@2, f32_ge}};

                    16#61 ->
                        {ok, {Reader@2, f64_eq}};

                    16#62 ->
                        {ok, {Reader@2, f64_ne}};

                    16#63 ->
                        {ok, {Reader@2, f64_lt}};

                    16#64 ->
                        {ok, {Reader@2, f64_gt}};

                    16#65 ->
                        {ok, {Reader@2, f64_le}};

                    16#66 ->
                        {ok, {Reader@2, f64_ge}};

                    16#67 ->
                        {ok, {Reader@2, i32_clz}};

                    16#68 ->
                        {ok, {Reader@2, i32_ctz}};

                    16#69 ->
                        {ok, {Reader@2, i32_popcnt}};

                    16#6a ->
                        {ok, {Reader@2, i32_add}};

                    16#6b ->
                        {ok, {Reader@2, i32_sub}};

                    16#6c ->
                        {ok, {Reader@2, i32_mul}};

                    16#6d ->
                        {ok, {Reader@2, i32_div_s}};

                    16#6e ->
                        {ok, {Reader@2, i32_div_u}};

                    16#6f ->
                        {ok, {Reader@2, i32_rem_s}};

                    16#70 ->
                        {ok, {Reader@2, i32_rem_u}};

                    16#71 ->
                        {ok, {Reader@2, i32_and}};

                    16#72 ->
                        {ok, {Reader@2, i32_or}};

                    16#73 ->
                        {ok, {Reader@2, i32_xor}};

                    16#74 ->
                        {ok, {Reader@2, i32_shl}};

                    16#75 ->
                        {ok, {Reader@2, i32_shr_s}};

                    16#76 ->
                        {ok, {Reader@2, i32_shr_u}};

                    16#77 ->
                        {ok, {Reader@2, i32_rotl}};

                    16#78 ->
                        {ok, {Reader@2, i32_rotr}};

                    16#79 ->
                        {ok, {Reader@2, i64_clz}};

                    16#7a ->
                        {ok, {Reader@2, i64_ctz}};

                    16#7b ->
                        {ok, {Reader@2, i64_popcnt}};

                    16#7c ->
                        {ok, {Reader@2, i64_add}};

                    16#7d ->
                        {ok, {Reader@2, i64_sub}};

                    16#7e ->
                        {ok, {Reader@2, i64_mul}};

                    16#7f ->
                        {ok, {Reader@2, i64_div_s}};

                    16#80 ->
                        {ok, {Reader@2, i64_div_u}};

                    16#81 ->
                        {ok, {Reader@2, i64_rem_s}};

                    16#82 ->
                        {ok, {Reader@2, i64_rem_u}};

                    16#83 ->
                        {ok, {Reader@2, i64_and}};

                    16#84 ->
                        {ok, {Reader@2, i64_or}};

                    16#85 ->
                        {ok, {Reader@2, i64_xor}};

                    16#86 ->
                        {ok, {Reader@2, i64_shl}};

                    16#87 ->
                        {ok, {Reader@2, i64_shr_s}};

                    16#88 ->
                        {ok, {Reader@2, i64_shr_u}};

                    16#89 ->
                        {ok, {Reader@2, i64_rotl}};

                    16#8a ->
                        {ok, {Reader@2, i64_rotr}};

                    16#8b ->
                        {ok, {Reader@2, f32_abs}};

                    16#8c ->
                        {ok, {Reader@2, f32_neg}};

                    16#8d ->
                        {ok, {Reader@2, f32_ceil}};

                    16#8e ->
                        {ok, {Reader@2, f32_floor}};

                    16#8f ->
                        {ok, {Reader@2, f32_trunc}};

                    16#90 ->
                        {ok, {Reader@2, f32_nearest}};

                    16#91 ->
                        {ok, {Reader@2, f32_sqrt}};

                    16#92 ->
                        {ok, {Reader@2, f32_add}};

                    16#93 ->
                        {ok, {Reader@2, f32_sub}};

                    16#94 ->
                        {ok, {Reader@2, f32_mul}};

                    16#95 ->
                        {ok, {Reader@2, f32_div}};

                    16#96 ->
                        {ok, {Reader@2, f32_min}};

                    16#97 ->
                        {ok, {Reader@2, f32_max}};

                    16#98 ->
                        {ok, {Reader@2, f32_copysign}};

                    16#99 ->
                        {ok, {Reader@2, f64_abs}};

                    16#9a ->
                        {ok, {Reader@2, f64_neg}};

                    16#9b ->
                        {ok, {Reader@2, f64_ceil}};

                    16#9c ->
                        {ok, {Reader@2, f64_floor}};

                    16#9d ->
                        {ok, {Reader@2, f64_trunc}};

                    16#9e ->
                        {ok, {Reader@2, f64_nearest}};

                    16#9f ->
                        {ok, {Reader@2, f64_sqrt}};

                    16#a0 ->
                        {ok, {Reader@2, f64_add}};

                    16#a1 ->
                        {ok, {Reader@2, f64_sub}};

                    16#a2 ->
                        {ok, {Reader@2, f64_mul}};

                    16#a3 ->
                        {ok, {Reader@2, f64_div}};

                    16#a4 ->
                        {ok, {Reader@2, f64_min}};

                    16#a5 ->
                        {ok, {Reader@2, f64_max}};

                    16#a6 ->
                        {ok, {Reader@2, f64_copysign}};

                    16#a7 ->
                        {ok, {Reader@2, i32_wrap_i64}};

                    16#a8 ->
                        {ok, {Reader@2, i32_trunc_f32_s}};

                    16#a9 ->
                        {ok, {Reader@2, i32_trunc_f32_u}};

                    16#aa ->
                        {ok, {Reader@2, i32_trunc_f64_s}};

                    16#ab ->
                        {ok, {Reader@2, i32_trunc_f64_u}};

                    16#ac ->
                        {ok, {Reader@2, i64_extend_i32_s}};

                    16#ad ->
                        {ok, {Reader@2, i64_extend_i32_u}};

                    16#ae ->
                        {ok, {Reader@2, i64_trunc_f32_s}};

                    16#af ->
                        {ok, {Reader@2, i64_trunc_f32_u}};

                    16#b0 ->
                        {ok, {Reader@2, i64_trunc_f64_s}};

                    16#b1 ->
                        {ok, {Reader@2, i64_trunc_f64_u}};

                    16#b2 ->
                        {ok, {Reader@2, f32_convert_i32_s}};

                    16#b3 ->
                        {ok, {Reader@2, f32_convert_i32_u}};

                    16#b4 ->
                        {ok, {Reader@2, f32_convert_i64_s}};

                    16#b5 ->
                        {ok, {Reader@2, f32_convert_i64_u}};

                    16#b6 ->
                        {ok, {Reader@2, f32_demote_f64}};

                    16#b7 ->
                        {ok, {Reader@2, f64_convert_i32_s}};

                    16#b8 ->
                        {ok, {Reader@2, f64_convert_i32_u}};

                    16#b9 ->
                        {ok, {Reader@2, f64_convert_i64_s}};

                    16#ba ->
                        {ok, {Reader@2, f64_convert_i64_u}};

                    16#bb ->
                        {ok, {Reader@2, f64_promote_f32}};

                    16#bc ->
                        {ok, {Reader@2, i32_reinterpret_f32}};

                    16#bd ->
                        {ok, {Reader@2, i64_reinterpret_f64}};

                    16#be ->
                        {ok, {Reader@2, f32_reinterpret_i32}};

                    16#bf ->
                        {ok, {Reader@2, f64_reinterpret_i64}};

                    16#c0 ->
                        {ok, {Reader@2, i32_extend8_s}};

                    16#c1 ->
                        {ok, {Reader@2, i32_extend16_s}};

                    16#c2 ->
                        {ok, {Reader@2, i64_extend8_s}};

                    16#c3 ->
                        {ok, {Reader@2, i64_extend16_s}};

                    16#c4 ->
                        {ok, {Reader@2, i64_extend32_s}};

                    16#fc ->
                        gleam@result:'try'(
                            parse_unsigned_leb128_integer(Reader@2),
                            fun(_use0@18) ->
                                {Reader@20, Actual_opcode} = _use0@18,
                                case Actual_opcode of
                                    16#00 ->
                                        {ok, {Reader@20, i32_trunc_sat_f32_s}};

                                    16#01 ->
                                        {ok, {Reader@20, i32_trunc_sat_f32_u}};

                                    16#02 ->
                                        {ok, {Reader@20, i32_trunc_sat_f64_s}};

                                    16#03 ->
                                        {ok, {Reader@20, i32_trunc_sat_f64_u}};

                                    16#04 ->
                                        {ok, {Reader@20, i64_trunc_sat_f32_s}};

                                    16#05 ->
                                        {ok, {Reader@20, i64_trunc_sat_f32_u}};

                                    16#06 ->
                                        {ok, {Reader@20, i64_trunc_sat_f64_s}};

                                    16#07 ->
                                        {ok, {Reader@20, i64_trunc_sat_f64_u}};

                                    Unknown ->
                                        _pipe@4 = gwr@parser@parsing_error:new(),
                                        _pipe@5 = gwr@parser@parsing_error:add_message(
                                            _pipe@4,
                                            <<<<"unknown saturating truncation instruction opcode \"0x"/utf8,
                                                    (gleam@int:to_base16(
                                                        Unknown
                                                    ))/binary>>/binary,
                                                "\""/utf8>>
                                        ),
                                        gwr@parser@parsing_error:to_error(
                                            _pipe@5
                                        )
                                end
                            end
                        );

                    16#0b ->
                        {ok, {Reader@2, 'end'}};

                    Unknown@1 ->
                        _pipe@6 = gwr@parser@parsing_error:new(),
                        _pipe@7 = gwr@parser@parsing_error:add_message(
                            _pipe@6,
                            <<<<"unknown opcode \"0x"/utf8,
                                    (gleam@int:to_base16(Unknown@1))/binary>>/binary,
                                "\""/utf8>>
                        ),
                        gwr@parser@parsing_error:to_error(_pipe@7)
                end, fun(_use0@19) ->
                    {Reader@21, Instruction} = _use0@19,
                    {ok, {Reader@21, Instruction}}
                end)
        end).

-file("src/gwr/parser.gleam", 801).
-spec parse_expression(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), list(gwr@spec:instruction())}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_expression(Reader) ->
    gleam@result:'try'(
        gwr@parser@byte_reader:get_remaining(Reader),
        fun(Data) ->
            Data_length = erlang:byte_size(Data),
            gleam@result:'try'(
                gleam@yielder:fold(
                    gleam@yielder:range(1, Data_length),
                    {ok, {Reader, []}},
                    fun(State, _) ->
                        gleam@result:'try'(
                            State,
                            fun(_use0) ->
                                {Reader@1, Current_expression} = _use0,
                                gleam@bool:guard(
                                    gleam@list:last(Current_expression) =:= {ok,
                                        'end'},
                                    State,
                                    fun() ->
                                        gleam@bool:guard(
                                            not gwr@parser@byte_reader:can_read(
                                                Reader@1
                                            )
                                            andalso (gleam@list:last(
                                                Current_expression
                                            )
                                            /= {ok, 'end'}),
                                            begin
                                                _pipe = gwr@parser@parsing_error:new(
                                                    
                                                ),
                                                _pipe@1 = gwr@parser@parsing_error:add_message(
                                                    _pipe,
                                                    <<"an expression must terminate with a End instruction"/utf8>>
                                                ),
                                                gwr@parser@parsing_error:to_error(
                                                    _pipe@1
                                                )
                                            end,
                                            fun() ->
                                                gleam@result:'try'(
                                                    parse_instruction(Reader@1),
                                                    fun(_use0@1) ->
                                                        {Reader@2, Instruction} = _use0@1,
                                                        {ok,
                                                            {Reader@2,
                                                                lists:append(
                                                                    Current_expression,
                                                                    [Instruction]
                                                                )}}
                                                    end
                                                )
                                            end
                                        )
                                    end
                                )
                            end
                        )
                    end
                ),
                fun(_use0@2) ->
                    {Reader@3, Expression} = _use0@2,
                    {ok, {Reader@3, Expression}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 30).
-spec parse_function_code(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:function_code()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_function_code(Reader) ->
    gleam@result:'try'(
        parse_vector(Reader, fun parse_locals_declaration/1),
        fun(_use0) ->
            {Reader@1, Locals_declaration} = _use0,
            gleam@result:'try'(
                parse_expression(Reader@1),
                fun(_use0@1) ->
                    {Reader@2, Expression} = _use0@1,
                    {ok,
                        {Reader@2,
                            {function_code, Locals_declaration, Expression}}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 44).
-spec parse_code(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:code()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_code(Reader) ->
    gleam@result:'try'(
        parse_unsigned_leb128_integer(Reader),
        fun(_use0) ->
            {Reader@1, Size} = _use0,
            gleam@result:'try'(
                parse_function_code(Reader@1),
                fun(_use0@1) ->
                    {Reader@2, Function_code} = _use0@1,
                    {ok, {Reader@2, {code, Size, Function_code}}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 844).
-spec do_parse_instructions_until(
    gwr@parser@byte_reader:byte_reader(),
    fun((gwr@spec:instruction()) -> boolean()),
    list(gwr@spec:instruction())
) -> {ok, {gwr@parser@byte_reader:byte_reader(), list(gwr@spec:instruction())}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
do_parse_instructions_until(Reader, Predicate, Accumulator) ->
    case gwr@parser@byte_reader:can_read(Reader) of
        true ->
            gleam@result:'try'(
                parse_instruction(Reader),
                fun(_use0) ->
                    {Reader@1, Instruction} = _use0,
                    case Predicate(Instruction) of
                        true ->
                            {ok,
                                {Reader@1,
                                    lists:append(Accumulator, [Instruction])}};

                        false ->
                            do_parse_instructions_until(
                                Reader@1,
                                Predicate,
                                lists:append(Accumulator, [Instruction])
                            )
                    end
                end
            );

        false ->
            _pipe = gwr@parser@parsing_error:new(),
            _pipe@1 = gwr@parser@parsing_error:add_message(
                _pipe,
                <<"reached the end of the data yet couldn't find the instruction matching the given predicate"/utf8>>
            ),
            gwr@parser@parsing_error:to_error(_pipe@1)
    end.

-file("src/gwr/parser.gleam", 874).
-spec parse_instructions_until(
    gwr@parser@byte_reader:byte_reader(),
    fun((gwr@spec:instruction()) -> boolean())
) -> {ok, {gwr@parser@byte_reader:byte_reader(), list(gwr@spec:instruction())}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_instructions_until(Reader, Predicate) ->
    do_parse_instructions_until(Reader, Predicate, []).

-file("src/gwr/parser.gleam", 989).
-spec parse_global(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:global()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_global(Reader) ->
    gleam@result:'try'(
        parse_global_type(Reader),
        fun(_use0) ->
            {Reader@1, Global_type} = _use0,
            gleam@result:'try'(
                parse_expression(Reader@1),
                fun(_use0@1) ->
                    {Reader@2, Expression} = _use0@1,
                    {ok, {Reader@2, {global, Global_type, Expression}}}
                end
            )
        end
    ).

-file("src/gwr/parser.gleam", 52).
-spec parse_section(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:section()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_section(Reader) ->
    gleam@result:'try'(case gwr@parser@byte_reader:read(Reader, 1) of
            {ok, {Reader@1, <<Section_type_id>>}} ->
                {ok, {Reader@1, Section_type_id}};

            _ ->
                _pipe = gwr@parser@parsing_error:new(),
                _pipe@1 = gwr@parser@parsing_error:add_message(
                    _pipe,
                    <<"can't get section type id raw data"/utf8>>
                ),
                gwr@parser@parsing_error:to_error(_pipe@1)
        end, fun(_use0) ->
            {Reader@2, Section_type_id@1} = _use0,
            gleam@result:'try'(
                parse_unsigned_leb128_integer(Reader@2),
                fun(_use0@1) ->
                    {Reader@3, Section_length} = _use0@1,
                    gleam@result:'try'(
                        gwr@parser@byte_reader:get_remaining(Reader@3),
                        fun(Remaining_data) ->
                            Remaining_data_length = erlang:byte_size(
                                Remaining_data
                            ),
                            gleam@bool:guard(
                                Section_length > Remaining_data_length,
                                begin
                                    _pipe@2 = gwr@parser@parsing_error:new(),
                                    _pipe@3 = gwr@parser@parsing_error:add_message(
                                        _pipe@2,
                                        <<<<<<<<"unexpected end of the section's content segment. Expected "/utf8,
                                                        (erlang:integer_to_binary(
                                                            Section_length
                                                        ))/binary>>/binary,
                                                    " bytes but got "/utf8>>/binary,
                                                (erlang:integer_to_binary(
                                                    Remaining_data_length
                                                ))/binary>>/binary,
                                            " bytes"/utf8>>
                                    ),
                                    gwr@parser@parsing_error:to_error(_pipe@3)
                                end,
                                fun() ->
                                    gleam@result:'try'(
                                        case {gwr@parser@byte_reader:can_read(
                                                Reader@3
                                            ),
                                            Section_type_id@1} of
                                            {true, Id} when Id =:= 16#00 ->
                                                gleam@result:'try'(
                                                    parse_name(Reader@3),
                                                    fun(_use0@2) ->
                                                        {Reader@4,
                                                            Custom_section_name} = _use0@2,
                                                        gleam@result:'try'(
                                                            gwr@parser@byte_reader:read_remaining(
                                                                Reader@4
                                                            ),
                                                            fun(_use0@3) ->
                                                                {Reader@5,
                                                                    Custom_section_data} = _use0@3,
                                                                {ok,
                                                                    {Reader@5,
                                                                        {section,
                                                                            16#00,
                                                                            Section_length,
                                                                            {some,
                                                                                {custom_section,
                                                                                    Custom_section_name,
                                                                                    {some,
                                                                                        Custom_section_data}}}}}}
                                                            end
                                                        )
                                                    end
                                                );

                                            {true, Id@1} when Id@1 =:= 16#01 ->
                                                gleam@result:'try'(
                                                    parse_vector(
                                                        Reader@3,
                                                        fun parse_function_type/1
                                                    ),
                                                    fun(_use0@4) ->
                                                        {Reader@6,
                                                            Function_types_vec} = _use0@4,
                                                        {ok,
                                                            {Reader@6,
                                                                {section,
                                                                    16#01,
                                                                    Section_length,
                                                                    {some,
                                                                        {type_section,
                                                                            Function_types_vec}}}}}
                                                    end
                                                );

                                            {true, Id@2} when Id@2 =:= 16#03 ->
                                                gleam@result:'try'(
                                                    parse_vector(
                                                        Reader@3,
                                                        fun(Reader@7) ->
                                                            gleam@result:'try'(
                                                                parse_unsigned_leb128_integer(
                                                                    Reader@7
                                                                ),
                                                                fun(_use0@5) ->
                                                                    {Reader@8,
                                                                        Index} = _use0@5,
                                                                    {ok,
                                                                        {Reader@8,
                                                                            Index}}
                                                                end
                                                            )
                                                        end
                                                    ),
                                                    fun(_use0@6) ->
                                                        {Reader@9, Indices_vec} = _use0@6,
                                                        {ok,
                                                            {Reader@9,
                                                                {section,
                                                                    16#03,
                                                                    Section_length,
                                                                    {some,
                                                                        {function_section,
                                                                            Indices_vec}}}}}
                                                    end
                                                );

                                            {true, Id@3} when Id@3 =:= 16#05 ->
                                                gleam@result:'try'(
                                                    parse_vector(
                                                        Reader@3,
                                                        fun parse_memory/1
                                                    ),
                                                    fun(_use0@7) ->
                                                        {Reader@10, Mem_vec} = _use0@7,
                                                        {ok,
                                                            {Reader@10,
                                                                {section,
                                                                    16#05,
                                                                    Section_length,
                                                                    {some,
                                                                        {memory_section,
                                                                            Mem_vec}}}}}
                                                    end
                                                );

                                            {true, Id@4} when Id@4 =:= 16#06 ->
                                                gleam@result:'try'(
                                                    parse_vector(
                                                        Reader@3,
                                                        fun parse_global/1
                                                    ),
                                                    fun(_use0@8) ->
                                                        {Reader@11, Globals_vec} = _use0@8,
                                                        {ok,
                                                            {Reader@11,
                                                                {section,
                                                                    16#06,
                                                                    Section_length,
                                                                    {some,
                                                                        {global_section,
                                                                            Globals_vec}}}}}
                                                    end
                                                );

                                            {true, Id@5} when Id@5 =:= 16#07 ->
                                                gleam@result:'try'(
                                                    parse_vector(
                                                        Reader@3,
                                                        fun parse_export/1
                                                    ),
                                                    fun(_use0@9) ->
                                                        {Reader@12, Exports_vec} = _use0@9,
                                                        {ok,
                                                            {Reader@12,
                                                                {section,
                                                                    16#07,
                                                                    Section_length,
                                                                    {some,
                                                                        {export_section,
                                                                            Exports_vec}}}}}
                                                    end
                                                );

                                            {true, Id@6} when Id@6 =:= 16#0a ->
                                                gleam@result:'try'(
                                                    parse_vector(
                                                        Reader@3,
                                                        fun parse_code/1
                                                    ),
                                                    fun(_use0@10) ->
                                                        {Reader@13, Codes_vec} = _use0@10,
                                                        {ok,
                                                            {Reader@13,
                                                                {section,
                                                                    16#0a,
                                                                    Section_length,
                                                                    {some,
                                                                        {code_section,
                                                                            Codes_vec}}}}}
                                                    end
                                                );

                                            {false, Id@7} when Id@7 =:= 16#00 ->
                                                {ok,
                                                    {Reader@3,
                                                        {section,
                                                            16#00,
                                                            Section_length,
                                                            none}}};

                                            {false, Id@8} when Id@8 =:= 16#01 ->
                                                {ok,
                                                    {Reader@3,
                                                        {section,
                                                            16#01,
                                                            Section_length,
                                                            none}}};

                                            {false, Id@9} when Id@9 =:= 16#03 ->
                                                {ok,
                                                    {Reader@3,
                                                        {section,
                                                            16#03,
                                                            Section_length,
                                                            none}}};

                                            {false, Id@10} when Id@10 =:= 16#05 ->
                                                {ok,
                                                    {Reader@3,
                                                        {section,
                                                            16#05,
                                                            Section_length,
                                                            none}}};

                                            {false, Id@11} when Id@11 =:= 16#07 ->
                                                {ok,
                                                    {Reader@3,
                                                        {section,
                                                            16#07,
                                                            Section_length,
                                                            none}}};

                                            {false, Id@12} when Id@12 =:= 16#0a ->
                                                {ok,
                                                    {Reader@3,
                                                        {section,
                                                            16#0a,
                                                            Section_length,
                                                            none}}};

                                            {_, _} ->
                                                _pipe@4 = gwr@parser@parsing_error:new(
                                                    
                                                ),
                                                _pipe@5 = gwr@parser@parsing_error:add_message(
                                                    _pipe@4,
                                                    <<<<"unknown section type id \""/utf8,
                                                            (erlang:integer_to_binary(
                                                                Section_type_id@1
                                                            ))/binary>>/binary,
                                                        "\""/utf8>>
                                                ),
                                                gwr@parser@parsing_error:to_error(
                                                    _pipe@5
                                                )
                                        end,
                                        fun(_use0@11) ->
                                            {Reader@14, Decoded_dection} = _use0@11,
                                            {ok, {Reader@14, Decoded_dection}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end).

-file("src/gwr/parser.gleam", 276).
-spec parse_binary_module(gwr@parser@byte_reader:byte_reader()) -> {ok,
        {gwr@parser@byte_reader:byte_reader(), gwr@spec:binary_()}} |
    {error, gwr@parser@parsing_error:parsing_error()}.
parse_binary_module(Reader) ->
    gleam@bool:guard(
        gwr@parser@byte_reader:is_empty(Reader),
        begin
            _pipe = gwr@parser@parsing_error:new(),
            _pipe@1 = gwr@parser@parsing_error:add_message(
                _pipe,
                <<"empty data"/utf8>>
            ),
            gwr@parser@parsing_error:to_error(_pipe@1)
        end,
        fun() ->
            {Reader@3, Found_magic_number} = case gwr@parser@byte_reader:read(
                Reader,
                4
            ) of
                {ok, {Reader@1, <<16#00, 16#61, 16#73, 16#6d>>}} ->
                    {Reader@1, true};

                {ok, {Reader@2, _}} ->
                    {Reader@2, false};

                {error, _} ->
                    {Reader, false}
            end,
            gleam@bool:guard(
                not Found_magic_number,
                begin
                    _pipe@2 = gwr@parser@parsing_error:new(),
                    _pipe@3 = gwr@parser@parsing_error:add_message(
                        _pipe@2,
                        <<"couldn't find module's magic number"/utf8>>
                    ),
                    gwr@parser@parsing_error:to_error(_pipe@3)
                end,
                fun() ->
                    gleam@result:'try'(
                        case gwr@parser@byte_reader:read(Reader@3, 4) of
                            {ok, {Reader@4, <<Version:32/unsigned-little>>}} ->
                                {ok, {Reader@4, Version}};

                            _ ->
                                _pipe@4 = gwr@parser@parsing_error:new(),
                                _pipe@5 = gwr@parser@parsing_error:add_message(
                                    _pipe@4,
                                    <<"couldn't find module version"/utf8>>
                                ),
                                gwr@parser@parsing_error:to_error(_pipe@5)
                        end,
                        fun(_use0) ->
                            {Reader@5, Module_wasm_version} = _use0,
                            Empty_module = {module,
                                [],
                                [],
                                [],
                                [],
                                [],
                                [],
                                [],
                                none,
                                [],
                                []},
                            gleam@result:'try'(
                                gleam@yielder:fold(
                                    gleam@yielder:range(16#00, 16#0c),
                                    {ok, {Reader@5, Empty_module, []}},
                                    fun(State, _) ->
                                        gleam@result:'try'(
                                            State,
                                            fun(_use0@1) ->
                                                {Reader@6,
                                                    Module,
                                                    Function_section_type_indices} = _use0@1,
                                                gleam@bool:guard(
                                                    not gwr@parser@byte_reader:can_read(
                                                        Reader@6
                                                    ),
                                                    State,
                                                    fun() ->
                                                        gleam@result:'try'(
                                                            parse_section(
                                                                Reader@6
                                                            ),
                                                            fun(_use0@2) ->
                                                                {Reader@7,
                                                                    Section} = _use0@2,
                                                                gleam@result:'try'(
                                                                    case erlang:element(
                                                                        4,
                                                                        Section
                                                                    ) of
                                                                        none ->
                                                                            {ok,
                                                                                {Module,
                                                                                    Function_section_type_indices}};

                                                                        {some,
                                                                            Content} ->
                                                                            case Content of
                                                                                {custom_section,
                                                                                    _,
                                                                                    _} ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Function_section_type_indices}};

                                                                                {type_section,
                                                                                    Function_types} ->
                                                                                    {ok,
                                                                                        {{module,
                                                                                                Function_types,
                                                                                                erlang:element(
                                                                                                    3,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    4,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    5,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    6,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    7,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    8,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    9,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    10,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    11,
                                                                                                    Module
                                                                                                )},
                                                                                            Function_section_type_indices}};

                                                                                import_section ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Function_section_type_indices}};

                                                                                {function_section,
                                                                                    Type_indices_list} ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Type_indices_list}};

                                                                                table_section ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Function_section_type_indices}};

                                                                                {memory_section,
                                                                                    Memories_list} ->
                                                                                    {ok,
                                                                                        {{module,
                                                                                                erlang:element(
                                                                                                    2,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    3,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    4,
                                                                                                    Module
                                                                                                ),
                                                                                                Memories_list,
                                                                                                erlang:element(
                                                                                                    6,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    7,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    8,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    9,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    10,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    11,
                                                                                                    Module
                                                                                                )},
                                                                                            Function_section_type_indices}};

                                                                                {global_section,
                                                                                    Globals_list} ->
                                                                                    {ok,
                                                                                        {{module,
                                                                                                erlang:element(
                                                                                                    2,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    3,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    4,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    5,
                                                                                                    Module
                                                                                                ),
                                                                                                Globals_list,
                                                                                                erlang:element(
                                                                                                    7,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    8,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    9,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    10,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    11,
                                                                                                    Module
                                                                                                )},
                                                                                            Function_section_type_indices}};

                                                                                {export_section,
                                                                                    Exports_list} ->
                                                                                    {ok,
                                                                                        {{module,
                                                                                                erlang:element(
                                                                                                    2,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    3,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    4,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    5,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    6,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    7,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    8,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    9,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    10,
                                                                                                    Module
                                                                                                ),
                                                                                                Exports_list},
                                                                                            Function_section_type_indices}};

                                                                                {start_section,
                                                                                    Start_function} ->
                                                                                    {ok,
                                                                                        {{module,
                                                                                                erlang:element(
                                                                                                    2,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    3,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    4,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    5,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    6,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    7,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    8,
                                                                                                    Module
                                                                                                ),
                                                                                                {some,
                                                                                                    Start_function},
                                                                                                erlang:element(
                                                                                                    10,
                                                                                                    Module
                                                                                                ),
                                                                                                erlang:element(
                                                                                                    11,
                                                                                                    Module
                                                                                                )},
                                                                                            Function_section_type_indices}};

                                                                                element_section ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Function_section_type_indices}};

                                                                                {code_section,
                                                                                    Code_entries} ->
                                                                                    gleam@result:'try'(
                                                                                        gleam@list:index_fold(
                                                                                            Code_entries,
                                                                                            {ok,
                                                                                                []},
                                                                                            fun(
                                                                                                Function_list,
                                                                                                Entry,
                                                                                                Index
                                                                                            ) ->
                                                                                                gleam@result:'try'(
                                                                                                    Function_list,
                                                                                                    fun(
                                                                                                        Function_list@1
                                                                                                    ) ->
                                                                                                        case begin
                                                                                                            _pipe@6 = Function_section_type_indices,
                                                                                                            _pipe@7 = gleam@list:take(
                                                                                                                _pipe@6,
                                                                                                                Index
                                                                                                                + 1
                                                                                                            ),
                                                                                                            gleam@list:last(
                                                                                                                _pipe@7
                                                                                                            )
                                                                                                        end of
                                                                                                            {ok,
                                                                                                                Function_type_index} ->
                                                                                                                Function = {function,
                                                                                                                    Function_type_index,
                                                                                                                    begin
                                                                                                                        _pipe@8 = gleam@list:map(
                                                                                                                            erlang:element(
                                                                                                                                2,
                                                                                                                                erlang:element(
                                                                                                                                    3,
                                                                                                                                    Entry
                                                                                                                                )
                                                                                                                            ),
                                                                                                                            fun(
                                                                                                                                Locals_declaration
                                                                                                                            ) ->
                                                                                                                                gleam@list:repeat(
                                                                                                                                    erlang:element(
                                                                                                                                        3,
                                                                                                                                        Locals_declaration
                                                                                                                                    ),
                                                                                                                                    erlang:element(
                                                                                                                                        2,
                                                                                                                                        Locals_declaration
                                                                                                                                    )
                                                                                                                                )
                                                                                                                            end
                                                                                                                        ),
                                                                                                                        gleam@list:flatten(
                                                                                                                            _pipe@8
                                                                                                                        )
                                                                                                                    end,
                                                                                                                    erlang:element(
                                                                                                                        3,
                                                                                                                        erlang:element(
                                                                                                                            3,
                                                                                                                            Entry
                                                                                                                        )
                                                                                                                    )},
                                                                                                                {ok,
                                                                                                                    lists:append(
                                                                                                                        Function_list@1,
                                                                                                                        [Function]
                                                                                                                    )};

                                                                                                            {error,
                                                                                                                _} ->
                                                                                                                _pipe@9 = gwr@parser@parsing_error:new(
                                                                                                                    
                                                                                                                ),
                                                                                                                _pipe@10 = gwr@parser@parsing_error:add_message(
                                                                                                                    _pipe@9,
                                                                                                                    <<"couldn't find type index "/utf8,
                                                                                                                        (erlang:integer_to_binary(
                                                                                                                            Index
                                                                                                                        ))/binary>>
                                                                                                                ),
                                                                                                                gwr@parser@parsing_error:to_error(
                                                                                                                    _pipe@10
                                                                                                                )
                                                                                                        end
                                                                                                    end
                                                                                                )
                                                                                            end
                                                                                        ),
                                                                                        fun(
                                                                                            Function_list@2
                                                                                        ) ->
                                                                                            {ok,
                                                                                                {{module,
                                                                                                        erlang:element(
                                                                                                            2,
                                                                                                            Module
                                                                                                        ),
                                                                                                        Function_list@2,
                                                                                                        erlang:element(
                                                                                                            4,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            5,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            6,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            7,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            8,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            9,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            10,
                                                                                                            Module
                                                                                                        ),
                                                                                                        erlang:element(
                                                                                                            11,
                                                                                                            Module
                                                                                                        )},
                                                                                                    Function_section_type_indices}}
                                                                                        end
                                                                                    );

                                                                                data_section ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Function_section_type_indices}};

                                                                                data_count_section ->
                                                                                    {ok,
                                                                                        {Module,
                                                                                            Function_section_type_indices}}
                                                                            end
                                                                    end,
                                                                    fun(_use0@3) ->
                                                                        {Module@1,
                                                                            Function_section_type_indices@1} = _use0@3,
                                                                        {ok,
                                                                            {Reader@7,
                                                                                Module@1,
                                                                                Function_section_type_indices@1}}
                                                                    end
                                                                )
                                                            end
                                                        )
                                                    end
                                                )
                                            end
                                        )
                                    end
                                ),
                                fun(_use0@4) ->
                                    {Reader@8, Filled_module, _} = _use0@4,
                                    {ok,
                                        {Reader@8,
                                            {binary,
                                                Module_wasm_version,
                                                gwr@parser@byte_reader:bytes_read(
                                                    Reader@8
                                                ),
                                                Filled_module}}}
                                end
                            )
                        end
                    )
                end
            )
        end
    ).