fun main() = repeat(readln().toInt()) {
  val n = readln().toInt()
  val a = readln().split(" ").map { it.toInt() }
  val p = a.runningReduce { x, y -> minOf(x, y) }
  val ans = (1..n).filter { i -> a[i - 1] != p[i - 1] }
  println(ans.size)
  println(ans.joinToString(" "))    
}

fun main() = repeat(readln().toInt()) {
  val (n, m) = readln().split(" ").map { it.toInt() }
  val a = readln().split(" ").map { it.toInt() }
  val b = readln().split(" ").map { it.toInt() }
  val k = a.intersect(b).size
  println(2 * minOf(n - k, m - k) + if (n > m) 2 else 1)
}

@file:Suppress("CanBeVal")

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.io.PrintWriter
import java.util.*
import kotlin.math.max
import kotlin.math.min

private fun solveTest() {
    val n = readInt()
    val res = emptyList<String>().toMutableList()
    for (i in 0..n - 1) {
        if (i % 2 == 0) {
            for (j in i..n - 1) {
                res.add("pushfront a[" + j + "]")
                res.add("min")
            }
            res.add("popback")
        } else {
            for (j in i..n - 1) {
                res.add("min")
                res.add("popfront")
            }
        }
    }
    println(res.size)
    for (s in res) {
        println(s)
    }
}

private fun solve() {
//    repeat(readInt()) {
    solveTest()
//    }
}

// TEMPLATE
fun main(args: Array<String>) {
    reader = BufferedReader(InputStreamReader(System.`in`))
    out = PrintWriter(OutputStreamWriter(System.out))
    solve()
    out.close()
}

private lateinit var out: PrintWriter
private lateinit var reader: BufferedReader
private var tokenizer: StringTokenizer? = null
private fun read(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
        tokenizer = StringTokenizer(readLn())
    }
    return tokenizer!!.nextToken()
}

private fun readInt() = read().toInt()
private fun readLong() = read().toLong()
private fun readLn() = reader.readLine()!!
private fun readInts() = readLn().split(" ").map { it.toInt() }
private fun readInts(sz: Int) = Array(sz) { readInt() }
private fun readLongs() = readLn().split(" ").map { it.toLong() }
private fun readLongs(sz: Int) = Array(sz) { readLong() }
private fun print(b: Boolean) = out.print(b)
private fun print(i: Int) = out.print(i)
private fun print(d: Double) = out.print(d)
private fun print(l: Long) = out.print(l)
private fun print(s: String) = out.print(s)
private fun print(message: Any?) = out.print(message)
private fun print(a: Array<Int>) = a.forEach { print("$it ") }
private fun <T> print(a: Array<out T>) = a.forEach { print("$it ") }
private fun <T> print(a: Collection<T>) = a.forEach { print("$it ") }
private fun println(b: Boolean) = out.println(b)
private fun println(i: Int) = out.println(i)
private fun println(d: Double) = out.println(d)
private fun println(l: Long) = out.println(l)
private fun println(s: String) = out.println(s)
private fun println() = out.println()
private fun println(message: Any?) = out.println(message)
private fun <T> println(a: Array<out T>) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: IntArray) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: LongArray) {
    a.forEach { print("$it ") }
    println()
}

private fun <T> println(a: Collection<T>) {
    a.forEach { print("$it ") }
    println()
}

private fun intarr(sz: Int, v: Int = 0) = IntArray(sz) { v }
private fun longarr(sz: Int, v: Long = 0) = LongArray(sz) { v }
private fun intarr2d(n: Int, m: Int, v: Int = 0) = Array(n) { intarr(m, v) }
private fun longarr2d(n: Int, m: Int, v: Long = 0) = Array(n) { longarr(m, v) }
private fun <T> init(vararg elements: T) = elements
private fun VI(n: Int = 0, init: Int = 0) = MutableList(n) { init }
private fun VVI(n: Int = 0, m: Int = 0, init: Int = 0) = MutableList(n) { VI(m, init) }
private fun <T1 : Comparable<T1>, T2 : Comparable<T2>> pairCmp(): Comparator<Pair<T1, T2>> {
    return Comparator { a, b ->
        val res = a.first.compareTo(b.first)
        if (res == 0) a.second.compareTo(b.second) else res
    }
}

