Hiking club "Up the hill" just returned from a walk. Now they are trying to remember which hills they've just walked through.

It is known that there were N stops, all on different integer heights between 1 and N kilometers (inclusive) above the sea level. On the first day they've traveled from the first stop to the second stop, on the second day they've traveled from the second to the third and so on, and on the last day they've traveled from the stop N - 1 to the stop N and successfully finished their expedition.

They are trying to find out which heights were their stops located at. They have an entry in a travel journal specifying how many days did they travel up the hill, and how many days did they walk down the hill.

Help them by suggesting some possible stop heights satisfying numbers from the travel journal.

Input

In the first line there is an integer non-negative number A denoting the number of days of climbing up the hill. Second line contains an integer non-negative number B — the number of days of walking down the hill (A + B + 1 = N, 1 ≤ N ≤ 100 000).

Output

Output N space-separated distinct integers from 1 to N inclusive, denoting possible heights of the stops in order of visiting.

Examples

Input

0
1


Output

2 1 


Input

2
1

Output

1 3 4 2
#include <bits/stdc++.h>
using namespace std;
class Pair;
class Item {
  friend ostream& operator<<(ostream& out, const Pair& c);
  friend istream& operator>>(istream& out, Pair& c);

 public:
  Item(string des) { description = des; }
  long long int keyF() {
    key = description.length();
    return key;
  }
  string toString() { return description; }
  long long int key;
  string description;
};
ostream& operator<<(ostream& out, const Item& c) {
  out << c.description;
  return out;
}
istream& operator>>(istream& in, Item& c) {
  in >> c.description;
  return in;
}
template <typename E>
void print(E value) {
  cout << value;
}
template <typename E>
void print(E value1, E value2) {
  cout << value1 << " " << value2;
}
template <typename E>
void print(E value1, E value2, E value3) {
  cout << value1 << " " << value2 << " " << value3;
}
template <typename E>
E read() {
  E value;
  cin >> value;
  return value;
}
string readString() {
  char* s = new char[1000];
  fgets(s, 1000, stdin);
  return string(s);
}
template <typename E>
void println(E value) {
  cout << value << endl;
}
template <typename E>
void println(E value1, E value2) {
  cout << value1 << " " << value2 << endl;
}
template <typename E>
void println(E value1, E value2, E value3) {
  cout << value1 << " " << value2 << " " << value3 << endl;
}
template <typename E>
void println(E value1, E value2, E value3, E value4) {
  cout << value1 << " " << value2 << " " << value3 << " " << value4 << endl;
}
long long int randomint(long long int min, long long int max) {
  if (max == min) {
    return max;
  }
  return rand() % (max - min + 1) + min;
}
class Pair {
  friend ostream& operator<<(ostream& out, const Pair& c);
  friend istream& operator>>(istream& out, Pair& c);

 public:
  Pair(Item* p);
  long long int key;
  Item* value;
};
Pair::Pair(Item* b) {
  key = b->key;
  value = b;
}
ostream& operator<<(ostream& out, const Pair& c) {
  out << "(" << c.value->key << " -> " << (c.value->toString()) << ")";
  return out;
}
template <typename E>
class Array {
 public:
  long long int size;
  Array<E>(long long int _capacity) {
    capacity = _capacity;
    array = new E[capacity];
    size = capacity;
    for (long long int i = 0; i < size; i++) {
      array[i] = 0;
    }
  }
  void sort() { std::sort(&array[0], &array[size]); }
  Array() {
    capacity = 0;
    array = new E[capacity];
    size = 0;
  }
  Array(vector<E>& vect) {
    long long int _size = vect.size();
    capacity = _size * 2;
    size = _size;
    array = new E[capacity];
    for (long long int i = 0; i < size; i++) {
      array[i] = vect[i];
    }
  }
  Array(long long int minBound, long long int maxBound, long long int _size) {
    srand(_size);
    capacity = _size * 2;
    size = _size;
    array = new E[capacity];
    for (long long int i = 0; i < size; i++) {
      array[i] = randomint(minBound, maxBound);
    }
  }
  void add(E item);
  vector<E> toVector();
  void toString();
  E& operator[](long long int i);
  E& index(long long int i);
  E* array;
  void null(void) {
    for (long long int i = 0; i < size; i++) {
      array[i] = 0;
    }
  }

