#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long double PI = 3.14159265358979323846264338327;
template <typename T>
void unique(T &c) {
  std::sort(c.begin(), c.end());
  c.resize(std::unique(c.begin(), c.end()) - c.begin());
}
template <typename T>
void sort(T &c) {
  std::sort(c.begin(), c.end());
}
template <typename T>
T minV() {
  return std::numeric_limits<T>::min();
}
template <typename T>
T maxV() {
  return std::numeric_limits<T>::max();
}
template <typename T>
std::string tostr(const T &el) {
  std::stringstream stream;
  stream << el;
  return stream.str();
}
template <typename T>
T fromstr(const std::string &s) {
  T el;
  std::stringstream stream;
  stream << s;
  stream >> el;
  return el;
}
std::vector<std::string> &split(const std::string &s, const std::string &delim,
                                std::vector<std::string> &tokens) {
  std::string::size_type lastPos = s.find_first_not_of(delim, 0);
  std::string::size_type pos = s.find_first_of(delim, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delim, pos);
    pos = s.find_first_of(delim, lastPos);
  }
  return tokens;
}
std::string &join(const std::vector<std::string> &vs, const std::string &delim,
                  std::string &out) {
  for (std::string::size_type i = 0; i < vs.size() - 1; ++i)
    out += (vs[i] + delim);
  out += vs.back();
  return out;
}
std::vector<std::string> split(const std::string &s, const std::string &delim) {
  std::vector<std::string> tokens;
  std::string::size_type lastPos = s.find_first_not_of(delim, 0);
  std::string::size_type pos = s.find_first_of(delim, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delim, pos);
    pos = s.find_first_of(delim, lastPos);
  }
  return tokens;
}
std::string join(const std::vector<std::string> &vs, const std::string &delim) {
  std::string out;
  for (std::string::size_type i = 0; i < vs.size() - 1; ++i)
    out += (vs[i] + delim);
  out += vs.back();
  return out;
}
std::string &lower_case(std::string &s) {
  std::transform(s.begin(), s.end(), s.begin(), ::tolower);
  return s;
}
std::string &upper_case(std::string &s) {
  std::transform(s.begin(), s.end(), s.begin(), ::toupper);
  return s;
}
void nl() { std::cout << std::endl; }
template <typename T>
void out(const T &c) {
  for (typename T::const_iterator it = c.begin(); it != c.end(); ++it)
    std::cout << *it << " ";
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &out, const std::pair<T1, T2> &P) {
  out << "(" << P.first << ";" << P.second << ")";
  return out;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &in, pair<T1, T2> &P) {
  in >> P.first >> P.second;
  return in;
}
struct team {
  int p, t;
  team() {}
  bool operator<(const team &T) { return p > T.p || (p == T.p && (T.t < T.t)); }
};
long long A[4][4];
long long B[4][4];
long long C[4][4];
void mul1() {
  for (int i = 0; i < 4; ++i) {
    for (int j = 0; j < 4; ++j) {
      C[i][j] = 0;
      for (int k = 0; k < 4; ++k) C[i][j] += A[i][k] * A[k][j];
    }
  }
  for (int i = 0; i < 4; ++i) {
    for (int j = 0; j < 4; ++j) {
      A[i][j] = C[i][j];
    }
  }
}
void mul2() {
  for (int i = 0; i < 4; ++i) {
    for (int j = 0; j < 4; ++j) {
      C[i][j] = 0;
      for (int k = 0; k < 4; ++k) C[i][j] += B[i][k] * A[k][j];
    }
  }
  for (int i = 0; i < 4; ++i) {
    for (int j = 0; j < 4; ++j) {
      B[i][j] = C[i][j];
    }
  }
}
int main() {
  int n, x;
  cin >> n >> x;
  vector<int> curr;
  int wasx = false;
  for (int i = 0; i < n; ++i) {
    int t;
    cin >> t;
    if (t == x) wasx = true;
    curr.push_back(t);
  }
  int add = 0;
  if (!wasx) {
    curr.push_back(x);
    add++;
  }
  while (true) {
    sort(curr.begin(), curr.end());
    int med = (curr.size() + 1) / 2 - 1;
    if (curr[med] == x)
      break;
    else if (curr[med] > x)
      curr.push_back(1);
    else {
      curr.push_back(100 * 1000);
    }
    add++;
  }
  cout << add << endl;
  return 0;
}