fun main() {
    repeat(readln().toInt()) {
        val (n, k) = readln().split(' ').map { it.toLong() }
        val a = readln().split(' ').map { it.toLong() }
        // n * resVal - a.sum() <= k
        val resVal = (k + a.sum()) / n
        if (resVal < a.maxOrNull()!!) {
            println(-1)
            return@repeat
        }
        val minEl = a.minOrNull()!!
        var ans = a.sumOf { resVal - it } - (resVal - minEl)
        if (minEl < resVal)
            ans -= a.count { it == minEl } - 1
        println(ans)
    }
}

const val MOD = 998244353;

fun main() = repeat(readln().toInt()) {
  val s = readln()
  var pw = 1
  repeat(s.drop(1).count { it == '?' }) {
    pw = pw * 2 % MOD
  }
  var ans = 0
  if (s[0] == '1' || s[0] == '?') {
    ans = (ans + pw) % MOD
  }
  if (s[0] == '0' || s[0] == '?') {
    val x = if (s.indexOf('0', 1) == -1) 1 else 0 
    ans = (ans + pw - x) % MOD
  }
  println(ans)
}

@file:Suppress("CanBeVal")

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.io.PrintWriter
import java.util.*
import kotlin.math.max
import kotlin.math.min

private fun solveTest() {
    val n = readInt()
    val a = readInts(n)
    val c = intarr(n)
    for (x in a) {
        c[x - 1]++
    }
    val res = intarr(n, Int.MAX_VALUE)
    c.sort()
    var j = 0
    for (k in 0..n) {
        while (j < n && c[j] <= k) j++
        var s = 0
        for (i in j..n) {
            val d = k + (n - i)
            if (s < n)
            res[s] = min(res[s], d)
            if (i < n) s += (c[i] - k)
        }
    }
    for (i in 1 .. n - 1) {
        res[i] = min(res[i], res[i - 1])
    }
    println(res)
}

private fun solve() {
    repeat(readInt()) {
        solveTest()
    }
}

// TEMPLATE
fun main(args: Array<String>) {
    reader = BufferedReader(InputStreamReader(System.`in`))
    out = PrintWriter(OutputStreamWriter(System.out))
    solve()
    out.close()
}

private lateinit var out: PrintWriter
private lateinit var reader: BufferedReader
private var tokenizer: StringTokenizer? = null
private fun read(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
        tokenizer = StringTokenizer(readLn())
    }
    return tokenizer!!.nextToken()
}

private fun readInt() = read().toInt()
private fun readLong() = read().toLong()
private fun readLn() = reader.readLine()!!
private fun readInts() = readLn().split(" ").map { it.toInt() }
private fun readInts(sz: Int) = Array(sz) { readInt() }
private fun readLongs() = readLn().split(" ").map { it.toLong() }
private fun readLongs(sz: Int) = Array(sz) { readLong() }
private fun print(b: Boolean) = out.print(b)
private fun print(i: Int) = out.print(i)
private fun print(d: Double) = out.print(d)
private fun print(l: Long) = out.print(l)
private fun print(s: String) = out.print(s)
private fun print(message: Any?) = out.print(message)
private fun print(a: Array<Int>) = a.forEach { print("$it ") }
private fun <T> print(a: Array<out T>) = a.forEach { print("$it ") }
private fun <T> print(a: Collection<T>) = a.forEach { print("$it ") }
private fun println(b: Boolean) = out.println(b)
private fun println(i: Int) = out.println(i)
private fun println(d: Double) = out.println(d)
private fun println(l: Long) = out.println(l)
private fun println(s: String) = out.println(s)
private fun println() = out.println()
private fun println(message: Any?) = out.println(message)
private fun <T> println(a: Array<out T>) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: IntArray) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: LongArray) {
    a.forEach { print("$it ") }
    println()
}

private fun <T> println(a: Collection<T>) {
    a.forEach { print("$it ") }
    println()
}

