Go: // Package main provides
//
// File:  1237.go
// Author: ymiyamoto
//
// Created on Wed Jul 11 10:35:26 2018
//
package main

import (
	"fmt"
	"strconv"
	"strings"
)

func comb(ns []string, aux [][]string) [][]string {
	if len(ns) == 0 {
		return aux
	}
	v := ns[0]
	a := [][]string{}
	for _, au := range aux {
		tmp := make([]string, len(au))
		copy(tmp, au)
		tmp[len(tmp)-1] += v
		a = append(a, tmp)

		au = append(au, v)
		a = append(a, au)
	}

	return comb(ns[1:], a)
}

func main() {
	for {
		var d int
		var num string
		fmt.Scan(&d, &num)
		if d == 0 {
			break
		}

		var min int
		ns := strings.Split(num, "")
		for i := range ns {
			v, _ := strconv.Atoi(ns[i])
			min += v
		}

		var ans int
		var pat []string
		var hasSame bool
		for _, c := range comb(ns[1:], [][]string{{ns[0]}}) {
			var total int
			for _, v := range c {
				n, _ := strconv.Atoi(v)
				total += n
			}
			if ans == total {
				hasSame = true
			} else if ans < total && total <= d {
				ans = total
				pat = c
				hasSame = false
			}
		}

		if ans == 0 {
			fmt.Println("error")
		} else if hasSame {
			fmt.Println("rejected")
		} else {
			fmt.Println(ans, strings.Join(pat, " "))
		}
	}
}

C++: #include <bits/stdc++.h>

using namespace std;

int t; string num;
int ans;
bool rej;
vector<int> avec;

void solve(int idx, int sum, vector<int> vec)
{
  if(idx == num.size()){
    if(ans < sum && sum <= t) ans = sum, avec = vec, rej = false;
    else if(ans == sum) rej = true;
    return;
  }
  for(int i = 1; i <= num.size() - idx; i++){
    vector<int> tmp = vec;
    tmp.push_back(stoi(num.substr(idx, i)));
    solve(idx + i, sum + stoi(num.substr(idx, i)), tmp);
  }
  return;
}

