Problem: You are given a circular array with n elements. The elements are numbered from some element with values from 1 to n in clockwise order. The i-th cell contains the value ai. The robot Simba is in cell s.

Each moment of time the robot is in some of the n cells (at the begin he is in s). In one turn the robot can write out the number written in current cell or move to the adjacent cell in clockwise or counterclockwise direction. To write out the number from the cell Simba doesn't spend any time, but to move to adjacent cell Simba spends one unit of time.

Simba wants to write the number from each cell one time, so the numbers will be written in a non decreasing order. Find the least number of time units to write out all numbers.

Input

The first line contains two integers n and s (1 ≤ s ≤ n ≤ 2000) — the number of cells in the circular array and the starting position of Simba.

The second line contains n integers ai ( - 109 ≤ ai ≤ 109) — the number written in the i-th cell. The numbers are given for cells in order from 1 to n. Some of numbers ai can be equal.

Output

In the first line print the number t — the least number of time units.

Each of the next n lines should contain the direction of robot movement and the number of cells to move in that direction. After that movement the robot writes out the number from the cell in which it turns out. The direction and the number of cells should be printed in the form of +x in case of clockwise movement and -x in case of counterclockwise movement to x cells (0 ≤ x ≤ n - 1).

Note that the sum of absolute values of x should be equal to t.

Examples

Input

9 1
0 1 2 2 2 1 0 1 1


Output

12
+0
-3
-1
+2
+1
+2
+1
+1
+1


Input

8 1
0 1 0 1 0 1 0 1


Output

13
+0
+2
+2
+2
-1
+2
+2
+2


Input

8 1
1 2 3 4 5 6 7 8


Output

7
+0
+1
+1
+1
+1
+1
+1
+1


Input

8 1
0 0 0 0 0 0 0 0


Output

