#include <bits/stdc++.h>
using namespace std;
const long long kInf = 1e12;
int a, b;
void load() { cin >> a >> b; }
struct SingleLayout {
  int small;
  int big;
  int num_small;
  int num_big;
  SingleLayout() : SingleLayout(0, 0, 0, 0) {}
  SingleLayout(int small, int big, int num_small, int num_big)
      : small(small), big(big), num_small(num_small), num_big(num_big) {}
  vector<int> get_sizes() const {
    vector<int> sol;
    sol.reserve(num_small + num_big);
    for (int i = 0; i < num_small; ++i) sol.push_back(small);
    for (int i = 0; i < num_big; ++i) sol.push_back(big);
    return sol;
  }
};
struct DoubleLayout {
  SingleLayout o, x;
  void interleave(char first, const vector<int>& first_sizes, char second,
                  const vector<int>& second_sizes) const {
    assert(first_sizes.size() >= second_sizes.size());
    for (int i = 0; i < first_sizes.size(); ++i) {
      cout << string(first_sizes[i], first);
      if (i < second_sizes.size()) {
        cout << string(second_sizes[i], second);
      }
    }
    cout << endl;
  }
  void reconstruct() const {
    vector<int> o_sizes = o.get_sizes();
    vector<int> x_sizes = x.get_sizes();
    if (o_sizes.size() > x_sizes.size()) {
      interleave('o', o_sizes, 'x', x_sizes);
    } else {
      interleave('x', x_sizes, 'o', o_sizes);
    }
  }
};
bool is_possible(int sum, int num_groups) {
  if (num_groups < 0 || num_groups > sum) {
    return false;
  }
  return true;
}
long long get_max_fast(long long sum, long long num_groups, SingleLayout* rec) {
  if (sum == 0 && num_groups == 0) {
    return 0;
  }
  if (!is_possible(sum, num_groups) || num_groups == 0) {
    return -kInf;
  }
  assert(sum > 0 && num_groups > 0);
  long long big = sum - (num_groups - 1);
  long long small = 1;
  long long num_small = (num_groups - 1);
  long long num_big = 1;
  assert(num_small * small + num_big * big == sum);
  *rec = SingleLayout(small, big, num_small, num_big);
  return num_small * small * small + num_big * big * big;
}
long long get_min_fast(long long sum, long long num_groups, SingleLayout* rec) {
  if (sum == 0 && num_groups == 0) {
    return 0;
  }
  if (!is_possible(sum, num_groups) || num_groups == 0) {
    return kInf;
  }
  assert(sum > 0 && num_groups > 0);
  long long num_small = num_groups - (sum % num_groups);
  long long num_big = num_groups - num_small;
  long long small = sum / num_groups;
  long long big = small + 1;
  assert(num_small * small + num_big * big == sum);
  *rec = SingleLayout(small, big, num_small, num_big);
  return num_small * small * small + num_big * big * big;
}
void solve() {
  long long mx = -kInf;
  DoubleLayout rec;
  for (int M = 0; M <= b; ++M) {
    for (int N = M - 1; N <= M + 1; ++N) {
      DoubleLayout cur_layout;
      long long cur =
          get_max_fast(a, N, &cur_layout.o) - get_min_fast(b, M, &cur_layout.x);
      if (cur > mx) {
        mx = cur;
        rec = cur_layout;
      }
    }
  }
  cout << mx << endl;
  rec.reconstruct();
}
int main() {
  load();
  solve();
  return 0;
}

### Prompt

Please create a solution in CPP to the following problem:

User ainta loves to play with cards. He has a cards containing letter "o" and b cards containing letter "x". He arranges the cards in a row, and calculates the score of the deck by the formula below.

  1. At first, the score is 0. 
  2. For each block of contiguous "o"s with length x the score increases by x2. 
  3. For each block of contiguous "x"s with length y the score decreases by y2. 



For example, if a = 6, b = 3 and ainta have arranged the cards in the order, that is described by string "ooxoooxxo", the score of the deck equals 22 - 12 + 32 - 22 + 12 = 9. That is because the deck has 5 blocks in total: "oo", "x", "ooo", "xx", "o".