 private:
  long long int capacity;
  void ensureCapacity(long long int cap);
};
template <typename E>
void Array<E>::ensureCapacity(long long int cap) {
  capacity = capacity * 2;
  E* newArray = new E[capacity];
  memcpy(newArray, array, sizeof(E) * size);
  delete[] array;
  array = newArray;
}
template <typename E>
void Array<E>::toString() {
  long long int i = 0;
  E* begin = array;
  cout << "[";
  while (i < size) {
    if (i == size - 1) {
      cout << *array;
    } else {
      cout << *array << " ";
    }
    array++;
    i++;
  }
  cout << "]";
  cout << endl;
  array = begin;
}
template <typename E>
void Array<E>::add(E item) {
  if (capacity < size + 1) {
    ensureCapacity(size + 1);
  }
  array[size] = item;
  size++;
}
template <typename E>
vector<E> Array<E>::toVector() {
  vector<E> res = vector<E>(size);
  for (long long int i = 0; i < res.size(); i++) {
    res[i] = array[i];
  }
  return res;
}
template <typename E>
E& Array<E>::operator[](long long int i) {
  if (i < size && i >= 0) {
    return array[i];
  } else {
    cout << "Array index out of bounds, index is " << i << ", size is " << size
         << endl;
    cout << "Array is " << endl;
    toString();
    assert(0);
  }
}
template <typename E>
class Matrix {
 public:
  long long int rows;
  long long int columns;
  Array<E> array;
  E& get(long long int x, long long int y);
  void set(long long int x, long long int y, E& value);
  void print();
  Matrix<E>(long long int r, long long int c) {
    rows = r;
    columns = c;
    array = Array<E>(rows * columns);
    array.null();
  }
  void swap(Matrix<E>& other) {
    std::swap(array, other.array);
    std::swap(rows, other.rows);
    std::swap(columns, other.columns);
  }
  Matrix<E>(long long int minBound, long long int maxBound, long long int _rows,
            long long int _columns) {
    rows = _rows;
    columns = _columns;
    long long int size = _rows * _columns;
    array = Array<E>(minBound, maxBound, size);
  }

