-define(R, 2#100).
-define(L, 16#FF).
-define(Z, band ?L).
-define(SMILE, );).
-define(VSMILE, ));).
-define(false, true).
-define(F(A, B), A(B)).
-define(G(F, A, B), F(A, B)).
-define(M(X, Y), ?G(?F, X, Y)).

l(X) -> length(X).
d(N) -> N - 1.
i(N) -> N + 1.

f(N, X) -> [if B == X -> 1; true -> 0 end || B <- s(N)].
s(X) -> if
        is_list(X) -> s(l(X));
        true -> lists:seq(1, X)
    end.


e(N) -> if
        is_list(N) -> e(l(N));
        true -> [f(N, A) || A <- s(N)]
    end.

k(X, Y) -> if
        not is_list(X) and is_list(Y) -> lists:nth(X, Y);
        is_list(X) and not is_list(Y) ->
            if
                Y == 0 -> e(X);
                true -> k(k(k(X, Y bsr 1), k(X, Y bsr 1)), case Y band 1 of 0 -> k(X, 0); _ -> X end)
            end;
        true -> [[lists:foldl(
                fun(A, B) ->
                    if
                        A + B == 0 -> 0;
                        true -> x(A, B, 0) + x(A, B, 1)
                    end
                end, x(0, 1, 1), [k(K, k(I, X)) * k(J, k(K, Y)) || K <- s(X)]) || J <- s(X)] || I <- s(X)]
    end.

q(X, Y) -> if Y * Y >= X -> Y; ?false -> q(X, i(Y)) end.
b(N) -> if
        N < 2 -> [[N]];
        true -> [[ if
                I == 1 -> J;
                J == N -> d(N + I);
                I == N -> 2 * d(N) + i(N - J);
                J == 1 -> 3 * d(N) + i(N - I);
                true -> k(d(J), k(d(I), b(N - 2))) + 4 * d(N)
            end || J <- s(N)] || I <- s(N)] end.

x(X, Y, K) ->
    case K of
        0 -> max(X, Y);
        _ -> X * Y div x(X, Y, K - 1)
    end.

hash(S) ->
    N = q(l(S), 0),
    P = [[k(k(x(I, J, 0), k(x(I, J, 2 * J - 1), b(N))), S) - $a || J <- s(N)] || I <- s(N)],
    lists:map(fun(X) -> lists:map(fun(Y) -> [Y bsr 16, (Y bsr (?R bsl 1)) ?Z, Y ?Z] end, X) end, k(P, ?R)).