-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_()),
    gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())}.
cfp_base(Deps, Ctx, Cache) ->
    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((FKI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKJ),
    fun((FKJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKK)
) -> fun((FKI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKK).
cfp1(Dep1, Fun) ->
    fun(Ctx, Cache) ->
        {Resp, Cache@1} = 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), Cache@1)
    end.

-spec cfp2(
    fun((FKM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKN),
    fun((FKM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKO),
    fun((FKN, FKO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKP)
) -> fun((FKM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKP).
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@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 => 24})
        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 => 25})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            Cache@1
        )
    end.

-spec cfp3(
    fun((FKR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKS),
    fun((FKR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKT),
    fun((FKR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKU),
    fun((FKS, FKT, FKU, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKV)
) -> fun((FKR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKV).
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@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 => 43})
        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 => 44})
        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 => 45})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            Cache@1
        )
    end.

-spec cfp4(
    fun((FKX, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKY),
    fun((FKX, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FKZ),
    fun((FKX, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLA),
    fun((FKX, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLB),
    fun((FKY, FKZ, FLA, FLB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLC)
) -> fun((FKX, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLC).
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@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 => 74})
        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 => 75})
        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 => 76})
        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 => 77})
        end,
        Fun(
            gleam@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            gleam@dynamic:unsafe_coerce(Val4),
            Cache@1
        )
    end.

-spec cfp5(
    fun((FLE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLF),
    fun((FLE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLG),
    fun((FLE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLH),
    fun((FLE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLI),
    fun((FLE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLJ),
    fun((FLF, FLG, FLH, FLI, FLJ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLK)
) -> fun((FLE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLK).
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@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 => 109})
        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 => 110})
        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 => 111})
        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 => 112})
        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 => 113})
        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),
            Cache@1
        )
    end.

-spec cfp6(
    fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLN),
    fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLO),
    fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLP),
    fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLQ),
    fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLR),
    fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLS),
    fun((FLN, FLO, FLP, FLQ, FLR, FLS, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLT)
) -> fun((FLM, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLT).
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@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 => 148})
        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 => 149})
        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 => 150})
        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 => 151})
        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 => 152})
        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 => 153})
        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),
            Cache@1
        )
    end.

-spec cfp7(
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLW),
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLX),
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLY),
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FLZ),
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMA),
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMB),
    fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMC),
    fun((FLW, FLX, FLY, FLZ, FMA, FMB, FMC, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMD)
) -> fun((FLV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMD).
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@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 => 191})
        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 => 192})
        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 => 193})
        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 => 194})
        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 => 195})
        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 => 196})
        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 => 197})
        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),
            Cache@1
        )
    end.

-spec cfp8(
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMG),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMH),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMI),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMJ),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMK),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FML),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMM),
    fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMN),
    fun((FMG, FMH, FMI, FMJ, FMK, FML, FMM, FMN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMO)
) -> fun((FMF, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMO).
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@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 => 238})
        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 => 239})
        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 => 240})
        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 => 241})
        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 => 242})
        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 => 243})
        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 => 244})
        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 => 245})
        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),
            Cache@1
        )
    end.

-spec cfp9(
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMR),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMS),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMT),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMU),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMV),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMW),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMX),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMY),
    fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FMZ),
    fun((FMR, FMS, FMT, FMU, FMV, FMW, FMX, FMY, FMZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FNA)
) -> fun((FMQ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> FNA).
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@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 => 289})
        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 => 290})
        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 => 291})
        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 => 292})
        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 => 293})
        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 => 294})
        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 => 295})
        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 => 296})
        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 => 297})
        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),
            Cache@1
        )
    end.