#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <vector>

typedef std::vector<std::string> stringvec;

void make_block(stringvec& block, int cx, int cy)
{
    for (int i=0; i<cy; ++i)
        block.push_back(std::string(cx, ' '));
}

void copy_block(stringvec& dst, stringvec const& src, int dx, int dy)
{
    stringvec::iterator idst = dst.begin() + dy;
    for (stringvec::const_iterator isrc = src.begin(); isrc != src.end(); ++isrc, ++idst)
        std::copy(isrc->begin(), isrc->end(), idst->begin() + dx);
}

void make_decoder(stringvec& decoder, int cy_message)
{
    int cx_decoder = 3 * cy_message + 1;
    int cy_decoder = cy_message + 5;
    
    make_block(decoder, cx_decoder, cy_decoder);
    
    stringvec::iterator decoder_main = decoder.begin() + cy_message;
    for (int i=0; i<cy_message; ++i)
    {
        decoder_main[-1-i][3*i+3] = '\\';
        decoder_main[1][3*i+1] = 'X';
        decoder_main[1][3*i+2] = '.';
        decoder_main[1][3*i+3] = '/';
        if (i)
        {
            decoder_main[0][3*i-1] = '0';
            decoder_main[0][3*i+1] = '+';
            decoder_main[2][3*i-1] = '+';
            decoder_main[2][3*i  ] = '<';
            decoder_main[2][3*i+1] = 'X';
            decoder_main[3][3*i  ] = '\\';
            decoder_main[3][3*i+1] = '/';
            decoder_main[4][3*i  ] = '+';
            decoder_main[4][3*i+1] = '+';
        }
    }
    decoder_main[2][0] = '@';
    decoder_main[2][1] = '\\';
    decoder_main[0][cx_decoder-2] = '-';
    decoder_main[2][cx_decoder-1] = '\\';
    decoder_main[3][cx_decoder-3] = 'X';
    decoder_main[3][cx_decoder-2] = '\\';
    decoder_main[4][cx_decoder-4] = ' ';
}

void make_encoder(stringvec& encoder, stringvec const& message)
{
    int cy_message = message.size();
    int cx_message = message.front().size();
    int c_steps = (cy_message+2) / 3;
    int c_balls = cx_message + (cy_message & ~1);
    int cx_encoder = 3 * c_balls;
    int one_step = c_steps == 1 ? 1 : 0;
    int cy_encoder = 6 * c_steps + 4 + one_step;
    int i;
    
    make_block(encoder, cx_encoder, cy_encoder);
    for (int j=0; j<c_balls; ++j)
    {
        encoder[0][3*j+1] = '>';
        encoder[1][3*j+1] = '*';
        encoder[2][3*j+0] = '>';
        encoder[2][3*j+1] = '^';
        encoder[2][3*j+2] = '<';
        for (i=0; i<c_steps-1; ++i)
        {
            encoder[6*i+3][3*j+2] = '+';
            encoder[6*i+4][3*j+1] = '@';
            encoder[6*i+5][3*j+0] = '/';
            encoder[6*i+5][3*j+1] = '0';
            for (int k = 0, x = j-3*i, y = cy_message-3*i-1; k < 3; ++k, --x, --y)
                if (x >= 0 && x < cx_message && !isspace(message[y][x]))
                    encoder[6*i+5][3*j+1] += 1 << k;
            encoder[6*i+5][3*j+2] = '^';
            encoder[6*i+6][3*j+1] = '@';
            encoder[6*i+6][3*j+2] = '*';
            encoder[6*i+7][3*j+0] = '/';
            encoder[6*i+7][3*j+1] = '8';
            encoder[6*i+7][3*j+2] = '^';
            encoder[6*i+8][3*j+1] = '@';
        }
        if (one_step)
            encoder[6*i+3][3*j+1] = '@';
        encoder[6*i+3+one_step][3*j+0] = '/';
        encoder[6*i+3+one_step][3*j+1] = '0';
        for (int k = 0, x = j-3*i, y = cy_message-3*i-1; 3*i+k < cy_message; ++k, --x, --y)
            if ((x >= 0 && x < cx_message && !isspace(message[y][x])) != (y == 0))
                encoder[6*i+3+one_step][3*j+1] += 1 << k;
        encoder[6*i+3+one_step][3*j+2] = '^';
        encoder[6*i+4+one_step][3*j+1] = '@';
        encoder[6*i+2*(j&1)+6+one_step][3*j+0] = 'X';
        encoder[6*i+2*(j&1)+6+one_step][3*j+1] = '/';
        encoder[6*i+2*(j&1)+7+one_step][3*j+0] = '\\';
        encoder[6*i+2*(j&1)+7+one_step][3*j+1] = '/';
    }
}

