#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <limits>
#include <set>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
template <typename T>
std::ostream &operator<<(std::ostream &os, const vector<T> &obj) {
bool first = true;
for (const auto &o : obj) {
if (first) {
cout << o;
first = false;
} else {
cout << ' ' << o;
}
}
cout << endl;
return os;
}
std::ostream &operator<<(std::ostream &os, const vector<pair<int, int>> &obj) {
for (const auto &o : obj) {
cout << o.first << ' ' << o.second << endl;
}
cout << endl;
return os;
}
// {adjacent, adjacents_idx(self), weight}
vector<vector<tuple<int, int, int>>> adjacency;
set<int> seen;
int source, drain;
bool _ff_dfs(int node, vector<tuple<int, int, int> *> &out) {
seen.insert(node);
// cout << "dfs(" << node << ')' << endl;
for (auto &adj : adjacency[node]) {
auto &[nb, rev, w] = adj;
// cout << "nb: " << nb << endl;
if (w <= 0) {
// cout << "zero w" << endl;
continue;
}
if (seen.contains(nb)) {
// cout << "visited" << endl;
continue;
}
// cout << ">" << endl;
if (nb == drain || _ff_dfs(nb, out)) {
out.push_back(&adj);
// cout << "<" << endl;
return true;
}
// cout << "<" << endl;
// cout << ">" << endl;
// if (_ff_dfs(nb, out)) {
// out.push_back(&adj);
// return true;
// }
// cout << "<" << endl;
}
return false;
}
float max_flow() {
float total = 0;
vector<tuple<int, int, int> *> path_weights;
while (_ff_dfs(source, path_weights)) {
// cout << "dfs ran" << endl;
seen.clear();
int minimum = numeric_limits<int>::max();
for (const auto ptr : path_weights) {
int w = get<2>(*ptr);
minimum = min(w, minimum);
}
// cout << "minimum: " << minimum << endl;
for (auto ptr : path_weights) {
auto &[nb, rev, w] = *ptr;
auto &rev_w = get<2>(adjacency[nb][rev]);
w -= minimum;
rev_w += minimum;
}
total += minimum;
// cout << "total: " << total << endl;
path_weights.clear();
}
return total;
}
// struct FordFulkerson {
// vector<vector<pair<int, float>>> edges;
// int source;
// int drain;
// set<int> visited;
//
// FordFulkerson(vector<vector<pair<int, float>>> edges, int source, int
// drain)
// : edges{edges}, source(source), drain(drain), visited() {}
//
// // void debug() {
// // cout << '{';
// // for (auto x : visited) {
// // cout << x << ',';
// // }
// // cout << '}' << endl;
// // }
//
// bool dfs(int node, vector<float *> &out_fwd) {
// visited.insert(node);
// cout << "dfs(" << node << ')' << endl;
// for (auto &[nb, w] : edges[node]) {
// cout << "nb: " << nb << endl;
// // if (w <= 0 || visited.contains(nb))
// // continue;
// // debug();
// if (w <= 0) {
// // cout << "zero w" << endl;
// continue;
// }
// if (visited.contains(nb)) {
// // cout << "visited" << endl;
// continue;
// }
//
// if (nb == drain) {
// out_fwd.push_back(&w);
// // cout << "found drain" << endl;
// return true;
// }
//
// cout << ">" << endl;
// if (dfs(nb, out_fwd)) {
// out_fwd.push_back(&w);
// return true;
// }
// cout << "<" << endl;
// }
// return false;
// }
//
// float solve() {
// float total = 0;
// vector<float *> path_weights;
// while (dfs(source, path_weights)) {
// // cout << "dfs ran" << endl;
// visited.clear();
// float minimum = INFINITY;
// for (const auto ptr : path_weights) {
// minimum = min(*ptr, minimum);
// }
// cout << "minimum: " << minimum << endl;
// for (auto ptr : path_weights) {
// (*ptr) -= minimum;
// }
// total += minimum;
// cout << "total: " << total << endl;
// path_weights.clear();
// }
// return total;
// }
// };
int matchings(int left, int right, const vector<pair<int, int>> &edges) {
adjacency = vector<vector<tuple<int, int, int>>>(
left + right + 2, vector<tuple<int, int, int>>(0));
// cout << edges;
source = left + right;
drain = left + right + 1;
for (int i = 0; i < left; ++i) {
int a = source;
int b = i;
int rev_f = adjacency[b].size();
int rev_b = adjacency[source].size();
adjacency[a].push_back({b, rev_f, 1});
adjacency[b].push_back({a, rev_b, 0});
}
for (int i = 0; i < right; ++i) {
int a = left + i;
int b = drain;
int rev_f = adjacency[drain].size();
int rev_b = adjacency[a].size();
adjacency[a].push_back({b, rev_f, 1});
adjacency[b].push_back({a, rev_b, 0});
}
// cout << "sources, drains" << endl;
for (const auto &e : edges) {
int a = e.first;
int b = e.second + left;
int rev_f = adjacency[b].size();
int rev_b = adjacency[a].size();
adjacency[a].push_back({b, rev_f, 1});
adjacency[b].push_back({a, rev_b, 0});
}
// for (int e = 0; e < left + right + 2; ++e) {
// cout << "edge: " << e << endl;
// for (auto adj : E[e]) {
// cout << adj.first << ", w: " << adj.second << endl;
// }
// }
// cout << "Running FF" << endl;
// return FordFulkerson(E, source, drain).solve();
return max_flow();
}
int main(int argc, char **argv) {
int n, m, k;
cin >> n >> m >> k;
// int desired_size[n];
// int sizes[m];
vector<int> desired_size(n);
vector<int> sizes(m);
for (int i = 0; i < n; ++i)
cin >> desired_size[i];
for (int i = 0; i < m; ++i)
cin >> sizes[i];
sort(sizes.begin(), sizes.end());
vector<pair<int, int>> edges;
for (int i = 0; i < n; ++i) {
int des = desired_size[i];
auto lo = lower_bound(sizes.begin(), sizes.end(), des - k);
auto hi = upper_bound(sizes.begin(), sizes.end(), des + k);
for (; lo < hi; ++lo) {
edges.push_back({i, distance(sizes.begin(), lo)});
}
}
cout << matchings(n, m, edges) << endl;
}