private fun intarr(sz: Int, v: Int = 0) = IntArray(sz) { v }
private fun longarr(sz: Int, v: Long = 0) = LongArray(sz) { v }
private fun intarr2d(n: Int, m: Int, v: Int = 0) = Array(n) { intarr(m, v) }
private fun longarr2d(n: Int, m: Int, v: Long = 0) = Array(n) { longarr(m, v) }
private fun <T> init(vararg elements: T) = elements
private fun VI(n: Int = 0, init: Int = 0) = MutableList(n) { init }
private fun VVI(n: Int = 0, m: Int = 0, init: Int = 0) = MutableList(n) { VI(m, init) }
private fun <T1 : Comparable<T1>, T2 : Comparable<T2>> pairCmp(): Comparator<Pair<T1, T2>> {
    return Comparator { a, b ->
        val res = a.first.compareTo(b.first)
        if (res == 0) a.second.compareTo(b.second) else res
    }
}

@file:Suppress("CanBeVal")

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.io.PrintWriter
import java.util.*
import kotlin.collections.HashMap
import kotlin.math.max
import kotlin.math.min

private fun solveTest() {
    val n = readInt()
    val p = TreeMap<Int, MutableList<Int>>()
    repeat(n) {
        val x = readInt()
        val y = readInt()
        if (!p.containsKey(y)) {
            p[y] = mutableListOf()
        }
        p[y]!!.add(x)
    }
    var lastY = Int.MIN_VALUE
    var lastD = mutableMapOf<Int, Int>()
    var res = 0L
    for (y in p.keys) {
        if (y != lastY + 1) {
            lastD.clear()
        }
        var d = mutableMapOf<Int, Int>()

        val xx = p[y]!!
        xx.sort()

        var lastX = Int.MIN_VALUE
        val st = mutableListOf<Pair<Int, Int>>()
        var sum1 = 0L
        var sum2 = 0L
        for (x in xx) {
            val dd = lastD.getOrDefault(x, 0) + 1
            d[x] = dd

            if (x != lastX + 1) {
                st.clear()
                sum1 = 0
                sum2 = 0
            }

            var c = 1
            while (st.isNotEmpty() && st.last().first > dd) {
                c += st.last().second
                sum1 -= st.last().first * st.last().second
                st.removeLast()
            }
            sum1 += c * dd
            st.add(dd to c)
            sum2++

            res += (sum1 - sum2 - dd + 1) * 4
            res += (sum2 - 1) * 2
            res += (dd - 1) * 2
//            println("" + y + " " + x + " " + dd + " " + sum1 + " " + sum2 + " " + res)
            lastX = x
        }

        lastY = y
        lastD = d
    }
    println(res)
}

private fun solve() {
    repeat(readInt()) {
        solveTest()
    }
}

// TEMPLATE
fun main(args: Array<String>) {
    reader = BufferedReader(InputStreamReader(System.`in`))
    out = PrintWriter(OutputStreamWriter(System.out))
    solve()
    out.close()
}

private lateinit var out: PrintWriter
private lateinit var reader: BufferedReader
private var tokenizer: StringTokenizer? = null
private fun read(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
        tokenizer = StringTokenizer(readLn())
    }
    return tokenizer!!.nextToken()
}

private fun readInt() = read().toInt()
private fun readLong() = read().toLong()
private fun readLn() = reader.readLine()!!
private fun readInts() = readLn().split(" ").map { it.toInt() }
private fun readInts(sz: Int) = Array(sz) { readInt() }
private fun readLongs() = readLn().split(" ").map { it.toLong() }
private fun readLongs(sz: Int) = Array(sz) { readLong() }
private fun print(b: Boolean) = out.print(b)
private fun print(i: Int) = out.print(i)
private fun print(d: Double) = out.print(d)
private fun print(l: Long) = out.print(l)
private fun print(s: String) = out.print(s)
private fun print(message: Any?) = out.print(message)
private fun print(a: Array<Int>) = a.forEach { print("$it ") }
private fun <T> print(a: Array<out T>) = a.forEach { print("$it ") }
private fun <T> print(a: Collection<T>) = a.forEach { print("$it ") }
private fun println(b: Boolean) = out.println(b)
private fun println(i: Int) = out.println(i)
private fun println(d: Double) = out.println(d)
private fun println(l: Long) = out.println(l)
private fun println(s: String) = out.println(s)
private fun println() = out.println()
private fun println(message: Any?) = out.println(message)
private fun <T> println(a: Array<out T>) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: IntArray) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: LongArray) {
    a.forEach { print("$it ") }
    println()
}

