Are you interested in t-shirts of previous years?

Yes, same thing happened to me.

hmmm, can you try https://passport.yandex.com for that?

I had the same problem. Then I tried replacing the option lang=en to lang=ru in the URL, and registration page appeared.

Since I don't understand Russian, I switched back to English and it was still working.

Sorry about that. (Ads) You can always use Yandex.Browser with turbo mode! (/ads)

We'll supply you with additional form with shipping information, when you will score within top 512 of elimination stage — make sure to fill in correct email address though.

sure! Elaborate on that issue in feedback page of the service (lower left corner), after the contest

Blind submissions are tested only on samples, but you get negative penalty time if it's Accepted on the full testset

see rules. In short — open submissions work like regular ACM submissions — you get penalty for time and wrong attempts and full feedback on testing. With blind submission you only have one (1) attempt to send submission that will pass sample tests and can't resubmit — if that submission is correct you get negative penalty time

One possible approach was to use matrix exponentiation and speed up multiplications using strassen's method. Eventually for large m the answer would approach a constant value and thus we don't even have to exponentiate to 10^(2016), much lesser will suffice. This could have passed the time limit (barely) but there must be a better solution.

It is actually a problem of finding a limit distribution of the Markov chain. It is guaranteed that 1 is an essential state, so at first step we should remove all inessential states (those are the states that cannot be reached from any other state with non-zero probability). After that all remaining states (in particular, 1) form an irreducible Markov chain where all states are positive recurrent (meaning that there is non-zero probability to return from each state to itself). For such Markov chain it can be proven that the limit distribution is exactly the stationary distribution (i.e. the distribution that transforms to itself after one step of a Markov chain), so we can find it as a left eigenvector of matrix B of that chain using Gauss elimination.

UPD: Looks like we don't even need to leave only essential states, it works even without it. All components of stationary distribution corresponding to the inessential states will be simply equal to zero that perfectly makes sense.

I didn't implement this, but I believe it works. Also I've seen author's solution, it also has a Gauss elimination :)

Yes, tomorrow we will post it here.

Update. Posted.

Yep

Read Wikipedia.

I just read the abstract of this paper.

And m = 1 is a special case to be considered apart.

From my experience from last year,

First they sum the number of points you get, who has more stays in front (using that grand prix formula for giving points, sum all points you get during the 3 elimination rounds).

Tie-breaks are made by number of problems solved (sum of number of problems during the 3 rounds).

I am not sure about the last one, but I guess if you are tied in points and number of problems the tie-break is the sum of your penalty during the 3 elimination rounds.

Edit: If you get a point in a round you are guaranteed a t-shirt as only 30 people get points in a round. Last year Petr got first place in the first round, he didn't participate in any other elimination rounds (if I remember correctly) and got a spot in the onsite finals (because he had a lot of points). Participating in more rounds gives more chances to get points and solve more problems (which is the first tie-break criterion), but it is possible to only participate in one round and get a t-shirt (though not advisable if you want the t-shirt and got no points for the round).

Don't know what did you mean exactly. But the solution for this problem is also a formula ;). I computed it in O(p) and didn't try to reduce the complexity and simplify:

inline int C(int n, int k) {
    return f[n] * fi[n - k] % MOD * fi[k] % MOD;
}

// number of ways to split n items to k groups
inline int D(int n, int k) {
    if (k == 0) return n == 0 ? 1 : 0;
    return C(n + k - 1, k - 1);
}

int solve() {
    if (p == 0) {
        if (m && w) return 0;
        return f[m] * f[w];
    }
    int res = 0;
    for (int i = 1; i <= p; ++i) {
        int x = i / 2 + 1, y = (i + 1) / 2;
        int g = w - i, b = m - i;
        int t = (D(g, x) * D(b, y) % MOD + D(g, y) * D(b, x) % MOD) % MOD;
        res += t * C(p, i) % MOD * f[i] % MOD * f[g] % MOD * f[b] % MOD;
        if (res >= MOD) res -= MOD;
    }
    return res;
}