#!/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())

# 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 test(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 = test(l)
print(sum(v for v in ans.values()))
print(len(ans))
[print(k, v) for k, v in ans.items()]