private fun <T> println(a: Collection<T>) {
    a.forEach { print("$it ") }
    println()
}

private fun intarr(sz: Int, v: Int = 0) = IntArray(sz) { v }
private fun longarr(sz: Int, v: Long = 0) = LongArray(sz) { v }
private fun intarr2d(n: Int, m: Int, v: Int = 0) = Array(n) { intarr(m, v) }
private fun longarr2d(n: Int, m: Int, v: Long = 0) = Array(n) { longarr(m, v) }
private fun <T> init(vararg elements: T) = elements
private fun VI(n: Int = 0, init: Int = 0) = MutableList(n) { init }
private fun VVI(n: Int = 0, m: Int = 0, init: Int = 0) = MutableList(n) { VI(m, init) }
private fun <T1 : Comparable<T1>, T2 : Comparable<T2>> pairCmp(): Comparator<Pair<T1, T2>> {
    return Comparator { a, b ->
        val res = a.first.compareTo(b.first)
        if (res == 0) a.second.compareTo(b.second) else res
    }
}

@file:Suppress("CanBeVal")

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.io.PrintWriter
import java.util.*
import kotlin.collections.HashMap
import kotlin.math.max
import kotlin.math.min

private fun solveTest() {
    val n = readInt()
    val m = readInt()
    val g = Array(n) { mutableListOf<Int>() }
    repeat(m) {
        val x = readInt() - 1
        val y = readInt() - 1
        g[x].add(y)
        g[y].add(x)
    }
    val z = intarr(n, 0)
    var a = (0..n - 1).toMutableSet()
    var res = Int.MAX_VALUE

    while (!a.isEmpty()) {
        var v = a.iterator().next()
        a.remove(v)
        z[v] = 1
        var s = mutableSetOf<Int>()
        for (x in g[v]) {
            if (z[x] == 0) s.add(x)
        }
        var k = 0
        while (true) {
            var ok = false
            for (x in a) {
                if (!s.contains(x) && z[x] == 0) {
                    z[x] = 1
                    a.remove(x)
                    var ss = mutableSetOf<Int>()
                    for (y in g[x]) {
                        if (z[y] == 0 && s.contains(y)) {
                            ss.add(y)
                        }
                    }
                    ok = true
                    s = ss
                    k++
                    break
                }
            }
            if (!ok) {
                res = min(res, k)
                break
            }
        }
    }

    if (res == 0) {
        println("" + res + " " + 0)
    } else {
        println("" + res + " " + (n - 1))
    }
}

private fun solve() {
//    repeat(readInt()) {
        solveTest()
//    }
}

// TEMPLATE
fun main(args: Array<String>) {
    reader = BufferedReader(InputStreamReader(System.`in`))
    out = PrintWriter(OutputStreamWriter(System.out))
    solve()
    out.close()
}

private lateinit var out: PrintWriter
private lateinit var reader: BufferedReader
private var tokenizer: StringTokenizer? = null
private fun read(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
        tokenizer = StringTokenizer(readLn())
    }
    return tokenizer!!.nextToken()
}

private fun readInt() = read().toInt()
private fun readLong() = read().toLong()
private fun readLn() = reader.readLine()!!
private fun readInts() = readLn().split(" ").map { it.toInt() }
private fun readInts(sz: Int) = Array(sz) { readInt() }
private fun readLongs() = readLn().split(" ").map { it.toLong() }
private fun readLongs(sz: Int) = Array(sz) { readLong() }
private fun print(b: Boolean) = out.print(b)
private fun print(i: Int) = out.print(i)
private fun print(d: Double) = out.print(d)
private fun print(l: Long) = out.print(l)
private fun print(s: String) = out.print(s)
private fun print(message: Any?) = out.print(message)
private fun print(a: Array<Int>) = a.forEach { print("$it ") }
private fun <T> print(a: Array<out T>) = a.forEach { print("$it ") }
private fun <T> print(a: Collection<T>) = a.forEach { print("$it ") }
private fun println(b: Boolean) = out.println(b)
private fun println(i: Int) = out.println(i)
private fun println(d: Double) = out.println(d)
private fun println(l: Long) = out.println(l)
private fun println(s: String) = out.println(s)
private fun println() = out.println()
private fun println(message: Any?) = out.println(message)
private fun <T> println(a: Array<out T>) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: IntArray) {
    a.forEach { print("$it ") }
    println()
}