User ainta likes big numbers, so he wants to maximize the score with the given cards. Help ainta make the score as big as possible. Note, that he has to arrange all his cards.

Input

The first line contains two space-separated integers a and b (0 ≤ a, b ≤ 105; a + b ≥ 1) — the number of "o" cards and the number of "x" cards.

Output

In the first line print a single integer v — the maximum score that ainta can obtain.

In the second line print a + b characters describing the deck. If the k-th card of the deck contains "o", the k-th character must be "o". If the k-th card of the deck contains "x", the k-th character must be "x". The number of "o" characters must be equal to a, and the number of "x " characters must be equal to b. If there are many ways to maximize v, print any.

Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Examples

Input

2 3


Output

-1
xoxox


Input

4 0


Output

16
oooo

Input

0 4


Output

-16
xxxx

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const long long kInf = 1e12;
int a, b;
void load() { cin >> a >> b; }
struct SingleLayout {
  int small;
  int big;
  int num_small;
  int num_big;
  SingleLayout() : SingleLayout(0, 0, 0, 0) {}
  SingleLayout(int small, int big, int num_small, int num_big)
      : small(small), big(big), num_small(num_small), num_big(num_big) {}
  vector<int> get_sizes() const {
    vector<int> sol;
    sol.reserve(num_small + num_big);
    for (int i = 0; i < num_small; ++i) sol.push_back(small);
    for (int i = 0; i < num_big; ++i) sol.push_back(big);
    return sol;
  }
};
struct DoubleLayout {
  SingleLayout o, x;
  void interleave(char first, const vector<int>& first_sizes, char second,
                  const vector<int>& second_sizes) const {
    assert(first_sizes.size() >= second_sizes.size());
    for (int i = 0; i < first_sizes.size(); ++i) {
      cout << string(first_sizes[i], first);
      if (i < second_sizes.size()) {
        cout << string(second_sizes[i], second);
      }
    }
    cout << endl;
  }
  void reconstruct() const {
    vector<int> o_sizes = o.get_sizes();
    vector<int> x_sizes = x.get_sizes();
    if (o_sizes.size() > x_sizes.size()) {
      interleave('o', o_sizes, 'x', x_sizes);
    } else {
      interleave('x', x_sizes, 'o', o_sizes);
    }
  }
};
bool is_possible(int sum, int num_groups) {
  if (num_groups < 0 || num_groups > sum) {
    return false;
  }
  return true;
}
long long get_max_fast(long long sum, long long num_groups, SingleLayout* rec) {
  if (sum == 0 && num_groups == 0) {
    return 0;
  }
  if (!is_possible(sum, num_groups) || num_groups == 0) {
    return -kInf;
  }
  assert(sum > 0 && num_groups > 0);
  long long big = sum - (num_groups - 1);
  long long small = 1;
  long long num_small = (num_groups - 1);
  long long num_big = 1;
  assert(num_small * small + num_big * big == sum);
  *rec = SingleLayout(small, big, num_small, num_big);
  return num_small * small * small + num_big * big * big;
}
long long get_min_fast(long long sum, long long num_groups, SingleLayout* rec) {
  if (sum == 0 && num_groups == 0) {
    return 0;
  }
  if (!is_possible(sum, num_groups) || num_groups == 0) {
    return kInf;
  }
  assert(sum > 0 && num_groups > 0);
  long long num_small = num_groups - (sum % num_groups);
  long long num_big = num_groups - num_small;
  long long small = sum / num_groups;
  long long big = small + 1;
  assert(num_small * small + num_big * big == sum);
  *rec = SingleLayout(small, big, num_small, num_big);
  return num_small * small * small + num_big * big * big;
}
void solve() {
  long long mx = -kInf;
  DoubleLayout rec;
  for (int M = 0; M <= b; ++M) {
    for (int N = M - 1; N <= M + 1; ++N) {
      DoubleLayout cur_layout;
      long long cur =
          get_max_fast(a, N, &cur_layout.o) - get_min_fast(b, M, &cur_layout.x);
      if (cur > mx) {
        mx = cur;
        rec = cur_layout;
      }
    }
  }
  cout << mx << endl;
  rec.reconstruct();
}
int main() {
  load();
  solve();
  return 0;
}

```