-module(context_fp_gleam).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([cfp1/2, cfp2/3, cfp3/4, cfp4/5, cfp5/6, cfp6/7, cfp7/8, cfp8/9, cfp9/10]).

-spec cfp_base(
    list(gleam@dynamic:dynamic_()),
    any(),
    gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())
) -> {gleam@dict:dict(integer(), gleam@dynamic:dynamic_()),
    gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())}.
cfp_base(Deps, Ctx, Cache) ->
    gleam@list:index_fold(
        Deps,
        {gleam@dict:new(), Cache},
        fun(Acc, Dep, Idx) ->
            {Resp, Cache@1} = Acc,
            From_cache = gleam@dict:get(Cache@1, Dep),
            case From_cache of
                {ok, Val} ->
                    {gleam@dict:insert(Resp, Idx, Val), Cache@1};

                {error, nil} ->
                    Val@1 = begin
                        _pipe = (gleam_stdlib:identity(Dep))(Ctx, Cache@1),
                        gleam@dynamic:from(_pipe)
                    end,
                    Cache@2 = gleam@dict:insert(Cache@1, Dep, Val@1),
                    {gleam@dict:insert(Resp, Idx, Val@1), Cache@2}
            end
        end
    ).

-spec cfp1(
    fun((JIM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIN),
    fun((JIN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIO)
) -> fun((JIM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIO).
cfp1(Dep1, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base([gleam@dynamic:from(Dep1)], Ctx, Cache),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp1"/utf8>>,
                            line => 11})
        end,
        Fun(gleam_stdlib:identity(Val1), Cache@1)
    end.

-spec cfp2(
    fun((JIQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIR),
    fun((JIQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIS),
    fun((JIR, JIS, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIT)
) -> fun((JIQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIT).
cfp2(Dep1, Dep2, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1), gleam@dynamic:from(Dep2)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp2"/utf8>>,
                            line => 24})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp2"/utf8>>,
                            line => 25})
        end,
        Fun(gleam_stdlib:identity(Val1), gleam_stdlib:identity(Val2), Cache@1)
    end.

-spec cfp3(
    fun((JIV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIW),
    fun((JIV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIX),
    fun((JIV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIY),
    fun((JIW, JIX, JIY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIZ)
) -> fun((JIV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JIZ).
cfp3(Dep1, Dep2, Dep3, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp3"/utf8>>,
                            line => 43})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp3"/utf8>>,
                            line => 44})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp3"/utf8>>,
                            line => 45})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            Cache@1
        )
    end.

-spec cfp4(
    fun((JJB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJC),
    fun((JJB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJD),
    fun((JJB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJE),
    fun((JJB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJF),
    fun((JJC, JJD, JJE, JJF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJG)
) -> fun((JJB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJG).
cfp4(Dep1, Dep2, Dep3, Dep4, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp4"/utf8>>,
                            line => 69})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp4"/utf8>>,
                            line => 70})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp4"/utf8>>,
                            line => 71})
        end,
        _assert_subject@3 = gleam@dict:get(Resp, 3),
        {ok, Val4} = case _assert_subject@3 of
            {ok, _} -> _assert_subject@3;
            _assert_fail@3 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@3,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp4"/utf8>>,
                            line => 72})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            gleam_stdlib:identity(Val4),
            Cache@1
        )
    end.

-spec cfp5(
    fun((JJI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJJ),
    fun((JJI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJK),
    fun((JJI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJL),
    fun((JJI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJM),
    fun((JJI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJN),
    fun((JJJ, JJK, JJL, JJM, JJN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJO)
) -> fun((JJI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJO).
cfp5(Dep1, Dep2, Dep3, Dep4, Dep5, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4),
                gleam@dynamic:from(Dep5)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp5"/utf8>>,
                            line => 104})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp5"/utf8>>,
                            line => 105})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp5"/utf8>>,
                            line => 106})
        end,
        _assert_subject@3 = gleam@dict:get(Resp, 3),
        {ok, Val4} = case _assert_subject@3 of
            {ok, _} -> _assert_subject@3;
            _assert_fail@3 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@3,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp5"/utf8>>,
                            line => 107})
        end,
        _assert_subject@4 = gleam@dict:get(Resp, 4),
        {ok, Val5} = case _assert_subject@4 of
            {ok, _} -> _assert_subject@4;
            _assert_fail@4 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@4,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp5"/utf8>>,
                            line => 108})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            gleam_stdlib:identity(Val4),
            gleam_stdlib:identity(Val5),
            Cache@1
        )
    end.

