//author Sergey Melnikov
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class TestGen extends Thread {
	class Test {
		ArrayList<Integer> al;

		public Test(ArrayList<Integer> al) {
			this.al = al;
		}

		public Test(int... a) {
			al = new ArrayList<Integer>();
			for (int i : a) {
				al.add(i);
			}
		}

		public void out(PrintWriter out) {
			int sum = 0;
			int prev = -1;
			for (int i : al) {
				assert 1 <= i;
				assert prev <= i;
				sum += i;
				prev = i;
			}
			assert sum <= 100000;
			out.print(sum + "=");
			for (int i = 0; i < al.size(); i++) {
				out.print(al.get(i));
				if (i == al.size() - 1) {
					out.println();
				} else {
					out.print("+");
				}
			}
		}

	}

	private int testCount = 0;

	private void write(Test t) {
		try {
			++testCount;
			String filename = testCount / 10 + "" + testCount % 10;
			PrintWriter out = new PrintWriter(filename);
			System.err.println(testCount);
			t.out(out);
			out.close();
		} catch (IOException ex) {
			throw new RuntimeException(ex);
		}
	}

	void myAssert(boolean b) {
		if (!b)
			throw new AssertionError();
	}

	static Random rand = new Random(1);
	final int MAXN = 100000;
	int[][] examples =
	{
	{ 1, 1, 3 },
	{ 5 } };
	int[][] hand =
	{
	/* Все разбиения числа 2 */
	{ 1, 1 },
	{ 2 },
	/* Все разбиения числа 4 */
	{ 1, 1, 1, 1 },
	{ 1, 1, 2 },
	{ 1, 3 },
	{ 2, 2 },
	{ 4 },
	/* MAXN - No solution */
	{ MAXN },
	/* Near MAXN / 2 */
	{ MAXN / 2, MAXN / 2 },
	{ MAXN / 2 - 1, MAXN / 2 + 1 },
	{ MAXN / 2 - 2, MAXN / 2 + 2 },

	};

	@Override
	public void run() {
		for (int[] i : examples) {
			write(new Test(i));
		}
		for (int[] i : hand) {
			write(new Test(i));
		}

		write(eqTail(1000, 50, 10));
		// Против sm_wrong7
		write(wrong7(10, 10000, 10));
		write(wrong7(1000, 50, 10));

		// 5 случайных тестов
		for (int i : new int[]
		{ 5, 10, 1001, 28170, 100000 }) {
			write(rand(i));
		}
		// Тест из 2009 единичек
		write(byOne(2009));
		// Тест на то, что ответ может сильно увеличится
		write(new Test(1, MAXN - 1));
		// Тест с максимальным количеством слагаемых
		write(byOne(MAXN));
	}

	Test eqTail(int n, int l, int k) {
		int x = rand.nextInt(n - 1) + 1;
		ArrayList<Integer> al = genSeq(1, x, l);
		for (int i = 0; i < k; i++) {
			al.add(n);
		}
		return new Test(al);
	}

	Test wrong7(int n, int l, int k) {
		int x = rand.nextInt(n - 1) + 1;
		ArrayList<Integer> al = genSeq(1, x, l);
		for (int i = 0; i < k - 1; i++) {
			al.add(n);
		}
		al.add(n + 2);
		return new Test(al);
	}

	ArrayList<Integer> genSeq(int min, int max, int count) {
		ArrayList<Integer> al = new ArrayList<Integer>();
		for (int i = 0; i < count; i++) {
			al.add(min + rand.nextInt(max - min + 1));
		}
		Collections.sort(al);
		return al;
	}

	ArrayList<Integer> randAL(int n) {
		if (n == 0)
			return new ArrayList<Integer>();
		int x = rand.nextInt(n);
		ArrayList<Integer> al = randAL(x);
		al.add(n - x);
		return al;
	}

	Test rand(int n) {
		ArrayList<Integer> al = randAL(n);
		Collections.sort(al);
		return new Test(al);
	}

	Test byOne(int n) {
		ArrayList<Integer> al = new ArrayList<Integer>();
		for (int i = 0; i < n; i++) {
			al.add(1);
		}
		return new Test(al);
	}

	public static void main(String[] args) {
		new TestGen().start();
	}
}
