-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@dynamic:unsafe_coerce(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((JDR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDS),
    fun((JDS, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDT)
) -> fun((JDR, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDT).
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@dynamic:unsafe_coerce(Val1), Cache@1)
    end.

-spec cfp2(
    fun((JDV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDW),
    fun((JDV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDX),
    fun((JDW, JDX, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDY)
) -> fun((JDV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JDY).
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@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            Cache@1
        )
    end.

-spec cfp3(
    fun((JEA, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEB),
    fun((JEA, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEC),
    fun((JEA, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JED),
    fun((JEB, JEC, JED, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEE)
) -> fun((JEA, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEE).
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@dynamic:unsafe_coerce(Val1),
            gleam@dynamic:unsafe_coerce(Val2),
            gleam@dynamic:unsafe_coerce(Val3),
            Cache@1
        )
    end.

-spec cfp4(
    fun((JEG, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEH),
    fun((JEG, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEI),
    fun((JEG, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEJ),
    fun((JEG, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEK),
    fun((JEH, JEI, JEJ, JEK, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEL)
) -> fun((JEG, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEL).
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 => 74})
        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 => 75})
        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 => 76})
        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 => 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((JEN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEO),
    fun((JEN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEP),
    fun((JEN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEQ),
    fun((JEN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JER),
    fun((JEN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JES),
    fun((JEO, JEP, JEQ, JER, JES, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JET)
) -> fun((JEN, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JET).
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 => 109})
        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 => 110})
        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 => 111})
        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 => 112})
        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 => 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((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEW),
    fun((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEX),
    fun((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEY),
    fun((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JEZ),
    fun((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFA),
    fun((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFB),
    fun((JEW, JEX, JEY, JEZ, JFA, JFB, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFC)
) -> fun((JEV, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFC).
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 => 148})
        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 => 149})
        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 => 150})
        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 => 151})
        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 => 152})
        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 => 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((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFF),
    fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFG),
    fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFH),
    fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFI),
    fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFJ),
    fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFK),
    fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFL),
    fun((JFF, JFG, JFH, JFI, JFJ, JFK, JFL, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFM)
) -> fun((JFE, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFM).
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 => 191})
        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 => 192})
        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 => 193})
        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 => 194})
        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 => 195})
        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 => 196})
        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 => 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((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFP),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFQ),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFR),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFS),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFT),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFU),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFV),
    fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFW),
    fun((JFP, JFQ, JFR, JFS, JFT, JFU, JFV, JFW, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFX)
) -> fun((JFO, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JFX).
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 => 238})
        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 => 239})
        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 => 240})
        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 => 241})
        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 => 242})
        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 => 243})
        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 => 244})
        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 => 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((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGA),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGB),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGC),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGD),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGE),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGF),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGG),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGH),
    fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGI),
    fun((JGA, JGB, JGC, JGD, JGE, JGF, JGG, JGH, JGI, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGJ)
) -> fun((JFZ, gleam@dict:dict(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_())) -> JGJ).
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 => 289})
        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 => 290})
        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 => 291})
        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 => 292})
        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 => 293})
        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 => 294})
        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 => 295})
        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 => 296})
        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 => 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.