#include <bits/stdc++.h>   using namespace std;   template <typename... As>   struct tpl : public std::tuple<As...> {     using std::tuple<As...>::tuple;     tpl() {}     tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }     template <typename T = tuple<As...> >     typename tuple_element<0, T>::type const& x() const {       return get<0>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<0, T>::type& x() {       return get<0>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<1, T>::type const& y() const {       return get<1>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<1, T>::type& y() {       return get<1>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<2, T>::type const& z() const {       return get<2>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<2, T>::type& z() {       return get<2>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<3, T>::type const& w() const {       return get<3>(*this);     }     template <typename T = tuple<As...> >     typename tuple_element<3, T>::type& w() {       return get<3>(*this);     }   };   using lli = long long int;   using llu = long long unsigned;   using pii = tpl<lli, lli>;   using piii = tpl<lli, lli, lli>;   using piiii = tpl<lli, lli, lli, lli>;   using vi = vector<lli>;   using vii = vector<pii>;   using viii = vector<piii>;   using vvi = vector<vi>;   using vvii = vector<vii>;   using vviii = vector<viii>;   template <class T>   using min_queue = priority_queue<T, vector<T>, greater<T> >;   template <class T>   using max_queue = priority_queue<T>;   template <size_t... I>   struct my_index_sequence {     using type = my_index_sequence;     static constexpr array<size_t, sizeof...(I)> value = {{I...}};   };   namespace my_index_sequence_detail {   template <typename I, typename J>   struct concat;   template <size_t... I, size_t... J>   struct concat<my_index_sequence<I...>, my_index_sequence<J...> >       : my_index_sequence<I..., (sizeof...(I) + J)...> {};   template <size_t N>   struct make_index_sequence       : concat<typename make_index_sequence<N / 2>::type,                typename make_index_sequence<N - N / 2>::type>::type {};   template <>   struct make_index_sequence<0> : my_index_sequence<> {};   template <>   struct make_index_sequence<1> : my_index_sequence<0> {};   }  // namespace my_index_sequence_detail   template <class... A>   using my_index_sequence_for =       typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;   template <class T, size_t... I>   void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {     using swallow = int[];     (void)swallow{0, (void(s << (I == 0 ?    :  ,  ) << get<I>(a)), 0)...};   }   template <class T>   ostream& print_collection(ostream& s, T const& a);   template <class... A>   ostream& operator<<(ostream& s, tpl<A...> const& a);   template <class... A>   ostream& operator<<(ostream& s, tuple<A...> const& a);   template <class A, class B>   ostream& operator<<(ostream& s, pair<A, B> const& a);   template <class T, size_t I>   ostream& operator<<(ostream& s, array<T, I> const& a) {     return print_collection(s, a);   }   template <class T>   ostream& operator<<(ostream& s, vector<T> const& a) {     return print_collection(s, a);   }   template <class T, class U>   ostream& operator<<(ostream& s, multimap<T, U> const& a) {     return print_collection(s, a);   }   template <class T>   ostream& operator<<(ostream& s, multiset<T> const& a) {     return print_collection(s, a);   }   template <class T, class U>   ostream& operator<<(ostream& s, map<T, U> const& a) {     return print_collection(s, a);   }   template <class T>   ostream& operator<<(ostream& s, set<T> const& a) {     return print_collection(s, a);   }   template <class T>   ostream& print_collection(ostream& s, T const& a) {     s <<  [ ;     for (auto it = begin(a); it != end(a); ++it) {       s << *it;       if (it != prev(end(a))) s <<    ;     }     return s <<  ] ;   }   template <class... A>   ostream& operator<<(ostream& s, tpl<A...> const& a) {     s <<  ( ;     print_tuple(s, a, my_index_sequence_for<A...>{});     return s <<  ) ;   }   template <class... A>   ostream& operator<<(ostream& s, tuple<A...> const& a) {     s <<  ( ;     print_tuple(s, a, my_index_sequence_for<A...>{});     return s <<  ) ;   }   template <class A, class B>   ostream& operator<<(ostream& s, pair<A, B> const& a) {     return s <<  (  << get<0>(a) <<  ,   << get<1>(a) <<  ) ;   }   int main() {     ios::sync_with_stdio(0);     cin.tie(0);     lli m, n;     cin >> n >> m;     vi A(m);     for (lli i = 0; i < (lli)(m); ++i) cin >> A[i];     lli left = n;     vi B = A;     vi cs;     for (lli i = 0; i < (lli)(m); ++i) {       if (left < B[i]) {         B[i] -= left;         B[i] %= n;         left = n;       }       left -= B[i];       if (i != m - 1) cs.emplace_back(n - left);     }     cs.push_back(0);     cs.push_back(n);     sort(begin(cs), end(cs));     vi S;     for (lli i = 0; i < (lli)(m); ++i) S.push_back(cs[i + 1] - cs[i]);     int j = 0;     vvi ans;     ans.emplace_back(m);     for (lli i = 0; i < (lli)(m); ++i) {       while (A[i] > 0) {         if (j == m) {           j = 0;           ans.emplace_back(m);         }         A[i] -= S[j];         ans.back()[j] = i;         j++;       }     }     cout << ans.size() <<   n ;     for (lli i = 0; i < (lli)(m); ++i) cout << S[i] <<    ;     cout <<   n ;     for (lli t = 0; t < (lli)(ans.size()); ++t) {       for (lli j = 0; j < (lli)(m); ++j) cout << ans[t][j] + 1 <<    ;       cout <<   n ;     }     cout << flush;     return 0;   }   