7
+0
+1
+1
+1
+1
+1
+1
+1

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = atan(1) * 4;
const long long M = 1000000007;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double cos_u2v(const PT &u, const PT &v) {
  return dot(u, v) / sqrt(dot(u, u) * dot(v, v));
}
double sin_u2v(const PT &u, const PT &v) {
  return cross(u, v) / sqrt(dot(u, u) * dot(v, v));
}
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
double vector2angle(const PT &v) { return atan2(v.y, v.x); }
struct UnionFind {
  vector<long long> C;
  UnionFind(long long n) : C(n) {
    for (int i = 0; i < n; i++) C[i] = i;
  }
  long long find(long long x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
  void merge(long long x, long long y) { C[find(x)] = find(y); }
};
long long mod(long long x, long long m) { return ((x % m) + m) % m; }
long long gcd(long long a, long long b) {
  for (; b > 0; swap(a, b)) a %= b;
  return a;
}
long long extended_euclid(long long a, long long b, long long &x,
                          long long &y) {
  long long xx = y = 0;
  long long yy = x = 1;
  while (b) {
    long long q = a / b;
    long long t = b;
    b = a % b;
    a = t;
    t = xx;
    xx = x - q * xx;
    x = t;
    t = yy;
    yy = y - q * yy;
    y = t;
  }
  return a;
}
long long mod_inverse(long long a, long long n) {
  long long x, y;
  long long d = extended_euclid(a, n, x, y);
  if (d > 1) return -1;
  return mod(x, n);
}
struct LPSolver {
  int m, n;
  vector<long long> B, N;
  vector<vector<long double>> D;
  LPSolver(const vector<vector<long double>> &A, const vector<long double> &b,
           const vector<long double> &c)
      : m(b.size()),
        n(c.size()),
        N(n + 1),
        B(m),
        D(m + 2, vector<long double>(n + 2)) {
    for (int i = 0; i < m; i++)
      for (int j = 0; j < n; j++) D[i][j] = A[i][j];
    for (int i = 0; i < m; i++) {
      B[i] = n + i;
      D[i][n] = -1;
      D[i][n + 1] = b[i];
    }
    for (int j = 0; j < n; j++) {
      N[j] = j;
      D[m][j] = -c[j];
    }
    N[n] = -1;
    D[m + 1][n] = 1;
  }
  void Pivot(int r, int s) {
    for (int i = 0; i < m + 2; i++)
      if (i != r)
        for (int j = 0; j < n + 2; j++)
          if (j != s) D[i][j] -= D[r][j] * D[i][s] / D[r][s];
    for (int j = 0; j < n + 2; j++)
      if (j != s) D[r][j] /= D[r][s];
    for (int i = 0; i < m + 2; i++)
      if (i != r) D[i][s] /= -D[r][s];
    D[r][s] = 1.0 / D[r][s];
    swap(B[r], N[s]);
  }
  bool Simplex(int phase) {
    int x = phase == 1 ? m + 1 : m;
    while (true) {
      int s = -1;
      for (int j = 0; j <= n; j++) {
        if (phase == 2 && N[j] == -1) continue;
        if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
          s = j;
      }
      if (D[x][s] > -EPS) return true;
      int r = -1;
      for (int i = 0; i < m; i++) {
        if (D[i][s] < EPS) continue;
        if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
            (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
          r = i;
      }
      if (r == -1) return false;
      Pivot(r, s);
    }
  }
  long double solve(vector<long double> &x) {
    int r = 0;
    for (int i = 1; i < m; i++)
      if (D[i][n + 1] < D[r][n + 1]) r = i;
    if (D[r][n + 1] < -EPS) {
      Pivot(r, n);
      if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
        return -numeric_limits<long double>::infinity();
      for (int i = 0; i < m; i++)
        if (B[i] == -1) {
          int s = -1;
          for (int j = 0; j <= n; j++)
            if (s == -1 || D[i][j] < D[i][s] ||
                D[i][j] == D[i][s] && N[j] < N[s])
              s = j;
          Pivot(i, s);
        }
    }
    if (!Simplex(2)) return numeric_limits<long double>::infinity();
    x = vector<long double>(n);
    for (int i = 0; i < m; i++)
      if (B[i] < n) x[B[i]] = D[i][n + 1];
    return D[m][n + 1];
  }
};
void edgelist2adjlists(long long n, const vector<long long> &froms,
                       const vector<long long> &tos, vector<long long> &v2e0,
                       vector<long long> &e2n) {
  v2e0.resize(n);
  v2e0.assign(n, -1);
  long long en = froms.size();
  e2n.resize(en);
  for (int i = 0; i < en; i++) {
    long long f = froms[i];
    long long t = tos[i];
    e2n[i] = v2e0[f];
    v2e0[f] = i;
  }
}
struct FordFulk {
  const vector<long long> &v2e0;
  const vector<long long> &e2f;
  const vector<long long> &e2t;
  const vector<long long> &e2c;
  const vector<long long> &e2n;
  long long s, t;
  FordFulk(const vector<long long> &_v2e0, const vector<long long> &_e2f,
           const vector<long long> &_e2t, const vector<long long> &_e2c,
           const vector<long long> &_e2n, long long _s, long long _t)
      : s(_s), t(_t), v2e0(_v2e0), e2f(_e2f), e2t(_e2t), e2c(_e2c), e2n(_e2n) {}
  long long _find_aug_path(const vector<long long> &v2e0,
                           const vector<long long> &e2f,
                           const vector<long long> &e2t,
                           const vector<long long> &e2c,
                           const vector<long long> &e2n, long long s,
                           long long t, vector<long long> &epath) {
    vector<long long> q2v;
    vector<long long> q2p;
    vector<long long> q2e;
    vector<long long> q2f;
    vector<bool> inq(v2e0.size(), false);
    q2v.push_back(s);
    q2p.push_back(-1);
    q2e.push_back(-1);
    q2f.push_back(INT_MAX);
    inq[s] = true;
    for (long long i = 0; i < q2v.size(); i++) {
      long long crt = q2v[i];
      long long f = q2f[i];
      for (long long j = v2e0[crt]; j != -1; j = e2n[j]) {
        long long to = e2t[j];
        long long rem = e2c[j];
        if (inq[to]) continue;
        if (rem <= 0) continue;
        q2v.push_back(to);
        q2p.push_back(i);
        q2e.push_back(j);
        q2f.push_back(min(f, rem));
        inq[to] = true;
      }
    }
    for (long long i = 0; i < q2v.size(); i++) {
      if (q2v[i] != t) continue;
      stack<long long> stk;
      for (long long j = i; j > 0; j = q2p[j]) {
        stk.push(q2e[j]);
      }
      while (!stk.empty()) {
        epath.push_back(stk.top());
        stk.pop();
      }
      return q2f[i];
    }
    return 0;
  }
  long long eval() {
    long long en = e2f.size();
    map<pair<long long, long long>, long long> rsd;
    for (long long i = 0; i < en; i++) {
      long long f = e2f[i];
      long long t = e2t[i];
      rsd[make_pair(f, t)] += e2c[i];
      rsd[make_pair(t, f)] += 0;
    }
    map<pair<long long, long long>, long long> nei;
    long long ren = 0;
    for (auto er : rsd) {
      nei[er.first] = ren++;
    }
    long long rvn = v2e0.size();
    vector<long long> rv2e0(rvn, -1);
    vector<long long> re2f(ren);
    vector<long long> re2t(ren);
    vector<long long> re2c(ren);
    vector<long long> re2n(ren);
    vector<long long> re2p(ren);
    long long rei = 0;
    for (auto er : rsd) {
      long long f = er.first.first;
      long long t = er.first.second;
      long long c = er.second;
      re2f[rei] = f;
      re2t[rei] = t;
      re2c[rei] = c;
      re2p[rei] = nei[make_pair(t, f)];
      re2n[rei] = rv2e0[f];
      rv2e0[f] = rei;
      ++rei;
    }
    long long sol = 0;
    vector<long long> epath;
    while (true) {
      epath.clear();
      long long res =
          _find_aug_path(rv2e0, re2f, re2t, re2c, re2n, s, t, epath);
      if (res == 0) break;
      for (auto ei : epath) {
        re2c[ei] -= res;
        re2c[re2p[ei]] += res;
      }
      sol += res;
    }
    return sol;
  }
};
template <typename T>
struct LazySegTree1D {
  vector<T> v;
  vector<long long> opr;
  vector<T> opd;
  vector<long long> nxt;
  long long LEFT;
  long long RGHT;
  T (*fnx)(long long, T);
  T (*fab)(T, T);
  LazySegTree1D(long long _l, long long _r, T _v, T (*_fnx)(long long, T),
                T (*_fab)(T, T))
      : v(1), opr(1), opd(1), nxt(1), LEFT(_l), RGHT(_r), fnx(_fnx), fab(_fab) {
    v[0] = fnx(RGHT - LEFT + 1, _v);
    opr[0] = 0;
    opd[0] = _v;
    nxt[0] = -1;
  }
  void _split(long long i, long long l0, long long r0) {
    assert(nxt[i] == -1);
    assert(opr[i] == 0);
    assert(l0 < r0);
    long long n = v.size();
    nxt[i] = n;
    long long m0 = (l0 + r0) / 2;
    v.push_back(fnx(m0 - l0 + 1, opd[i]));
    v.push_back(fnx(r0 - m0, opd[i]));
    opr.push_back(0);
    opr.push_back(0);
    opd.push_back(opd[i]);
    opd.push_back(opd[i]);
    nxt.push_back(-1);
    nxt.push_back(-1);
  }
  void _pushdown(long long i, long long l0, long long r0) {
    if (opr[i] == -1) return;
    long long m0 = (l0 + r0) / 2;
    if (nxt[i] == -1)
      _split(i, l0, r0);
    else if (opr[i] >= 0) {
      _set(nxt[i], l0, m0, l0, m0, opr[i], opd[i]);
      _set(nxt[i] + 1, m0 + 1, r0, m0 + 1, r0, opr[i], opd[i]);
    }
    opr[i] = -1;
  }
  void _set(long long i, long long l0, long long r0, long long l1, long long r1,
            long long o1, T v1) {
    assert(l1 >= l0 && r1 <= r0);
    if (l0 == l1 && r0 == r1) {
      if (o1 == 0) {
        v[i] = fnx(r0 - l0 + 1, v1);
        opr[i] = 0;
        opd[i] = v1;
      } else if (o1 == 1) {
        v[i] = fab(v[i], fnx(r0 - l0 + 1, v1));
        if (opr[i] == -1) {
          opr[i] = 1;
          opd[i] = v1;
        } else if (opr[i] == 0) {
          opr[i] = 0;
          opd[i] = fab(opd[i], v1);
        } else if (opr[i] == 1) {
          opr[i] = 1;
          opd[i] = fab(opd[i], v1);
        }
      }
      return;
    }
    long long m0 = (l0 + r0) / 2;
    _pushdown(i, l0, r0);
    if (l1 <= m0) _set(nxt[i], l0, m0, l1, min(r1, m0), o1, v1);
    if (r1 > m0) _set(nxt[i] + 1, m0 + 1, r0, max(l1, m0 + 1), r1, o1, v1);
    v[i] = fab(v[nxt[i]], v[nxt[i] + 1]);
  }
  T _get(long long i, long long l0, long long r0, long long l1, long long r1) {
    assert(l0 <= l1 && r1 <= r0);
    if (l0 == l1 && r1 == r0) return v[i];
    _pushdown(i, l0, r0);
    long long m0 = (l0 + r0) / 2;
    if (r1 <= m0) return _get(nxt[i], l0, m0, l1, r1);
    if (m0 + 1 <= l1) return _get(nxt[i] + 1, m0 + 1, r0, l1, r1);
    T lv = _get(nxt[i], l0, m0, l1, m0);
    T rv = _get(nxt[i] + 1, m0 + 1, r0, m0 + 1, r1);
    return fab(lv, rv);
  }
  void updres(long long l1, long long r1, T v1) {
    _set(0, LEFT, RGHT, l1, r1, 1, v1);
  }
  void setval(long long l1, long long r1, T v1) {
    _set(0, LEFT, RGHT, l1, r1, 0, v1);
  }
  T get(long long l1, long long r1) { return _get(0, LEFT, RGHT, l1, r1); }
};
long long getmove(long long n, long long from, long long to) {
  long long c = ((to + n - from) % n);
  long long cc = ((from + n - to) % n);
  if (c < cc) return c;
  return -cc;
}
vector<long long> getpath0(long long n, vector<long long> &eles, long long from,
                           long long to) {
  vector<long long> ret;
  long long en = eles.size();
  while (from != to) {
    long long nxt = (from + 1) % en;
    ret.push_back(((eles[nxt] + n - eles[from]) % n));
    from = nxt;
  }
  return ret;
}
vector<long long> getpath1(long long n, vector<long long> &eles, long long from,
                           long long to) {
  vector<long long> ret;
  long long en = eles.size();
  while (from != to) {
    long long nxt = (from + en - 1) % en;
    ret.push_back(-((eles[from] + n - eles[nxt]) % n));
    from = nxt;
  }
  return ret;
}
vector<long long> convec(const vector<long long> &va,
                         const vector<long long> &vb) {
  vector<long long> ret(va);
  ret.insert(ret.end(), vb.begin(), vb.end());
  return ret;
}
long long getlocalcost(long long n, vector<long long> &eles, long long from,
                       long long to) {
  long long en = eles.size();
  long long topre = (to + en - 1) % en;
  long long tonxt = (to + 1) % en;
  long long c0 =
      ((eles[topre] + n - eles[from]) % n) + ((eles[topre] + n - eles[to]) % n);
  long long c1 =
      ((eles[from] + n - eles[tonxt]) % n) + ((eles[to] + n - eles[tonxt]) % n);
  return min(c0, c1);
}
vector<long long> getlocalpath(long long n, vector<long long> &eles,
                               long long from, long long to) {
  long long en = eles.size();
  if (en == 1) return vector<long long>(0);
  long long topre = (to + en - 1) % en;
  long long tonxt = (to + 1) % en;
  long long c0 =
      ((eles[topre] + n - eles[from]) % n) + ((eles[topre] + n - eles[to]) % n);
  long long c1 =
      ((eles[from] + n - eles[tonxt]) % n) + ((eles[to] + n - eles[tonxt]) % n);
  vector<long long> seq;
  vector<long long> dir;
  if (c0 <= c1) {
    for (long long i = from;; i = (i + 1) % en) {
      seq.push_back(eles[i]);
      if (i == topre) break;
      dir.push_back(0);
    }
    for (long long i = (from + en - 1) % en;; i = (i + en - 1) % en) {
      dir.push_back(1);
      seq.push_back(eles[i]);
      if (i == to) break;
    }
  } else {
    for (long long i = from;; i = (i + en - 1) % en) {
      seq.push_back(eles[i]);
      if (i == tonxt) break;
      dir.push_back(1);
    }
    for (long long i = (from + 1) % en;; i = (i + 1) % en) {
      dir.push_back(0);
      seq.push_back(eles[i]);
      if (i == to) break;
    }
  }
  vector<long long> ret;
  for (long long i = 1; i < seq.size(); i++)
    ret.push_back((dir[i - 1] == 0) ? ((seq[i] + n - seq[i - 1]) % n)
                                    : -((seq[i - 1] + n - seq[i]) % n));
  return ret;
}
void dijkstra(vector<long long> &v2e0, vector<long long> &e2t,
              vector<long long> &e2c, vector<long long> &e2n, long long src,
              vector<long long> &dist, vector<long long> &prec) {
  long long n = v2e0.size();
  dist.assign(n, INT_MAX);
  prec.assign(n, -1);
  vector<bool> arr(n);
  long long sel = src;
  dist[sel] = 0;
  while (sel >= 0) {
    arr[sel] = true;
    for (long long i = v2e0[sel]; i >= 0; i = e2n[i]) {
      long long to = e2t[i];
      long long cost = e2c[i];
      if (!arr[to] && dist[to] > dist[sel] + cost) {
        dist[to] = dist[sel] + cost;
        prec[to] = sel;
      }
    }
    sel = -1;
    for (long long i = 0; i < n; i++)
      if (!arr[i] && (sel == -1 || dist[i] < dist[sel])) sel = i;
  }
}
bool inseg(long long l, long long r, long long m) {
  if (l == r) return true;
  if (l < r) return l <= m && m < r;
  if (l > r) return m >= l || m < r;
}
long long discretize(vector<long long> &x) {
  set<long long> avset(x.begin(), x.end());
  map<long long, long long> vmap;
  long long dn = 0;
  for (auto it = avset.begin(); it != avset.end(); it++) vmap[*it] = dn++;
  for (long long i = 0, n = x.size(); i < n; i++) x[i] = vmap[x[i]];
  return dn;
}
int main() {
  long long n, p0;
  cin >> n >> p0;
  long long gvn = n * 2 + 2;
  p0--;
  vector<long long> a(n);
  for (long long i = 0; i < n; i++) cin >> a[i];
  long long bn = discretize(a);
  vector<vector<long long>> b2p(bn);
  for (long long i = 0; i < n; i++) b2p[a[i]].push_back(i);
  for (auto ps : b2p) sort(ps.begin(), ps.end());
  long long vn = 0;
  vector<long long> e2f;
  vector<long long> e2t;
  vector<long long> e2n;
  vector<long long> e2c;
  vector<long long> v2e0(gvn, -1);
  vector<long long> v2pos(gvn, -1);
  vector<long long> v2bi(gvn, -1);
  for (long long i = 0; i < bn; i++) {
    auto poss = b2p[i];
    long long pn = poss.size();
    for (long long j = 0; j < pn; j++)
      v2pos[vn + j] = v2pos[vn + pn + j] = poss[j];
    for (long long j = 0; j < pn; j++) v2bi[vn + j] = v2bi[vn + pn + j] = j;
    if (pn == 1) {
      {
        e2f.push_back(vn);
        e2t.push_back(vn + 1);
        e2c.push_back(0);
      };
    } else {
      for (long long j = 0; j < pn; j++)
        for (long long k = 0; k < pn; k++) {
          if (k == j) continue;
          long long cost = getlocalcost(n, poss, j, k);
          {
            e2f.push_back(vn + j);
            e2t.push_back(vn + pn + k);
            e2c.push_back(cost);
          };
        }
    }
    if (i < bn - 1) {
      auto nxtp = b2p[i + 1];
      long long nxtpsz = nxtp.size();
      if (nxtpsz == 1) {
        for (long long j = 0, k = 0; j < pn; j++) {
          e2f.push_back(vn + pn + j);
          e2t.push_back(vn + pn * 2);
          e2c.push_back(min(((nxtp[0] + n - poss[j]) % n),
                            ((poss[j] + n - nxtp[0]) % n)));
        };
      } else {
        for (long long j = 0, k = 0; j < pn; j++) {
          for (; !inseg(nxtp[k], nxtp[(k + 1) % nxtpsz], poss[j]);
               k = (k + 1) % nxtpsz)
            ;
          long long k1 = (k + 1) % nxtpsz;
          {
            e2f.push_back(vn + pn + j);
            e2t.push_back(vn + pn * 2 + k);
            e2c.push_back(((poss[j] + n - nxtp[k]) % n));
          };
          {
            e2f.push_back(vn + pn + j);
            e2t.push_back(vn + pn * 2 + k1);
            e2c.push_back(((nxtp[k1] + n - poss[j]) % n));
          };
        }
      }
    }
    vn += pn * 2;
  }
  v2pos[gvn - 2] = p0;
  long long k = 0, kn = b2p[0].size();
  for (; !inseg(b2p[0][k], b2p[0][(k + 1) % kn], p0); k = (k + 1) % kn)
    ;
  if (p0 == b2p[0][k]) {
    {
      e2f.push_back(gvn - 2);
      e2t.push_back(k);
      e2c.push_back(0);
    };
  } else {
    {
      e2f.push_back(gvn - 2);
      e2t.push_back(k);
      e2c.push_back(((p0 + n - b2p[0][k]) % n));
    };
    {
      e2f.push_back(gvn - 2);
      e2t.push_back((k + 1) % kn);
      e2c.push_back(((b2p[0][(k + 1) % kn] + n - p0) % n));
    };
  }
  auto lastposs = b2p.back();
  long long lastkn = lastposs.size();
  for (long long i = gvn - 2 - lastkn; i < gvn - 2; i++) {
    e2f.push_back(i);
    e2t.push_back(gvn - 1);
    e2c.push_back(0);
  };
  edgelist2adjlists(gvn, e2f, e2t, v2e0, e2n);
  vector<long long> prec(gvn, -1);
  vector<long long> dist(gvn, INT_MAX);
  dijkstra(v2e0, e2t, e2c, e2n, gvn - 2, dist, prec);
  stack<long long> solstk;
  for (long long i = prec[gvn - 1]; i != gvn - 2; i = prec[prec[i]]) {
    long long lo = i;
    long long li = prec[lo];
    auto zu = b2p[a[v2pos[li]]];
    auto lp = getlocalpath(n, zu, v2bi[li], v2bi[lo]);
    for (auto it = lp.rbegin(); it != lp.rend(); ++it) solstk.push(*it);
    long long gp = getmove(n, v2pos[prec[li]], v2pos[li]);
    solstk.push(gp);
  }
  cout << dist.back() << endl;
  for (; !solstk.empty();) {
    long long mv = solstk.top();
    solstk.pop();
    if (mv >= 0) cout << "+";
    cout << mv << endl;
  }
  return 0;
}