-module(jsonlogic@internal@evaluation).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/jsonlogic/internal/evaluation.gleam").
-export([evaluate_literal/2, evaluate/2, evaluate_operation/3]).

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

?MODULEDOC(false).

-file("src/jsonlogic/internal/evaluation.gleam", 541).
?DOC(false).
-spec do_if(list({boolean(), gleam@dynamic:dynamic_()})) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, any()}.
do_if(Values) ->
    case Values of
        [] ->
            {ok, gleam@dynamic:nil()};

        [{_, First}] ->
            {ok, First};

        [{true, _}, {_, Second} | _] ->
            {ok, Second};

        [{false, _}, _, {_, Third}] ->
            {ok, Third};

        [_, _ | Rest] ->
            do_if(Rest)
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 582).
?DOC(false).
-spec do_missing(list(gleam@dynamic:dynamic_()), gleam@dynamic:dynamic_()) -> {ok,
        list(gleam@dynamic:dynamic_())} |
    {error, jsonlogic@error:evaluation_error()}.
do_missing(Keys, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Keys,
            fun jsonlogic@internal@decoding:dynamic_to_string/1
        ),
        fun(String_keys) ->
            _pipe@2 = gleam@list:try_map(
                String_keys,
                fun(Key) -> _pipe = gleam_stdlib:identity(Key),
                    _pipe@1 = jsonlogic@internal@decoding:decode_data(
                        _pipe,
                        Data,
                        none
                    ),
                    gleam@result:map(
                        _pipe@1,
                        fun(Resolved) -> {Key, Resolved} end
                    ) end
            ),
            _pipe@3 = gleam@result:map(
                _pipe@2,
                fun(_capture) ->
                    gleam@list:filter(
                        _capture,
                        fun(Value) ->
                            erlang:element(2, Value) =:= gleam@dynamic:nil()
                        end
                    )
                end
            ),
            gleam@result:map(
                _pipe@3,
                fun(_capture@1) ->
                    gleam@list:map(
                        _capture@1,
                        fun(Value@1) ->
                            gleam_stdlib:identity(erlang:element(1, Value@1))
                        end
                    )
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 27).
?DOC(false).
-spec evaluate_literal(
    jsonlogic@internal@rule:json_literal(),
    gleam@dynamic:dynamic_()
) -> {ok, gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
evaluate_literal(Literal, Data) ->
    case Literal of
        {bool_literal, Value} ->
            {ok, gleam_stdlib:identity(Value)};

        {string_literal, Value@1} ->
            {ok, gleam_stdlib:identity(Value@1)};

        {int_literal, Value@2} ->
            {ok, gleam_stdlib:identity(Value@2)};

        {float_literal, Value@3} ->
            {ok, gleam_stdlib:identity(Value@3)};

        {array_literal, Values} ->
            _pipe = gleam@list:try_map(
                Values,
                fun(_capture) -> evaluate(_capture, Data) end
            ),
            gleam@result:map(_pipe, fun gleam_stdlib:identity/1);

        nil_literal ->
            {ok, gleam@dynamic:nil()}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 15).
