package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type State struct {
	d1, d2 int
	al     int
	mask   uint32
}

var (
	l, m, w   []int
	firstHalf []State
	bestAl    int
	bestMask1 uint32
	bestMask2 uint32
	possible  bool
	n1        int
)

func gen1(idx, end, d1, d2, al int, mask uint32) {
	if idx == end {
		firstHalf = append(firstHalf, State{d1, d2, al, mask})
		return
	}
	shift := 2 * idx
	w_ := w[idx]
	m_ := m[idx]
	l_ := l[idx]
	gen1(idx+1, end, d1-w_, d2+m_-w_, al, mask|(0<<shift))
	gen1(idx+1, end, d1+l_-w_, d2-w_, al+l_, mask|(1<<shift))
	gen1(idx+1, end, d1+l_, d2+m_, al+l_, mask|(2<<shift))
}

func gen2(idx, end, d1, d2, al int, mask uint32) {
	if idx == end {
		left, right := 0, len(firstHalf)-1
		nd1, nd2 := -d1, -d2
		for left <= right {
			mid := left + (right-left)/2
			st := &firstHalf[mid]
			if st.d1 == nd1 {
				if st.d2 == nd2 {
					if !possible || st.al+al > bestAl {
						possible = true
						bestAl = st.al + al
						bestMask1 = st.mask
						bestMask2 = mask
					}
					break
				} else if st.d2 < nd2 {
					left = mid + 1
				} else {
					right = mid - 1
				}
			} else if st.d1 < nd1 {
				left = mid + 1
			} else {
				right = mid - 1
			}
		}
		return
	}
	shift := 2 * (idx - n1)
	w_ := w[idx]
	m_ := m[idx]
	l_ := l[idx]
	gen2(idx+1, end, d1-w_, d2+m_-w_, al, mask|(0<<shift))
	gen2(idx+1, end, d1+l_-w_, d2-w_, al+l_, mask|(1<<shift))
	gen2(idx+1, end, d1+l_, d2+m_, al+l_, mask|(2<<shift))
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(reader, &n)
	if n == 0 {
		return
	}
	l = make([]int, n)
	m = make([]int, n)
	w = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &l[i], &m[i], &w[i])
	}

	n1 = n / 2
	p1 := 1
	for i := 0; i < n1; i++ {
		p1 *= 3
	}
	firstHalf = make([]State, 0, p1)
	gen1(0, n1, 0, 0, 0, 0)

	sort.Slice(firstHalf, func(i, j int) bool {
		if firstHalf[i].d1 != firstHalf[j].d1 {
			return firstHalf[i].d1 < firstHalf[j].d1
		}
		if firstHalf[i].d2 != firstHalf[j].d2 {
			return firstHalf[i].d2 < firstHalf[j].d2
		}
		return firstHalf[i].al > firstHalf[j].al
	})

	compacted := make([]State, 0, len(firstHalf))
	for i := 0; i < len(firstHalf); i++ {
		if i == 0 || firstHalf[i].d1 != firstHalf[i-1].d1 || firstHalf[i].d2 != firstHalf[i-1].d2 {
			compacted = append(compacted, firstHalf[i])
		}
	}
	firstHalf = compacted

	gen2(n1, n, 0, 0, 0, 0)

	if !possible {
		fmt.Println("Impossible")
		return
	}

	choices := []string{"MW", "LW", "LM"}
	writer := bufio.NewWriter(os.Stdout)
	for i := 0; i < n; i++ {
		if i < n1 {
			c := (bestMask1 >> (2 * i)) & 3
			fmt.Fprintln(writer, choices[c])
		} else {
			c := (bestMask2 >> (2 * (i - n1))) & 3
			fmt.Fprintln(writer, choices[c])
		}
	}
	writer.Flush()
}