Language: C

using System;
using System.Linq;
using System.Collections.Generic;

using E = System.Linq.Enumerable;
using System.Collections;

public class Program
{
    const long Mod = (long)1e9 + 7;

    public static void Main()
    {
        var nk = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
        var (n, k) = (nk[0], nk[1]);

        var count = 
            from sum in Aggregation.How((Modular<long> t, long y) => from x in t select x + y)
            select Modular<long>.Empty(Mod) into sum
            from x in
                from x in E.Range(k, n + 1 - k + 1)
                select (long)x into x
                select x * (n - x + 1) + 1
            select x;

        Console.WriteLine(count.Value);
    }

}

static class Aggregation
{
    public static Aggregation<T, R> How<T, R>(Func<R, T, R> accumulator) => new Aggregation<T, R>(accumulator);
}

class Aggregation<TSource, TAccumulate>
{
    Config config;
    public bool SeedWithFirst { get; set; }

    internal struct Config
    {
        public TAccumulate Seed;
        public readonly Func<TAccumulate, TSource, TAccumulate> Accumulator;

        public Config(TAccumulate x, Func<TAccumulate, TSource, TAccumulate> f) => (Seed, Accumulator) = (x, f);

        public override bool Equals(object obj)
        {
            return obj is Config other &&
                EqualityComparer<TAccumulate>.Default.Equals(Seed, other.Seed) &&
                EqualityComparer<Func<TAccumulate, TSource, TAccumulate>>.Default.Equals(Accumulator, other.Accumulator);
        }

        public override int GetHashCode()
        {
            return HashCode.Combine(Seed, Accumulator);
        }

        private TAccumulate Aggregate(IEnumerable<TSource> collection) => collection.Aggregate(this.Seed, this.Accumulator);

        public static TAccumulate Perform(Aggregation<TSource, TAccumulate>.Config behavior, IEnumerable<TSource> collection)
            => behavior.Aggregate(collection);

        public static S Perform<S>(Aggregation<S, S>.Config behavior, IEnumerable<S> collection, bool seedWithFirst)
            => behavior.Aggregate(behavior.Treat(collection, seedWithFirst));

        private IEnumerable<TAccumulate> Treat(IEnumerable<TAccumulate> collection, bool seedWithFirst)
        {
            using var e = collection.GetEnumerator();
            var s = this.Seed;
            if (seedWithFirst && e.MoveNext())
            {
                this.Seed = e.Current;
            }
            while (e.MoveNext())
            {
                yield return e.Current;
            }
            this.Seed = s;
        }

        public void Deconstruct(out TAccumulate x, out Func<TAccumulate, TSource, TAccumulate> f) => (x, f) = (Seed, Accumulator);

        public static implicit operator (TAccumulate X, Func<TAccumulate, TSource, TAccumulate> F)(Config value) => (value.Seed, value.Accumulator);
        public static implicit operator Config((TAccumulate X, Func<TAccumulate, TSource, TAccumulate> F) value) => new Config(value.X, value.F);
    }

    public Aggregation(TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator) => (config, SeedWithFirst) = ((seed, accumulator), false);
    public Aggregation(Func<TAccumulate, TSource, TAccumulate> accumulator) => (config, SeedWithFirst) = ((default, accumulator), true);

    public static void Usage()
    {
        var z =
            from _ in Aggregation.How((Modular<long> t, long y) => from x in t select x + y)
            select Modular<long>.Empty(13) into a
            from i in E.Range(11, 5).Select(x => (long)x)
            select i;
        Console.Error.WriteLine(z.Value);
    }

    public Aggregation<TSource, TAccumulate> Select(Func<Config, TAccumulate> selector)
    {
        this.config.Seed = selector(this.config);
        this.SeedWithFirst = false;
        return this;
    }

    public static TAccumulate SelectManyTrans<TCollection>(
        Aggregation<TSource, TAccumulate> ag,
        Func<Config, IEnumerable<TCollection>> collectionSelector,
        Func<Config, TCollection, TSource> resultSelector)
    {
        if (ag.SeedWithFirst)
        {
            throw new InvalidOperationException();
        }
        var xs = collectionSelector(ag.config).Select(x => resultSelector(ag.config, x));
        return Aggregation<TSource, TAccumulate>.Config.Perform(ag.config, xs);
    }

    public static TAccumulate SelectManyCis<TCollection>(
        Aggregation<TAccumulate, TAccumulate> ag,
        Func<Aggregation<TAccumulate, TAccumulate>.Config, IEnumerable<TCollection>> collectionSelector,
        Func<Aggregation<TAccumulate, TAccumulate>.Config, TCollection, TAccumulate> resultSelector)
    {
        var xs = collectionSelector(ag.config).Select(x => resultSelector(ag.config, x));
        return Aggregation<TCollection, TCollection>.Config.Perform(ag.config, xs, ag.SeedWithFirst);
    }
}

