```go
package main

import (
	"fmt"
	"sort"
)

type Tile struct {
	id                       int
	top, right, bottom, left int
	chars                    [2]string
}

var tiles = []Tile{
	{0, 0, 0, 0, 0, [2]string{"..", ".."}},
	{1, 1, 1, 1, 1, [2]string{"**", "**"}},
	{2, 1, 1, 0, 0, [2]string{"\\*", ".\\"}},
	{3, 0, 1, 1, 0, [2]string{"./", "/*"}},
	{4, 0, 0, 1, 1, [2]string{"/.", "*/"}},
	{5, 1, 0, 0, 1, [2]string{"*\\", "\\."}},
}

var (
	n, m                 int
	a, b, c              int
	bottomEdge           [][]int
	rightEdge            [][]int
	ans                  []int
	found                bool
)

func solve(idx int, remB, remW, remM int) bool {
	if idx == n*m {
		return true
	}
	r := idx / m
	col := idx % m

	top := -1
	if r > 0 {
		top = bottomEdge[r-1][col]
	}
	left := -1
	if col > 0 {
		left = rightEdge[r][col-1]
	}

	order := []int{0, 1, 2, 3, 4, 5}
	
	score := func(id int) int {
		if id == 0 {
			if remW == 0 {
				return -1
			}
			return remW
		}
		if id == 1 {
			if remB == 0 {
				return -1
			}
			return remB
		}
		if remM == 0 {
			return -1
		}
		return remM
	}

	sort.SliceStable(order, func(i, j int) bool {
		return score(order[i]) > score(order[j])
	})

	for _, id := range order {
		if score(id) == -1 {
			continue
		}
		t := tiles[id]
		if top != -1 && t.top != top {
			continue
		}
		if left != -1 && t.left != left {
			continue
		}

		bottomEdge[r][col] = t.bottom
		rightEdge[r][col] = t.right
		ans[idx] = id

		nB, nW, nM := remB, remW, remM
		if id == 0 {
			nW--
		} else if id == 1 {
			nB--
		} else {
			nM--
		}

		if solve(idx+1, nB, nW, nM) {
			return true
		}
	}
	return false
}

func main() {
	if _, err := fmt.Scan(&n, &m); err != nil {
		return
	}
	if _, err := fmt.Scan(&a, &b, &c); err != nil {
		return
	}

	bottomEdge = make([][]int, n)
	rightEdge = make([][]int, n)
	for i := 0; i < n; i++ {
		bottomEdge[i] = make([]int, m)
		rightEdge[i] = make([]int, m)
	}
	ans = make([]int, n*m)

	solve(0, a, b, c)

	for i := 0; i < n; i++ {
		for row := 0; row < 2; row++ {
			for j := 0; j < m; j++ {
				fmt.Print(tiles[ans[i*m+j]].chars[row])
			}
			fmt.Println()
		}
	}
}
```