// Maximum-TNT

#include <climits>
#include <iostream>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <algorithm>
#include <fstream>

using namespace std;

#define cin fin
const int BUFSIZE = 1024;
ifstream fin("optimal.txt");
vector<vector<int> > g_stacks;

vector<int> g_input, g_output;
int g_n;
enum{ADD, DIV, DUP, MUL, SUB};
vector<int> g_result;
int g_ansmin;

bool IsOutputCorrect()
{
    for(int i=0;i<g_n;i++)
    {
	if(g_stacks[i].size() == 1 && g_stacks[i].back() == g_output[i])
	    ;
	else return false;
    }
    return true;
}

bool AcceptOrder(int order)
{
    int m = g_stacks[0].size(); // number of stacked integers
    for(int i=0;i<g_n;i++)
    {
	if(order == ADD)
	{
	    if(m == 0 || m == 1) return false;
	    int r = g_stacks[i][m-1] + g_stacks[i][m-2];
	    if(abs(r) > 30000) return false;
	    g_stacks[i].pop_back();
	    g_stacks[i].pop_back();
	    g_stacks[i].push_back(r);
	}
	else if(order == DIV)
	{
	    if(m == 0 || m == 1) return false;
	    if(g_stacks[i][m-1] == 0) return false;
	    int r = g_stacks[i][m-2] / g_stacks[i][m-1];
	    g_stacks[i].pop_back();
	    g_stacks[i].pop_back();
	    g_stacks[i].push_back(r);
	}
	else if(order == DUP)
	{
	    if(m == 0) return false;
	    g_stacks[i].push_back(g_stacks[i].back());
	}
	else if(order == MUL)
	{
	    if(m == 0 || m == 1) return false;
	    int r = g_stacks[i][m-2] * g_stacks[i][m-1];
	    if(abs(r) > 30000) return false;
	    g_stacks[i].pop_back();
	    g_stacks[i].pop_back();
	    g_stacks[i].push_back(r);
	}
	else if(order == SUB)
	{
	    if(m == 0 || m == 1) return false;
	    int r = g_stacks[i][m-2] - g_stacks[i][m-1];
	    if(abs(r) > 30000) return false;
	    g_stacks[i].pop_back();
	    g_stacks[i].pop_back();
	    g_stacks[i].push_back(r);
	}
    }
    return true;
}

void OutputStack()
{
    for(int i=0;i<g_n;i++)
    {
	for(int j=0;j<(int)g_stacks[i].size();j++)
	{
	    cout << g_stacks[i][j] << " ";
	}
	cout << endl;
    }
}

void RecurseveSolve(int depth, vector<int> &path)
{
    if(depth >= g_ansmin) return;
    if(IsOutputCorrect())
    {
	g_result = path;
	g_ansmin = depth;
	return;
    }
    if(depth >= g_ansmin - 1 || g_ansmin - depth < (int)g_stacks[0].size())
	return;
    for(int i=0;i<5;i++)
    {
	vector<vector<int> >tmp = g_stacks;
//	cout << "before" << endl;
//	OutputStack();
	if(AcceptOrder(i))
	{
//	    cout << "order:" << i << endl;
//	    OutputStack();
	    path[depth] = i;
	    RecurseveSolve(depth+1, path);
	}
	g_stacks.swap(tmp);
    }
}

void Output()
{
    if(g_ansmin == 11)
    {
	cout << "Impossible" << endl;
    }
    else if(g_ansmin == 0)
    {
	cout << "Empty sequence" << endl;
    }
    else
    {
	for(int i=0;i<g_ansmin;i++)
	{
	    if(i > 0) cout << " ";
	    string ans[] = {"ADD", "DIV", "DUP", "MUL", "SUB"};
	    cout << ans[g_result[i]];
	}
	cout << endl;
    }
    cout << endl;
}

void Solve()
{
    g_ansmin = 11;
    for(int i=0;i<g_n;i++)
    {
	g_stacks[i].assign(1, g_input[i]);
    }
    vector<int> path(10);
    RecurseveSolve(0, path);
    Output();
}

bool Input()
{
    cin >> g_n;
    if(g_n == 0)
	return false;
    g_input.assign(g_n, 0);
    g_output.assign(g_n, 0);
    g_result.assign(10, 0);
    g_stacks.assign(g_n, vector<int>());
    for(int i=0;i<g_n;i++)
    {
	cin >> g_input[i];
    }
    for(int i=0;i<g_n;i++)
    {
	cin >> g_output[i];
    }
    return true;
}

int main()
{
    int  casenum = 1;
    while(Input())
    {
	cout << "Program " << casenum++ << endl;
	Solve();
    }
    return 0;
}