-spec cfp6(
    fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJR),
    fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJS),
    fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJT),
    fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJU),
    fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJV),
    fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJW),
    fun((JJR, JJS, JJT, JJU, JJV, JJW, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJX)
) -> fun((JJQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JJX).
cfp6(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4),
                gleam@dynamic:from(Dep5),
                gleam@dynamic:from(Dep6)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp6"/utf8>>,
                            line => 143})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp6"/utf8>>,
                            line => 144})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp6"/utf8>>,
                            line => 145})
        end,
        _assert_subject@3 = gleam@dict:get(Resp, 3),
        {ok, Val4} = case _assert_subject@3 of
            {ok, _} -> _assert_subject@3;
            _assert_fail@3 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@3,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp6"/utf8>>,
                            line => 146})
        end,
        _assert_subject@4 = gleam@dict:get(Resp, 4),
        {ok, Val5} = case _assert_subject@4 of
            {ok, _} -> _assert_subject@4;
            _assert_fail@4 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@4,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp6"/utf8>>,
                            line => 147})
        end,
        _assert_subject@5 = gleam@dict:get(Resp, 5),
        {ok, Val6} = case _assert_subject@5 of
            {ok, _} -> _assert_subject@5;
            _assert_fail@5 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@5,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp6"/utf8>>,
                            line => 148})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            gleam_stdlib:identity(Val4),
            gleam_stdlib:identity(Val5),
            gleam_stdlib:identity(Val6),
            Cache@1
        )
    end.

-spec cfp7(
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKA),
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKB),
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKC),
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKD),
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKE),
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKF),
    fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKG),
    fun((JKA, JKB, JKC, JKD, JKE, JKF, JKG, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKH)
) -> fun((JJZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKH).
cfp7(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Dep7, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4),
                gleam@dynamic:from(Dep5),
                gleam@dynamic:from(Dep6),
                gleam@dynamic:from(Dep7)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 186})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 187})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 188})
        end,
        _assert_subject@3 = gleam@dict:get(Resp, 3),
        {ok, Val4} = case _assert_subject@3 of
            {ok, _} -> _assert_subject@3;
            _assert_fail@3 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@3,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 189})
        end,
        _assert_subject@4 = gleam@dict:get(Resp, 4),
        {ok, Val5} = case _assert_subject@4 of
            {ok, _} -> _assert_subject@4;
            _assert_fail@4 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@4,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 190})
        end,
        _assert_subject@5 = gleam@dict:get(Resp, 5),
        {ok, Val6} = case _assert_subject@5 of
            {ok, _} -> _assert_subject@5;
            _assert_fail@5 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@5,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 191})
        end,
        _assert_subject@6 = gleam@dict:get(Resp, 6),
        {ok, Val7} = case _assert_subject@6 of
            {ok, _} -> _assert_subject@6;
            _assert_fail@6 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@6,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp7"/utf8>>,
                            line => 192})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            gleam_stdlib:identity(Val4),
            gleam_stdlib:identity(Val5),
            gleam_stdlib:identity(Val6),
            gleam_stdlib:identity(Val7),
            Cache@1
        )
    end.

