/* cs */

/* 
 * Problem  : 	LUCKY
 * Contest  : 	UOI-2006 (Dnepropetrovsk)
 * Type     : 	Solution
 * Date     : 	Aprlil 1, 2006
 * Author   : 	Shamil Yagiyayev
 * Language :	C#
 * Compiler :	.NET 1.1
 * Algorithm:	Author Solution. Allows operating with multiple tests in one folder, generates statistics.
 */

using System;
using System.Collections;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

public class IntSequence
{
	public int[] s;

	public override string ToString()
	{
		StringBuilder sb = new StringBuilder();
		for (int i=0; i<s.Length;i++)
		{
			sb.Append(String.Format("{0}{1}", (i!=0) ? " " : "", s[i].ToString()));
		}
		return sb.ToString();
	}

	public override bool Equals(object obj)
	{
		IntSequence o = (IntSequence) obj;
		if (o.s.Length != s.Length ) return false;
		for (int i=0; i<s.Length;i++)
			if (o.s[i]!=s[i]) return false;
		return true;
	}


	public IntSequence(string[] ss, int depth)
	{
		int n = 0;
		for(int i=0;i<depth;i++)
			if (ss[i]!="-" && ss[i]!="+" && ss[i]!="*" && ss[i]!="/") n++;
		s = new int[n];
		int j = 0;
		for(int i=0;i<depth;i++)
		{
			//Console.WriteLine(ss[i]);
			if (ss[i]!="-" && ss[i]!="+" && ss[i]!="*" && ss[i]!="/") s[j++] = int.Parse(ss[i]);
		}
	}
}

class Lucky
{
	static string FILE_IN = "lucky.dat";
	static string FILE_OUT = "lucky.sol";

	static readonly int TICKET_LENGTH = 6;
	
	static string ticket = ""; 
	static int k;

	static int[] poland = new int[TICKET_LENGTH*2];	
	static string[] pl = new string[TICKET_LENGTH*2];

	static int manySols;
	static int manyUniqueSols;

	static ArrayList seqs;

	static StreamWriter swSol;

	static string[] solution = null;
	static int solDepth = 0;

	static bool haveToUsePlus;
	static bool haveToUseMinus;
	static bool haveToUseMultiply;
	static bool haveToUseDivide;
	static bool haveToUseMultiDivide;
	static bool haveToUseUnary;
	static int minSolDepth;
	static int maxSolDepth;

	static void ReadData()
	{
		StreamReader sr = new StreamReader(FILE_IN);
		string[] line = (sr.ReadLine()).Split(new char[] {' '});
		k = int.Parse(line[0]);
		ticket = line[1];
	}

	/// <summary>
	/// Fills the poland array
	/// </summary>
	/// <param name="depth">Next symbol from ticket to use</param>
	/// <param name="curr">Current index in poland</param>
	/// <param name="operations">How many operations we can add</param>
	/// <param name="plnum">Actual depth of the recursion</param>
	static void FillPoland(int depth, int curr, int operations, int plnum)
	{
		// if (solution != null) return;

		if (depth == TICKET_LENGTH && operations == 0)
		{
			if (poland[0] == k || poland[0] == -k)
			{
				solution = (string[]) pl.Clone();
				solDepth = plnum;
				manySols++;
				if (poland[0] == k) haveToUseUnary = false;
				if (solDepth < minSolDepth) minSolDepth = solDepth;
				if (solDepth > maxSolDepth) maxSolDepth = solDepth;
				WriteSolution();
			}
			return;
		}

		if (depth < TICKET_LENGTH)
		{
			for (int i=1; i<=TICKET_LENGTH-depth; i++)
			{
				poland[curr] = int.Parse(ticket.Substring(depth,i));
				pl[plnum] = ticket.Substring(depth,i);
				FillPoland(depth+i, curr+1, operations+1, plnum+1);
			}
		}

		if (operations > 0)
		{
			int a = poland[curr-2];
			int b = poland[curr-1];
			int prev = poland[curr-2];

			poland[curr-2] = a+b;
			pl[plnum] = "+";
			FillPoland(depth, curr-1, operations-1, plnum+1);

			poland[curr-2] = a-b;
			pl[plnum] = "-";
			FillPoland(depth, curr-1, operations-1, plnum+1);

			poland[curr-2] = a*b;
			pl[plnum] = "*";
			FillPoland(depth, curr-1, operations-1, plnum+1);

			if (b !=0 && a % b == 0)
			{
				poland[curr-2] = a/b;
				pl[plnum] = "/";
				FillPoland(depth, curr-1, operations-1, plnum+1);
			}

			poland[curr-2] = prev;
		}
	}

