-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_())
) -> list(gleam@dynamic:dynamic_()).
cfp_base(Deps, Ctx, Cache) ->
    erlang:element(
        1,
        gleam@list:fold(
            Deps,
            {[], Cache},
            fun(Acc, Dep) ->
                {Resp, Cache@1} = Acc,
                From_cache = gleam@dict:get(Cache@1, Dep),
                case From_cache of
                    {ok, Val} ->
                        {gleam@list:append(Resp, [Val]), Cache@1};

                    {error, nil} ->
                        Val@1 = begin
                            _pipe = (gleam@dynamic:unsafe_coerce(Dep))(
                                Ctx,
                                Cache@1
                            ),
                            gleam@dynamic:from(_pipe)
                        end,
                        Cache@2 = gleam@dict:insert(Cache@1, Dep, Val@1),
                        {gleam@list:append(Resp, [Val@1]), Cache@2}
                end
            end
        )
    ).

-spec cfp1(
    fun((FJU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FJV),
    fun((FJV) -> FJW)
) -> fun((FJU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FJW).
cfp1(Dep1, Fun) ->
    fun(Ctx, Cache) ->
        Resp = cfp_base([gleam@dynamic:from(Dep1)], Ctx, Cache),
        _assert_subject = gleam@list:at(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@dynamic:unsafe_coerce(Val1))
    end.

-spec cfp2(
    fun((FJY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FJZ),
    fun((FJY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKA),
    fun((FJZ, FKA) -> FKB)
) -> fun((FJY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKB).
cfp2(Dep1, Dep2, Fun) ->
    fun(Ctx, Cache) ->
        Resp = cfp_base(
            [gleam@dynamic:from(Dep1), gleam@dynamic:from(Dep2)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@list:at(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 => 23})
        end,
        _assert_subject@1 = gleam@list:at(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 => 24})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2)
        )
    end.

-spec cfp3(
    fun((FKD, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKE),
    fun((FKD, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKF),
    fun((FKD, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKG),
    fun((FKE, FKF, FKG) -> FKH)
) -> fun((FKD, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKH).
cfp3(Dep1, Dep2, Dep3, Fun) ->
    fun(Ctx, Cache) ->
        Resp = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@list:at(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 => 42})
        end,
        _assert_subject@1 = gleam@list:at(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 => 43})
        end,
        _assert_subject@2 = gleam@list:at(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 => 44})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3)
        )
    end.

-spec cfp4(
    fun((FKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKK),
    fun((FKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKL),
    fun((FKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKM),
    fun((FKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKN),
    fun((FKK, FKL, FKM, FKN) -> FKO)
) -> fun((FKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKO).
cfp4(Dep1, Dep2, Dep3, Dep4, Fun) ->
    fun(Ctx, Cache) ->
        Resp = cfp_base(
            [gleam@dynamic:from(Dep1),
                gleam@dynamic:from(Dep2),
                gleam@dynamic:from(Dep3),
                gleam@dynamic:from(Dep4)],
            Ctx,
            Cache
        ),
        _assert_subject = gleam@list:at(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 => 72})
        end,
        _assert_subject@1 = gleam@list:at(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 => 73})
        end,
        _assert_subject@2 = gleam@list:at(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 => 74})
        end,
        _assert_subject@3 = gleam@list:at(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 => 75})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4)
        )
    end.

-spec cfp5(
    fun((FKQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKR),
    fun((FKQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKS),
    fun((FKQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKT),
    fun((FKQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKU),
    fun((FKQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKV),
    fun((FKR, FKS, FKT, FKU, FKV) -> FKW)
) -> fun((FKQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKW).
cfp5(Dep1, Dep2, Dep3, Dep4, Dep5, Fun) ->
    fun(Ctx, Cache) ->
        Resp = 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@list:at(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 => 106})
        end,
        _assert_subject@1 = gleam@list:at(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 => 107})
        end,
        _assert_subject@2 = gleam@list:at(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 => 108})
        end,
        _assert_subject@3 = gleam@list:at(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 => 109})
        end,
        _assert_subject@4 = gleam@list:at(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 => 110})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4),
            gleam@dynamic:unsafe_coerce(Val5)
        )
    end.

