Language: C++

void main()
{
    long[] tmp = rdRow;
    long n = tmp[0], k = tmp[1];

    long result = (n / k) ^^ 3;
    if (!(k & 1))
    {
        result += ((n + k / 2) / k) ^^ 3;
    }

    result.writeln;
}

enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;

T rdElem(T = long)()
if (!is(T == struct))
{
    return readln.chomp.to!T;
}

alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);

T rdElem(T)()
if (is(T == struct))
{
    T result;
    string[] input = rdRow!string;
    assert(T.tupleof.length == input.length);
    foreach (i, ref x; result.tupleof)
    {
        x = input[i].to!(typeof(x));
    }
    return result;
}

T[] rdRow(T = long)()
{
    return readln.split.to!(T[]);
}

T[] rdCol(T = long)(long col)
{
    return iota(col).map!(x => rdElem!T).array;
}

T[][] rdMat(T = long)(long col)
{
    return iota(col).map!(x => rdRow!T).array;
}

void wrMat(T = long)(T[][] mat)
{
    foreach (row; mat)
    {
        foreach (j, compo; row)
        {
            compo.write;
            if (j == row.length - 1) writeln;
            else " ".write;
        }
    }
}

import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.traits;
import std.container;
import std.functional;
import std.typecons;
import std.ascii;
import std.uni;

Compiler output:
a.cc:1:1: error: '::main' must return 'int'
    1 | void main()
      | ^~~~
a.cc: In function 'int main()':
a.cc:3:9: error: structured binding declaration cannot have type 'long int'
    3 |     long[] tmp = rdRow;
      |         ^~
a.cc:3:9: note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'
a.cc:3:9: error: empty structured binding declaration
a.cc:3:12: error: expected initializer before 'tmp'
    3 |     long[] tmp = rdRow;
      |            ^~~
a.cc:4:14: error: 'tmp' was not declared in this scope
    4 |     long n = tmp[0], k = tmp[1];
      |              ^~~
a.cc:6:24: error: 'k' was not declared in this scope
    6 |     long result = (n / k) ^^ 3;
      |                        ^
a.cc:6:28: error: expected primary-expression before '^' token
    6 |     long result = (n / k) ^^ 3;
      |                            ^
a.cc:9:38: error: expected primary-expression before '^' token
    9 |         result += ((n + k / 2) / k) ^^ 3;
      |                                      ^
a.cc:12:12: error: request for member 'writeln' in 'result', which is of non-class type 'long int'
   12 |     result.writeln;
      |            ^~~~~~~
a.cc: At global scope:
a.cc:15:6: error: expected identifier before 'long'
   15 | enum long mod = 10^^9 + 7;
      |      ^~~~
a.cc:15:20: error: expected primary-expression before '^' token
   15 | enum long mod = 10^^9 + 7;
      |                    ^
a.cc:16:6: error: expected identifier before 'long'
   16 | enum long inf = 1L << 60;
      |      ^~~~
a.cc:18:1: error: 'T' does not name a type
   18 | T rdElem(T = long)()
      | ^
a.cc:24:1: error: 'alias' does not name a type
   24 | alias rdStr = rdElem!string;
      | ^~~~~
a.cc:25:1: error: 'alias' does not name a type
   25 | alias rdDchar = rdElem!(dchar[]);
      | ^~~~~
a.cc:27:1: error: 'T' does not name a type
   27 | T rdElem(T)()
      | ^
a.cc:40:1: error: 'T' does not name a type
   40 | T[] rdRow(T = long)()
      | ^
a.cc:45:1: error: 'T' does not name a type
   45 | T[] rdCol(T = long)(long col)
      | ^
a.cc:50:1: error: 'T' does not name a type
   50 | T[][] rdMat(T = long)(long col)
      | ^
a.cc:55:6: error: variable or field 'wrMat' declared void
   55 | void wrMat(T = long)(T[][] mat)
      |      ^~~~~
a.cc:55:12: error: 'T' was not declared in this scope
   55 | void wrMat(T = long)(T[][] mat)
      |            ^
a.cc:55:16: error: expected primary-expression before 'long'
   55 | void wrMat(T = long)(T[][] mat)
      |                ^~~~
a.cc:68:1: error: 'import' does not name a type
   68 | import std.stdio;
      | ^~~~~~
a.cc:68:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:69:1: error: 'import' does not name a type
   69 | import std.string;
      | ^~~~~~
a.cc:69:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:70:1: error: 'import' does not name a type
   70 | import std.array;
      | ^~~~~~
a.cc:70:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:71:1: error: 'import' does not name a type
   71 | import std.conv;
      | ^~~~~~
a.cc:71:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:72:1: error: 'import' does not name a type
   72 | import std.algorithm;
      | ^~~~~~
a.cc:72:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:73:1: error: 'import' does not name a type
   73 | import std.range;
      | ^~~~~~
a.cc:73:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:74:1: error: 'import' does not name a type
   74 | import std.math;
      | ^~~~~~
a.cc:74:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:75:1: error: 'import' does not name a type
   75 | import std.numeric;
      | ^~~~~~
a.cc:75:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:76:1: error: 'import' does not name a type
   76 | import std.traits;
      | ^~~~~~
a.cc:76:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:77:1: error: 'import' does not name a type
   77 | import std.container;
      | ^~~~~~
a.cc:77:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:78:1: error: 'import' does not name a type
   78 | import std.functional;
      | ^~~~~~
a.cc:78:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:79:1: error: 'import' does not name a type
   79 | import std.typecons;
      | ^~~~~~
a.cc:79:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:80:1: error: 'import' does not name a type
   80 | import std.ascii;
      | ^~~~~~
a.cc:80:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:81:1: error: 'import' does not name a type
   81 | import std.uni;
      | ^~~~~~
a.cc:81:1: note: C++20 'import' only available with '-fmodules-ts'