	static void PrintPoland(string[] a, int leng, StreamWriter sw, bool operations)
	{
		bool written = false;
		for (int i=0;i<leng;i++)
		{
			if (operations || (a[i]!="-" && a[i]!="+" && a[i]!="*" && a[i]!="/"))
			{
				if (written) sw.Write(" ");
				written = true;
				sw.Write(a[i]);
			}
		}
		sw.WriteLine();
	}

	static void WriteSolution()
	{
		if (Array.IndexOf(solution, "+") == -1 || Array.IndexOf(solution, "+") >= solDepth) haveToUsePlus = false;
		if (Array.IndexOf(solution, "-") == -1 || Array.IndexOf(solution, "-") >= solDepth) haveToUseMinus = false;
		if (Array.IndexOf(solution, "*") == -1 || Array.IndexOf(solution, "*") >= solDepth) haveToUseMultiply = false; 
		if (Array.IndexOf(solution, "/") == -1 || Array.IndexOf(solution, "/") >= solDepth) haveToUseDivide = false;

		IntSequence iseq = new IntSequence(solution, solDepth);
		bool was = false;
		for(int i=0;i<seqs.Count;i++)
			if (((IntSequence)seqs[i]).Equals(iseq))
			{
				was = true;
				break;
			}
		if (! was)
		{
			manyUniqueSols++;
			seqs.Add(iseq);
			PrintPoland(solution, solDepth, swSol, false);
		}
	}

	static void Main(string[] args)
	{
		string FILE_IN_REGEX;
		string FILE_OUT_FORMAT;
		string SUMMARY = "tests-lucky.csv";
		Regex r;
		if ( args.Length == 0 )
		{
			FILE_IN_REGEX = "lucky\\.dat";
			r = new Regex(FILE_IN_REGEX);
			FILE_OUT_FORMAT = "lucky.sol";
		}
		else
		{
			FILE_IN_REGEX = args[0];
			r = new Regex(FILE_IN_REGEX);
			FILE_OUT_FORMAT = args[1];
		}

		StreamWriter sw = File.CreateText(SUMMARY);
		sw.WriteLine("File;K;Number;Sols;Unique;min;max;+;-;*;/;+/;Unary");

		DirectoryInfo di = new DirectoryInfo(Environment.CurrentDirectory);
		FileInfo[] fi = di.GetFiles();
		Match m;
		foreach (FileInfo fiTemp in fi)
			if ((m = r.Match(fiTemp.Name)).Success)
			{
				FILE_IN = fiTemp.Name;
				string test = m.Groups[1].ToString();
				Console.WriteLine("{0} {1}", FILE_OUT_FORMAT, test);
				FILE_OUT = String.Format(FILE_OUT_FORMAT, test);

				swSol = File.CreateText(FILE_OUT);

				manySols = 0;
				solution = null;
				solDepth = 0;

				haveToUsePlus = true;
				haveToUseMinus = true;
				haveToUseMultiply = true;
				haveToUseDivide = true;
				haveToUseMultiDivide = true;
				haveToUseUnary = true;
				minSolDepth = 1000;
				maxSolDepth = 0;
				manyUniqueSols = 0;

				seqs = new ArrayList();

				ReadData();
				FillPoland(0, 0, -1, 0);
				haveToUseMultiDivide = haveToUseMultiply && haveToUseDivide;

				if (manySols == 0) swSol.WriteLine(0);

				swSol.Close();

				sw.Write("{0};", fiTemp.Name); // filename
				sw.Write("{0};", k); // k
				sw.Write("'{0};", ticket); // ticket
				sw.Write("{0};", manySols); // manySols
				sw.Write("{0};", manyUniqueSols); // manySols
				sw.Write("{0};", (manySols!=0)? ((minSolDepth+1)/2).ToString() :""); // manySols
				sw.Write("{0};", (manySols!=0)? ((maxSolDepth+1)/2).ToString() :""); // maxSolDepth
				sw.Write("{0};", (manySols!=0)?haveToUsePlus.ToString() :""); 
				sw.Write("{0};", (manySols!=0)?haveToUseMinus.ToString() :""); 
				sw.Write("{0};", (manySols!=0)?haveToUseMultiply.ToString() :""); 
				sw.Write("{0};", (manySols!=0)?haveToUseDivide.ToString() :""); 
				sw.Write("{0};", (manySols!=0)?haveToUseMultiDivide.ToString() :""); 
				sw.Write("{0};", (manySols!=0)?haveToUseUnary.ToString() :""); 
				sw.WriteLine();
			}
		sw.Close();
	}
}