#include <bits/stdc++.h>
template <typename T>
class IntegerIterator {
 public:
  using value_type = T;
  using difference_type = std::ptrdiff_t;
  using pointer = T*;
  using reference = T;
  using iterator_category = std::input_iterator_tag;
  explicit IntegerIterator(T value) : value(value) {}
  IntegerIterator& operator++() {
    ++value;
    return *this;
  }
  IntegerIterator operator++(int) {
    IntegerIterator copy = *this;
    ++value;
    return copy;
  }
  IntegerIterator& operator--() {
    --value;
    return *this;
  }
  IntegerIterator operator--(int) {
    IntegerIterator copy = *this;
    --value;
    return copy;
  }
  T operator*() const { return value; }
  bool operator==(IntegerIterator rhs) const { return value == rhs.value; }
  bool operator!=(IntegerIterator rhs) const { return !(*this == rhs); }

 private:
  T value;
};
template <typename T>
class IntegerRange {
 public:
  IntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
  IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
  IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }

 private:
  T begin_;
  T end_;
};
template <typename T>
class ReversedIntegerRange {
  using IteratorType = std::reverse_iterator<IntegerIterator<T>>;

 public:
  ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
  IteratorType begin() const {
    return IteratorType(IntegerIterator<T>(begin_));
  }
  IteratorType end() const { return IteratorType(IntegerIterator<T>(end_)); }

 private:
  T begin_;
  T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
  return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
  return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
  return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
  return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
  return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
  return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
  return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
  return ReversedIntegerRange<T>(from + 1, to);
}
namespace impl {
using Random = std::mt19937;
}
inline impl::Random& randomEngine() {
  static std::random_device device;
  static impl::Random engine(device());
  return engine;
}
inline int randomInteger() {
  std::uniform_int_distribution<int> d;
  return d(randomEngine());
}
inline int randomInteger(int to) {
  ;
  std::uniform_int_distribution<int> d(0, to - 1);
  return d(randomEngine());
}
inline int randomInteger(int from, int to) {
  return from + randomInteger(to - from);
}
using std::endl;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::vector;
class AAlmostEqual {
 public:
  static bool check(const vector<int>& res) {
    vector<int> sums;
    for (int start : range(res.size())) {
      int temp = 0;
      for (int i = start; i < start + (res.size() / 2); i++) {
        temp += res[i % res.size()];
      }
      sums.push_back(temp);
    }
    int delta = *std::max_element(sums.begin(), sums.end()) -
                *std::min_element(sums.begin(), sums.end());
    return delta <= 1;
  }
  static void solveSlow(std::stringstream& in, std::ostream& out) {
    int n;
    in >> n;
    vector<int> res(2 * n);
    for (int i : range(res.size())) res[i] = i + 1;
    do {
      if (check(res)) {
        out << "YES" << endl;
        return;
      }
    } while (std::next_permutation(res.begin(), res.end()));
    out << "NO" << endl;
  }
  static constexpr int kStressIterations = 10;
  static void generateTest(std::ostringstream& in, std::ostringstream& ___) {
    in << randomInteger(5) + 1 << endl;
    auto _____ = std::stringstream(in.str());
    solveSlow(_____, ___);
  }
  void solve(std::istream& in, std::ostream& out) {
    int n;
    in >> n;
    vector<int> res(2 * n);
    for (int i = 0; i < res.size(); i += 2) {
      int a = i + 1;
      int b = i + 2;
      if ((i / 2) % 2 == 1) {
        swap(a, b);
      }
      res[i / 2] = a;
      res[(i / 2 + n) % res.size()] = b;
    }
    if (n % 2 == 1) {
      out << "YES" << endl;
      for (int val : res) out << val << " ";
      out << endl;
    } else {
      out << "NO" << endl;
    }
  }
};
int main() {
  std::ios_base::sync_with_stdio(false);
  AAlmostEqual solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  in.tie(nullptr);
  solver.solve(in, out);
  return 0;
}