?DOC(false).
-spec evaluate(jsonlogic@internal@rule:rule(), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
evaluate(Rule, Data) ->
    _pipe = case Rule of
        {literal, Literal} ->
            evaluate_literal(Literal, Data);

        {operation, Operator, Values} ->
            evaluate_operation(Operator, Values, Data)
    end,
    gleam@result:map(_pipe, fun jsonlogic@internal@util:normalize_dynamic/1).

-file("src/jsonlogic/internal/evaluation.gleam", 107).
?DOC(false).
-spec evaluate_preserve_data(
    jsonlogic@internal@rule:rule(),
    gleam@dynamic:dynamic_()
) -> {ok, {gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_()}} |
    {error, jsonlogic@error:evaluation_error()}.
evaluate_preserve_data(Value, Data) ->
    gleam@result:map(
        evaluate(Value, Data),
        fun(Evaluated) -> {Evaluated, Data} end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 115).
?DOC(false).
-spec abstract_equals(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
abstract_equals(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(First@1) ->
                    gleam@result:'try'(
                        evaluate(Second, Data),
                        fun(Second@1) ->
                            gleam@result:'try'(
                                jsonlogic@internal@decoding:coerce_types(
                                    First@1,
                                    Second@1
                                ),
                                fun(_use0) ->
                                    {First@2, Second@2} = _use0,
                                    {ok, First@2 =:= Second@2}
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 127).
?DOC(false).
-spec abstract_not_equals(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
abstract_not_equals(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(First@1) ->
                    gleam@result:'try'(
                        evaluate(Second, Data),
                        fun(Second@1) ->
                            gleam@result:'try'(
                                jsonlogic@internal@decoding:coerce_types(
                                    First@1,
                                    Second@1
                                ),
                                fun(_use0) ->
                                    {First@2, Second@2} = _use0,
                                    {ok, First@2 /= Second@2}
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 139).
?DOC(false).
-spec strict_equals(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
strict_equals(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(First@1) ->
                    gleam@result:'try'(
                        evaluate(Second, Data),
                        fun(Second@1) -> {ok, First@1 =:= Second@1} end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 150).
?DOC(false).
-spec strict_not_equals(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
strict_not_equals(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(First@1) ->
                    gleam@result:'try'(
                        evaluate(Second, Data),
                        fun(Second@1) -> {ok, First@1 /= Second@1} end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 164).
?DOC(false).
-spec greater_than(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
greater_than(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) ->
                    jsonlogic@internal@util:comparison_reduce(
                        Float_values,
                        fun(A, B) -> A > B end
                    )
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 176).
?DOC(false).
-spec less_than(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        boolean()} |
    {error, jsonlogic@error:evaluation_error()}.
less_than(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) ->
                    jsonlogic@internal@util:comparison_reduce(
                        Float_values,
                        fun(A, B) -> A < B end
                    )
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 188).
?DOC(false).
-spec greater_than_or_equal(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
greater_than_or_equal(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) ->
                    jsonlogic@internal@util:comparison_reduce(
                        Float_values,
                        fun(A, B) -> A >= B end
                    )
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 200).
?DOC(false).
-spec less_than_or_equal(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
less_than_or_equal(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) ->
                    jsonlogic@internal@util:comparison_reduce(
                        Float_values,
                        fun(A, B) -> A =< B end
                    )
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 212).
?DOC(false).
-spec negate(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        boolean()} |
    {error, jsonlogic@error:evaluation_error()}.
negate(Values, Data) ->
    case Values of
        [Value] ->
            gleam@result:'try'(
                evaluate(Value, Data),
                fun(Evaluated_value) ->
                    gleam@result:map(
                        jsonlogic@internal@decoding:dynamic_to_bool(
                            Evaluated_value
                        ),
                        fun(_use0) ->
                            {Bool_value, _} = _use0,
                            gleam@bool:negate(Bool_value)
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 228).
?DOC(false).
-spec double_negate(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, boolean()} | {error, jsonlogic@error:evaluation_error()}.
double_negate(Values, Data) ->
    case Values of
        [] ->
            {ok, false};

        [Value] ->
            gleam@result:'try'(
                evaluate(Value, Data),
                fun(Evaluated_value) ->
                    _pipe = jsonlogic@internal@decoding:dynamic_to_bool(
                        Evaluated_value
                    ),
                    gleam@result:map(_pipe, fun(B) -> erlang:element(1, B) end)
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 243).
?DOC(false).
-spec 'or'(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
'or'(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_bool/1
                ),
                fun(Bool_values) ->
                    _pipe = gleam@list:find_map(
                        Bool_values,
                        fun(Value) -> case erlang:element(1, Value) of
                                true ->
                                    {ok, erlang:element(2, Value)};

                                false ->
                                    {error, nil}
                            end end
                    ),
                    _pipe@1 = gleam@result:unwrap(
                        _pipe,
                        gleam_stdlib:identity(false)
                    ),
                    {ok, _pipe@1}
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 262).
?DOC(false).
-spec 'and'(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
'and'(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_bool/1
                ),
                fun(Bool_values) ->
                    _pipe = gleam@list:fold_until(
                        Bool_values,
                        gleam_stdlib:identity(true),
                        fun(_, Value) -> case erlang:element(1, Value) of
                                true ->
                                    {continue, erlang:element(2, Value)};

                                false ->
                                    {stop, erlang:element(2, Value)}
                            end end
                    ),
                    {ok, _pipe}
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 280).
?DOC(false).
-spec conditional(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
conditional(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_bool/1
                ),
                fun(Bool_values) -> case Bool_values of
                        [{true, First}, _] ->
                            {ok, First};

                        [{false, _}, {_, Second}] ->
                            {ok, Second};

                        [{true, _}, {_, Second@1}, _] ->
                            {ok, Second@1};

                        [{false, _}, _, {_, Third}] ->
                            {ok, Third};

                        _ ->
                            {error, invalid_arguments_error}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 298).
?DOC(false).
-spec in(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
in(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) -> case Evaluated_values of
                [] ->
                    {ok, gleam_stdlib:identity(false)};

                [_] ->
                    {ok, gleam_stdlib:identity(false)};

                [First, Second] ->
                    case {gleam_stdlib:classify_dynamic(First),
                        gleam_stdlib:classify_dynamic(Second)} of
                        {<<"String"/utf8>>, <<"String"/utf8>>} ->
                            First@2 = case gleam@dynamic@decode:run(
                                First,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            ) of
                                {ok, First@1} -> First@1;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"jsonlogic/internal/evaluation"/utf8>>,
                                                function => <<"in"/utf8>>,
                                                line => 308,
                                                value => _assert_fail,
                                                start => 9156,
                                                'end' => 9211,
                                                pattern_start => 9167,
                                                pattern_end => 9176})
                            end,
                            Second@2 = case gleam@dynamic@decode:run(
                                Second,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            ) of
                                {ok, Second@1} -> Second@1;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"jsonlogic/internal/evaluation"/utf8>>,
                                                function => <<"in"/utf8>>,
                                                line => 309,
                                                value => _assert_fail@1,
                                                start => 9222,
                                                'end' => 9279,
                                                pattern_start => 9233,
                                                pattern_end => 9243})
                            end,
                            _pipe = gleam_stdlib:contains_string(
                                Second@2,
                                First@2
                            ),
                            _pipe@1 = gleam_stdlib:identity(_pipe),
                            {ok, _pipe@1};

                        {<<"String"/utf8>>, <<"List"/utf8>>} ->
                            First@4 = case gleam@dynamic@decode:run(
                                First,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            ) of
                                {ok, First@3} -> First@3;
                                _assert_fail@2 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"jsonlogic/internal/evaluation"/utf8>>,
                                                function => <<"in"/utf8>>,
                                                line => 315,
                                                value => _assert_fail@2,
                                                start => 9428,
                                                'end' => 9483,
                                                pattern_start => 9439,
                                                pattern_end => 9448})
                            end,
                            Second@4 = case gleam@dynamic@decode:run(
                                Second,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                )
                            ) of
                                {ok, Second@3} -> Second@3;
                                _assert_fail@3 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"jsonlogic/internal/evaluation"/utf8>>,
                                                function => <<"in"/utf8>>,
                                                line => 317,
                                                value => _assert_fail@3,
                                                start => 9529,
                                                'end' => 9599,
                                                pattern_start => 9540,
                                                pattern_end => 9550})
                            end,
                            _pipe@2 = gleam@list:contains(Second@4, First@4),
                            _pipe@3 = gleam_stdlib:identity(_pipe@2),
                            {ok, _pipe@3};

                        {_, _} ->
                            {error, invalid_arguments_error}
                    end;

                _ ->
                    {error, invalid_arguments_error}
            end end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 328).
?DOC(false).
-spec concatenate(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
concatenate(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_string/1
                ),
                fun(String_values) ->
                    _pipe = gleam@string:join(String_values, <<""/utf8>>),
                    _pipe@1 = gleam_stdlib:identity(_pipe),
                    {ok, _pipe@1}
                end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 342).
?DOC(false).
-spec modulo(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
modulo(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case erlang:length(Float_values) > 1 of
                        true ->
                            _pipe = jsonlogic@internal@util:chain_reduce_result(
                                Float_values,
                                fun jsonlogic@internal@util:modulo/2
                            ),
                            gleam@result:map(
                                _pipe,
                                fun jsonlogic@internal@util:float_to_dynamic/1
                            );

                        false ->
                            {error, invalid_arguments_error}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 359).
?DOC(false).
-spec max(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
max(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case Float_values of
                        [First] ->
                            {ok,
                                jsonlogic@internal@util:float_to_dynamic(First)};

                        [_ | _] ->
                            _pipe = jsonlogic@internal@util:chain_reduce(
                                Float_values,
                                fun gleam@float:max/2
                            ),
                            gleam@result:map(
                                _pipe,
                                fun jsonlogic@internal@util:float_to_dynamic/1
                            );

                        _ ->
                            {error, invalid_arguments_error}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 377).
?DOC(false).
-spec min(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
min(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case Float_values of
                        [First] ->
                            {ok,
                                jsonlogic@internal@util:float_to_dynamic(First)};

                        [_ | _] ->
                            _pipe = jsonlogic@internal@util:chain_reduce(
                                Float_values,
                                fun gleam@float:min/2
                            ),
                            gleam@result:map(
                                _pipe,
                                fun jsonlogic@internal@util:float_to_dynamic/1
                            );

                        _ ->
                            {error, invalid_arguments_error}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 395).
?DOC(false).
-spec plus(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
plus(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case Float_values of
                        [] ->
                            {ok, gleam_stdlib:identity(0)};

                        [_ | _] ->
                            _pipe = gleam@float:sum(Float_values),
                            _pipe@1 = jsonlogic@internal@util:float_to_dynamic(
                                _pipe
                            ),
                            {ok, _pipe@1}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 413).
?DOC(false).
-spec multiply(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
multiply(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case Float_values of
                        [] ->
                            {ok, gleam_stdlib:identity(1)};

                        [_ | _] ->
                            _pipe = gleam@float:product(Float_values),
                            _pipe@1 = jsonlogic@internal@util:float_to_dynamic(
                                _pipe
                            ),
                            {ok, _pipe@1}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 431).
?DOC(false).
-spec minus(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
minus(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case Float_values of
                        [] ->
                            {ok, gleam_stdlib:identity(0)};

                        [First] ->
                            _pipe = gleam@float:negate(First),
                            _pipe@1 = jsonlogic@internal@util:float_to_dynamic(
                                _pipe
                            ),
                            {ok, _pipe@1};

                        [_ | _] ->
                            _pipe@2 = jsonlogic@internal@util:chain_reduce(
                                Float_values,
                                fun gleam@float:subtract/2
                            ),
                            gleam@result:map(
                                _pipe@2,
                                fun jsonlogic@internal@util:float_to_dynamic/1
                            )
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 452).
?DOC(false).
-spec divide(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
divide(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_float/1
                ),
                fun(Float_values) -> case Float_values of
                        [] ->
                            {ok, gleam_stdlib:identity(1)};

                        [_ | _] ->
                            _pipe = jsonlogic@internal@util:chain_reduce_result(
                                Float_values,
                                fun jsonlogic@internal@util:divide/2
                            ),
                            gleam@result:map(
                                _pipe,
                                fun jsonlogic@internal@util:float_to_dynamic/1
                            )
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 469).
?DOC(false).
-spec substring(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
substring(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) -> case Evaluated_values of
                [First] ->
                    _pipe = jsonlogic@internal@decoding:dynamic_to_string(First),
                    gleam@result:map(_pipe, fun gleam_stdlib:identity/1);

                [First@1, Second] ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_int(Second),
                        fun(Second@1) ->
                            gleam@result:map(
                                jsonlogic@internal@decoding:dynamic_to_string(
                                    First@1
                                ),
                                fun(First@2) -> _pipe@1 = case Second@1 < 0 of
                                        true ->
                                            string:length(First@2) + Second@1;

                                        false ->
                                            Second@1
                                    end,
                                    _pipe@2 = gleam@string:drop_start(
                                        First@2,
                                        _pipe@1
                                    ),
                                    gleam_stdlib:identity(_pipe@2) end
                            )
                        end
                    );

                [First@3, Second@2, Third] ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_int(Third),
                        fun(Third@1) ->
                            gleam@result:'try'(
                                jsonlogic@internal@decoding:dynamic_to_int(
                                    Second@2
                                ),
                                fun(Second@3) ->
                                    gleam@result:map(
                                        jsonlogic@internal@decoding:dynamic_to_string(
                                            First@3
                                        ),
                                        fun(First@4) ->
                                            Left_trimmed = begin
                                                _pipe@3 = case Second@3 < 0 of
                                                    true ->
                                                        string:length(First@4) + Second@3;

                                                    false ->
                                                        Second@3
                                                end,
                                                gleam@string:drop_start(
                                                    First@4,
                                                    _pipe@3
                                                )
                                            end,
                                            _pipe@4 = case Third@1 < 0 of
                                                true ->
                                                    - Third@1;

                                                false ->
                                                    string:length(Left_trimmed)
                                                    - Third@1
                                            end,
                                            _pipe@5 = gleam@string:drop_end(
                                                Left_trimmed,
                                                _pipe@4
                                            ),
                                            gleam_stdlib:identity(_pipe@5)
                                        end
                                    )
                                end
                            )
                        end
                    );

                _ ->
                    {error, invalid_arguments_error}
            end end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 511).
?DOC(false).
-spec merge(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
merge(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_array/1
                ),
                fun(Array_values) -> case Array_values of
                        [] ->
                            {ok, gleam_stdlib:identity([])};

                        _ ->
                            _pipe = lists:append(Array_values),
                            _pipe@1 = gleam_stdlib:identity(_pipe),
                            {ok, _pipe@1}
                    end end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 529).
?DOC(false).
-spec if_(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
if_(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            gleam@result:'try'(
                gleam@list:try_map(
                    Evaluated_values,
                    fun jsonlogic@internal@decoding:dynamic_to_bool/1
                ),
                fun(Bool_values) -> do_if(Bool_values) end
            )
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 551).
?DOC(false).
-spec value(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
value(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            jsonlogic@internal@decoding:decode_data_val(Evaluated_values, Data)
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 559).
?DOC(false).
-spec variable(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
variable(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) -> case Evaluated_values of
                [] ->
                    {ok, Data};

                [First] ->
                    jsonlogic@internal@decoding:decode_data(First, Data, none);

                [First@1, Second | _] ->
                    jsonlogic@internal@decoding:decode_data(
                        First@1,
                        Data,
                        {some, Second}
                    )
            end end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 572).
?DOC(false).
-spec missing(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
missing(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) ->
            Flattened_values = jsonlogic@internal@util:flatten(Evaluated_values),
            _pipe = do_missing(Flattened_values, Data),
            gleam@result:map(_pipe, fun gleam_stdlib:identity/1)
        end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 596).
?DOC(false).
-spec missing_some(
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
missing_some(Values, Data) ->
    gleam@result:'try'(
        gleam@list:try_map(
            Values,
            fun(_capture) -> evaluate(_capture, Data) end
        ),
        fun(Evaluated_values) -> case Evaluated_values of
                [First, Second] ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_int(First),
                        fun(Minimum_keys) ->
                            gleam@result:'try'(
                                jsonlogic@internal@decoding:dynamic_to_array(
                                    Second
                                ),
                                fun(Keys) ->
                                    gleam@result:map(
                                        do_missing(Keys, Data),
                                        fun(Missing_keys) ->
                                            case (erlang:length(Keys) - erlang:length(
                                                Missing_keys
                                            ))
                                            >= Minimum_keys of
                                                true ->
                                                    gleam_stdlib:identity([]);

                                                false ->
                                                    gleam_stdlib:identity(
                                                        Missing_keys
                                                    )
                                            end
                                        end
                                    )
                                end
                            )
                        end
                    );

                _ ->
                    {error, invalid_arguments_error}
            end end
    ).

-file("src/jsonlogic/internal/evaluation.gleam", 615).
?DOC(false).
-spec filter(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
filter(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(Input) ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_array(Input),
                        fun(Input@1) ->
                            gleam@result:'try'(
                                gleam@list:try_map(
                                    Input@1,
                                    fun(_capture) ->
                                        evaluate_preserve_data(Second, _capture)
                                    end
                                ),
                                fun(Evaluated) ->
                                    gleam@result:map(
                                        gleam@list:try_map(
                                            Evaluated,
                                            fun(Value) ->
                                                Predicate = jsonlogic@internal@decoding:dynamic_to_bool(
                                                    erlang:element(1, Value)
                                                ),
                                                case Predicate of
                                                    {ok, {true, _}} ->
                                                        {ok,
                                                            {some,
                                                                erlang:element(
                                                                    2,
                                                                    Value
                                                                )}};

                                                    {ok, {false, _}} ->
                                                        {ok, none};

                                                    {error, E} ->
                                                        {error, E}
                                                end
                                            end
                                        ),
                                        fun(Evaluated@1) ->
                                            _pipe = gleam@option:values(
                                                Evaluated@1
                                            ),
                                            gleam_stdlib:identity(_pipe)
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 644).
?DOC(false).
-spec map(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
map(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(Input) ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_array(Input),
                        fun(Input@1) ->
                            gleam@result:map(
                                gleam@list:try_map(
                                    Input@1,
                                    fun(_capture) ->
                                        evaluate(Second, _capture)
                                    end
                                ),
                                fun(Evaluated) ->
                                    gleam_stdlib:identity(Evaluated)
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 659).
?DOC(false).
-spec reduce(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
reduce(Values, Data) ->
    case Values of
        [Input, Function, Initial_value] ->
            gleam@result:'try'(
                evaluate(Input, Data),
                fun(Input@1) ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_array(Input@1),
                        fun(Input@2) ->
                            gleam@result:'try'(
                                evaluate(Initial_value, Data),
                                fun(Initial_value@1) ->
                                    gleam@list:try_fold(
                                        Input@2,
                                        Initial_value@1,
                                        fun(Accumulator, Current) ->
                                            evaluate(
                                                Function,
                                                gleam@dynamic:properties(
                                                    [{gleam_stdlib:identity(
                                                                <<"current"/utf8>>
                                                            ),
                                                            Current},
                                                        {gleam_stdlib:identity(
                                                                <<"accumulator"/utf8>>
                                                            ),
                                                            Accumulator}]
                                                )
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 682).
?DOC(false).
-spec all(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
all(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(Input) ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_array(Input),
                        fun(Input@1) ->
                            gleam@result:'try'(
                                gleam@list:try_map(
                                    Input@1,
                                    fun(_capture) ->
                                        evaluate_preserve_data(Second, _capture)
                                    end
                                ),
                                fun(Evaluated) ->
                                    _pipe = gleam@list:fold_until(
                                        Evaluated,
                                        {ok, false},
                                        fun(_, Value) ->
                                            case jsonlogic@internal@decoding:dynamic_to_bool(
                                                erlang:element(1, Value)
                                            ) of
                                                {ok, {true, _}} ->
                                                    {continue, {ok, true}};

                                                {ok, {false, _}} ->
                                                    {stop, {ok, false}};

                                                {error, E} ->
                                                    {stop, {error, E}}
                                            end
                                        end
                                    ),
                                    gleam@result:map(
                                        _pipe,
                                        fun gleam_stdlib:identity/1
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 706).
?DOC(false).
-spec none(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
none(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(Input) ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_array(Input),
                        fun(Input@1) ->
                            gleam@result:'try'(
                                gleam@list:try_map(
                                    Input@1,
                                    fun(_capture) ->
                                        evaluate_preserve_data(Second, _capture)
                                    end
                                ),
                                fun(Evaluated) ->
                                    _pipe = gleam@list:fold_until(
                                        Evaluated,
                                        {ok, true},
                                        fun(_, Value) ->
                                            case jsonlogic@internal@decoding:dynamic_to_bool(
                                                erlang:element(1, Value)
                                            ) of
                                                {ok, {false, _}} ->
                                                    {continue, {ok, true}};

                                                {ok, {true, _}} ->
                                                    {stop, {ok, false}};

                                                {error, E} ->
                                                    {stop, {error, E}}
                                            end
                                        end
                                    ),
                                    gleam@result:map(
                                        _pipe,
                                        fun gleam_stdlib:identity/1
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 730).
?DOC(false).
-spec some(list(jsonlogic@internal@rule:rule()), gleam@dynamic:dynamic_()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
some(Values, Data) ->
    case Values of
        [First, Second] ->
            gleam@result:'try'(
                evaluate(First, Data),
                fun(Input) ->
                    gleam@result:'try'(
                        jsonlogic@internal@decoding:dynamic_to_array(Input),
                        fun(Input@1) ->
                            gleam@result:'try'(
                                gleam@list:try_map(
                                    Input@1,
                                    fun(_capture) ->
                                        evaluate_preserve_data(Second, _capture)
                                    end
                                ),
                                fun(Evaluated) ->
                                    _pipe = gleam@list:fold_until(
                                        Evaluated,
                                        {ok, false},
                                        fun(_, Value) ->
                                            case jsonlogic@internal@decoding:dynamic_to_bool(
                                                erlang:element(1, Value)
                                            ) of
                                                {ok, {false, _}} ->
                                                    {continue, {ok, false}};

                                                {ok, {true, _}} ->
                                                    {stop, {ok, true}};

                                                {error, E} ->
                                                    {stop, {error, E}}
                                            end
                                        end
                                    ),
                                    gleam@result:map(
                                        _pipe,
                                        fun gleam_stdlib:identity/1
                                    )
                                end
                            )
                        end
                    )
                end
            );

        _ ->
            {error, invalid_arguments_error}
    end.

-file("src/jsonlogic/internal/evaluation.gleam", 43).
?DOC(false).
-spec evaluate_operation(
    jsonlogic@internal@operator:operator(),
    list(jsonlogic@internal@rule:rule()),
    gleam@dynamic:dynamic_()
) -> {ok, gleam@dynamic:dynamic_()} |
    {error, jsonlogic@error:evaluation_error()}.
evaluate_operation(Operator, Values, Data) ->
    case Operator of
        abstract_equals ->
            _pipe = abstract_equals(Values, Data),
            gleam@result:map(_pipe, fun gleam_stdlib:identity/1);

        abstract_not_equals ->
            _pipe@1 = abstract_not_equals(Values, Data),
            gleam@result:map(_pipe@1, fun gleam_stdlib:identity/1);

        strict_equals ->
            _pipe@2 = strict_equals(Values, Data),
            gleam@result:map(_pipe@2, fun gleam_stdlib:identity/1);

        strict_not_equals ->
            _pipe@3 = strict_not_equals(Values, Data),
            gleam@result:map(_pipe@3, fun gleam_stdlib:identity/1);

        greater_than ->
            _pipe@4 = greater_than(Values, Data),
            gleam@result:map(_pipe@4, fun gleam_stdlib:identity/1);

        less_than ->
            _pipe@5 = less_than(Values, Data),
            gleam@result:map(_pipe@5, fun gleam_stdlib:identity/1);

        greater_than_or_equal ->
            _pipe@6 = greater_than_or_equal(Values, Data),
            gleam@result:map(_pipe@6, fun gleam_stdlib:identity/1);

        less_than_or_equal ->
            _pipe@7 = less_than_or_equal(Values, Data),
            gleam@result:map(_pipe@7, fun gleam_stdlib:identity/1);

        negate ->
            _pipe@8 = negate(Values, Data),
            gleam@result:map(_pipe@8, fun gleam_stdlib:identity/1);

        double_negate ->
            _pipe@9 = double_negate(Values, Data),
            gleam@result:map(_pipe@9, fun gleam_stdlib:identity/1);

        'or' ->
            'or'(Values, Data);

        'and' ->
            'and'(Values, Data);

        conditional ->
            conditional(Values, Data);

        in ->
            in(Values, Data);

        concatenate ->
            concatenate(Values, Data);

        modulo ->
            modulo(Values, Data);

        max ->
            max(Values, Data);

        min ->
            min(Values, Data);

        plus ->
            plus(Values, Data);

        multiply ->
            multiply(Values, Data);

        minus ->
            minus(Values, Data);

        divide ->
            divide(Values, Data);

        substring ->
            substring(Values, Data);

        merge ->
            merge(Values, Data);

        'if' ->
            if_(Values, Data);

        value ->
            value(Values, Data);

        variable ->
            variable(Values, Data);

        missing ->
            missing(Values, Data);

        missing_some ->
            missing_some(Values, Data);

        filter ->
            filter(Values, Data);

        map ->
            map(Values, Data);

        reduce ->
            reduce(Values, Data);

        all ->
            all(Values, Data);

        none ->
            none(Values, Data);

        some ->
            some(Values, Data)
    end.