int main() {
  int n, b, d;
  std::cin >> n >> b >> d;

  int current_size = 0;
  int result = 0;
  int x;
  for (; n > 0; --n) {
    std::cin >> x;
    if (x > b) {
      continue;
    }
    current_size += x;
    if (current_size > d) {
      ++result;
      current_size = 0;
    }
  }

  std::cout << result << "\n";
  return 0;
}

const int MAXN = 100000;

int x[MAXN];

int main() {
  int n, A;
  scanf("%d %d", &n, &A);
  if (n == 1) {
    printf("0\n");
    return 0;
  }
  for (int i = 0; i < n; i++) {
    scanf("%d", &x[i]);
  }
  int first_max = -2e6;
  int second_max = -2e6;
  int first_min = 2e6;
  int second_min = 2e6;

  for (int i = 0; i < n; i++) {
    if (x[i] > second_max) {
      second_max = x[i];
      if (second_max > first_max) {
        swap(second_max, first_max);
      }
    }
    if (x[i] < second_min) {
      second_min = x[i];
      if (second_min < first_min) {
        swap(second_min, first_min);
      }
    }
  }
  printf("%d\n", min(first_max - second_min + min(abs(A - first_max), abs(A - second_min)),
                     second_max - first_min + min(abs(A - second_max), abs(A - first_min))));

  return 0;
}

void solve() {
  string s;
  cin >> s;
  for (int i = 0; i < s.length(); ++i) {
    if (s[i] == 'a') {
      continue;
    }
    int j = i + 1;
    while (j < s.length() && s[j] != 'a') {
      ++j;
    }
    for (int r = i; r < j; ++r) {
      --s[r];
    }
    cout << s << "\n";
    return;
  }

  s.back() = 'z';
  cout << s << "\n";

}

void imp() {
  cout << "Impossible\n";
  exit(0);
}

ll invtriange(ll x) {
  ll l = 1, r = 1000000;
  while (r - l > 1) {
    ll m = (l + r) / 2;
    if (m * (m - 1) / 2 > x) r = m;
    else l = m;
  }
  if (l * (l - 1) / 2 != x) {
    imp();
  }
  return l;
}

int main() {
  vvl a(2, vl(2));
  for (int i = 0; i < 2; ++i) for (int j = 0; j < 2; ++j) {
    cin >> a[i][j];
  }
  if (a[0][0] + a[0][1] + a[1][0] + a[1][1] == 0) {
    cout << "0\n";
    return 0;
  }
  ll c0 = invtriange(a[0][0]);
  ll c1 = invtriange(a[1][1]);
  if (a[0][0] == 0 || a[1][1] == 0) {
    if (a[0][1] + a[1][0] == 0) {
      if (c0 == 1) c0 = 0;
      if (c1 == 1) c1 = 0;
      cout << string(c0, '0') << string(c1, '1');
      return 0;
    }
  }
  if (c0 * c1 != a[0][1] + a[1][0]) {
    imp();
  }
  string s(c0 + c1, '0');
  for (int i = 0; i < s.size(); ++i) {
    if (c0 == 0 || a[0][1] < c1) {
      s[i] = '1';
      a[1][0] -= c0;
      --c1;
    } else {
      a[0][1] -= c1;
      --c0;
    }
  }
  cout << s << endl;
  return 0;
}

int n;
vector<vector<int>> g;
vector<int> cnt;

int min_mx = 1e9;
int center = -1;

void dfs(int v, int p) {
	cnt[v] = 1;
	int mx = 0;
	for (int to : g[v]) {
		if (to == p) {
			continue;
		}
		dfs(to, v);
		cnt[v] += cnt[to];
		mx = max(mx, cnt[to]);
	}
	mx = max(mx, n - cnt[v]);
	if (mx < min_mx) {
		min_mx = mx;
		center = v;
	}
}

vector<pair<int, int>> subtrees;
vector<int> ans;

void dfs1(int v, int p, int sum_other, int prev) {
	if (sum_other <= n / 2) {
		ans[v] = 1;
	}
	for (int i = 0; i < 2 && i < subtrees.size(); ++i) {
		if (subtrees[i].second == prev) {
			continue;
		}
		if (n - cnt[v] - subtrees[i].first <= n / 2) {
			ans[v] = 1;
		}
	}
	for (int to : g[v]) {
		if (to == p) {
			continue;
		}
		dfs1(to, v, sum_other, prev);
	}
}