void init_multiplier(stringvec& multiplier, int init_power)
{
    int temp = 1 << init_power;
    for (int i=0; i<temp; ++i)
        multiplier.push_back("'");
    multiplier.push_back("v \\");
    multiplier.push_back("0@ ");
    multiplier.back()[0] += temp;
    multiplier.push_back("v /");
}

void dbl_multiplier(stringvec& multiplier, bool& side)
{
    if (side)
    {
        multiplier.push_back("/\\ ");
        multiplier.push_back(" X/");
        multiplier.push_back("*/ ");
        side = false;
    }
    else
    {
        multiplier.push_back(" /\\");
        multiplier.push_back("\\X ");
        multiplier.push_back(" \\*");
        side = true;
    }
}

void inc_multiplier(stringvec& multiplier, bool& side, int incr)
{
    if (side)
    {
        multiplier.push_back("/ v");
        multiplier.push_back(" @0");
        multiplier.back()[2] += 1 << incr;
        multiplier.push_back("* /");
        side = false;
    }
    else
    {
        multiplier.push_back("v \\");
        multiplier.push_back("0@ ");
        multiplier.back()[0] += 1 << incr;
        multiplier.push_back("\\ *");
        side = true;
    }
}

void make_multiplier(stringvec& multiplier, int cy_message)
{
    int power = 32 - cy_message;
    int temp = 1;
    while (temp * 4 <= power)
        temp *= 2;
    init_multiplier(multiplier, power / temp);
    power %= temp;
    bool side = false;
    while (temp /= 2)
    {
        dbl_multiplier(multiplier, side);
        if (temp * 2 <= power)
        {
            inc_multiplier(multiplier, side, power / temp);
            power %= temp;
        }
    }
    if (power)
        inc_multiplier(multiplier, side, 1);
    if (!side)
        multiplier.push_back("\\ \\");
    multiplier.push_back("/ /");
    multiplier.push_back(" @ ");
    multiplier.push_back("\\  ");
    multiplier.push_back("   ");
}

void dump(stringvec const& block)
{
    for (stringvec::const_iterator i = block.begin(); i != block.end(); ++i)
        std::cout << *i << std::endl;
}

int main()
{
    stringvec message;
    std::string line;
    int cx_message = 0;
    while (std::getline(std::cin, line))
    {
        if (line.size() > cx_message)
            cx_message = line.size();
        message.push_back(line);
    }
    if (cx_message == 0)
    {
        std::cerr << "No message." << std::endl;
        return -1;
    }
    int cy_message = message.size();
    
    if (cy_message > 32)
    {
        std::cerr << "Implementation limit of height <= 32." << std::endl;
        return 1;
    }
    
    for (stringvec::iterator i = message.begin(); i != message.end(); ++i)
        i->resize(cx_message, ' ');
    
    stringvec decoder;
    make_decoder(decoder, cy_message);
    int cx_decoder = decoder.front().size(), cy_decoder = decoder.size();
    
    stringvec encoder;
    make_encoder(encoder, message);
    int cx_encoder = encoder.front().size(), cy_encoder = encoder.size();
    
    stringvec multiplier;
    make_multiplier(multiplier, cy_message);
    int cx_multiplier = 3, cy_multiplier = multiplier.size();
    
    int cx_code = std::max(cx_decoder + cx_message + 2, cx_encoder + 3);
    int cy_code = std::max(cy_decoder + cy_encoder + 1, cy_message + cy_multiplier);
    stringvec code;
    make_block(code, cx_code, cy_code);
    copy_block(code, decoder, cx_code - cx_decoder, 0);
    copy_block(code, encoder, 3, cy_code - cy_encoder);
    copy_block(code, multiplier, 0, cy_code - cy_multiplier);
    
    code[0][0] = 'v';
    for (int i=0; i<cy_message; ++i)
        code[i][1] = '#';
    code[cy_code-cy_encoder][cx_code-1] = '/';
    int temp = (cx_message + 1) / 2 + cy_message;
    if (temp <= 3)
    {
        code[cy_decoder-2][cx_code-2] = ' ';
        code[cy_decoder-2][cx_code-1] = '^';
    }
    else
    {
        temp -= 3;
        if (temp <= cy_code - cy_encoder - cy_decoder + 2)
        {
            code[cy_decoder-2+temp][cx_code-2] = '>';
            code[cy_decoder-2+temp][cx_code-1] = '^';
        }
        else
        {
            temp -= cy_code - cy_encoder - cy_decoder + 2;
            code[cy_code-cy_encoder-1][cx_code-2] = '<';
            code[cy_code-cy_encoder-1][cx_code-temp-2] = 'v';
            code[cy_code-cy_encoder-0][cx_code-temp-2] = '>';
        }
    }
    
    dump(code);
    
    return 0;
}