fun main() {
    val testCase = readln().toInt()
    for (case in 1 .. testCase) {
        val (p, str) = readln().split(' ')
        when(val result = solve(p.toInt(), str)) {
            null -> println("Case #$case: IMPOSSIBLE")
            else -> println("Case #$case: POSSIBLE\n${result.joinToString(" ")}")
        }
    }
}


fun solve2(str: String): List<String>? {
    fun canSort(left: IntArray, right: IntArray): Boolean {
        val small = left.copyOf()
        val large = right.copyOf()
        var l = 0
        var r = 25
        while (true) {
            while (l < 26 && small[l] == 0) {
                ++l
            }
            while (0 <= r && large[r] == 0) {
                --r
            }
            if (l < r) return true
            if (l == 26) return true
            if (r < 0) return false
            if (l > r) return false
            val min = minOf(small[l], large[r])
            small[l] -= min
            large[r] -= min
        }
    }
    val right = IntArray(26){0}
    val left = IntArray(26){0}
    for (c in str) {
        ++right[c - 'A']
    }
    for (i in 0 until str.length - 1) {
        ++left[str[i] - 'A']
        --right[str[i] - 'A']
        if (!canSort(left, right)) {
            return listOf(str.substring(0, i + 1), str.substring(i + 1))
        }
    }
    return null
}
fun solveOver4(p: Int, str: String): List<String>? {
    val chars = str.toCharArray()
    val revPos = (1 until str.length).find { chars[it - 1] > chars[it] } ?: return null
    val left = mutableListOf<String>()
    val right = mutableListOf<String>()
    var leftIndex = 0
    while (left.size  + 4 < p && leftIndex < revPos - 1) {
        left.add(str.substring(leftIndex, leftIndex + 1))
        ++leftIndex
    }
    if (leftIndex < revPos - 1) left.add(str.substring(leftIndex, revPos - 1))
    left.add(str.substring(revPos - 1, revPos))
    left.add(str.substring(revPos, revPos + 1))
    var rightIndex = str.length
    while (left.size + right.size + 1 < p && revPos + 1 < rightIndex) {
        right.add(str.substring(rightIndex - 1, rightIndex))
        --rightIndex
    }
    if (revPos + 1 < rightIndex) right.add(str.substring(revPos + 1, rightIndex))
    return left + right.reversed()
}

fun solve3(str: String): List<String>? {
    if (str.length == 3) {
        if (str == str.toList().sorted().joinToString("")) return null
        else return str.map { it.toString() }
    }
    val min = str.minOrNull()!!
    val lastMin = str.lastIndexOf(min)
    if (lastMin > 1) {
        return if (lastMin == str.lastIndex) listOf(str.substring(0, 1), str.substring(1, str.lastIndex), str.substring(str.lastIndex))
        else listOf(str.substring(0, lastMin), str.substring(lastMin, lastMin + 1), str.substring(lastMin + 1))
    }
    if (lastMin == 1 && str.first() != min) {
        return listOf(str.substring(0, 1), str.substring(1, 2), str.substring(2))
    }
    val max = str.maxOrNull()!!
    val lastMax = str.lastIndexOf(max)
    if (lastMax != str.lastIndex) {
        return listOf(str.substring(0, lastMax), str.substring(lastMax, lastMax + 1), str.substring(lastMax + 1))
    }
    val tail = solve2(str.drop(1))
    if (tail != null) {
        return listOf(str.substring(0, 1)) + tail
    }
    val tail2 = if (str.length >= 4) solve2(str.drop(2)) else null
    if (tail2 != null) {
        return listOf(str.substring(0, 2)) + tail2
    }
    val maxIndices = str.indices.filter { str[it] == max }
    var right = 0
    for (i in maxIndices.indices) {
        if (i < right) continue
        right = i + 1
        while (right < maxIndices.size && maxIndices[right - 1] + 1 == maxIndices[right]) {
            right += 1
        }
        if (right == maxIndices.size) {
            --right
        }
        val length = right - i
        val rest = maxIndices.size - right
        if (length > rest) {
            val l = maxIndices[i]
            val r = maxIndices[right - 1]
            return listOf(str.substring(0, l), str.substring(l, r + 1), str.substring(r + 1))
        }
    }
    return null
}
fun solve(p: Int, str: String): List<String>? {
    return when(p) {
        2 -> solve2(str)
        3 -> solve3(str)
        else -> solveOver4(p, str)
    }
}