#!/usr/bin/env python3
import itertools
from collections import defaultdict
from math import ceil

# NOTE: Fails when using e.g. IX to make X's but no I's are available.

M, D, C, L, X, V, I = map(int, input().split())


def test(l):
    ans = True

    def fill(n, f, m):
        nonlocal ans
        if n > m * (l - f):
            ans = None
            return -1
        return 0 if n <= (m - 1) * (l - f) else n - (m - 1) * (l - f)

    ms = fill(M, 0, 4)
    ds = fill(D, ms, 1)
    cs = fill(C - ms, ms, 4)
    ls = fill(L, cs, 1)
    xs = fill(X - cs, cs, 4)
    vs = fill(V, xs, 1)
    Is = fill(I - xs, xs, 3)
    return ans


# n: number of chars needed
# l: number of positions available
def getcnts(n, l, max=4):
    cs = [0, 0, 0, 0, 0]
    for i in range(1, max + 1):
        if n <= i * l:
            cs[i] = n - (i - 1) * l
            cs[i - 1] = l - cs[i]
            return cs
    return False


def solve(l):
    ans = defaultdict(int)
    ans[""] = l

    # Number of chars needed of type.
    # Number of entries where it can not follow.
    # Pattern it is not allowed to follow.
    # Suffixes containing 1, 2, ... occurrences of char.
    def fill(needed, forbidden, forbidden_pattern, suffixes):
        nonlocal ans
        ss = getcnts(needed, l - forbidden, max=len(suffixes))
        if not ss:
            ans = None
        if ans is None:
            return [0, 0, 0, 0, 0]
        r = ss[:]
        for k, v in list(ans.items()):
            if k.endswith(forbidden_pattern):
                continue
            for i, suf in enumerate(suffixes, start=1):
                c = min(ss[i], ans.get(k, 0))
                if c == 0:
                    continue
                ss[i] -= c
                ans[k] -= c
                ans[k + suf] += c
                if ans[k] == 0:
                    del ans[k]
        return r

    ms = fill(M, 0, "_", ["M", "MM", "MMM", "MMMCM"])
    ds = fill(D, ms[4], "CM", ["D"])
    cs = fill(C - ms[4], ms[4], "CM", ["C", "CC", "CCC", "CCCXC"])
    ls = fill(L, cs[4], "XC", ["L"])
    xs = fill(X - cs[4], cs[4], "XC", ["X", "XX", "XXX", "XXXIX"])
    vs = fill(V, xs[4], "IX", ["V"])
    Is = fill(I - xs[4], xs[4], "IX", ["I", "II", "III"])

    return ans


l, h = 1, 10 ** 18
while l < h:
    m = (l + h) // 2
    if test(m):
        h = m
    else:
        l = m + 1

ans = solve(l)
print(sum(v for v in ans.values()))
print(len(ans))
[print(k, v) for k, v in ans.items()]