private fun println(a: LongArray) {
    a.forEach { print("$it ") }
    println()
}

private fun <T> println(a: Collection<T>) {
    a.forEach { print("$it ") }
    println()
}

private fun intarr(sz: Int, v: Int = 0) = IntArray(sz) { v }
private fun longarr(sz: Int, v: Long = 0) = LongArray(sz) { v }
private fun intarr2d(n: Int, m: Int, v: Int = 0) = Array(n) { intarr(m, v) }
private fun longarr2d(n: Int, m: Int, v: Long = 0) = Array(n) { longarr(m, v) }
private fun <T> init(vararg elements: T) = elements
private fun VI(n: Int = 0, init: Int = 0) = MutableList(n) { init }
private fun VVI(n: Int = 0, m: Int = 0, init: Int = 0) = MutableList(n) { VI(m, init) }
private fun <T1 : Comparable<T1>, T2 : Comparable<T2>> pairCmp(): Comparator<Pair<T1, T2>> {
    return Comparator { a, b ->
        val res = a.first.compareTo(b.first)
        if (res == 0) a.second.compareTo(b.second) else res
    }
}

import kotlin.math.min

const val K = 17
const val N = K * 2
const val MOD = 998244353

fun add(x: Int, y: Int): Int {
    return ((x + y) % MOD + MOD) % MOD
}

fun mul(x: Int, y: Int): Int {
    return (x.toLong() * y % MOD).toInt()
}

fun binpow(x: Int, y: Int): Int {
    var z = 1
    var base = x
    var exponent = y
    while (exponent > 0) {
        if (exponent % 2 == 1) z = mul(z, base)
        base = mul(base, base)
        exponent /= 2
    }
    return z
}

data class State(
    var unpaired: Int = 0,
    var unpairedLess: Int = 0,
    var pairedLess: Int = 0,
    var flag: Int = 0,
    var ways: Int = 0
)

fun comp(a: State, b: State): Boolean {
    if (a.unpaired != b.unpaired) return a.unpaired < b.unpaired
    if (a.unpairedLess != b.unpairedLess) return a.unpairedLess < b.unpairedLess
    if (a.pairedLess != b.pairedLess) return a.pairedLess < b.pairedLess
    return a.flag < b.flag
}

fun fix(v: MutableList<State>) {
    v.sortWith(compareBy(State::unpaired).thenBy { it.unpairedLess }.thenBy { it.pairedLess }.thenBy { it.flag })
    val v2 = mutableListOf<State>()
    for (s in v) {
        if (s.ways == 0) continue
        if (v2.isEmpty() || comp(v2.last(), s)) {
            v2.add(s)
        } else {
            v2.last().ways = add(v2.last().ways, s.ways)
        }
    }
    v.clear()
    v.addAll(v2)
}

val fact = IntArray(N)
val rfact = IntArray(N)
val g = Array(N) { mutableListOf<Int>() }
val dp = Array(N) { mutableListOf<MutableList<State>>() }
var n = 0

fun choose(x: Int, y: Int): Int {
    return mul(fact[x], mul(rfact[y], rfact[x - y]))
}

