Problem:
大きさが異なる n 個のコップと 3 つのトレイ（お盆）A，B，C があり，それらのコップは 3 つのトレイの上にそれぞれ何個かずつ一山に重ねて置かれている．ただし，どのトレイにおいても，そのトレイの中で一番小さいコップが一番下に， 2 番目に小さいコップがその上に， 3 番目に小さいコップがその上にと，小さい順に伏せて重ねてある．例えば，下図の右側は， n = 5 個のコップがトレイ A，B，C にそれぞれ 2 個，0 個，3 個重ねて置かれている状態を示している．

このように，コップの初期状態が与えられたとき，次の規則 1 〜 3 を守りながら，すべてのコップを A または C のどちらかのトレイに移動させるには何回移動を行えばよいかを求めたい．

（規則 1） 1 回に 1 つのコップだけを移動させることができる．それは，そのトレイにあるコップの中で一番上のコップ（つまり，一番大きいコップ）である．

（規則 2）大きいコップの上に小さいコップを重ねてはいけない．

（規則 3）コップ 1 個の直接移動は，トレイ A から B，B から A，B から C，C から B のみが許され， A から C への直接移動や C から A への直接移動は許されない．

　n 個のコップの初期状態と整数 m が与えられたとき， m 回以内の移動で， A または C のどちらかのトレイにすべてのコップをまとめて重ねることができるかどうかを判定し，可能な場合には移動回数の最小値を，不可能な場合には -1 を出力するプログラムを作成しなさい．

　入力ファイルの 1 行目には， n と m がこの順に空白を区切り文字として書いてある． 1 ≦ n ≦ 15 であり， 1 ≦ m ≦ 15000000 である． 2 行目，3 行目，4 行目には， 1 から n までの整数を何個かずつ 3 つのグループに分けて，それぞれのグループ内で小さい順（昇順）に並べたものが書いてある．ただし，各行の先頭（それらの整数の前）には，それらの個数が書いてある． 2 行目に書かれている整数（先頭の 1 つを除く）はトレイ A の上に重ねられている各コップの大きさを表す．同様に， 3 行目に書かれている整数（先頭の 1 つを除く）はトレイ B の上に重ねられている各コップの大きさを表し， 4 行目に書かれている整数（先頭の１つを除く）はトレイ C の上に重ねられている各コップの大きさを表す．

入力例１

入力例２

入力例３

入力例４

3 10

4 20

2 5

3 3

0

2 1 2

2 1 2

0

1 1

1 3

0

1 1

2 2 3

1 4

0

2 2 3

　

出力例１

出力例２

出力例３

出力例４

9

3

0

-1

入力

入力は複数のデータセットからなる．n, m がともに 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、移動回数または -1 を１行に出力する．

入力例

3 10
0
1 1
2 2 3
4 20
2 1 2
1 3
1 4
2 5
2 1 2
0
0
3 3
0
1 1
2 2 3
0 0

出力例

9
3
0
-1

各データセットの出力（移動回数または -1）の後に改行を入れること．

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in Scala (judge verdict: Wrong Answer)

