import std.conv, std.functional, std.range, std.stdio, std.string; import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons; import core.bitop; class EOFException : Throwable { this() { super("EOF"); } } string[] tokens; string readToken() { for (; tokens.empty; ) { if (stdin.eof) { throw new EOFException; } tokens = readln.split; } auto token = tokens.front; tokens.popFront; return token; } int readInt() { return readToken.to!int; } long readLong() { return readToken.to!long; } real readReal() { return readToken.to!real; } bool chmin(T)(ref T t, in T f) { if (t > f) { t = f; return true; } else { return false; } } bool chmax(T)(ref T t, in T f) { if (t < f) { t = f; return true; } else { return false; } } int binarySearch(alias pred, T)(in T[] as) { int lo = -1, hi = cast(int)(as.length); for (; lo + 1 < hi; ) { const mid = (lo + hi) >> 1; (unaryFun!pred(as[mid]) ? hi : lo) = mid; } return hi; } int lowerBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a >= val)); } int upperBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a > val)); } void main() { try { for (; ; ) { const N = readInt(); const K = readLong(); auto A = new long[N]; foreach (i; 0 .. N) { A[i] = readLong(); } long ans; foreach (i; 0 .. N) { if (A[i] + A[i] == K) { ans += 1; } } void solve(int l, int r) { if (r - l <= 1) { return; } const mid = (l + r) / 2; solve(l, mid); solve(mid, r); alias Entry = Tuple!(long, "val", int, "pos"); Entry[] ps, qs; { long mn = long.max; int cnt; foreach_reverse (i; l .. mid) { if (chmin(mn, A[i])) cnt = 0; if (mn == A[i]) ++cnt; if (cnt == 1) ps ~= Entry(mn, i); } } { long mn = long.max; int cnt; foreach (i; mid .. r) { if (chmin(mn, A[i])) cnt = 0; if (mn == A[i]) ++cnt; if (cnt == 1) qs ~= Entry(mn, i); } } long[] vals; foreach (ref p; ps) vals ~= p.val; foreach (ref q; qs) vals ~= q.val; vals = vals.sort.uniq.array; debug { writeln("solve ", l, " ", mid, " ", r); writeln(" ps = ", ps); writeln(" qs = ", qs); } const psLen = cast(int)(ps.length); const qsLen = cast(int)(qs.length); int kp, kq; long[long] s0P, s1P, s0Q, s1Q; foreach_reverse (val; vals) { int lp, lq; for (lp = kp; lp < psLen && ps[lp].val == val; ++lp) {} for (lq = kq; lq < qsLen && qs[lq].val == val; ++lq) {} debug { writeln(" ", val, " ", [kp, lp], " ", [kq, lq]); } foreach (m; kp .. lp) { const i = ps[m].pos; if ((K - A[i]) in s0Q) { debug { writeln(" P ", ps[m], " ", (s1Q[K - A[i]] - s0Q[K - A[i]] * (i - 1))); } ans += (s1Q[K - A[i]] - s0Q[K - A[i]] * (i - 1)); } } foreach (m; kq .. lq) { const i = qs[m].pos; if ((K - A[i]) in s0P) { debug { writeln(" Q ", qs[m], " ", (s0P[K - A[i]] * (i + 1) - s1P[K - A[i]])); } ans += (s0P[K - A[i]] * (i + 1) - s1P[K - A[i]]); } } foreach (m; kp .. lp) { const i = ps[m].pos; s0P[A[i]] += 1; s1P[A[i]] += i; } foreach (m; kq .. lq) { const i = qs[m].pos; s0Q[A[i]] += 1; s1Q[A[i]] += i; } kp = lp; kq = lq; } } solve(0, N); writeln(ans); } } catch (EOFException e) { } }