/*
 P : N>0 and sorted(A,0,N-1) and V=A
 Q : perm(V,A) and sorted(V,0,N)
 
 
 I : perm(V,A) and sorted(V,0,n) and sorted(V,n, N) 
and (0<n<N-1 - > V[n-1]<V[n+1]) and 0 <= n <= N-1
 
 !B : n==0 || V[n]>=V[n-1]
 
  B : n > 0 && V[n]<V[n-1]
 
|- I and !B -> Q
 
Quote:
 
  C(n) = n >= 0 
 
|- I -> C(n) >= 0 
 
Invariant snapshot:
-------------------
 
0                 n           N
+-----+-----+-----+-----+-----+
|  0  |  1  |  3  |  2  |  4  |
+-----+-----+-----+-----+-----+
 
Init:
-----
 n = N- 1
 
|- P -> I[n/N-1]
 
Step:
----
  n= n- 1
 
|- I and B and n=T -> (n<T)[n/n-1]
 
Restore:
--------
 
  V[n],V[n-1]=V[n-1],V[n]
 
Pseudocode:
-----------
 
   n=N-1
   while n>0 and V[n]<V[n-1] do
     V[n],V[n-1]=V[n-1],V[n]
     n=n-1
   done
 
*/
 
void *insertChar(char V[], int N)
{
  for(int n=N-1 ; (n && V[n]<V[n-1]);n--)
    {
      const int An=V[n];  /* To do swapping */
      V[n]=V[n-1];
      V[n-1]=An;
    }
  return V;
}
 
 
 
#include <stdio.h>
#include <string.h>
 
 
#define MAX 100000
int main(int argc, char* args[])
{
  int N;
  char V[MAX];
  memset(V,0, MAX);
 
  for(N=0 ; (scanf("%c",&c)==1) && c!='\n' ; )
    {
      V[N++]=c;
      printf("%d %c %s\n",strlen(V),c,insertChar(V,N));
    }
  return 0;
}

 gcc char.cc -o char && ./char
enunlugardelamancha
1 e e
2 n en
3 u enu
4 n ennu
5 l elnnu
6 u elnnuu
7 g eglnnuu
8 a aeglnnuu
9 r aeglnnruu
10 d adeglnnruu
11 e adeeglnnruu
12 l adeegllnnruu
13 a aadeegllnnruu
14 m aadeegllmnnruu
15 a aaadeegllmnnruu
16 n aaadeegllmnnnruu
17 c aaacdeegllmnnnruu
18 h aaacdeeghllmnnnruu
19 a aaaacdeeghllmnnnruu

int vertir-un-numero(int n)
{
tpila pila;
init_stack(pila);
while(n>0){
push_stack(pila,n%10);
n/=10;
}
for(int i=0;empty_stack(pila)==false;i++)
n+=pop_stack(pila)*pow(10.0,i);
return n;
}

for(int i=0,power=1;empty_stack(pila)==false;i++)
{
n+=pop_stack(pila)*power;
power *=10 ;
}
 

int invertir_un_numeroG(const int N,int &power);
 
/*
 P : A[0..log(N)) and N = \sum i : 0 <= i < log(N) : A[i]*10^i
 Q : M = \sum i : 0 <= i < log(N) : A[i]*10^(log(N)-i)
*/
int invertir_un_numero(const int N)
{
  int power;
  return invertir_un_numeroG(N,power);
}
 
 
/* P' : P 
   Q' : Q and power=10^log(N)
*/
int invertir_un_numeroG(const int N,int &power)
{
  if (N==0) { power = 1 ; return 0 ; }
  int result;
  result = invertir_un_numeroG(N/10,power);
  result += N%10 * power ;
  power *= 10;
  return result;
}
 
#include <iostream>
 
using namespace std;
 
int main(int argc, char* args[])
{
  int N;
  for( ; cin >> N ; )
    cout << invertir_un_numero(N) << endl;
  return 0;
}

bash-2.04$ ./main
45
54
4678
8764
12345678
87654321

 
/*         
 P : strict(V)
 fun k_paired(V[0..N) of int, int k) dev r
 Q : r =#i,j : 0 <= i , j<N : V[j]-V[i]=k
 
 I : Q[N/n] and 0 <= m <= n <= N and
     n<N -> \forall i : 0<=i < m : V[n]-V[i] > k   **
 
     ** m for efficiency reasons, discarding 
        subtrahends V[i] far from V[n].
     
 
 !B : n==N     B: n<N
 
  C(N,n,m)= 2N - (m+n) >= 0
 
 
 
Invariant snapshot:
-------------------
 
k = 20  , r = 0
0                 m                             n           N
+-----+-----+-----+-----+-...-+-----+-----+-----+-----+-...-+
|  1  |  3  |  5  |  40 |     |     | 49  | 50  | 60  |     |
+-----+-----+-----+-----+-...-+-----+-----+-----+-----+-...-+
 
 
*/
 
 
 
#include <iostream>
 
using namespace std;
int k_paired(const int V[], const int N, const int k)
{
  int n,m,r;
  for(n=m=r=0;n<N;)
    if (V[n]-V[m] <= k)
      r+=(V[n++]-V[m] == k);
    else m++;
  return r;
 
}
 
#define MAX 100000
 
int main(int argc, char **args)
{
  int N,k;
  int V[MAX];
  for(cin >> N ; N!=-1 ; cin>>N)
    {
      cin >> k;
      for(int n=0;n<N;n++)
	cin >> V[n];
      cout << k_paired(V,N,k) << endl;
    }
  return 0;
}