import java.util.Arrays;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Alphametic
{
    public static void main(String[] args)
    {
        try (Scanner in = new Scanner(System.in))
        {
            while (in.hasNextLine())
            {
                new Alphametic(in.nextLine()).print();
            }
        }
    }

    private static Pattern pat = Pattern.compile("([0-9A-Z]+)([+-\\\\*])([0-9A-Z]+)=([0-9A-Z]+)");
    private final String sa;
    private final String sb;
    private final String sc;
    private final String op;
    private final String[] st;
    private final Op operator;
    private final int e;

    private final int[] map = new int[256];
    private final boolean[] used = new boolean[10];
    private String[] result = new String[0];

    private Alphametic(String exp)
    {
        Matcher mat = pat.matcher(exp);
        if (!mat.matches()) throw new IllegalArgumentException();

        this.sa = mat.group(1);
        this.op = mat.group(2);
        this.sb = mat.group(3);
        this.sc = mat.group(4);
        this.st = new String[] { sa, sb, sc };
        switch(op)
        {
        case "+": operator = (a, b) -> a + b; break;
        case "-": operator = (a, b) -> a - b; break;
        case "*": operator = (a, b) -> a * b; break;
        default: throw new IllegalArgumentException();
        }

        for (int i = 0; i <= 9; i++) map['0' + i] = i;
        for (int i = 'A'; i <= 'Z'; i++) map[i] = i;
        e = Math.max(Math.max(sa.length(), sb.length()), sc.length()) * 3;
        solve(0, new long[3], 1);
    }

    private void solve(int p, long[] ls, long d)
    {
        if (p == e)
        {
            if (!operator.test(ls[0], ls[1], ls[2], Long.MAX_VALUE)) return;
            for (String s : st) if (map[s.charAt(0)] <= 0) return;
            result = Arrays.copyOf(result, result.length + 1);
            result[result.length - 1] = String.format("%d%s%d=%d", ls[0], op, ls[1], ls[2]);
            return;
        }

        int i = p / 3;
        int j = p % 3;
        if (p > 0 && j == 0)
        {
            d *= 10;
            if (!operator.test(ls[0], ls[1], ls[2], d)) return;
        }

        int n = ch(st[j], i);
        long l = ls[j];

        if (n >= 'A' && n <= 'Z')
        {
            for (int k = 0; k < 10; k++)
            {
                if (used[k]) continue;
                used[k] = true;
                map[n] = k;
                ls[j] = l + k * d;
                solve(p + 1, ls, d);
                used[k] = false;
            }
            map[n] = n;
        }
        else
        {
            ls[j] += n * d;
            solve(p + 1, ls, d);
        }
        ls[j] = l;
    }

    private int ch(String s, int i)
    {
        return s.length() <= i ? 0 : map[s.charAt(s.length() - i - 1)];
    }

    void print()
    {
        System.out.printf("%s%s%s=%s%n", sa, op, sb, sc);
        for (String s : result) System.out.println(s);
        System.out.println();
    }

    private interface Op
    {
        long op(long a, long b);

        default boolean test(long a, long b, long c, long d)
        {
            return Math.abs(op(a, b) - c) % d == 0;
        }
    }
}