class SuperNumber[T](val list: List[T]) {
  def sum(othr: SuperNumber[T])(implicit processor: Processor[T]): SuperNumber[T] = {
    processor.sum(this, othr)
  }

  def ||(othr: SuperNumber[T])(implicit logic: Processor.Logic[T]): SuperNumber[T] = {
    logic.or(this, othr)
  }

  def &&(othr: SuperNumber[T])(implicit logic: Processor.Logic[T]): SuperNumber[T] = {
    logic.and(this, othr)
  }

}

abstract class Processor[T] {
  def sum(a: SuperNumber[T], b: SuperNumber[T]): SuperNumber[T]
}

object Processor {

  implicit object int extends Processor[Int] {
    override def sum(a: SuperNumber[Int], b: SuperNumber[Int]): SuperNumber[Int] = {
      new SuperNumber[Int]((a.list, b.list).zipped.map(_ + _))
    }
  }

  abstract class Logic[T] extends Processor[T] {
    def or(a: SuperNumber[T], b: SuperNumber[T]): SuperNumber[T]
    def and(a: SuperNumber[T], b: SuperNumber[T]): SuperNumber[T]
  }

  implicit object bool extends Logic[Boolean] {

    val binarySum: (Boolean, List[Boolean], List[Boolean]) => List[Boolean] = {
      case (flag, Nil, Nil) if flag => List(flag)
      case (flag, Nil, Nil) if !flag => List()
      case (flag, Nil, second) if !flag => second
      case (flag, Nil, s::second) if flag => if(s) false::binarySum(true, Nil, second) else true::binarySum(false, Nil, second)
      case (flag, first, Nil) if !flag => first
      case (flag, f::first, Nil) if flag => if(f) false::binarySum(true, Nil, first) else true::binarySum(false, Nil, first)
      case (flag, f :: first, s :: second) if !flag => if (f && s || !f && !s) false :: binarySum(f && s, first, second) else true :: binarySum(false, first, second)
      case (flag, f :: first, s :: second) if flag => if (f && s || !f && !s) true :: binarySum(f && s, first, second) else false :: binarySum(true, first, second)
    }

    override def or(a: SuperNumber[Boolean], b: SuperNumber[Boolean]): SuperNumber[Boolean] = {
      new SuperNumber[Boolean]((a.list.reverse, b.list.reverse).zipped.map(_ | _).reverse)
    }

    override def and(a: SuperNumber[Boolean], b: SuperNumber[Boolean]): SuperNumber[Boolean] = {
      new SuperNumber[Boolean]((a.list.reverse, b.list.reverse).zipped.map(_ & _).reverse)
    }

    override def sum(a: SuperNumber[Boolean], b: SuperNumber[Boolean]): SuperNumber[Boolean] = {
      new SuperNumber[Boolean](binarySum(false, a.list.reverse, b.list.reverse).reverse)
    }
  }

}

object Hello {
  def main(args: Array[String]): Unit = {
    val s1 = new SuperNumber[Int](List(1, 2, 3))
    val s2 = new SuperNumber[Boolean](List( false,true, true))
    val s3 = new SuperNumber[Boolean](List( true ,true, true))
    println(s1.sum(new SuperNumber[Int](List(3, 2, 1))).list)
    println((s2 sum s3).list)
    println((s2 && new SuperNumber[Boolean](List(true, true, false))).list)
    println((s2 || new SuperNumber[Boolean](List(true, true, false))).list)

  }
}