TheBiggestTaskSib

internal class Cube private constructor(
    private val upEdge: Edge,
    private val frontEdge: Edge,
    private val rightEdge: Edge,
    private val backEdge: Edge,
    private val leftEdge: Edge,
    private val downEdge: Edge
) {
    internal enum class Rotation { LEFT, RIGHT }

    private data class Edge(
        var c1: Char,
        var c2: Char,
        var c3: Char,
        var c4: Char,
        var c5: Char,
        var c6: Char,
        var c7: Char,
        var c8: Char,
        var c9: Char,
    ) {
        fun rotateSelf(rotation: Rotation) {
            val c1 = c1
            val c2 = c2
            val c3 = c3
            val c4 = c4
            val c6 = c6
            val c7 = c7
            val c8 = c8
            val c9 = c9

            when (rotation) {
                Rotation.LEFT -> {
                    this.c1 = c3
                    this.c2 = c6
                    this.c3 = c9
                    this.c4 = c2
                    this.c6 = c8
                    this.c7 = c1
                    this.c8 = c4
                    this.c9 = c7
                }

                Rotation.RIGHT -> {
                    this.c1 = c7
                    this.c2 = c4
                    this.c3 = c1
                    this.c4 = c8
                    this.c6 = c2
                    this.c7 = c9
                    this.c8 = c6
                    this.c9 = c3
                }
            }
        }
    }

    internal companion object {
        private lateinit var INSTANCE: Cube

        @JvmStatic
        internal fun initialize() {
            val upEdge = (1..3).flatMap {
                val (f, s, t) = readLine()!!.toCharArray()
                listOf(f, s, t)
            }.let {
                Edge(it[0], it[1], it[2], it[3], it[4], it[5], it[6], it[7], it[8])
            }

            val (frontEdge, rightEdge, backEdge, leftEdge) = kotlin.run {
                val up = readLine()!!.toCharArray()
                val mid = readLine()!!.toCharArray()
                val down = readLine()!!.toCharArray()

                listOf(
                    Edge(up[0], up[1], up[2], mid[0], mid[1], mid[2], down[0], down[1], down[2]),
                    Edge(up[3], up[4], up[5], mid[3], mid[4], mid[5], down[3], down[4], down[5]),
                    Edge(up[6], up[7], up[8], mid[6], mid[7], mid[8], down[6], down[7], down[8]),
                    Edge(up[9], up[10], up[11], mid[9], mid[10], mid[11], down[9], down[10], down[11]),
                )
            }

            val downEdge = (1..3).flatMap {
                val (f, s, t) = readLine()!!.toCharArray()
                listOf(f, s, t)
            }.let {
                Edge(it[0], it[1], it[2], it[3], it[4], it[5], it[6], it[7], it[8])
            }

            INSTANCE = Cube(upEdge, frontEdge, rightEdge, backEdge, leftEdge, downEdge)
        }

        internal val instance: Cube
            @JvmStatic
            get() = INSTANCE
    }

    internal fun rotateUp(rotation: Rotation) {
        upEdge.rotateSelf(rotation)

        val front1 = frontEdge.c1
        val front2 = frontEdge.c2
        val front3 = frontEdge.c3

        val right1 = rightEdge.c1
        val right2 = rightEdge.c2
        val right3 = rightEdge.c3

        val back1 = backEdge.c1
        val back2 = backEdge.c2
        val back3 = backEdge.c3

        val left1 = leftEdge.c1
        val left2 = leftEdge.c2
        val left3 = leftEdge.c3

        when (rotation) {
            Rotation.LEFT -> {
                frontEdge.c1 = left1
                frontEdge.c2 = left2
                frontEdge.c3 = left3

                rightEdge.c1 = front1
                rightEdge.c2 = front2
                rightEdge.c3 = front3

                backEdge.c1 = right1
                backEdge.c2 = right2
                backEdge.c3 = right3

                leftEdge.c1 = back1
                leftEdge.c2 = back2
                leftEdge.c3 = back3
            }

            Rotation.RIGHT -> {
                frontEdge.c1 = right1
                frontEdge.c2 = right2
                frontEdge.c3 = right3

                leftEdge.c1 = front1
                leftEdge.c2 = front2
                leftEdge.c3 = front3

                backEdge.c1 = left1
                backEdge.c2 = left2
                backEdge.c3 = left3

                rightEdge.c1 = back1
                rightEdge.c2 = back2
                rightEdge.c3 = back3
            }
        }
    }

    internal fun rotateDown(rotation: Rotation) {
        downEdge.rotateSelf(rotation)

        val front7 = frontEdge.c7
        val front8 = frontEdge.c8
        val front9 = frontEdge.c9

        val right7 = rightEdge.c7
        val right8 = rightEdge.c8
        val right9 = rightEdge.c9

        val back7 = backEdge.c7
        val back8 = backEdge.c8
        val back9 = backEdge.c9

        val left7 = leftEdge.c7
        val left8 = leftEdge.c8
        val left9 = leftEdge.c9

        when (rotation) {
            Rotation.LEFT -> {
                frontEdge.c7 = right7
                frontEdge.c8 = right8
                frontEdge.c9 = right9

                leftEdge.c7 = front7
                leftEdge.c8 = front8
                leftEdge.c9 = front9

                backEdge.c7 = left7
                backEdge.c8 = left8
                backEdge.c9 = left9

                rightEdge.c7 = back7
                rightEdge.c8 = back8
                rightEdge.c9 = back9
            }

            Rotation.RIGHT -> {
                frontEdge.c7 = left7
                frontEdge.c8 = left8
                frontEdge.c9 = left9

                rightEdge.c7 = front7
                rightEdge.c8 = front8
                rightEdge.c9 = front9

                backEdge.c7 = right7
                backEdge.c8 = right8
                backEdge.c9 = right9

                leftEdge.c7 = back7
                leftEdge.c8 = back8
                leftEdge.c9 = back9
            }
        }
    }

    internal fun rotateFront(rotation: Rotation) {
        frontEdge.rotateSelf(rotation)

        val up7 = upEdge.c7
        val up8 = upEdge.c8
        val up9 = upEdge.c9

        val right1 = rightEdge.c1
        val right4 = rightEdge.c4
        val right7 = rightEdge.c7

        val down1 = downEdge.c1
        val down2 = downEdge.c2
        val down3 = downEdge.c3

        val left3 = leftEdge.c3
        val left6 = leftEdge.c6
        val left9 = leftEdge.c9

        when (rotation) {
            Rotation.RIGHT -> {
                upEdge.c7 = left9
                upEdge.c8 = left6
                upEdge.c9 = left3

                rightEdge.c1 = up7
                rightEdge.c4 = up8
                rightEdge.c7 = up9

                downEdge.c3 = right1
                downEdge.c2 = right4
                downEdge.c1 = right7

                leftEdge.c3 = down1
                leftEdge.c6 = down2
                leftEdge.c9 = down3
            }

            Rotation.LEFT -> {
                upEdge.c7 = right1
                upEdge.c8 = right4
                upEdge.c9 = right7

                rightEdge.c1 = down3
                rightEdge.c4 = down2
                rightEdge.c7 = down1

                downEdge.c1 = left3
                downEdge.c2 = left6
                downEdge.c3 = left9

                leftEdge.c3 = up9
                leftEdge.c6 = up8
                leftEdge.c9 = up7
            }
        }
    }

    internal fun rotateBack(rotation: Rotation) {
        backEdge.rotateSelf(rotation)

        val up1 = upEdge.c1
        val up2 = upEdge.c2
        val up3 = upEdge.c3

        val right3 = rightEdge.c3
        val right6 = rightEdge.c6
        val right9 = rightEdge.c9

        val down7 = downEdge.c7
        val down8 = downEdge.c8
        val down9 = downEdge.c9

        val left1 = leftEdge.c1
        val left4 = leftEdge.c4
        val left7 = leftEdge.c7

        when (rotation) {
            Rotation.RIGHT -> {
                upEdge.c1 = right3
                upEdge.c2 = right6
                upEdge.c3 = right9

                rightEdge.c3 = down9
                rightEdge.c6 = down8
                rightEdge.c9 = down7

                downEdge.c7 = left1
                downEdge.c8 = left4
                downEdge.c9 = left7

                leftEdge.c1 = up3
                leftEdge.c4 = up2
                leftEdge.c7 = up1
            }

            Rotation.LEFT -> {
                upEdge.c1 = left7
                upEdge.c2 = left4
                upEdge.c3 = left1

                rightEdge.c3 = up1
                rightEdge.c6 = up2
                rightEdge.c9 = up3

                downEdge.c7 = right9
                downEdge.c8 = right6
                downEdge.c9 = right3

                leftEdge.c1 = down7
                leftEdge.c4 = down8
                leftEdge.c7 = down9
            }
        }
    }

    internal fun rotateLeft(rotation: Rotation) {
        leftEdge.rotateSelf(rotation)

        val up1 = upEdge.c1
        val up4 = upEdge.c4
        val up7 = upEdge.c7

        val back3 = backEdge.c3
        val back6 = backEdge.c6
        val back9 = backEdge.c9

        val down1 = downEdge.c1
        val down4 = downEdge.c4
        val down7 = downEdge.c7

        val front1 = frontEdge.c1
        val front4 = frontEdge.c4
        val front7 = frontEdge.c7

        when (rotation) {
            Rotation.RIGHT -> {
                upEdge.c1 = back9
                upEdge.c4 = back6
                upEdge.c7 = back3

                backEdge.c3 = down7
                backEdge.c6 = down4
                backEdge.c9 = down1

                downEdge.c1 = front1
                downEdge.c4 = front4
                downEdge.c7 = front7

                frontEdge.c1 = up1
                frontEdge.c4 = up4
                frontEdge.c7 = up7
            }

            Rotation.LEFT -> {
                upEdge.c1 = front1
                upEdge.c4 = front4
                upEdge.c7 = front7

                backEdge.c3 = up7
                backEdge.c6 = up4
                backEdge.c9 = up1

                downEdge.c1 = back9
                downEdge.c4 = back6
                downEdge.c7 = back3

                frontEdge.c1 = down1
                frontEdge.c4 = down4
                frontEdge.c7 = down7
            }
        }
    }

    internal fun rotateRight(rotation: Rotation) {
        rightEdge.rotateSelf(rotation)

        val up3 = upEdge.c3
        val up6 = upEdge.c6
        val up9 = upEdge.c9

        val back1 = backEdge.c1
        val back4 = backEdge.c4
        val back7 = backEdge.c7

        val down3 = downEdge.c3
        val down6 = downEdge.c6
        val down9 = downEdge.c9

        val front3 = frontEdge.c3
        val front6 = frontEdge.c6
        val front9 = frontEdge.c9

        when (rotation) {
            Rotation.RIGHT -> {
                upEdge.c3 = front3
                upEdge.c6 = front6
                upEdge.c9 = front9

                backEdge.c1 = up9
                backEdge.c4 = up6
                backEdge.c7 = up3

                downEdge.c3 = back7
                downEdge.c6 = back4
                downEdge.c9 = back1

                frontEdge.c3 = down3
                frontEdge.c6 = down6
                frontEdge.c9 = down9
            }

            Rotation.LEFT -> {
                upEdge.c3 = back7
                upEdge.c6 = back4
                upEdge.c9 = back1

                backEdge.c1 = down9
                backEdge.c4 = down6
                backEdge.c7 = down3

                downEdge.c3 = front3
                downEdge.c6 = front6
                downEdge.c9 = front9

                frontEdge.c3 = up3
                frontEdge.c6 = up6
                frontEdge.c9 = up9
            }
        }
    }

    internal fun printCube() {
        println("${upEdge.c1}${upEdge.c2}${upEdge.c3}")
        println("${upEdge.c4}${upEdge.c5}${upEdge.c6}")
        println("${upEdge.c7}${upEdge.c8}${upEdge.c9}")

        println("${frontEdge.c1}${frontEdge.c2}${frontEdge.c3}${rightEdge.c1}${rightEdge.c2}${rightEdge.c3}${backEdge.c1}${backEdge.c2}${backEdge.c3}${leftEdge.c1}${leftEdge.c2}${leftEdge.c3}")
        println("${frontEdge.c4}${frontEdge.c5}${frontEdge.c6}${rightEdge.c4}${rightEdge.c5}${rightEdge.c6}${backEdge.c4}${backEdge.c5}${backEdge.c6}${leftEdge.c4}${leftEdge.c5}${leftEdge.c6}")
        println("${frontEdge.c7}${frontEdge.c8}${frontEdge.c9}${rightEdge.c7}${rightEdge.c8}${rightEdge.c9}${backEdge.c7}${backEdge.c8}${backEdge.c9}${leftEdge.c7}${leftEdge.c8}${leftEdge.c9}")

        println("${downEdge.c1}${downEdge.c2}${downEdge.c3}")
        println("${downEdge.c4}${downEdge.c5}${downEdge.c6}")
        println("${downEdge.c7}${downEdge.c8}${downEdge.c9}")
    }
}

fun main() {
    Cube.initialize()
    readLine()

    readLine()!!.split(' ').forEach {
        val rotation = if (it.length == 2) Cube.Rotation.LEFT else Cube.Rotation.RIGHT
        when (it.first()) {
            'F' -> Cube.instance.rotateFront(rotation)
            'B' -> Cube.instance.rotateBack(rotation)
            'U' -> Cube.instance.rotateUp(rotation)
            'D' -> Cube.instance.rotateDown(rotation)
            'R' -> Cube.instance.rotateRight(rotation)
            else -> Cube.instance.rotateLeft(rotation)
        }
    }

    Cube.instance.printCube()
}