// 2位RCA的电路
                   +-----+
C0-----------------|     |
        +-----+    | and |--+
A0---+--|     | +--|     |  |
     |  | xor |-+  +-----+  |  +----+
B0-+----|     |             +--|    |
   | |  +-----+                | or |--+
   | |                      +--|    |  |
   | |  +-----+             |  +----+  |
   | +--|     |             |          |  +-----+
   |    | and |-------------+          +--|     |
   +----|     |                           | and |--+
        +-----+                        +--|     |  |
                                       |  +-----+  |
        +-----+                        |           |
A1---+--|     |                        |           |  +----+
     |  | xor |------------------------+           +--|    |
B1-+----|     |                                       | or |----C2
   | |  +-----+                                    +--|    |
   | |                                             |  +----+
   | |  +-----+                                    |
   | +--|     |                                    |
   |    | and |------------------------------------+
   +----|     |
        +-----+

             A/B12~15   A/B8~11   A/B4~7    A/B0~3
                ||        ||        ||        ||
         +---------------------------------------------+
S0~3  <--|------||--------||--------||------+ ||       |
S4~7  <--|------||--------||------+ ||      | ||       |
S8~11 <--|------||------+ ||      | ||      | ||       |
S12~15<--|-+    VV      | VV      | VV      | VV       |
         | | +----+    +----+    +----+    +----+      |
         | +-|4CLA|<-+ |4CLA|<-+ |4CLA|<-+ |4CLA|<--+--|--C0
         |   +----+  | +----+  | +----+  | +----+   |  |
         |      ||   |    ||   |    ||   |    ||    |  |
         |      VV   |    VV   |    VV   |    VV    |  |
         |  +------------------------------------+  |  |
         |  |  P3G3 C12  P2G2 C8   P1G1 C4   P0G0|  |  |
  C16 <--|--|C16  Carry Lookahead Unit(CLU)      |<-+  |
         |  |                           PG  GG   |     |
         |  +------------------------------------+     |
         | 16-bit Carry-Lookahead Adder  |   |         |
         +---------------------------------------------+
                                         |   |
                                         V   V

         colunm i+1              colunm i
         in1  in2               in1  in2
           |  |                   |  |
        +----------+           +----------+
        |  |  |    |           |  |  |    |
        |  V  V    |           |  V  V    |
        | +----+   |           | +----+   |
cout1<--|-| FA |<--|-- in3 +---|-| FA |<--|-- in3
        | +----+   |       |   | +----+   |
        |   |  +---|-- in4 |   |   |  +---|-- in4
        |   |  |   |       |   |   |  |   |
        |   V  V   |     +-+   |   V  V   |
        |  +----+  | cin |     |  +----+  |
cout2<--|--| FA |<-|-----+ +---|--| FA |<-|-- cin
        |  +----+  |       |   |  +----+  |
        |    |     |       |   |    |     |
        +----------+       |   +----------+
             |             |        |
             V s     cout2 V        V s
      +-------------------------------------+
      |              Next Layer             |
      +-------------------------------------+

def addOneColumn(col: Seq[Bool], cin: Seq[Bool]):
  (Seq[Bool], Seq[Bool], Seq[Bool]) = {
  var sum = Seq[Bool]()
  var cout1 = Seq[Bool]()
  var cout2 = Seq[Bool]()
  col.size match {
    case 1 =>  // do nothing
      sum = col ++ cin
    case 2 =>
      val c22 = Module(new C22)
      c22.io.in := col
      sum = c22.io.out(0).asBool() +: cin
      cout2 = Seq(c22.io.out(1).asBool())
    case 3 =>
      val c32 = Module(new C32)
      c32.io.in := col
      sum = c32.io.out(0).asBool() +: cin
      cout2 = Seq(c32.io.out(1).asBool())
    case 4 =>
      val c53 = Module(new C53)
      for((x, y) <- c53.io.in.take(4) zip col){
        x := y
      }
      c53.io.in.last := (if(cin.nonEmpty) cin.head else 0.U)
      sum = Seq(c53.io.out(0).asBool()) ++ (if(cin.nonEmpty) cin.drop(1) else Nil)
      cout1 = Seq(c53.io.out(1).asBool())
      cout2 = Seq(c53.io.out(2).asBool())
    case n =>
      val cin_1 = if(cin.nonEmpty) Seq(cin.head) else Nil
      val cin_2 = if(cin.nonEmpty) cin.drop(1) else Nil
      val (s_1, c_1_1, c_1_2) = addOneColumn(col take 4, cin_1)
      val (s_2, c_2_1, c_2_2) = addOneColumn(col drop 4, cin_2)
      sum = s_1 ++ s_2
      cout1 = c_1_1 ++ c_2_1
      cout2 = c_1_2 ++ c_2_2
  }
  (sum, cout1, cout2)
}

def addAll(cols: Array[Seq[Bool]], depth: Int):
  (UInt, UInt) = {
  if(max(cols.map(_.size)) <= 2){
    val sum = Cat(cols.map(_(0)).reverse)
    var k = 0
    while(cols(k).size == 1) k = k+1
    val carry = Cat(cols.drop(k).map(_(1)).reverse)
    (sum, Cat(carry, 0.U(k.W)))
  } else {
    val columns_next = Array.fill(2*len)(Seq[Bool]())
    var cout1, cout2 = Seq[Bool]()
    for( i <- cols.indices){
      val (s, c1, c2) = addOneColumn(cols(i), cout1)
      columns_next(i) = s ++ cout2
      cout1 = c1
      cout2 = c2
    }

    val needReg = depth == 4
    val toNextLayer = if(needReg)
      columns_next.map(_.map(
        x => RegEnable(x, io.regEnables(1))))
    else
      columns_next

    addAll(toNextLayer, depth+1)
  }
}

val columns_reg = columns.map(col => col.map(
     b => RegEnable(b, io.regEnables(0))))
val (sum, carry) = addAll(columns_reg, 0)

io.result := sum + carry

import chisel3._
import chisel3.util._
import chiseltest._
import chisel3.experimental.BundleLiterals._
import chiseltest.formal._
import chiseltest.formal.BoundedCheck
import utest._

class Sub extends Module {
  val io = IO(new Bundle {
    val a = Input(UInt(4.W))
    val b = Input(UInt(4.W))
    val c = Output(UInt(4.W))
  })
  //val cnt = Counter(true.B, 16)._1
  //io.c := io.a + ~io.b + Mux(cnt === 3.U, 2.U, 1.U)
  io.c := io.a + ~io.b + 1.U
  val ref = io.a - io.b
  chisel3.assert(io.c === ref)
}

object Sub extends TestSuite {
  val tests: Tests = Tests {
    test("mytest") {
      new Formal with HasTestName {
        def getTestName: String = s"sub"
      }.verify(new Sub, Seq(BoundedCheck(1)))
    }
  }
}