void solve() {
	cin >> n;
	g.resize(n);
	cnt.assign(n, 0);
	for (int i = 1; i < n; ++i) {
		int a, b;
		cin >> a >> b;
		--a; --b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	dfs(0, 0);

	assert(center != -1);
	ans.assign(n, 0);
	ans[center] = 1;
	dfs(center, center);
	int sum_all = 0;
	for (int to : g[center]) {
		subtrees.emplace_back(cnt[to], to);
		sum_all += cnt[to];
	}
	sort(all(subtrees));
	reverse(all(subtrees));

	for (int to : g[center]) {
		dfs1(to, center, n - cnt[to], to);
	}

	for (int i = 0; i < n; ++i) {
		cout << ans[i] << ' ';
	}
	cout << "\n";

}

class FixFlow {
public:
	void solve(std::istream& in, std::ostream& out) {
		int n, m;
		in >> n >> m;
		int s = n;
		int t = n + 1;
		MinCostFlow<int, int> flow(n + 2);
		vector<int> balance(n);
		int INF = 1000000000;
		flow.addEdge((size_t) (n - 1), 0, INF, 0);


		int defaultAnswer = 0;
		for (int i: range(m)) {
			int a, b, c, f;
			in >> a >> b >> c >> f;
			--a, --b;
			balance[a] += f;
			balance[b] -= f;
			if (f <= c) {
				flow.addEdge(a, b, c - f, 1);
				flow.addEdge(a, b, INF, 2);
				flow.addEdge(b, a, f, 1);
			} else {
				// f > c
				defaultAnswer += f - c;
				flow.addEdge(a, b, INF, 2);
				flow.addEdge(b, a, f - c, 0);
				flow.addEdge(b, a, c, 1);
			}
		}

		int sumB = 0;
		for (int i: range(n)) {
			if (balance[i] > 0) {
				flow.addEdge(i, t, balance[i], 0);
				sumB += balance[i];
			} else {
				flow.addEdge(s, i, -balance[i], 0);
			}
		}

		auto res = flow.findFlow(s, t, MinCostMaxFlowStrategy());
		assert(res.flow == sumB);
		out << res.cost + defaultAnswer << "\n";
	}
};

class MAI {
public:
	void solve(std::istream& in, std::ostream& out) {
		int N, m;
		int a, b;
		int k;
		in >> N >> m >> a >> b >> k;
		using Z = ZnConst<1000000007>;
		Z p = Z::valueOf(a) / b;
		Z q = 1 - p;

		// dp[r'] = sum l < r <= r' d[l][r]
		vector<Z> dp(m + 1, Z());
		dp[m] = 1;

		vector<Z> powersP(k + 1), powersQ(k + 1);
		powersP[0] = powersQ[0] = 1;
		for (int i: range(k)) {
			powersP[i + 1] = powersP[i] * p;
			powersQ[i + 1] = powersQ[i] * q;
		}

		vector<Z> fact = factorials<Z>(k + 1);
		vector<Z> invfact = fact;
		for (auto& x: invfact) {
			x = 1 / x;
		}

		auto get_p_one_side = [&](int l) {
			if (l > k) {
				return Z();
			}
			return powersP[l] * powersQ[k - l] * fact[k] * invfact[l] * invfact[k - l];
		};

		for (int iter: range(N)) {
			vector<Z> dp_one(m + 1, Z());
			Z sumPl, sumPlDpl;

			for (int r: inclusiveRange(m)) {
				//new_d[l][r] = p[l] * p[n - r] * (have_something - dp[l] - dp[n - r])
				Z have_something = dp.back();
				dp_one[r] = get_p_one_side(m - r) * (
						have_something * sumPl - sumPlDpl - sumPl * dp[m - r]
				);
				sumPl += get_p_one_side(r);
				sumPlDpl += get_p_one_side(r) * dp[r];
			}

			for (int i: range(m)) {
				dp_one[i + 1] += dp_one[i];
			}

			dp = move(dp_one);
		}

		out << dp.back();
	}
};