-spec cfp6(
    fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKZ),
    fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLA),
    fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLB),
    fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLC),
    fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLD),
    fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLE),
    fun((FKZ, FLA, FLB, FLC, FLD, FLE) -> FLF)
) -> fun((FKY, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLF).
cfp6(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Fun) ->
    fun(Ctx, Cache) ->
        Resp = 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@list:at(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 => 144})
        end,
        _assert_subject@1 = gleam@list:at(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 => 145})
        end,
        _assert_subject@2 = gleam@list:at(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 => 146})
        end,
        _assert_subject@3 = gleam@list:at(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 => 147})
        end,
        _assert_subject@4 = gleam@list:at(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 => 148})
        end,
        _assert_subject@5 = gleam@list:at(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 => 149})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4),
            gleam@dynamic:unsafe_coerce(Val5),
            gleam@dynamic:unsafe_coerce(Val6)
        )
    end.

-spec cfp7(
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLI),
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLJ),
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLK),
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLL),
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLM),
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLN),
    fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLO),
    fun((FLI, FLJ, FLK, FLL, FLM, FLN, FLO) -> FLP)
) -> fun((FLH, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLP).
cfp7(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Dep7, Fun) ->
    fun(Ctx, Cache) ->
        Resp = 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@list:at(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@list:at(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@list:at(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@list:at(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@list:at(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@list:at(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@list:at(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@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4),
            gleam@dynamic:unsafe_coerce(Val5),
            gleam@dynamic:unsafe_coerce(Val6),
            gleam@dynamic:unsafe_coerce(Val7)
        )
    end.

-spec cfp8(
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLS),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLT),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLU),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLV),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLW),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLX),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLY),
    fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLZ),
    fun((FLS, FLT, FLU, FLV, FLW, FLX, FLY, FLZ) -> FMA)
) -> fun((FLR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMA).
cfp8(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Dep7, Dep8, Fun) ->
    fun(Ctx, Cache) ->
        Resp = 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@list:at(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 => 232})
        end,
        _assert_subject@1 = gleam@list:at(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 => 233})
        end,
        _assert_subject@2 = gleam@list:at(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 => 234})
        end,
        _assert_subject@3 = gleam@list:at(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 => 235})
        end,
        _assert_subject@4 = gleam@list:at(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 => 236})
        end,
        _assert_subject@5 = gleam@list:at(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 => 237})
        end,
        _assert_subject@6 = gleam@list:at(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 => 238})
        end,
        _assert_subject@7 = gleam@list:at(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 => 239})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4),
            gleam@dynamic:unsafe_coerce(Val5),
            gleam@dynamic:unsafe_coerce(Val6),
            gleam@dynamic:unsafe_coerce(Val7),
            gleam@dynamic:unsafe_coerce(Val8)
        )
    end.

-spec cfp9(
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMD),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FME),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMF),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMG),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMH),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMI),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMJ),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMK),
    fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FML),
    fun((FMD, FME, FMF, FMG, FMH, FMI, FMJ, FMK, FML) -> FMM)
) -> fun((FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMM).
cfp9(Dep1, Dep2, Dep3, Dep4, Dep5, Dep6, Dep7, Dep8, Dep9, Fun) ->
    fun(Ctx, Cache) ->
        Resp = 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@list:at(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 => 282})
        end,
        _assert_subject@1 = gleam@list:at(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 => 283})
        end,
        _assert_subject@2 = gleam@list:at(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 => 284})
        end,
        _assert_subject@3 = gleam@list:at(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 => 285})
        end,
        _assert_subject@4 = gleam@list:at(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 => 286})
        end,
        _assert_subject@5 = gleam@list:at(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 => 287})
        end,
        _assert_subject@6 = gleam@list:at(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 => 288})
        end,
        _assert_subject@7 = gleam@list:at(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 => 289})
        end,
        _assert_subject@8 = gleam@list:at(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 => 290})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4),
            gleam@dynamic:unsafe_coerce(Val5),
            gleam@dynamic:unsafe_coerce(Val6),
            gleam@dynamic:unsafe_coerce(Val7),
            gleam@dynamic:unsafe_coerce(Val8),
            gleam@dynamic:unsafe_coerce(Val9)
        )
    end.