int main()
{
  while(cin >> t >> num, t || num != "0"){
    ans = -1;
    rej = false;
    vector<int> vec;
    solve(0, 0, vec);
    if(rej) cout << "rejected" << endl;
    else if(ans < 0) cout << "error" << endl;
    else{
      cout << ans;
      for(int i = 0; i < avec.size(); i++) cout << " " << avec[i];
      cout << endl;
    }
  }
  return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;

#define int long long

int t;
string num;
int ans;
int cnt;
vector<int> ans_arr;

void dfs(int n, int sum, vector<int> arr) {
  if ( sum > t ) return;  
  if ( n == num.size() ) {
    if ( sum == ans ) {
      cnt++;      
    } else if ( sum > ans ) {
      cnt = 1;
      ans = sum;      
      ans_arr = arr;
    }
    return;    
  }
  int now = 0;
  for ( int i = n; i < (int)num.size(); i++ ) {    
    now *= 10;
    now += num[i]-'0';
    vector<int> nxt_arr = arr;
    nxt_arr.emplace_back(now);    
    dfs(i+1, sum+now, nxt_arr);    
  }
  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  while ( cin >> t >> num ) {
    if ( t == 0 && num == "0" ) break;
    ans = -1;
    cnt = 0;

    dfs(0, 0, {});    

    if ( cnt >= 2 ) cout << "rejected" << endl;
    else if ( ans == -1 ) cout << "error" << endl;
    else {
      cout << ans << " ";
      for ( int i = 0; i < (int)ans_arr.size(); i++ ) {
	if ( i ) cout << " ";
	cout << ans_arr[i];
      }
      cout << endl;
    }
  }
  
  return 0;
}

C++: /* main code starts from line 155. */

/* ---------- STL Libraries ---------- */

// IO library
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>

// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>

// container library
#include <array>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>

/* ---------- Namespace ---------- */

using namespace std;

/* ---------- Type Abbreviation ---------- */

template <typename T>
using V = vector<T>;
template <typename T, typename U>
using P = pair<T, U>;
template <typename T>
using PQ = priority_queue<T>;
template <typename T>
using GPQ = priority_queue<T, vector<T>, greater<T>>;

using ll = long long;

#define fst first
#define snd second
#define pb push_back
#define mp make_pair
#define mt make_tuple

/* ---------- conversion ---------- */

#define INT(c) static_cast<int>(c)
#define CHAR(n) static_cast<char>(n)
#define LL(n) static_cast<ll>(n)
#define DOUBLE(n) static_cast<double>(n)

/* ---------- container ---------- */

#define ALL(v) (v).begin(), (v).end()
#define SIZE(v) (LL((v).size()))

#define FIND(v, k) (v).find(k) != (v).end()
#define VFIND(v, k) find(ALL(v), k) != (v).end()

#define SORT(v) sort(ALL(v))
#define GSORT(v) sort(ALL(v), greater<decltype((v).front())>())

/* ---------- repetition ---------- */

#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (ll i = (a); i >= (b); i--)

/* ---------- Short Functions ---------- */

template <typename T>
T sq(T a) {
    return a * a;
}

template <typename T>
T gcd(T a, T b) {
    if (a > b) return gcd(b, a);
    return a == 0 ? b : gcd(b % a, a);
}

template <typename T, typename U>
T mypow(T b, U n) {
    if (n == 0) return 1;
    if (n == 1) return b;
    if (n % 2 == 0) {
        return mypow(sq(b), n / 2);
    } else {
        return mypow(b, n - 1) * b;
    }
}

#define fcout cout << fixed << setprecision(10)

/* ----------- debug ---------- */

template <typename T, typename U>
void testP2(T a, U b) {
    cout << "(" << a << ", " << b << ")" << endl;
    return;
}

template <typename T>
void testV(T v) {
    cout << "[";
    for (auto i : v) {
        cout << i << ", ";
    }
    cout << "\b\b]" << endl;
    return;
}

template <typename T>
void testV2(T v) {
    for (auto sv : v) {
        testV(sv);
    }
    cout << endl;
    return;
}

#define GET_VAR_NAME(variable) #variable
#define test(x) cout << GET_VAR_NAME(x) << " = " << x << endl;
#define testP(p)                      \
    cout << GET_VAR_NAME(p) << " = "; \
    testP2(p.fst, p.snd);

/* ---------- Constants ---------- */

// const ll MOD = 1e9 + 7;
// const int INF = 1 << 25;
// const ll INF = 1LL << 50;
// const double PI = acos(-1);
// const double EPS = 1e-10;
// const ll dx[4] = {0, -1, 1, 0};
// const ll dy[4] = {-1, 0, 0, 1};
// const ll dx[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
// const ll dy[8] = {-1, -1, -1, 0, 0, 1, 1, 1};

/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */

/* ---------- Type Definition ----------- */


/* ---------- Global Variance ----------- */


/* ------------- Functions -------------- */


/* ----------- Main Function ------------ */

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    while (true) {
        ll target;
        string num;
        cin >> target >> num;
        if (target == 0) break;

        ll N = SIZE(num);
        V<V<ll>> cut;

        FOR(b, 0, (1 << (N - 1)) - 1) {
            V<ll> v = {0};
            FOR(i, 0, N - 2) {
                if ((b >> i) & 1) v.pb(i + 1);
            }
            v.pb(N);

            V<ll> shred;
            FOR(i, 0, SIZE(v) - 2) {
                string p = num.substr(v[i], v[i + 1] - v[i]);
                shred.pb(stoi(p));
            }

            cut.pb(shred);
        }


        PQ<P<ll, V<ll>>> que;
        for (auto v : cut) {
            ll sum = 0;
            for (auto c : v) {
                sum += c;
            }

            if (sum <= target) {
                que.push(mp(sum, v));
            }
        }

        if (que.empty()) {
            cout << "error" << endl;
            continue;
        }

        auto p = que.top();
        que.pop();
        if (!que.empty() && p.fst == que.top().fst) {
            cout << "rejected" << endl;
        } else {
            cout << p.fst;
            for (auto c : p.snd) {
                cout << " " << c;
            }
            cout << endl;
        }
    }
    return 0;
}