object Main {
  import scala.io.StdIn.{ readLine }
  import scala.language.implicitConversions
  def main(args : Array[String]) {
    recursive
  }
  def recursive : Unit = {
    var args = readLine.split(" ").map(_.toInt)
    while (args(0) + args(1) != 0) {
      val a = toSeqList(readLine.split(" ").map(s => new Cup(s.toInt)).toList.tail)
      val b = toSeqList(readLine.split(" ").map(s => new Cup(s.toInt)).toList.tail)
      val c = toSeqList(readLine.split(" ").map(s => new Cup(s.toInt)).toList.tail)
      val min = minStep(a, b, c)
      if (args(1) >= min) {
        println(min)
      } else {
        println(-1)
      }
      args = readLine.split(" ").map(_.toInt)
    }
  }
  implicit def bool2int(b:Boolean) = if (b) 1 else 0
  def getOrder(a : Cup, b : Cup, c : Cup) = {
    ((a > b) + (a > c), (b > a) + (b > c), (c > a) + (c > b))
  }
  def toSeqList(list : List[Cup], result : List[Cup] = List[Cup](new Stage)) : List[Cup] = {
    list match {
      case Nil => result
      case first :: rest =>
        if (first ^ result.head)
          toSeqList(rest, (first + result.head) :: result.tail)
        else
          toSeqList(rest, first :: result)
      case _ => throw new Exception
    }
  }
  def xor(a : Boolean, b : Boolean) : Boolean = !(a == b)
  def subOneStep3(a : List[Cup], b : List[Cup], c : List[Cup]) = {
    getOrder(a.head, b.head, c.head) match {
      case (0, 1, 2) =>
        (a, (c.head + b.head) :: b.tail, c.tail, c.head.moveCost * (if (xor((c.tail.head > a.head), (c.head.parity == b.head.parity))) 1 else -1))
      case (2, 1, 0) =>
        (a.tail, (a.head + b.head) :: b.tail, c, a.head.moveCost * (if (xor((a.tail.head > c.head), (a.head.parity == b.head.parity))) 1 else -1))
      case (1, 2, 0) =>
        ((b.head + a.head) :: a.tail, b.tail, c, b.head.moveCost * (if (xor((b.tail.head > c.head), (b.head.parity == a.head.parity))) 1 else -1))
      case (0, 2, 1) =>
        (a, b.tail, (b.head + c.head) :: c.tail, b.head.moveCost * (if (xor((b.tail.head > a.head), (b.head.parity == c.head.parity))) 1 else -1))
      case (1, 0, 2) =>
        (a, (c.head + b.head) :: b.tail, c.tail, -c.head.moveCost)
      case (2, 0, 1) =>
        (a.tail, (a.head + b.head) :: b.tail, c, -a.head.moveCost)
      case _ => throw (new Exception)
    }
  }
  def subOneStep2(a : List[Cup], b : List[Cup], c : List[Cup]) = {
    getOrder(a.head, b.head, c.head) match {
      case (0, 1, 2) =>
        (a, (c.head + b.head) :: b.tail, c.tail, -c.head.moveCost)
      case (2, 1, 0) =>
        (a.tail, (a.head + b.head) :: b.tail, c, -a.head.moveCost)
      case (1, 2, 0) =>
        ((b.head + a.head) :: a.tail, b.tail, c, b.head.moveCost * (if (b.size == 2) 1 else -1))
      case (0, 2, 1) =>
        (a, b.tail, (b.head + c.head) :: c.tail, b.head.moveCost * (if (b.size == 2) 1 else -1))
      case (1, 0, 2) =>
        (a, (c.head + b.head) :: b.tail, c.tail, -c.head.moveCost)
      case (2, 0, 1) =>
        (a.tail, (a.head + b.head) :: b.tail, c, -a.head.moveCost)
      case _ => throw (new Exception)
    }
  }
  def minStep(a : List[Cup], b : List[Cup], c : List[Cup], step : Int = 0) : Int = {
    ((a.size > 1) + (b.size > 1) + (c.size > 1)) match {
      case 3 =>
        val tuple = subOneStep3(a, b, c)
        minStep(tuple._1, tuple._2, tuple._3, step + tuple._4)
      case 2 =>
        val tuple = subOneStep2(a, b, c)
        minStep(tuple._1, tuple._2, tuple._3, step + tuple._4)
      case 1 if (b.size > 1) =>
        step + b.head.moveCost
      case 1 =>
        step
      case _ => throw (new Exception)
    }
  }

}
class Cup(val bottom : Int, val top : Int) extends Ordered[Cup] {
  def this(s : Int) = this(s, s)
  lazy val size = top - bottom + 1
  override def compare(that : Cup) : Int = this.bottom - that.bottom
  def +(other : Cup) : Cup = {
    (this < other) match {
      case true  => new Cup(bottom, other.top)
      case false => new Cup(other.bottom, top)
    }
  }
  lazy val moveCost = (pow(top - bottom + 1, 1) - 1) / 2
  private lazy val pow : (Int, Int) => Int = (n, r) => {
    n match {
      case 0 => r
      case _ => pow(n - 1, 3 * r)
    }
  }
  def ^(other : Cup) : Boolean = (((other.bottom + 1) == top) || ((bottom + 1) == other.top))
  lazy val parity = bottom % 2
}
class Stage extends Cup(-1, -1) {
  override def ^(other : Cup) : Boolean = false
}