 private:
};
template <typename E>
E& Matrix<E>::get(long long int x, long long int y) {
  if (x >= columns || x < 0) {
    assert(0);
  }
  if (y >= rows || y < 0) {
    assert(0);
  }
  return array.array[x + y * columns];
}
template <typename E>
void Matrix<E>::print(void) {
  for (size_t y = 0; y < rows; y++) {
    for (size_t x = 0; x < columns; x++) {
      long long int index = x + y * columns;
      cout << array.array[x + y * columns] << " ";
    }
    cout << endl;
  }
}
template <typename E>
void Matrix<E>::set(long long int x, long long int y, E& value) {
  if (x >= columns || x < 0) {
    assert(0);
  }
  if (y >= rows || y < 0) {
    assert(0);
  }
  array.array[x + y * columns] = value;
}
long long int bpow(long long int a, long long int b) {
  if (b == 0) {
    return 1;
  } else {
    if (b % 2 == 0) {
      long long int half = bpow(a, b / 2);
      return half * half;
    } else {
      return bpow(a, b - 1) * a;
    }
  }
}
long long int gcd(long long int a, long long int b) {
  if (!b) {
    return a;
  } else {
    return gcd(b, a % b);
  }
}
vector<pair<long long int, long long int> > factorize(long long int n) {
  vector<pair<long long int, long long int> > res =
      vector<pair<long long int, long long int> >();
  for (long long int i = 2; i < sqrt((double)n) + 1; i++) {
    if (n % i == 0) {
      pair<long long int, long long int> comp = make_pair(i, 1);
      n /= i;
      while (n % i == 0) {
        comp.second++;
        n /= i;
      }
      res.push_back(comp);
    }
  }
  if (n > 1) {
    res.push_back(make_pair(n, 1));
  }
  return res;
}
long long int euler(long long int n) {
  vector<pair<long long int, long long int> > fact = factorize(n);
  long long int res = 1;
  for (unsigned long long int i = 0; i < fact.size(); i++) {
    long long int factor =
        pow((double)fact[i].first, (double)fact[i].second) -
        pow((double)fact[i].first, (double)fact[i].second - 1);
    res *= factor;
  }
  return res;
}
long long int inversePrime(long long int a, long long int m) {
  return bpow(a, m - 2) % m;
}
long long int inverseCoprimes(long long int a, long long int m) {
  return bpow(a, euler(m) - 1) % m;
}
long long int inverse(long long int a, long long int m) {
  if (gcd(a, m) == 1) {
    return inverseCoprimes(a, m);
  } else {
    assert(0);
    return -1;
  }
}
vector<long long int> enumerateDivisors(long long int n) {
  vector<pair<long long int, long long int> > divs = factorize(n);
  vector<long long int> totals = vector<long long int>(divs.size() + 1);
  totals[0] = 1;
  for (unsigned long long int i = 1; i < divs.size() + 1; i++) {
    totals[i] = totals[i - 1] * (divs[i - 1].second + 1);
  }
  vector<long long int> res = vector<long long int>();
  for (long long int i = 0; i < totals[totals.size() - 1]; i++) {
    vector<long long int> values = vector<long long int>(divs.size());
    for (unsigned long long int j = 0; j < values.size(); j++) {
      values[j] = (i / totals[j]) % (divs[j].second + 1);
    }
    long long int r = 1;
    for (unsigned long long int i = 0; i < values.size(); i++) {
      r *= bpow(divs[i].first, values[i]);
    }
    res.push_back(r);
  }
  return res;
}
istream& operator>>(istream& in, Pair& c) {
  in >> c.value->description;
  c.value->key = c.value->keyF();
  return in;
}
void reverse(char* str) {
  char temp;
  size_t len = strlen(str) - 1;
  size_t i;
  size_t k = len;
  for (i = 0; i < len; i++) {
    temp = str[k];
    str[k] = str[i];
    str[i] = temp;
    k--;
    if (k == (len / 2)) {
      break;
    }
  }
}
map<long long int, long long int> count(Array<long long int> a) {
  map<long long int, long long int> res;
  for (long long int i = 0; i < a.size; i++) {
    res[a[i]]++;
  }
  return res;
}
void itoa(long long int n, char s[]) {
  long long int i, sign;
  if ((sign = n) < 0) n = -n;
  i = 0;
  do {
    s[i++] = n % 10 + '0';
  } while ((n /= 10) > 0);
  if (sign < 0) s[i++] = '-';
  s[i] = '\0';
  reverse(s);
}
long long int* vectorToArray(vector<long long int> v) {
  long long int* a = new long long int[v.size()];
  for (unsigned long long int i = 0; i < v.size(); i++) {
    a[i] = v[i];
  }
  return a;
}
bool hadSameDigit(long long int x, long long int y) {
  char* a = new char[15];
  char* b = new char[15];
  itoa(x, a);
  itoa(y, b);
  long long int lena = strlen(a);
  long long int lenb = strlen(b);
  for (long long int i = 0; i < lena; i++) {
    for (long long int j = 0; j < lenb; j++) {
      if (a[i] == b[j]) {
        delete[] a;
        delete[] b;
        return true;
      }
    }
  }
  delete[] a;
  delete[] b;
  return false;
}
int main(void) {
  long long int A;
  long long int B;
  cin >> A;
  cin >> B;
  if (A == 0) {
    for (long long int i = 0; i < B + 1; i++) {
      println(A + B - i + 1);
    }
    return 0;
  }
  if (B == 0) {
    for (long long int i = 0; i < A + 1; i++) {
      println(i + 1);
    }
    return 0;
  }
  long long int current = 1;
  println(current);
  for (long long int i = 0; i < A; i++) {
    long long int reserved = 1 + B + 1;
    println(reserved + i);
  }
  for (long long int j = 0; j < B; j++) {
    long long int reserved = 1 + B;
    println(reserved - j);
  }
}