fun merge2(x: MutableList<State>, y: MutableList<State>): MutableList<State> {
    val res = mutableListOf<State>()
    for (a in x) {
        for (b in y) {
            for (pairLess in 0..min(a.unpairedLess, b.unpairedLess)) {
                for (pairGreater in 0..min(a.unpaired - a.unpairedLess, b.unpaired - b.unpairedLess)) {
                    var numOfChoices = mul(fact[pairLess], fact[pairGreater])
                    numOfChoices = mul(numOfChoices, choose(a.unpairedLess, pairLess))
                    numOfChoices = mul(numOfChoices, choose(a.unpaired - a.unpairedLess, pairGreater))
                    numOfChoices = mul(numOfChoices, choose(b.unpairedLess, pairLess))
                    numOfChoices = mul(numOfChoices, choose(b.unpaired - b.unpairedLess, pairGreater))
                    numOfChoices = mul(numOfChoices, a.ways)
                    numOfChoices = mul(numOfChoices, b.ways)
                    var flag = 0
                    if (a.unpairedLess > 0 || b.unpairedLess > 0) flag = 1
                    if (a.unpairedLess < a.unpaired || b.unpairedLess < b.unpaired) flag = 2
                    res.add(State(a.unpaired + b.unpaired - 2 * pairLess - 2 * pairGreater, a.unpairedLess + b.unpairedLess - pairLess * 2, a.pairedLess + b.pairedLess + pairLess, maxOf(flag, a.flag), numOfChoices))
                }
            }
        }
    }
    fix(res)
    return res
}

fun merge(a: MutableList<MutableList<State>>, b: MutableList<MutableList<State>>): MutableList<MutableList<State>> {
    val res = MutableList(2) { mutableListOf<State>() }
    for (i in 0..1) {
        for (j in 0..1) {
            if (i == 1 && j == 1) continue
            val cur = merge2(a[i], b[j])
            res[i + j].addAll(cur)
        }
    }
    for (i in 0..1) fix(res[i])
    return res
}

fun getDp(s: MutableList<State>, cntLess: Int, flag: Int): Int {
    for (x in s) {
        if (x.unpaired == 0 && x.pairedLess == cntLess && x.flag == flag) return x.ways
    }
    return 0
}

fun forceSpecial(a: MutableList<MutableList<State>>): MutableList<MutableList<State>> {
    val res = MutableList(2) { mutableListOf<State>() }
    for (x in a[0]) {
        when (x.flag) {
            0 -> res[1].add(x)
            1 -> {
                res[0].add(x.copy())
                res[1].add(x.copy())
            }
            else -> res[0].add(x)
        }
    }
    for (x in a[1]) {
        res[1].add(x)
    }
    fix(res[0])
    fix(res[1])
    return res
}

fun dfs(v: Int, p: Int) {
    val children = mutableListOf<Int>()
    for (x in g[v]) {
        if (x != p) {
            dfs(x, v)
            children.add(x)
        }
    }
    if (g[v].size == 1 && v != p) {
        val s1 = State(1, 1, 0, 0, 1)
        val s2 = State(1, 0, 0, 0, 1)
        dp[v] = mutableListOf(mutableListOf(s1, s2), mutableListOf())
        fix(dp[v][0])
        return
    }
    var aux = MutableList(2) { mutableListOf<State>() }
    aux[0].add(State(0, 0, 0, 0, 1))
    for (c in children) {
        aux = merge(aux, dp[c])
    }
    dp[v] = forceSpecial(aux)
}

fun main() {
    val reader = System.`in`.bufferedReader()
    n = reader.readLine().toInt()
    for (i in 0 until n - 1) {
        val (x, y) = reader.readLine().split(" ").map { it.toInt() }
        g[x - 1].add(y - 1)
        g[y - 1].add(x - 1)
    }
    val leaves = mutableListOf<Int>()
    val nonLeaves = mutableListOf<Int>()
    for (i in 0 until n) {
        if (g[i].size == 1) leaves.add(i) else nonLeaves.add(i)
    }
    fact[0] = 1
    for (i in 1..n) fact[i] = mul(fact[i - 1], i)
    for (i in 0..n) rfact[i] = binpow(fact[i], MOD - 2)
    var ans = 0
    if (leaves.size % 2 == 0) {
        val root = nonLeaves[0]
        dfs(root, root)
        ans = mul(fact[leaves.size / 2], getDp(dp[root][0], 0, 2))
        println("${leaves.size / 2} $ans")
    } else {
        print("${(leaves.size + 1) / 2} ")
        for (x in leaves) {
            dfs(x, x)
            for (j in 0..leaves.size / 2) {
                val cur = getDp(dp[x][1], j, 0)
                ans = add(ans, mul(cur, mul(fact[j], fact[leaves.size / 2 - j])))
            }
        }
        println(ans)
    }
}