static class AggregationExtension
{
    public static TAccumulate SelectMany<TSource, TCollection, TAccumulate>(
        this Aggregation<TSource, TAccumulate> aggregation,
        Func<Aggregation<TSource, TAccumulate>.Config, IEnumerable<TCollection>> collectionSelector,
        Func<Aggregation<TSource, TAccumulate>.Config, TCollection, TSource> resultSelector) 
        => Aggregation<TSource, TAccumulate>.SelectManyTrans(aggregation, collectionSelector, resultSelector);

    public static TAccumulate SelectMany<TCollection, TAccumulate>(this Aggregation<TAccumulate, TAccumulate> aggregation,
        Func<Aggregation<TAccumulate, TAccumulate>.Config, IEnumerable<TCollection>> collectionSelector,
        Func<Aggregation<TAccumulate, TAccumulate>.Config, TCollection, TAccumulate> resultSelector) 
        => Aggregation<TAccumulate, TAccumulate>.SelectManyCis(aggregation, collectionSelector, resultSelector);
}
    
readonly struct Modular<TSource>
{
    public readonly long Mod;
    public readonly TSource Value;

    public Modular(TSource x, long m) : this() => (this.Value, this.Mod) = (x, m);
    public static Modular<TSource> Empty(long m) => new Modular<TSource>(default, m);
    public Modular<long> Return(long x) => new Modular<long>((x % this.Mod + this.Mod) % this.Mod, this.Mod);
    public Modular<TResult> Return<TResult>(TResult x) => new Modular<TResult>(x, this.Mod);

    public Modular<long> Select(Func<TSource, long> selector) => this.Return(selector(this.Value));
    public Modular<TResult> Select<TResult>(Func<TSource, TResult> selector) => this.Return(selector(this.Value));
    public Modular<TResult> SelectMany<TCollection, TResult>(Func<TSource, TCollection> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
        => this.Select(x => resultSelector(x, collectionSelector(x)));
    public Modular<TResult> SelectMany<TCollection, TResult>(Func<TSource, Modular<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
        => this.SelectMany(x => collectionSelector(x).Value, resultSelector);
}


Compiler output:
main.c:1:1: error: unknown type name 'using'
    1 | using System;
      | ^~~~~
main.c:2:1: error: unknown type name 'using'
    2 | using System.Linq;
      | ^~~~~
main.c:2:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    2 | using System.Linq;
      |             ^
main.c:3:1: error: unknown type name 'using'
    3 | using System.Collections.Generic;
      | ^~~~~
main.c:3:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    3 | using System.Collections.Generic;
      |             ^
main.c:5:1: error: unknown type name 'using'
    5 | using E = System.Linq.Enumerable;
      | ^~~~~
main.c:5:17: error: request for member 'Linq' in something not a structure or union
    5 | using E = System.Linq.Enumerable;
      |                 ^
main.c:6:1: error: unknown type name 'using'
    6 | using System.Collections;
      | ^~~~~
main.c:6:13: error: expected '=', ',', ';', 'asm' or '__attribute__' before '.' token
    6 | using System.Collections;
      |             ^
main.c:8:1: error: unknown type name 'public'
    8 | public class Program
      | ^~~~~~
main.c:8:14: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'Program'
    8 | public class Program
      |              ^~~~~~~
main.c:31:8: error: unknown type name 'class'
   31 | static class Aggregation
      |        ^~~~~
main.c:32:1: error: expected '=', ',', ';', 'asm' or '__attribute__' before '{' token
   32 | {
      | ^
main.c:36:1: error: unknown type name 'class'
   36 | class Aggregation<TSource, TAccumulate>
      | ^~~~~
main.c:36:18: error: expected '=', ',', ';', 'asm' or '__attribute__' before '<' token
   36 | class Aggregation<TSource, TAccumulate>
      |                  ^
main.c:132:8: error: unknown type name 'class'
  132 | static class AggregationExtension
      |        ^~~~~
main.c:133:1: error: expected '=', ',', ';', 'asm' or '__attribute__' before '{' token
  133 | {
      | ^
main.c:146:9: error: expected ';' before 'struct'
  146 | readonly struct Modular<TSource>
      |         ^~~~~~~
      |         ;
main.c:146:24: error: expected identifier or '(' before '<' token
  146 | readonly struct Modular<TSource>
      |                        ^