-spec cfp8(
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKK),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKL),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKM),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKN),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKO),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKP),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKQ),
    fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKR),
    fun((JKK, JKL, JKM, JKN, JKO, JKP, JKQ, JKR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKS)
) -> fun((JKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKS).
cfp8(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Dep7, Dep8, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4),
                gleam@dynamic:from(Dep5),
                gleam@dynamic:from(Dep6),
                gleam@dynamic:from(Dep7),
                gleam@dynamic:from(Dep8)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 233})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 234})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 235})
        end,
        _assert_subject@3 = gleam@dict:get(Resp, 3),
        {ok, Val4} = case _assert_subject@3 of
            {ok, _} -> _assert_subject@3;
            _assert_fail@3 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@3,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 236})
        end,
        _assert_subject@4 = gleam@dict:get(Resp, 4),
        {ok, Val5} = case _assert_subject@4 of
            {ok, _} -> _assert_subject@4;
            _assert_fail@4 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@4,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 237})
        end,
        _assert_subject@5 = gleam@dict:get(Resp, 5),
        {ok, Val6} = case _assert_subject@5 of
            {ok, _} -> _assert_subject@5;
            _assert_fail@5 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@5,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 238})
        end,
        _assert_subject@6 = gleam@dict:get(Resp, 6),
        {ok, Val7} = case _assert_subject@6 of
            {ok, _} -> _assert_subject@6;
            _assert_fail@6 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@6,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 239})
        end,
        _assert_subject@7 = gleam@dict:get(Resp, 7),
        {ok, Val8} = case _assert_subject@7 of
            {ok, _} -> _assert_subject@7;
            _assert_fail@7 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@7,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp8"/utf8>>,
                            line => 240})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            gleam_stdlib:identity(Val4),
            gleam_stdlib:identity(Val5),
            gleam_stdlib:identity(Val6),
            gleam_stdlib:identity(Val7),
            gleam_stdlib:identity(Val8),
            Cache@1
        )
    end.

-spec cfp9(
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKV),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKW),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKX),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKY),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JKZ),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JLA),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JLB),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JLC),
    fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JLD),
    fun((JKV, JKW, JKX, JKY, JKZ, JLA, JLB, JLC, JLD, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JLE)
) -> fun((JKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JLE).
cfp9(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Dep7, Dep8, Dep9, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4),
                gleam@dynamic:from(Dep5),
                gleam@dynamic:from(Dep6),
                gleam@dynamic:from(Dep7),
                gleam@dynamic:from(Dep8),
                gleam@dynamic:from(Dep9)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@dict:get(Resp, 0),
        {ok, Val1} = case _assert_subject of
            {ok, _} -> _assert_subject;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 284})
        end,
        _assert_subject@1 = gleam@dict:get(Resp, 1),
        {ok, Val2} = case _assert_subject@1 of
            {ok, _} -> _assert_subject@1;
            _assert_fail@1 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@1,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 285})
        end,
        _assert_subject@2 = gleam@dict:get(Resp, 2),
        {ok, Val3} = case _assert_subject@2 of
            {ok, _} -> _assert_subject@2;
            _assert_fail@2 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@2,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 286})
        end,
        _assert_subject@3 = gleam@dict:get(Resp, 3),
        {ok, Val4} = case _assert_subject@3 of
            {ok, _} -> _assert_subject@3;
            _assert_fail@3 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@3,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 287})
        end,
        _assert_subject@4 = gleam@dict:get(Resp, 4),
        {ok, Val5} = case _assert_subject@4 of
            {ok, _} -> _assert_subject@4;
            _assert_fail@4 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@4,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 288})
        end,
        _assert_subject@5 = gleam@dict:get(Resp, 5),
        {ok, Val6} = case _assert_subject@5 of
            {ok, _} -> _assert_subject@5;
            _assert_fail@5 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@5,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 289})
        end,
        _assert_subject@6 = gleam@dict:get(Resp, 6),
        {ok, Val7} = case _assert_subject@6 of
            {ok, _} -> _assert_subject@6;
            _assert_fail@6 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@6,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 290})
        end,
        _assert_subject@7 = gleam@dict:get(Resp, 7),
        {ok, Val8} = case _assert_subject@7 of
            {ok, _} -> _assert_subject@7;
            _assert_fail@7 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@7,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 291})
        end,
        _assert_subject@8 = gleam@dict:get(Resp, 8),
        {ok, Val9} = case _assert_subject@8 of
            {ok, _} -> _assert_subject@8;
            _assert_fail@8 ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail@8,
                            module => <<"context_fp_gleam"/utf8>>,
                            function => <<"cfp9"/utf8>>,
                            line => 292})
        end,
        Fun(
            gleam_stdlib:identity(Val1),
            gleam_stdlib:identity(Val2),
            gleam_stdlib:identity(Val3),
            gleam_stdlib:identity(Val4),
            gleam_stdlib:identity(Val5),
            gleam_stdlib:identity(Val6),
            gleam_stdlib:identity(Val7),
            gleam_stdlib:identity(Val8),
            gleam_stdlib:identity(Val9),
            Cache@1
        )
    end.